Akka 2.4 plus commercial features in Typesafe Reactive Platform

Akka 2.4.x
and
Commercial Features
1 September 2015
Akka 2.4 and RP commercial features
with Konrad `@ktosopl` Malawski

Konrad `ktoso` Malawski
Akka Team,
Reactive Streams TCK

Reactive Platform: Akka
• Reactive Platform: Versioning explained
• Remoting / Cluster: Docker networking support
• Cluster: Split Brain Resolver (beta)
• Akka Persistence: Cross-Scala-version snapshot deseriali
• Java 6: Extended LTS
• Akka 2.4.x (currently in Release Candidate phase)
• Cluster Tools promoted to stable!
• Persistence promoted to stable!
• Persistence Queries (experimental)
• Akka Typed (experimental)
• Distributed Data (experimental)
• Akka Streams (currently 1.0, will be included in 2.4.x eventually)
• Q / A

Reactive Platform

Reactive Platform
https://together.typesafe.com/products/reactivePlatform

Reactive Platform Versioning
15v05p01
year
month
patch
=
Scala 2.10.x
Akka 2.3.x
…

15v05p01
year
month
patch
=
Scala 2.10.x
Akka 2.3.x
…
15v09p01 =
Scala 2.11.x
Akka 2.3.12 => 2.3.++ (binary compatible!)
…

How does this help?
• Huge integration test suite before release
• Certified to work well together
• Priority updates / additional features
• Back-ports, fixes, long-term support
Life cycle of each release: 2 years

NAT Support

support
(NAT support)

support
(NAT support)
Available in:
RP 15v01p## (Akka 2.3.x),
OSS only in Akka 2.4.x (work in progress)

Docker / NAT support
docker run -d -p 8000:2551 akka-app
Akka App
172.17.0.11:2551
Outside world
example.com:8000
doc.akka.io/docs/akka/2.4.0-RC1/general/remoting.html#Peer-to-Peer_vs__Client-Server

Docker / NAT support
akka.remote {
netty.tcp {
hostname = example.com # external (logical) hostname
port = 8000 # external (logical) port
bind-hostname = 172.17.0.11 # internal (bind) hostname
bind-port = 2552 # internal (bind) port
}
}
doc.akka.io/docs/akka/2.4.0-RC1/general/remoting.html#Peer-to-Peer_vs__Client-Server

Split Brain Resolver

Split Brain Resolver (customer beta)
Installing the Reactive Platform with Split Brain Resolver

• Fundamental Problem in all distributed systems
• SBR helps to make decisions, is not a magic wand
• A set of pre-built strategies
for when to down nodes in a cluster.
• Strategies:
• Static Quorum (like zoo-keeper)
• Keep Majority
• Keep Oldest
• Keep Referee
http://doc.akka.io/docs/akka/rp-15v09p01/scala/split-brain-resolver.html

• The default behaviour of Akka Cluster is “Manual Downing”:
• A node needs to issue cluster.down(address)
• This decision can be powered by external monitoring,
or DevOps teams observing the cluster.
• It is Safe.
however involves the most human/automated work
• A naive implementation exists called “auto-downing”
• It is not very safe to be used in real clusters
• Definitely not a good choice for apps using Persistence
• It is not recommended for production deployments.
http://doc.akka.io/docs/akka/rp-15v09p01/scala/split-brain-resolver.html

Heartbeats
A

Heartbeats
A
everyone is down!

Heartbeats
A
`n-1` is down!
I’ll take over `A`!

Heartbeats
A
`n-1` is down!
I’ll take over `A`!
A
good if: n-1 really is down.
bad: if n-1 is just very unresponsive
Fundamentally, it is hard to distinguish the two states in distributed systems.

