Event Sourcing in less than 20 minutes - With Akka and Java 8
82
Kiki Carter Enterprise Architect May 2017 Event Sourcing and CQRS in 20 minutes with Akka & Java 8
-
Upload
j-on-the-beach -
Category
Technology
-
view
786 -
download
1
Transcript of Event Sourcing in less than 20 minutes - With Akka and Java 8
Kiki CarterEnterprise Architect
May 2017
Event Sourcing and CQRS in 20
minutes with Akka & Java 8
Lightbend
Headquarters in
San Francisco &
Lausanne,
Switzerland
>2 million
downloads
Lightbend
Reactive
Platform Originators of the
Reactive Manifesto
>17,000 signers
Reactive Experts
in 20 Countries
around the globe
About me
Some things I like Some things I don’t like
IG: @thatskiki
Heights
Wild wildlife
Unintentional Sharing
These things
Why are we talking about this
anyway?
Not really *new* buzzwords
Legacy App Modernization(is a thing again)
Distributed Systems(for real this
time)
A system of
autonomous
collaborative distributed
services
AutonomyFrom Greek Auto-nomos:
auto meaning self
nomos meaning law
Leading the
way:
Promise
Theory
Think in Promises
not Obligations
“Autonomy makes information
local, leading to greater certainty
and stability”
- In Search for Certainty by Mark Burgess
No one can tell my story better than
I can…
Obligations diverge into unpredictable outcomes from definite beginnings⇒ decreased certainty
Promises converge towards a definite outcome from unpredictable beginnings⇒ improved certainty
Decreased Certainty IRL
An Autonomous
Service can only
Promise its own
Behavior
How do we get there? (irl)
Data Center A
eCommerceserver
eCommerceserver
eCommerceserver
Database Database
Data Center B
eCommerceserver
eCommerceserver
eCommerceserver
Database Database
Heritage
Distributed
Systems
Enter Distributed Scaling
User
order
cart
Shop
data
User
order
cart
Shop
data
Scale by “stateless services”
Eat your broccoli!
I’m eating it!
I’m eating it!
I’m eating it!
User
order
cart
Shop
data
User
order
cart
Shop
data
data
data
data
But wait, there’s more!
User
order
cart
Shop
data
User
order
cart
Shop
data
Shar
ed d
om
ain
ob
js
User
order
cart
Shop
data
User
order
cart
Shop
data
data
data
dataShar
ed d
om
ain
ob
js
User
order
cart
Shop
data
User
order
cart
Shop
data
data
data
data
May not be accurate – probably isn’t
It’s not the things, it’s the things
that happen
#facts
Define with events
Example: Instead of a shop
service, events that happen within
the shopping context
What happens to our state?
First: A true story
Enter Event Sourcing
Shopping context
data data
eventsevents
events
Stateless Gateway
entity entity entity
state state state
Akka
Persistence commands
In Akka Persistence: key structures
Command
Events
State
EventsEvents
Inside your persistent Actor:
Anatomy:
Anatomy:
Recovery, a first class concept:
Why bring cqrs along?
The world revolves around events:
command
command
command
eventevent
eventeventevent
event
state Snapshots | EventsRead-side
representation
queries
Read-side processing
Read-only command
And if you need to share facts
outside of your context boundary…
command
command
command
eventevent
eventeventevent
event
state Snapshots | Events
distributed
pub-sub Read-only command
Read-side representation
queries
Read-side processing
Service A Service B
Technology Implications
• The storage system becomes an additive only architecture
• Append-only architectures distribute
• Far fewer locks to deal with
• Horizontal Partitioning is difficult for a relational model
Business Implications
• Criteria is tracked from inception as an event stream
• You can answer questions form the origin of the system
• You can answer questions not asked yet!
• Natural audit log
Questions?
An Open Source framework for building micro service systems
Rate of change with levels of
abstraction
Low level languages
High level languages
Libraries / packages
Application Frameworks
Application Networking
System Building Frameworks
Rate of change Levels of abstraction
Shopping context
data data
eventsevents
events
Stateless Gateway
entity entity entity
state state state
Akka
Persistence
is focused
in the entity
commands
Web Application Framework
Concurrency Toolkit \ Runtime
Thin, powerful abstraction over
Microservice system framework
Other curated tools,
architectural
principles and
patterns used for
building reactive
microservice systems
Enterprise Challenge
Build faster
Maintain architectural integrity as you move fast
Enterprise software development is a high stakes game
Success is high reward, failure is high risk
Too Many Choices
Analysis Paralysis
Challenge
Lagom makes reasonable choices for
you.
It’s built on message-driven technology
that’s highly responsive, elastic and fault-
tolerant.
It’s Reactive.
Lagom Components
Akka – Persistence, PubSub, Cluster, Streaming Async Services
Play Framework – Web framework
Cassandra – managing data persistence
Guice – dependency injection
SLF4J & Logback – Logging
Typesafe Config – configuration
JSON Serialization – Play JSON (Scala) Jackson (Java)
Service Gateway
Message Broker - Kafka
Difficult to Consistently Scale
Architectural Integrity
Challenge
Lagom consistently applies
patterns for Reactive System
Building
Architectural Principles Enforced by Lagom
Single Responsibility
Principle
Service Oriented
Architecture
EncapsulationHexagonal
Architecture
Asynchronous
& Non
Blocking
Event
Sourcing
Command
query
responsibility
segregation
Eventual
Consistency
Domain
Driven Design(Bounded Contexts,
Context Maps, Aggregate
Entities)
Service
Locator
Discovery
Edge Service
Lagom Design Patterns
Key Patterns
Required
when building
distributed
reactive
microservice
systems
Circuit
Breaker
Example: Event Sourcing
Experts Required
Challenge
Experts Required
You don’t need “Lagom developers” just Scala or Java developers
willing to apply Lagom semantics.
Must Protect Developer
Productivity
Challenge
Practical Productivity
Scala
&
Java API
Use Any IDE
Quick Start
w/ Batteries
Included
Hot Reload
& Single
Command
to Runall
Developer
productivity
is a core
feature of
the
Framework
Unplanned Complexity or Chaos
Challenge
Monolith
with many
moving
parts.
You cannot simply
break the seal and
expect everything
to function correctly
Lagom minimizes chaos through
isolation, autonomous services
Lagom Encourages and Enables
You to Contain Mutable State &
Publish Facts
Example:
State contained
Publish Facts
Lagom Allows You to Untangle
Read & Write Models with CQRS &
Event Sourcing
Lagom uses asynchronous
messaging, asynchronous IO &
distributed persistence patterns
client
co
mm
and
co
mm
and
node
nodenode
node
Reactive programmingRES
Tmessaging streaming
Stateless Behavior
node
Reactive programming
Stateful Entity
Write model
event log
DS
Event
(fact)Event
(fact)
Read model
query db
DS
Event
(fact)
Event
(fact)
Service
discovery
Service
gateway
Authentication
…
command
command
command
Reactive S
yste
m
All or Nothing
This and Everything
Challenge
Lagom & your Legacy
• Language agnostic communication with external services
• Safe Interaction with legacy systems via circuit breakers
• No need to tear everything down and start over
• Embraces polyglot systems
With Withoutor
Governance, Templates, Ref Apps,
Documentation, scaling architecture
expertise, etc.
Boot
Reactor
Kafka
CassandraNetflix
Patternsasynchronous REST
streaming CQRS
Event Sourcing
Eventual consistency
DDD
Service locator
Java
Eventuate
Axon
Spring Cloud …
Play
AkkaKafka
CassandraScala
Patternsasynchronous REST
streaming CQRS
Event Sourcing
Eventual consistency
DDD
Service locator
Java
In Summary
In order to keep up with the pace of change and
maintain architectural integrity as you move, try
using a framework that provides an abstraction
above the application level – at the system level.
….and what if you don’t?
Try Lagom• www.lagomframework.com , https://github.com/lagom
• Basic example “Hello World” -
https://www.lagomframework.com/get-started-scala.html
• More robust example “Online Auction” -
https://github.com/lagom/online-auction-scala
• Ask me for a demo:
• Twitter: @kikisworldrace
Questions?
