With the advent of the Reactive Manifesto, the constant development of Java, Scala and toolkit’s such as Akka, we now have the means by which we can create fully distributable applications on the JVM. But even when equipped with this knowledge and set of tools, we still find ourselves looking for a good set of blueprints. This session will focus on the review of three Reactive Reference Architectures; that will give you a foundation from which you can build a wide variety of distributed software solutions.

1. Reactive Reference
Architecture
Markus Jura
@markusjura

2. Big data
Massive Learning Platform http://allthingsd.com/files/2013/07/minions-­‐640x327.jpg

3. 3
Principles of Reactive Systems

4. Architecture
4
Web
(Play)
backend
(Akka)
Journal
(Cassandra)
Fast
data
processing
(Spark)

5. Problem: Splitting application

6. Monolithic App
6

7. Splitting App
7
Frontend
nodes
Backend
nodes

8. Akka Distributed Pub/Sub
• Location transparency
• Publish/Subscribe
• Dynamically add/remove
8

9. Distributed Pub/Sub Mediator
9
Frontend
nodes
Backend
nodes
M M
M M M

10. Code

11. Frontend
11
// Starting up the mediator
val mediator = DistributedPubSubExtension(system).mediator
// Sending message through mediator
mediator ? DistributedPubSubMediator.Send(“/user/course-aggregate”,
CreateCourse(course),
localAffinity = true)

12. Backend
12
// Starting up the mediator
val mediator = DistributedPubSubExtension(system).mediator
// Setting up the services
val courseAggregate =
system.actorOf(CourseRepository.props, "course-aggregate")
mediator ! DistributedPubSubMediator.Put(courseAggregate)
val levelAggregate =
system.actorOf(LevelRepository.props, "level-aggregate")
mediator ! DistributedPubSubMediator.Put(levelAggregate)

13. Problem: Distributed State

14. State on single node
14
Frontend
nodes
Backend
nodes

15. State across nodes
15
Frontend
nodes
Backend
nodes

16. Akka Cluster Sharding
• Partition actors across Cluster
• Location transparency
• Rebalancing
16

17. How does it work?
17

18. How does it work?
18

19. Code

20. Backend: Create ShardRegion
20
// Backend: Start cluster sharing in non-proxy mode
ClusterSharding(system).start(
"users",
Some(User.props),
UserSharding.idExtractor,
UserSharding.shardResolver())

21. Backend: Shard Resolver & Id Extractor
21
// Extract the user shard
// Rule of thumb: 10 times the max numbers of sharding nodes
def shardResolver(shardCount: Int = 20) = {
case UserService.Envelope(email, _) =>
email.hashCode % shardCount.toString
}
// Extract the id and payload of the user actor
val idExtractor: ShardRegion.IdExtractor = {
case UserService.Envelope(email, payload) =>
(email, payload)
}

22. Frontend
22
// Send message via shard region
shardRegion ? UserService.Envelope(email, GetUser(email))
// Start sharding in proxy mode on every frontend node
val shardRegion: ActorRef = ClusterSharding(system).start(
"users",
None,
UserSharding.idExtractor,
UserSharding.shardResolver())

23. Problem: Loosing State

24. State in memory
24
Frontend
nodes
Backend
nodes

25. Persist state
25
Frontend
Backend

26. Akka Persistence
• Stores state in Journal DB
• Event Sourcing
• Restore state
26

27. Code

28. Write user state
28
class User extends PersistentActor {
// User id / sharding extractor id
override def persistenceId: String = self.path.name
// Persist UserCreated event to Cassandra journal
override def receiveCommand: Receive = {
case UserService.CreateUser(userProgress) =>
persist(UserCreated(userProgress)) { userCreated =>
// Update user state
onUserCreated(userCreated)
sender() ! UserService.UserCreated
}
}
...

29. Recover user state
29
...
// Replay UserCreated message to recover state
override def receiveRecover: Receive = {
case e: UserCreated => onUserCreated(e)
}

30. Problem: Replicate Cache

31. Caching
31
Frontend
Backend
C? C?

32. CRDT Replicator
32
Frontend
nodes
Backend
nodes
CR
R R R
RC

33. What is CRDT?
33
Conflict-free replicated data type is a type
of specially designed data structure used
to achieve strong eventual consistency
Great
talk
on
CRDT
by
Sean
Cribbs:
Eventually
Consistent
Data
Structures

34. Akka Data replication
• CRDT for Akka cluster
• Replicated in-memory data store
• Supports many types: (GSet, ORSet, PNCounter…)
34

35. Code

36. Frontend
36
//starting up the replicator
val replicator = DataReplication(system).replicator
//get cache entry
val f = replicator ? Get(key, ReadLocal, None)

37. Backend
37
//starting up the replicator
val replicator = DataReplication(system).replicator
//updating the cache
replicator ! Update(Course.cacheKey, GSet.empty, WriteLocal)
(_ + courseCreated.course)

38. Q & Option[A]
@markusjura

39. 39
React.js
frontend
REST API Actors
backend
Cache
PubSub CRDTPersistenceCluster Sharding
journal

40. ©Typesafe 2014 – All Rights Reserved