Static Quorum (3 (> (n/2 +1))
A

Static Quorum (3 (> (n/2 +1))
we need to down
ourselves
A

Keep Majority (aka. dynamic quorum)
A

Keep Majority (aka. dynamic quorum)
A
we need to down
ourselves

referee node
Keep Referee
A
down-all-if-less-than-nodes

referee node
Keep Referee
A
can’t see referee node!
down-all-if-less-than-nodes

oldest node
Keep Oldest
A
can’t see oldest node!
down-if-alone
oldest node can change,
if “up until now oldest node” leaves the
cluster.
This is more dynamic than keep-referee.

Persistence
Cross-scala-version
compatibility for snapshots

Persistence: Cross-scala-version compat
Enhanced compatibility for persistent snapshot envelope.
(Payload compatibility depends on application.)

• Scala 2.10 is not binary compatible with 2.11
• 10 => 11 is “major update” by design

• More compatible deserialisation than the language
itself!
• Eases migration to latest Scala versions
• (Your journal may actually not be affected and be compatible
anyway.)
• Scala 2.10 is not binary compatible with 2.11
• 10 => 11 is “major update” by design

saveSnapshot( )
Akka 2.3 + Scala 2.10

saveSnapshot( )
loadSnapshot

Java 6
Extended LTS

Java 6: Extended LTS
• Existing RP releases keep Java 1.6 compatibility

• Akka Streams & Http currently work with 1.6
• will be merged into Akka 2.4 (likely after 1.1)
• we can back-port and support for RP (Akka 2.3)

• Akka Streams & Http currently work with 1.6
• will be merged into Akka 2.4 (likely after 1.1)
• we can back-port and support for RP (Akka 2.3)
• Akka 2.4 does require Java 8
• Scala 2.11 + Scala 2.12 (once released)
• it will enter RP once released

Akka 2.4

Akka 2.4
• 2.3 => 2.4 is a major update
• additional effort made it binary compatible!
• it does require Java 1.8
• i.e. update your JDK, same sources “just work”
• Future:
• Version bump to 3.0 if binary incompatible

Cluster Tools
Now Stable!

Akka 2.4 Cluster Tools (Now Stable!)
• Distributed Pub Sub
• Smart message batching (1 send per node)
• Cluster Singleton
• useful for “master” or coordinator Actors
• Cluster Sharding
• useful for sharding load onto the cluster
• graceful shut-down
• balancing load across cluster

doc.akka.io/docs/akka/2.4.0-RC1/scala/distributed-pub-sub.html
class Subscriber extends Actor with ActorLogging {
import DistributedPubSubMediator.{ Subscribe, SubscribeAck }
val mediator = DistributedPubSub(context.system).mediator
// subscribe to the topic named "content"
mediator ! Subscribe("content", self)
def receive = {
case SubscribeAck(Subscribe("content", None, `self`)) ⇒
context become ready
}
def ready: Actor.Receive = {
case s: String ⇒
log.info("Got {}", s)
}
}
Akka 2.4 Cluster Tools - PubSub (Now Stable!)

class Publisher extends Actor {
import DistributedPubSubMediator.Publish
// activate the extension
val mediator = DistributedPubSub(context.system).mediator
def receive = {
case in: String ⇒
val out = in.toUpperCase
mediator ! Publish("content", out)
}
}
doc.akka.io/docs/akka/2.4.0-RC1/scala/distributed-pub-sub.html
Akka 2.4 Cluster Tools - PubSub (Now Stable!)

A
B
C D
http://doc.akka.io/docs/akka/2.4.0-RC1/scala/cluster-singleton.html
Akka 2.4 Cluster Tools - Cluster Singleton (Now Stable!)

A
B
C
D
role: backend-2 role: backend-2
http://doc.akka.io/docs/akka/2.4.0-RC1/scala/cluster-singleton.html
Akka 2.4 Cluster Tools - Cluster Singleton (Now Stable!)

Akka 2.4 Cluster Tools - Sharding (Now Stable!)
A B
C
D
doc.akka.io/docs/akka/2.4.0-RC1/scala/cluster-sharding.html

Akka 2.4 Cluster Tools - Sharding (Now Stable!)
val counterRegion: ActorRef = ClusterSharding(system).start(
typeName = "Counter",
entityProps = Props[Counter],
settings = ClusterShardingSettings(system),
extractEntityId = extractEntityId,
extractShardId = extractShardId)
val counterRegion: ActorRef =
ClusterSharding(system).shardRegion("Counter")
counterRegion ! Get(123)
expectMsg(0)
Start a shard region:
Other nodes in cluster send messages to it:
doc.akka.io/docs/akka/2.4.0-RC1/scala/cluster-sharding.html

Persistence
Now Stable!

var state = S0
persistenceId = “a”
Command
Journal
Akka 2.4 Persistence (Now Stable!)

var state = S0
Journal
Generate Events

var state = S0
Journal
Generate Events
E1

ACK “persisted”
Journal
E1
var state = S0

“Apply” event
Journal
E1
var state = S0
E1

Journal
E1
var state = S0
E1
Okey!

Journal
E1
var state = S0
E1
Ok, he got my $.

…sum of states…
Journal
E1 E2 E3 E4
E5 E6 E7 E8

Snapshot Store
snapshot!
state until [E5]
S5Journal
E1 E2 E3 E4
E5 E6 E7 E8

Snapshot Store
state until [E8]
S8Journal
E1 E2 E3 E4
E5 E6 E7 E8
S5

state until [E8]
S8
Snapshot Store
Journal
E1 E2 E3 E4
E5 E6 E7 E8
crash!
S5

Snapshot Store
Journal
E1 E2 E3 E4
E5 E6 E7 E8
crash!
S5

“bring me up-to-date!”
Snapshot Store
Journal
E1 E2 E3 E4
E5 E6 E7 E8
restart!
replay!
S5

“bring me up-to-date!”
Snapshot Store
restart!
replay!
S5
Journal
E1 E2 E3 E4
E5 E6 E7 E8
S5

state until [E8]
Snapshot Store
S5
restart!
replay!
S8
Journal
E1 E2 E3 E4
E5 E6 E7 E8

Advanced support for long-term schema evolution.
EventAdapters & StringManifestSerializers

Persistence Query
New module, experimental!

Akka 2.4 Persistence Queries (experimental)
API still work in progress, should be polished very soon.
val query: Source[RichEvent, QueryStats] =
readJournal.query(ByTagsWithStats(Set("red", "blue")))
query
.map { event => s"Event payload: ${event.payload}" }
.runWith(Sink.ignore)

Akka 2.4 Persistence Queries (experimental)
API still work in progress, should be polished very soon.
val query: Source[RichEvent, QueryStats] =
readJournal.query(ByTagsWithStats(Set("red", "blue")))
query
.map { event => s"Event payload: ${event.payload}" }
.runWith(Sink.ignore)
Journalwrite-side query-side
Query
Optimised
Journal
Simple view / result

Akka Typed

doc.akka.io/docs/akka/2.4.0-RC1/scala/typed-actors.html
class Greeter extends Actor {
def receive = {
case msg: Greet ⇒
println(s"Hello ${msg.whom}!")
sender() ! Greeted(msg.whom)
}
}
val system: ActorSystem =
ActorSystem(“akka-actor-system“)
val greeter =
system.actorOf(Props[Greeter])
system ! Greet("kapi", system.deadLetters)
Akka Actor
Akka 2.4 Typed (experimental)

val greeter = Total[Greet] { msg ⇒
msg.replyTo ! Greeted(msg.whom)
Same
}
val system: ActorSystem[Greet] =
ActorSystem(“typed", Props(totalGreeter))
def receive = {
case msg: Greet ⇒
}
}
val greeter =
Akka Actor Akka Typed

Same
}
def receive = {
case msg: Greet ⇒
}
}
val greeter =
The main concept is Behaviour[T]
Explicit protocols for the win!

