Scaling Up & Out with Actors: Introducing Akka

Transcription

1 Scaling Up & Out with Actors: Introducing Akka Akka Tech Lead

2 The problem It is way too hard to build: 1. correct highly concurrent systems 2. truly scalable systems 3. fault-tolerant systems that self-heals...using state-of-the-art tools

3 Introducing

4 Introducing Akka (Áhkká): The name comes from the goddess in the Sami mythology that represented all the wisdom and beauty in the world. It is also the name of a beautiful mountain in Laponia in the north part of Sweden

5 Introducing View from the summit

6 Vision Simpler Concurrency Scalability Fault-tolerance

7 Vision...with a single unified Programming Model Managed Runtime Open Source Distribution

8 Manage system overload

9 Scale up & Scale out

10 Replicate and distribute for fault-tolerance

11 Transparent load balancing

12 INTRODUCING Akka 2.0

13 Akka 2.0-RC1

14 636 tickets closed

15 1011 files changed

16 96261 lines added

17 56733 lines removed

18 56733 lines removed

19 ARCHITECTURE CORE SERVICES

20 ADD-ON MODULES ARCHITECTURE

21 ARCHITECTURE TYPESAFE STACK ADD-ONS

22 WHERE IS AKKA USED? SOME EXAMPLES: FINANCE Stock trend Analysis & Simulation Event-driven messaging systems BETTING & GAMING Massive multiplayer online gaming High throughput and transactional betting TELECOM Streaming media network gateways SIMULATION 3D simulation engines E-COMMERCE Social media community sites

23 Scale up

24 What is an Actor?

25 Actor Behavior State

26 Eventdriven Actor Behavior State

27 Eventdriven Actor Behavior State

28 Eventdriven Actor Behavior State

29 Eventdriven Actor Behavior State

30 Eventdriven Actor Behavior State

31 Actor Behavior State

32 Eventdriven Actor Behavior State

33 Akka Actors one tool in the toolbox

34 Actors case object Tick class Counter extends Actor { var counter = 0 } def receive = { case Tick => counter += 1 println(counter) } Scala API

35 Actors class Counter extends UntypedActor { int counter = 0; } void onreceive(object msg) { if (msg.equals( Tick )) { counter += 1; System.out.println(counter); } } Java API

36 Create Application val conf = ConfigFactory.load( application ) val system = ActorSystem( my-app, conf) Scala API

37 Create Application Config conf = ConfigFactory.load( application ); ActorSystem system = ActorSystem.create( my-app, conf); Java API

38 Create Actors val counter = system.actorof(props[counter]) counter is an ActorRef Creates a top-level actor Scala API

39 Create Actors ActorRef counter = system.actorof(new Props(Counter.class)); Creates a top-level actor Java API

40 Stop actors system.stop(counter)...also stops all actors in the hierarchy below

41 Send:! counter! Tick fire-forget Scala API

42 ...or use tell counter tell Tick fire-forget Scala API

43 ...or use tell counter.tell(tick); fire-forget Java API

44 Send:? import akka.patterns.ask // returns a future val future = actor? message future onsuccess { case x => println(x) } returns the Future directly Scala API

45 ...or use ask import akka.patterns.ask // returns a future val future = actor ask message future onsuccess { case x => println(x) } returns the Future directly Scala API

