Road to Reactive Micorservices With Akka

1. About me
1
Yıldız Teknik Üniversitesi
Bilgisayar Mühendisliği
2000 - 2006
Bahçeşehir Üniversitesi
Engineering Management
2006 - 2012
Softtech A.Ş.
Senior Developer, Architect, Solution Architect
2006 - ...
United Parcel Service
Developer
2002 - 2006
Solution Architect, Full Stack Developer
M.Sc Engineering Management
B.Sc Computer Engineering

2. Jonas Bonér
2
Founder and CTO of
http://www.jonasboner.com
Creator of project
https://www.slideshare.net/jboner
https://www.youtube.com/watch?v=DRK7WYNh6AA

3. What changed ?
3

4. Reactive Manifesto
4
The system responds in a timely manner if at all possible.
The system stays
responsive in the
face of failure.
Resilience is achieved by
replication, containment,
isolation and delegation.
The system stays
responsive under varying
workload.
Reactive Systems can react to
changes in the input rate by
increasing or decreasing the
resources allocated to service these
inputs.
Reactive Systems rely on asynchronous message-passing to
establish a boundary between components.
That ensures loose coupling, isolation, location transparency, and provides the means to
delegate errors as messages

5. Operating at the Edge of Failure
5
‘‘Going solid’’: a model of system dynamics and consequences for patient safety - R Cook, J Rasmussen
Resilience in complex adaptive systems: Operating at the Edge of Failure - Richard Cook - Talk at Velocity NY 2013

6. We have Complex Software Systems
Today 6
https://www.slideshare.net/jboner/without-resilience-nothing-else-matters-56053062 , December 11, 2015 – Jonas Bonér

7. Resiliency & Failure Management
7
Manage Failure, Not to Avoid It
Let It Crash
STOP = Crash Safely
START = Recover Fast
Bulkheading Error Kernel
Isolation, Containment, Delegation
https://www.slideshare.net/jboner/without-resilience-nothing-else-matters-56053062 , December 11, 2015 – Jonas Bonér
Rest over HTTP is good
for frontend 2 backend
communication,
Go asynchronous
messaging with TCP for
backend 2 backend
communication

8. Event Driven Architecture
8
‘’ Event-driven architecture (EDA) is a design paradigm in which
a software component executes in response to receiving one or
more event notifications.’’
- Gartner
Events;
 Drive autonomy
 Help reduce risk
 Help you move faster
 Increase Loose coupling
 Increase stability
 Increase scalability
 Increase resilience
 Increase traceability
 Allow for time-travel
https://www.slideshare.net/jboner/how-events-are-reshaping-modern-systems-81845642 , November 10, 2017 – Jonas Bonér

9. CQRS
9
https://www.slideshare.net/jboner/how-events-are-reshaping-modern-systems-81845642 , November 10, 2017 – Jonas Bonér
http://microservices.io/patterns/data/cqrs.html
Read & Write side concerns are different
 Scalable
 Reduced Complexity
 Flexibility

10. Event Sourcing
10
https://www.slideshare.net/jboner/how-events-are-reshaping-modern-systems-81845642 , November 10, 2017 – Jonas Bonér
employee_created
{
"id": 123,
"name": "john",
"salary": 3000,
"date": "2016-01-01"
}
salary_upgraded
{
"id": 123,
"ratio": 8.0,
"date": "2017-01-01"
}
bonus_gained
{
"id": 123,
"ratio": 1.5,
"date": "2017-06-01"
}
salary_upgraded
{
"id": 123,
"ratio": 8.0,
"date": "2018-01-01"
}
bonus_gained
{
"id": 123,
"ratio": 1.5,
"date": "2018-06-01"
}
STATE
Event Sourcing;
 Trace
 Audit Log
 Replay
 Audit Log
 Replay
time
t0 t1 t2 t4t3 t5
CRUD

11. Event Storming and DDD
11
https://blog.redelastic.com/corporate-arts-crafts-modelling-reactive-systems-with-event-storming-73c6236f5dd7

12. What about Transactions?
12
http://www.enterpriseintegrationpatterns.com/ramblings/18_starbucks.html, November 19, 2004 – Gregor HOHPE
Customer Line
Guess, Apologize, Compensate
Correlation Id Payment Prepare Coffee
Consistency Boundary
Asynchronous
Boundaries
Isolated