Same
}
def receive = {
case msg: Greet ⇒
}
}
val greeter =
Since Behaviour[Greet] is typed,
msgis-a Greet.

Same
}
def receive = {
case msg: Greet ⇒
}
}
val greeter =
The Behaviour[T]is the receive.

Same
}
def receive = {
case msg: Greet ⇒
}
}
val greeter =
sender()is no more.

Same
}
def receive = {
case msg: Greet ⇒
}
}
val greeter =
sender()is no more.
final case class Greet(whom: String, replyTo: ActorRef[Greeted])

Same
}
def receive = {
case msg: Greet ⇒
}
}
val greeter =
ActorRef[T]is now typed!

Same
}
def receive = {
case msg: Greet ⇒
}
}
val greeter =
become()is required.
And replaced by returning the “next” Behaviour[T]
// context.become(receive)

Same
}
def receive = {
case msg: Greet ⇒
}
}
val greeter =
On a conceptual level at least,
we provide Static[T]if you don’t need become.

Same
}
def receive = {
case msg: Greet ⇒
}
}
val greeter =
Special behaviors:
Same / Unhandled / Empty / Stopped / Ignore

Same
}
def receive = {
case msg: Greet ⇒
}
}
val greeter =
“Root actor” is not user-defined for ActorSystem[T]
Encourages thinking about supervision.

Akka Distributed Data

Akka 2.4 Distributed Data (experimental)
for “small, fast data”
Implements various CRDTs and gossips changes through the
Cluster.
CRDTs = Conflict-free Replicated Data Types
Data structures that can be concurrently updated
and always eventually converge on the same value.
doc.akka.io/docs/akka/2.4.0-RC1/scala/distributed-data.html

