Building Reactive Applications with Akka

Size: px

Start display at page:

Download "Building Reactive Applications with Akka"

Allan Tyler
6 years ago
Views:

1 Building Reactive Applications with Akka Jonas Bonér Typesafe CTO &

2 This is an era of profound change.

3 Implications are massive, change is unavoidable Users! Users are demanding richer and more personalized experiences.! Yet, at the same time, expecting blazing fast load time. Applications! Mobile and HTML5; Data and compute clouds; scaling on demand.! Modern application technologies are fueling the always-on, realtime user expectation. Businesses! Businesses are being pushed to react to these changing user expectations!...and embrace modern application requirements.! Reactive Applications 3

4 As a matter of necessity, businesses are going Reactive.

5 Reactive applications share four traits Reactive Applications 5

6 Reactive applications react to changes in the world around them.

7 Event-Driven Loosely coupled architecture, easier to extend, maintain, evolve Asynchronous and non-blocking Concurrent by design, immutable state Lower latency and higher throughput Clearly, the goal is to do these operations concurrently and non-blocking, so that entire blocks of seats or sections are not locked. We re able to find and allocate seats under load in less than 20ms without trying very hard to achieve it. Andrew Headrick, Platform Architect, Ticketfly 7

8 Introducing the Actor Model.

9 The Actor Model 9

10 The Actor Model A computational model that embodies: 9

11 A computational model that embodies: Processing The Actor Model 9

12 A computational model that embodies: Processing Storage The Actor Model 9

13 A computational model that embodies: Processing Storage Communication The Actor Model 9

14 A computational model that embodies: Processing Storage Communication The Actor Model Supports 3 axioms when an Actor receives a message it can: 9

15 A computational model that embodies: Processing Storage Communication Supports 3 axioms when an Actor receives a message it can: 1. Create new Actors The Actor Model 9

16 A computational model that embodies: Processing Storage Communication The Actor Model Supports 3 axioms when an Actor receives a message it can: 1. Create new Actors 2. Send messages to Actors it knows 9

17 A computational model that embodies: Processing Storage Communication The Actor Model Supports 3 axioms when an Actor receives a message it can: 1. Create new Actors 2. Send messages to Actors it knows 3. Designate how it should handle the next message it receives 9

18 The essence of an actor 0. DEFINE 1. CREATE 2. SEND 3. BECOME 4. SUPERVISE 10

19 0. DEFINE case class Greeting(who: String)! class GreetingActor extends Actor with ActorLogging { def receive = { case Greeting(who) => log.info(s"hello ${who}") } } 11

20 0. DEFINE Define the message(s) the Actor should be able to respond to case class Greeting(who: String)! class GreetingActor extends Actor with ActorLogging { def receive = { case Greeting(who) => log.info(s"hello ${who}") } } 11

21 0. DEFINE Define the message(s) the Actor should be able to respond to Define the Actor class case class Greeting(who: String)! class GreetingActor extends Actor with ActorLogging { def receive = { case Greeting(who) => log.info(s"hello ${who}") } } 11

22 0. DEFINE Define the message(s) the Actor should be able to respond to Define the Actor class case class Greeting(who: String)! class GreetingActor extends Actor with ActorLogging { def receive = { case Greeting(who) => log.info(s"hello ${who}") } } Define the Actor s behavior 11

23 1. CREATE case class Greeting(who: String)! class GreetingActor extends Actor with ActorLogging { def receive = { case Greeting(who) => log.info("hello " + who) } }! val system = ActorSystem("MySystem") val greeter = system.actorof(props[greetingactor], name = "greeter")

24 1. CREATE case class Greeting(who: String)! class GreetingActor extends Actor with ActorLogging { def receive = { case Greeting(who) Create an Actor => system log.info("hello " + who) } }! val system = ActorSystem("MySystem") val greeter = system.actorof(props[greetingactor], name = "greeter")

25 1. CREATE case class Greeting(who: String)! class GreetingActor extends Actor with ActorLogging { def receive = { case Greeting(who) Create an Actor => system log.info("hello " + who) } Actor configuration }! val system = ActorSystem("MySystem") val greeter = system.actorof(props[greetingactor], name = "greeter")

26 1. CREATE case class Greeting(who: String)! class GreetingActor extends Actor with ActorLogging { def receive = { case Greeting(who) Create an Actor => system log.info("hello " + who) } Actor configuration }! val system = ActorSystem("MySystem") val greeter = system.actorof(props[greetingactor], name = "greeter") Give it a name

