Victor Klang on Akka

Transcript

1. Akka: Simpler Concurrency, Scalability & Fault-tolerance through Actors @viktorklang Scalable Solutions
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. akka Introducing
4. Vision Simpler Concurrency Scalability Fault-tolerance
5. Vision ...with One single unified Programming model Runtime service
6. Manage system overload
7. Scale up & Scale out
8. Replicate and distribute for fault-tolerance
9. Transparent load balancing
10. CORE SERVICES ARCHITECTURE
11. ADD-ON MODULES ARCHITECTURE
12. ARCHITECTURE CLOUDY AKKA
13. 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 SOME EXAMPLES: WHERE IS AKKA USED?
14. What is an Actor?
15. Event-driven Thread Event-driven Thread Behavior State Actor
16. Akka Actors one tool in the toolbox
17. case object Tick class Counter extends Actor { var counter = 0 def receive = { case Tick => counter += 1 println(counter) } } Actors
18. val counter = actorOf[Counter] Create Actors counter is an ActorRef
19. val actor = actorOf(new MyActor(..)) Create Actors create actor with constructor arguments
20. val counter = actorOf[Counter] counter.start Start actors
21. val counter = actorOf[Counter].start Start actors
22. val counter = actorOf[Counter].start counter.stop Stop actors
23. class MyActor extends Actor { override def preStart = { ... // called before ‘start’ } override def postStop = { ... // called after ‘stop’ } } life-cycle callbacks
24. counter ! Tick Send: ! fire-forget
25. // returns a future val future = actor !!! Message future.await val result = future.result Send: !!! returns the Future directly
26. Future val future1, future2, future3 = new DefaultCompletableFuture(1000) future1.await future2.onComplete(f => ...) future1.completeWithResult(...) future2.completeWithException(...) future3.completeWith(future2)
27. Future //Blocking Futures.awaitOne(futures) Futures.awaitAll(futures) //Non-blocking val f = Futures.firstCompletedOf(futures) val f = Futures.reduce(futures)((x, y) => ...) val f = Futures.fold(zero)(futures)((x, y) => ...)
28. val result = (actor !! Message).as[String] Send: !! uses Future under the hood and blocks until timeout or completion
29. class SomeActor extends Actor { def receive = { case User(name) => // use reply self.reply(“Hi ” + name) } } Reply
30. HotSwap self become { // new body case NewMessage => ... }
31. HotSwap actor ! HotSwap { // new body case NewMessage => ... }
32. HotSwap self.unbecome()
33. val actors = Actor.registry.actors() val actors = Actor.registry.actorsFor[TYPE] val actors = Actor.registry.actorsFor(id) val actor = Actor.registry.actorFor(uuid) Actor.registry.shutdownAll() ActorRegistry
34. class MyActor extends Actor { self.dispatcher = Dispatchers .newThreadBasedDispatcher(self) ... } actor.dispatcher = dispatcher // before started Set dispatcher
35. Remote Actors
36. // use host & port in config Actor.remote.start() Actor.remote.start("localhost", 2552) Remote Server Scalable implementation based on NIO (Netty) & Protobuf
37. Two types of remote actors Client initiated & managed Server initiated & managed
38. import Actor._ val service = remote.actorOf[MyActor](host, port) service ! message Client-managed supervision works across nodes
39. import Actor._ remote.register(“service:id”, actorOf[MyService]) Server-managed register and manage actor on server client gets “dumb” proxy handle server part
40. val service = remote.actorFor( “service:id”, “darkstar”, 9999) service ! message Server-managed client part
41. import Actor._ remote.register(actorOf[MyService]) remote.registerByUuid(actorOf[MyService]) remote.registerPerSession( “service:id”, actorOf[MyService]) remote.unregister(“service:id”) remote.unregister(actorRef) Server-managed server part
42. akka { remote { secure-cookie = "050E0A0D0D06010A00000900040D060F0C09060B" server { require-cookie = on untrusted-mode = on } } } Remoting Security Erlang-style secure cookie
43. Clustered Actors
44. • Subscription-based cluster membership service • Highly available cluster registry for actors • Highly available centralized configuration service • Automatic replication with automatic fail-over upon node crash • Transparent and user-configurable load-balancing • Transparent adaptive cluster rebalancing • Leader election Cloudy Akka
45. Let it crash fault-tolerance
46. Stolen from Erlang
47. 9 nines
48. ...let’s take a standard OO application
49. Which components have critically important state and explicit error handling?
51. Classification of State • Scratch data • Static data • Supplied at boot time • Supplied by other components • Dynamic data • Data possible to recompute • Input from other sources; data that is impossible to recompute Must be protected by any means
52. Fault-tolerant onion-layered Error Kernel
53. Error Kernel
54. Error Kernel Node 1 Node 2
55. Node 1 Node 2 Replication
56. link(actor) unlink(actor) startLink(actor) spawnLink[MyActor] Linking
57. AllForOneStrategy( errors, maxNrOfRetries, withinTimeRange) OneForOneStrategy( errors, maxNrOfRetries, withinTimeRange) Fault handlers
58. class Supervisor extends Actor { faultHandler = AllForOneStrategy( List(classOf[IllegalStateException]) 5, 5000)) def receive = { case Register(actor) => link(actor) } } Supervision
59. class FaultTolerantService extends Actor { ... override def preRestart(reason: Throwable) = { ... // clean up before restart } override def postRestart(reason: Throwable) = { ... // init after restart } } Manage failure
60. Deploy as dependency JAR in WEB-INF/lib etc. Run as stand-alone microkernel OSGi-enabled; drop in any OSGi container (Spring DM server, Karaf etc.) How to run it?
61. Akka Camel
62. class MyConsumer extends Actor with Consumer { def endpointUri = "file:data/input" def receive = { case msg: Message => log.info("received %s" format msg.bodyAs(classOf[String])) } } Camel: consumer
63. class MyConsumer extends Actor with Consumer { def endpointUri = "jetty:http://0.0.0.0:8877/camel/test" def receive = { case msg: Message => reply("Hello %s" format msg.bodyAs(classOf[String])) } } Camel: consumer
64. class CometProducer extends Actor with Producer { def endpointUri = "cometd://localhost:8111/test" } Camel: producer
65. val producer = actorOf[CometProducer].start producer ! ("Current time: " + new Date) Camel: producer
66. AMQP Dataflow Security ...and much much more HTTP Guice OSGi JTA FSM STM Spring
67. Get it and learn more http://akka.io
68. EOF