value = 5
n1: 2
n2: 0
n3: 3
Akka Cluster (gossip)
GCounter example:
value = 5
n1: 2
n2: 0
n3: 3
value = 5
n1: 2
n2: 0
n3: 3
node-1 node-2
node-3

value = 6
n1: 2+1
n2: 0
n3: 3
GCounter example:
value = 5
n1: 2
n2: 0
n3: 3
value = 6
n1: 2
n2: 0
n3: 3+1
node-1 node-2
node-3

node-1 node-2
node-3
value = 7
n1: 2+1
n2: 0
n3: 3+1
GCounter example:
value = 5
n1: 2
n2: 0
n3: 3
value = 6
n1: 2
n2: 0
n3: 3+1

node-1 node-2
node-3
value = 7
n1: 2+1
n2: 0
n3: 3+1
GCounter example:
value = 7
n1: 2+1
n2: 0
n3: 3+1
value = 7
n1: 2+1
n2: 0
n3: 3+1

implicit val node = Cluster(system)
val replicator = DistributedData(system).replicator
val Counter1Key = PNCounterKey("counter1")
replicator ! Update(Counter1Key, PNCounter(), WriteLocal)(_ + 1)

Provided data types:
• Counters: GCounter, PNCounter
• Sets: GSet, ORSet
• Maps: ORMap, ORMultiMap, LWWMap, PNCounterMap
• Registers: LWWRegister, Flag

Akka Streams & Http
1.0 (experimental) currently.
will join the Akka 2.4.x release.

Akka Streams & Http (experimental, to eventually join Akka 2.4.x)
Akka Streams
Asynchronous Back-pressured Stream Processing
An implementation of Reactive Streams.
Reactive Streams
an initiative co-lead by Typesafe, Netflix, Pivotal, RedHat),
allowing for inter-op of asynchronous streaming libraries.
Akka Http
Superseeds Spray.io, the well known high-performance Http serv
Fully based on Akka Streams.
http://doc.akka.io/docs/akka-stream-and-http-experimental/1.0/scala.html

http://www.reactive-streams.org/
Reactive Streams (1.0, en route to be included in JDK9)

Akka Streams <-> Actors – Advanced
val subscriber = ActorSubscriber(
system.actorOf(Props[SubStreamParent], ”parent”)
)
Source(1 to 100)
.map(_.toString)
.filter(_.length == 2)
.drop(2)
.conflate(seed => seed)((acc, i) => acc + i)
.groupBy(_.last)
.runWith(subscriber)
All the usual ops available for Linear Flows.
http://doc.akka.io/docs/akka-stream-and-http-experimental/1.0/scala.html

Links
• akka.io
• reactive-streams.org
• akka-user
• https://www.typesafe.com/subscription
• Streams and Http
• http://doc.akka.io/docs/akka-stream-and-http-
experimental/1.0/scala.html
• http://doc.akka.io/docs/akka-stream-and-http-
experimental/1.0/java.html
• Akka 2.4 RC1
• http://doc.akka.io/docs/akka/2.4.0-RC1/scala.html
• http://doc.akka.io/docs/akka/2.4.0-RC1/java.html

Perhaps you’d also like…
WEBINAR
Introducing Typesafe
ConductR
WATCH NOW
HAVE QUESTIONS?
Get in touch with
Typesafe today!
CONTACT US
ACTIVATOR TEMPLATE
Akka Distributed
Data Samples (Scala)
CHECK IT OUT

EXPERT TRAINING
Delivered on-site for Akka, Spark, Scala and Play
Help is just a click away. Get in touch
with Typesafe about our training courses.
• Intro Workshop to Apache Spark
• Fast Track & Advanced Scala
• Fast Track to Akka with Java or
Scala
• Fast Track to Play with Java or Scala
• Advanced Akka with Java or Scala
Ask us about local trainings available by
24 Typesafe partners in 14 countries
around the world.
CONTACT US Learn more about on-site training

Akka 2.4 plus commercial features in Typesafe Reactive Platform

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (12)

Similar to Akka 2.4 plus commercial features in Typesafe Reactive Platform

Similar to Akka 2.4 plus commercial features in Typesafe Reactive Platform (20)

More from Legacy Typesafe (now Lightbend)

More from Legacy Typesafe (now Lightbend) (14)

Recently uploaded

Recently uploaded (20)

Akka 2.4 plus commercial features in Typesafe Reactive Platform

Editor's Notes