This document introduces Akka, an open-source toolkit for building highly concurrent, distributed, and fault-tolerant event-driven applications on the JVM. It provides a single unified programming model based on actors that simplifies concurrency, scalability, and fault tolerance. Akka supports both Scala and Java APIs and can be deployed on single nodes or in a distributed, clustered environment in the cloud.

1. Above the Clouds:
Introducing Akka
Vojin Jovanovic, EPFL
Philipp Haller, Typesafe
Based on material provided by the Akka team at Typesafe

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-heal
...using “state-of-the-art” tools

3. Vision
Simpler
Concurrency
Scalability
Fault-tolerance

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

5. ARCHITECTURE
CORE
SERVICES

6. ARCHITECTURE
Play! Play-mini Microkernel
Camel AMQP
TestKit
integration integration
ADD-ON
MODULES

7. ARCHITECTURE
Play! Play-mini Microkernel
Camel AMQP
TestKit
integration integration
TYPESAFE
STACK
ADD-ONS

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

9. Akka Actors
one tool in the toolbox

10. ACTOR CONCURRENCY
• Actors = lightweight isolated processes
• No shared state
• Asynchronous message passing (non-blocking)
• Sequential message processing (one message at a
time)
• Actor mailbox: queue of not-yet-processed messages

11. Actor
Behavior
State

12. Event-
driven
Actor
Behavior
State

13. Event-
driven
Actor
Behavior
State

14. Event-
driven
Actor
Behavior
State

15. Event-
driven
Actor
Behavior
State

16. Event-
driven
Actor
Behavior
State

17. Actor
Behavior
State

18. Event-
driven
Actor
Behavior
State

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

20. Actors
class Counter extends UntypedActor {
int counter = 0;
void onReceive(Object msg) {
if (msg.equals(“Tick”)) {
counter += 1;
System.out.println(counter);
}
}
}
Java API

21. ACTOR SYSTEMS
• Actors are created in the context of an actor system
• Actor system = unit for managing shared facilities:
scheduling services, configuration, logging etc.
• Several actor systems with different configurations
may co-exist within the same JVM instance (there is
no global state within Akka itself)
• There may be millions of actors within a single actor
system

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

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

24. Create Actors
val counter = system.actorOf(Props[Counter])
counter is an ActorRef
Creates a top-level actor
Scala API

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

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

27. Send: !
counter ! Tick
fire-forget
Scala API

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

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

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

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

32. 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

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

34. ...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

35. 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

36. Future
firstCompletedOf
fold
reduce
find
traverse
sequence
Combinators for collections of Futures

37. Promise
promise1.successful(...)
promise2.failure(...)
promise3.completeWith(future)
Promise is the write side of the Future
Future is the read side

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

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

40. unbecome
context.unbecome()

41. Scale up?

42. ThreadPoolExecutor

43. ThreadPoolExecutor

44. new ForkJoinPool

45. new ForkJoinPool

46. New
Remote Actors

47. Name
val actor = system.actorOf(Props[MyActor], “my-service”)
Bind the actor to a name
Scala API

48. Name
ActorRef actor = system.actorOf(
new Props(MyActor.class), “my-service”);
Bind the actor to a name
Java API

49. Deployment
Actor name is virtual and
decoupled from how it is deployed

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

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

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

53. Deployment
Allows runtime to dynamically
and adaptively change topology

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

55. Let it crash
fault-tolerance

56. The
Erlang
model

57. Error
Kernel

58. Node 1 Node 2

59. Parental automatic supervision
// from within an actor
val child = context.actorOf(Props[MyActor], “my-actor”)
transparent and automatic fault handling by design
Scala API

60. 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

61. Parental automatic supervision
Guardian System Actor

62. Parental automatic supervision
Guardian System Actor
system.actorOf(Props[Foo], “Foo”)

63. Parental automatic supervision
Guardian System Actor
Foo system.actorOf(Props[Foo], “Foo”)

64. Parental automatic supervision
Guardian System Actor
Foo
context.actorOf(Props[A], “A”)

65. Parental automatic supervision
Guardian System Actor
Foo
A context.actorOf(Props[A], “A”)

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

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

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

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

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

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

72. 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

73. 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

74. 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

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

76. ...and much much more
TestKit FSM
HTTP/REST
EventBus Pub/Sub
Durable Mailboxes Camel
IO
Microkernel SLF4J
AMQP
ZeroMQ Dataflow
Transactors
Agents Spring

77. get it and learn more
http://akka.io
http://typesafe.com

78. Typesafe Console

79. Typesafe Console

81. Akka 2.1+

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

83. The runtime provides
Automatic adaptive cluster rebalancing

84. The runtime provides
Automatic cluster-wide deployment

85. The runtime provides
Highly available configuration service

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

87. The runtime provides
Transparent and user-configurable
load-balancing

88. Akka Node

89. Akka Node
val ping = actorOf(Props[Ping], “ping”)
val pong = actorOf(Props[Pong], “pong”)
ping ! Ball(pong)

90. Akka Node
val ping = actorOf(Props[Ping], “ping”)
val pong = actorOf(Props[Pong], “pong”)
ping ! Ball(pong)
Ping Pong

91. Akka Node
Akka
Cluster Node
Ping Pong

92. Akka
Cluster Node
Akka Node
Akka Akka
Cluster Node Cluster Node
Ping Pong
Akka Akka
Cluster Node Cluster Node

93. Akka
Cluster Node
Akka Akka
Cluster Node Cluster Node
Ping Pong
Akka Akka
Cluster Node Cluster Node

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

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

96. Akka
Pong
Cluster Node
Akka Akka
Ping Pong
Cluster Node akka { Cluster Node
actor {
deployment {
/pong {
router = "round-robin"
nr-of-instances = 3
}
}
}
}
Fail-over
Redirect references
Akka Akka
Pong
Cluster Node Cluster Node

99. Develop

100. Migration
Scala IDE sbt
Manager

101. Run
Migration
Scala IDE sbt
Manager

102. Scala Akka Play
Migration
Scala IDE sbt
Manager

103. Manage
Scala Akka Play
Migration
Scala IDE sbt
Manager

104. Typesafe Typesafe
Provisioning
Subscription Console
Scala Akka Play
Migration
Scala IDE sbt
Manager

105. Typesafe Typesafe
Provisioning
Subscription Console
Scala Akka Play
Migration
Scala IDE sbt
Manager

106. live demo
http://console-demo.typesafe.com

107. sample video
of the
Typesafe Console

108. sample video
of the
Typesafe Console

109. EOF