27 1. CREATE case class Greeting(who: String)! class GreetingActor extends Actor with ActorLogging { def receive = { case Greeting(who) Create an Actor => system log.info("hello " + who) } Actor configuration }! val system = ActorSystem("MySystem") val greeter = system.actorof(props[greetingactor], name = "greeter") Create the Actor Give it a name

1. CREATE case class Greeting(who: String)! class GreetingActor extends Actor with ActorLogging { def receive = { case Greeting(who) Create an Actor => system log.

28 1. CREATE case class Greeting(who: String)! class GreetingActor extends Actor with ActorLogging { def receive = { case Greeting(who) Create an Actor => system log.info("hello " + who) } Actor configuration }! val system = ActorSystem("MySystem") val greeter = system.actorof(props[greetingactor], name = "greeter") You get an ActorRef back Create the Actor Give it a name

29 Actors can form hierarchies Guardian System Actor

30 Actors can form hierarchies Guardian System Actor system.actorof(props[foo], Foo )

31 Actors can form hierarchies Guardian System Actor Foo system.actorof(props[foo], Foo )

32 Actors can form hierarchies Guardian System Actor Foo context.actorof(props[a], A )

33 Actors can form hierarchies Guardian System Actor Foo A context.actorof(props[a], A )

34 Actors can form hierarchies Guardian System Actor Foo Bar A C A B E B C D

35 Name resolution like a file-system Guardian System Actor Foo Bar A C A B E B C D

36 Name resolution like a file-system Guardian System Actor /Foo Foo Bar A C A B E B C D

37 Name resolution like a file-system Guardian System Actor /Foo Foo Bar /Foo/A A C A B E B C D

38 Name resolution like a file-system Guardian System Actor /Foo Foo Bar /Foo/A A C A /Foo/A/B B E B C D

39 Name resolution like a file-system Guardian System Actor /Foo Foo Bar /Foo/A A C A /Foo/A/B B E B C /Foo/A/D D

40 2. SEND case class Greeting(who: String)! class GreetingActor extends Actor with ActorLogging { def receive = { case Greeting(who) => log.info(s Hello ${who}") } }! val system = ActorSystem("MySystem") val greeter = system.actorof(props[greetingactor], name = "greeter") greeter! Greeting("Charlie Parker") 15

41 2. SEND case class Greeting(who: String)! class GreetingActor extends Actor with ActorLogging { def receive = { case Greeting(who) => log.info(s Hello ${who}") } }! val system = ActorSystem("MySystem") val greeter = system.actorof(props[greetingactor], name = "greeter") greeter! Greeting("Charlie Parker") Send the message asynchronously 15

42 Bring it together case class Greeting(who: String)! class GreetingActor extends Actor with ActorLogging { def receive = { case Greeting(who) => log.info(s Hello ${who}") } }! val system = ActorSystem("MySystem") val greeter = system.actorof(props[greetingactor], name = "greeter") greeter! Greeting("Charlie Parker") 16

43 DEMO TIME A simple game of ping pong

44 3. BECOME class GreetingActor extends Actor with ActorLogging { def receive = happy! val happy: Receive = { case Greeting(who) => log.info(s Hello ${who}") case Angry => context become angry }! } val angry: Receive = { case Greeting(_) => log.info("go away!") case Happy => context become happy } 18

45 3. BECOME class GreetingActor extends Actor with ActorLogging { def receive = happy! val happy: Receive = { case Greeting(who) => log.info(s Hello ${who}") case Angry => context become angry }! } val angry: Receive = { case Greeting(_) => log.info("go away!") case Happy => context become happy } Redefine the behavior 18

46 Reactive applications are architected to handle failure at all levels.

47 Resilient Failure is embraced as a natural state in the app lifecycle Resilience is a first-class construct Failure is detected, isolated, and managed Applications self heal The Typesafe Reactive Platform helps us maintain a very aggressive development and deployment cycle, all in a fail-forward manner. It s now the default choice for developing all new services. Peter Hausel, VP Engineering, Gawker Media 20

48 Think Vending Machine

49 Think Vending Machine Programmer Coffee Machine

50 Think Vending Machine Inserts coins Programmer Coffee Machine

51 Think Vending Machine Inserts coins Programmer Add more coins Coffee Machine

52 Think Vending Machine Inserts coins Programmer Add more coins Gets coffee Coffee Machine

53 Think Vending Machine Programmer Coffee Machine

54 Think Vending Machine Inserts coins Programmer Coffee Machine

55 Think Vending Machine Inserts coins Programmer Out of coffee beans error Coffee Machine

56 Think Vending Machine Inserts coins Programmer Out of coffee beans error Wrong Coffee Machine

57 Think Vending Machine Inserts coins Programmer Coffee Machine

58 Think Vending Machine Inserts coins Out of coffee beans error Programmer Coffee Machine

59 Think Vending Machine Service Guy Inserts coins Out of coffee beans error Programmer Coffee Machine

60 Think Vending Machine Service Guy Inserts coins Out of coffee beans error Adds more beans Programmer Coffee Machine

61 Think Vending Machine Service Guy Inserts coins Out of coffee beans error Adds more beans Programmer Coffee Machine Gets coffee

62 The Right Way Client Service

63 The Right Way Request Client Service

64 The Right Way Request Client Service Response

65 The Right Way Request Client Validation Error Service Response

66 The Right Way Request Application Error Client Validation Error Service Response

67 The Right Way Supervisor Request Application Error Client Validation Error Service Response

68 The Right Way Supervisor Request Application Error Manages Failure Client Validation Error Service Response

70 Use Bulkheads Isolate the failure Compartmentalize Manage failure locally Avoid cascading failures

71 Use Bulkheads Isolate the failure Compartmentalize Manage failure locally Avoid cascading failures

72 Enter Supervision

73 Enter Supervision

74 Supervisor hierarchies Automatic and mandatory supervision Foo Bar A C A B E B C D

75 4. SUPERVISE Every single actor has a default supervisor strategy. Which is usually sufficient. But it can be overridden. 28

76 4. SUPERVISE Every single actor has a default supervisor strategy. Which is usually sufficient. But it can be overridden. class Supervisor extends Actor { override val supervisorstrategy = OneForOneStrategy(maxNrOfRetries = 10, withintimerange = 1 minute) { case _: ArithmeticException => Resume case _: NullPointerException => Restart case _: Exception => Escalate }!! val worker = context.actorof(props[worker], name = "worker") 28

77 4. SUPERVISE class Supervisor extends Actor { override val supervisorstrategy = OneForOneStrategy(maxNrOfRetries = 10, withintimerange = 1 minute) { case _: ArithmeticException => Resume case _: NullPointerException => Restart case _: Exception => Escalate }!! }! val worker = context.actorof(props[worker], name = "worker") def receive = { case n: Int => worker forward n } 28

78 Cleanup & (Re)initialization class Worker extends Actor {... override def prerestart( reason: Throwable, message: Option[Any]) {... // clean up before restart } } override def postrestart(reason: Throwable) {... // init after restart } 29

79 Monitor through Death Watch class Watcher extends Actor { val child = context.actorof(props.empty, "child")! } context.watch(child) def receive = { case Terminated(`child`) => // handle child termination } 30

80 Reactive applications scale up and down to meet demand.

Scalable Scalability and elasticity to embrace the Cloud Leverage all cores via asynchronous programming Clustered servers support joining and leaving of nodes More cost-efficient utilization of

81 Scalable Scalability and elasticity to embrace the Cloud Leverage all cores via asynchronous programming Clustered servers support joining and leaving of nodes More cost-efficient utilization of hardware Our traffic can increase by as much as 100x for 15 minutes each day. Until a couple of years ago, noon was a stressful time. Nowadays, it s usually a non-event. Eric Bowman, VP Architecture, Gilt Groupe 32

82 Scale UP Scale OUT 33

83 Essentially the same thing 33

84 We need to 1. Minimize Contention 2. Maximize Locality of Reference 34

85 Share NOTHING Design 35

86 Fully event-driven apps are a necessity Amdahl s Law will hunt you down 36

87 Define a router val router = context.actorof( RoundRobinPool(5).props(Props[Worker])), router ) Paths can be local or remote actor paths 37

88 or from config akka.actor.deployment { /service/router { router = round-robin-pool resizer { lower-bound = 12 upper-bound = 15 } } } 38

89 Turn on clustering akka { actor { provider = "akka.cluster.clusteractorrefprovider"... } cluster { seed-nodes = [ akka.tcp://clustersystem@ :2551", akka.tcp://clustersystem@ :2552" ] } } auto-down = off 39

90 Use clustered routers akka.actor.deployment { /service/master { router = consistent- hashing- pool nr- of- instances = 100! cluster { enabled = on max-nr-of-instances-per-node = 3 allow- local- routees = on use- role = compute } } } 40

91 Use clustered routers Or perhaps use an AdaptiveLoadBalancingPool akka.actor.deployment { /service/master { router = consistent- hashing- pool nr- of- instances = 100! cluster { enabled = on max-nr-of-instances-per-node = 3 allow- local- routees = on use- role = compute } } } 40

92 Use clustered pub-sub 41

93 Use clustered pub-sub class Subscriber extends Actor { val mediator = DistributedPubSubExtension(context.system).mediator mediator! Subscribe( content, self) } def receive = { } 41

94 Use clustered pub-sub class Publisher extends Actor { val mediator = DistributedPubSubExtension(context.system).mediator } def receive = { case in: String => mediator! Publish("content", in.touppercase) } 41

95 Other Akka Cluster features Cluster Membership Cluster Leader Clustered Singleton Cluster Roles Cluster Sharding 42

96 Use Akka Persistence Supports two different models: Command Sourcing at least once Event Sourcing at most once Great for implementing durable actors replication CQRS etc. Messages persisted to Journal and replayed on restart 43

97 Command Sourcing write-ahead-log Event Sourcing derive events from a command same behavior during recovery as normal operation external interaction can be problematic persisted before validation only state-changing behavior during recovery events cannot fail allows retroactive changes to the business logic fixing the business logic will not affect persisted events naming: represent intent, imperative naming: things that have completed, verbs in past tense Akka Persistence Webinar

98 Life beyond Distributed Transactions: an Apostate s Opinion Position Paper by Pat Helland db.cs.wisc.edu/cidr/cidr2007/papers/cidr07p15.pdf In general, application developers simply do not implement large scalable applications assuming distributed transactions. Pat Helland Akka Persistence Webinar

99 Consistency boundary Aggregate Root is the Transactional Boundary Strong consistency within an Aggregate Eventual consistency between Aggregates No limit to scalability Akka Persistence Webinar

100 Domain Events Things that have completed, facts Immutable Verbs in past tense CustomerRelocated CargoShipped InvoiceSent State transitions are an important part of our problem space and should be modeled within our domain. Greg Young, 2008 Akka Persistence Webinar

101 DEMO TIME Persist a game of ping pong

102 Reactive applications enrich the user experience with low latency response.

Responsive Real-time, engaging, rich and collaborative Create an open and ongoing dialog with users More efficient workflow; inspires a feeling of connectedness Fully Reactive enabling push instead

103 Responsive Real-time, engaging, rich and collaborative Create an open and ongoing dialog with users More efficient workflow; inspires a feeling of connectedness Fully Reactive enabling push instead of pull The move to these technologies is already paying off. Response times are down for processor intensive code such as image and PDF generation by around 75%. Brian Pugh, VP of Engineering, Lucid Software 50

104 Responsive Keep latency consistent under: 1. Blue sky scenarios 2. Traffic spikes 3. Failures The system should always be responsive 51

105

106 Typesafe Activator

107 Typesafe Reactive Platform 54

108 Typesafe Reactive Platform Asynchronous and immutable programming constructs Composable abstractions enabling simpler concurrency and parallelism 54

109 Typesafe Reactive Platform Actors are asynchronous and communicate via message passing Supervision and clustering in support of fault tolerance Asynchronous and immutable programming constructs Composable abstractions enabling simpler concurrency and parallelism 54

Typesafe Reactive Platform Purely asynchronous

required, no inherent bottlenecks in session

communicate via message passing Supervision and

110 Typesafe Reactive Platform Purely asynchronous and non-blocking web frameworks No container required, no inherent bottlenecks in session management Actors are asynchronous and communicate via message passing Supervision and clustering in support of fault tolerance Asynchronous and immutable programming constructs Composable abstractions enabling simpler concurrency and parallelism 54

111 Reactive is being adopted across a wide range of industries.

112 Finance Internet/Social Media Mfg/Hardware Government Retail 56

113 Questions?

Akka. Reactive Applications made easy

Akka. Reactive Applications made easy Akka Reactive Applications made easy Michael Pisula JavaLand, 2014-03-25 Akka Akka mountain by Arvelius What are reactive applications? New requirements demand new technologies - The Reactive Manifesto