13. What about Transactions?
13
http://www.enterpriseintegrationpatterns.com/ramblings/18_starbucks.html, November 19, 2004 – Gregor HOHPE
Guess, Apologize, Compensate

14. Coffee Break
14
15 Minutes

15. 15
Lightbend Reactive Platform

16. 16
The Stack View
http://www.enterpriseintegrationpatterns.com/ramblings/18_starbucks.html, November 19, 2004 – Gregor HOHPE

17. What is Akka
17
?
Akka is a toolkit for building highly concurrent,
distributed, and resilient message-driven
applications for Java and Scala
Akka is the implementation of the Actor Model
on the JVM.
Simpler Concurrent & Distributed Systems
Actors and Streams let you build systems that scale up,
using the resources of a server more efficiently, and out,
using multiple servers.
Resilient by Design
Building on the principles of The Reactive Manifesto Akka
allows you to write systems that self-heal and stay
responsive in the face of failures.
High Performance
Up to 50 million msg/sec on a single machine. Small
memory footprint; ~2.5 million actors per GB of heap.
Elastic & Decentralized
Distributed systems without single points of failure. Load
balancing and adaptive routing across nodes. Event
Sourcing and CQRS with Cluster Sharding. Distributed Data
for eventual consistency using CRDTs.
Reactive Streaming Data
Asynchronous non-blocking stream processing with
backpressure. Fully async and streaming HTTP server and
client provides a great platform for building microservices.
Streaming integrations with Alpakka.

18. What Actors are not ?
18

19. What is Actor Model ?
Created by Carl Hewitt (1973)
 Actor : The fundemantal unit of computation, a computation model.
Actor has 3 elements;
 Process
 Storage
 Communication
When an actor receives a message;
 Create more actors
 Send messages to other Actors that it has addresses for
 Designate how the Actor is going to handle the next message it receives
Ericsson has succeed 9 uptime with Erlang Actor Model & Concurrency in telecom systems for many years
19
https://channel9.msdn.com/Shows/Going+Deep/Hewitt-Meijer-and-Szyperski-The-Actor-Model-everything-you-wanted-to-know-but-were-afraid-to-ask

20. Akka Actor Model
20
Sender ActorRef
Mailbox
Actor
Dispatcher
send
enqueue dequeue
schedule
Design principles behind;
 Share Nothing
 Let It Crash
 Immutable Messages
Encapsulates
 State
 Behavior
 Message Queue
https://blog.codecentric.de/en/2015/08/introduction-to-akka-actors/

21. Akka Actor Hierarchy
21
https://doc.akka.io/docs/akka/current/general/addressing.html

22. Akka Actor Hierarchy
22
https://doc.akka.io/docs/akka/current/general/addressing.html
Error Kernel Pattern
 Isolated
 Avoid catastrophic failures
 Seperate Business Logic & Error
handling

23. Location Transparency
23

24. Demo
24

25. Cloud Design Patterns
25
Command Query Responsiblity Segregation (CQRS)
Circuit Breaker
Event Sourcing
External Configuration Store
Health Endpoint Monitoring
Retry
Sharding
Throttling
Resilience
Fault Tolerant
Session Grid
Containerization

26. Architecture Design 26

27. The Nottify Stack coming
soon...
 Reactive
• Responsive
• Elastic
• Resilient
• Message-driven
 Always On
• Active-Active
• Multi Data Center
 DevOps
• Containerized
• Infrastructure as Code
• Externalized Configuration
 Cloud Design Patterns
• CQRS + Event Sourcing
• Circuit Breaker
• Leader Election
• Health Monitoring
• Highly Scalable

28. Questions & Answers
28

29. References
 https://akka.io/docs/
 http://www.lightbend.com
 https://www.slideshare.net/jboner
 https://www.youtube.com/watch?v=DRK7WYNh6AA
 http://www.enterpriseintegrationpatterns.com/ramblings/18_starbucks.html
 https://gist.github.com/rbishop/9082539
 https://blog.codecentric.de/en/2015/08/introduction-to-akka-actors/
 https://www.slideshare.net/jboner/without-resilience-nothing-else-matters-
56053062?qid=bd262b90-241b-486a-9908-f06600f5568a&v=&b=&from_search=13
 https://www.youtube.com/watch?v=iYTEZ0fm4Pw#action=share
29