46 Reply class SomeActor extends Actor { def receive = { case User(name) => // reply to sender sender! ( Hi + name) } } Scala API

47 Reply class SomeActor extends UntypedActor { void onreceive(object msg) { if (msg instanceof User) { User user = (User) msg; // reply to sender getsender().tell( Hi + user.name); } } } Java API

48 ...or use ask import akka.patterns.ask // returns a future val future = actor ask message future onsuccess { case x => println(x) } Scala API

49 ...or use ask import static akka.patterns.patterns.ask; Future<Object> future = ask(actor, message, timeout); future.onsuccess(new OnSuccess<Object>() { public void onsuccess(string result) { System.out.println(result); } }); Java API

50 Future val f = Promise[String]() f oncomplete {... } onsuccess {... } onfailure {... } f foreach {... } f map {... } f flatmap {... } f filter {... } f zip otherf f fallbackto otherf Await.result(f, 5 seconds) Scala API

51 Future firstcompletedof find sequence fold traverse reduce Combinators for collections of Futures

52 become context become { // new body case NewMessage =>... } Scala API

53 become context.become(new Procedure[Object]() { void apply(object msg) { // new body if (msg instanceof NewMessage) { NewMessage newmsg = (NewMessage)msg;... } } }); Java API

54 unbecome context.unbecome()

55 Routers val router = system.actorof( Props[SomeActor].withRouter( RoundRobinRouter(nrOfInstances = 5))) Scala API

56 Router + Resizer val resizer = DefaultResizer(lowerBound = 2, upperbound = 15) val router = system.actorof( Props[ExampleActor1].withRouter( RoundRobinRouter(resizer = Some(resizer)) ) ) Scala API

57 Scale up?

58 ThreadPoolExecutor

59 ThreadPoolExecutor

60 new ForkJoinPool

61 new ForkJoinPool

62 Scale out

63 New Remote Actors

64 Name val actor = system.actorof(props[myactor], my-service ) Bind the actor to a name Scala API

65 Name ActorRef actor = system.actorof( new Props(MyActor.class), my-service ) Bind the actor to a name Java API

66 Deployment Actor name is virtual and decoupled from how it is deployed

67 Deployment If no deployment configuration exists then actor is deployed as local

68 Deployment The same system can be configured as distributed without code change (even change at runtime)

69 Deployment Write as local but deploy as distributed in the cloud without code change

70 Deployment Allows runtime to dynamically and adaptively change topology

71 Deployment configuration akka { actor { deployment { /my-service { router = "round-robin" nr-of-instances = 3 target { nodes = ["wallace:2552", "gromit:2552"] } } } } }

72 Let it crash fault-tolerance

73 The Erlang model

74 9 nines

75 ...let s take a standard OO application

76

77 Which components have critically important state and explicit error handling?

78

79 Fault-tolerant onion-layered Error Kernel

80 Error Kernel

81 Error Kernel

82 Error Kernel

83 Error Kernel

84 Error Kernel

85 Error Kernel

86 Node 1 Node 2

87 Parental automatic supervision // from within an actor val child = context.actorof(props[myactor], my-actor ) transparent and automatic fault handling by design Scala API

88 Parental automatic supervision // from within an actor ActorRef child = getcontext().actorof( new Props(MyActor.class), my-actor ); transparent and automatic fault handling by design Java API

89 Parental automatic supervision Guardian System Actor

90 Parental automatic supervision Guardian System Actor system.actorof(props[foo], Foo )

91 Parental automatic supervision Guardian System Actor Foo system.actorof(props[foo], Foo )

92 Parental automatic supervision Guardian System Actor Foo context.actorof(props[a], A )

93 Parental automatic supervision Guardian System Actor Foo A context.actorof(props[a], A )

94 Parental automatic supervision Guardian System Actor Foo Bar A C A B E B C D

95 Name resolution Guardian System Actor Foo Bar A C A B E B C D

96 Name resolution Guardian System Actor /Foo Foo Bar A C A B E B C D

97 Name resolution Guardian System Actor /Foo Foo Bar /Foo/A A C A B E B C D

98 Name resolution Guardian System Actor /Foo Foo Bar /Foo/A A C A /Foo/A/B B E B C D

99 Name resolution Guardian System Actor /Foo Foo Bar /Foo/A A C A /Foo/A/B B E B C /Foo/A/D D

100 Supervision class MySupervisor extends Actor { def supervisorstrategy = OneForOneStrategy({ case _: ActorKilledException => Stop case _: ArithmeticException => Resume case _: Exception => Restart case _ => Escalate }, maxnrofretries = None, withintimerange = None) def receive = { case NewUser(name) =>... = context.actorof[user](name) } } Scala API

101 Supervision class MySupervisor extends Actor { def supervisorstrategy = AllForOneStrategy OneForOneStrategy({ case _: ActorKilledException => Stop case _: ArithmeticException => Resume case _: Exception => Restart case _ => Escalate }, maxnrofretries = None, withintimerange = None) } def receive = { case NewUser(name) =>... = context.actorof[user](name) } Scala API

102 Manage failure class FaultTolerantService extends Actor {... override def prerestart( reason: Throwable, message: Option[Any]) = {... // clean up before restart } override def postrestart(reason: Throwable) = {... // init after restart } } Scala API

103 watch/unwatch val buddy: ActorRef =... val watcher = system.actorof(props( new Actor { context.watch(buddy) } )) def receive = { case t: Terminated =>... } Scala API

104 Akka 2.1+

105 The runtime provides Decentralized P2P gossip-based cluster membership (dynamo-style w/ vector clocks, hand-off on fail-over etc.)

106 The runtime provides Automatic adaptive cluster rebalancing

107 The runtime provides Automatic cluster-wide deployment

108 The runtime provides Highly available configuration service

109 The runtime provides Automatic replication with automatic fail-over upon node crash

110 The runtime provides Transparent and user-configurable load-balancing

111 Akka Node

112 Akka Node val ping = actorof(props[ping], ping ) val pong = actorof(props[pong], pong ) ping! Ball(pong)

113 Akka Node val ping = actorof(props[ping], ping ) val pong = actorof(props[pong], pong ) ping! Ball(pong) Ping Pong

114 Akka Node Akka Cluster Node Ping Pong

115 Akka Cluster Node Akka Node Akka Cluster Node Akka Cluster Node Ping Pong Akka Cluster Node Akka Cluster Node

116 Akka Cluster Node Akka Cluster Node Akka Cluster Node Ping Pong Akka Cluster Node Akka Cluster Node

117 Akka Cluster Node Akka Cluster Node Ping akka { actor { deployment { /ping {} /pong { router = "round-robin" nr-of-instances = 3 } } Pong } } Akka Cluster Node Akka Cluster Node Akka Cluster Node

118 Akka Cluster Node Akka Cluster Ping Node akka { actor { deployment { /ping {} /pong { router = "round-robin" nr-of-instances = 3 } } Pong } } Akka Cluster Node Akka Cluster Node Akka Cluster Node

119 Akka Pong Cluster Node Akka Cluster Ping Node akka { actor { deployment { /ping {} /pong { router = "round-robin" nr-of-instances = 3 } } } } Akka Pong Cluster Node Akka Pong Cluster Node Akka Cluster Node

120 ...and much much more HTTP Transactors FSM Durable Mailboxes Microkernel SLF4J Camel NIO ZeroMQ Dataflow AMQP Agents Spring TestKit

121 Get it and learn more

122 EOF