Gentle introduction to Akka and its ecosystem on the shoulder of Scala. The slides were presented at the Backend Meetup Slovenia, June 2021.

1. Akka with Scala
Oto Brglez, June 2021
Gentle introduction to tomorrows tech Today.

2. Oto Brglez
• Engineering manager && Software Architect @ GWI
• R&D Stuff => 🚀
to 🌕
• Consultant / Founder @ OPALAB => epic.blog
• @otobrglez
bit.ly/oto-brglez-cv
* FB.com/groups/developerji

4. Do you use this stuff?

5. Yes.

6. What kind of problem are you
solving?

7. GET. NEW. DATA!

9. Pollpass
• Market Research platform with focus on
superior experience
• Conversations not surveys
• Real-time && distributed
• 16+ languages, X countries…
• Sophisticated scripting, routing and logic
• Expression engine, ASTs, piping etc…
• Enterprise grade and integrated

13. Future?

14. Voice

16. 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.
* How Actors Work?

17. Akka Actors

18. class PersonActor(firstName: String, lastName: String) extends Actor with ActorLogging {
override def receive: Receive = {
case "eat-ice-cream" =>
log.info(s"$firstName has started eating ice cream. ")
Thread.sleep(5.seconds.toMillis)
log.info(s"$firstName has eaten his ice cream. ")
}
}
object MainApp extends App {
val system = ActorSystem("first-system")
val kid1: ActorRef = system.actorOf(Props(classOf[PersonActor], "Rudi", "Brglez"), "rudi")
val kid2: ActorRef = system.actorOf(Props(classOf[PersonActor], "Tinkara", "Brglez"), "tinkara")
val me: ActorRef = system.actorOf(Props(classOf[PersonActor], "Oto", "Brglez"), "oto")
kid1 ! "eat-ice-cream"
kid1 ! "eat-ice-cream"
kid1 ! "eat-ice-cream"
kid2 ! "eat-ice-cream"
me ! "drink-beer"
}
Actor that
represents a
person 👉
“Main” 👉
}business logic
AS initialisation 👉
Spawning actors{
Sending messages{
More messages{

20. object Person {
trait PersonCommand
final case object EatIceCream extends PersonCommand
final case object FinishedEatingIceCream extends PersonCommand
def apply(firstName: String): Behavior[PersonCommand] = idle(firstName)
private def idle(firstName: String): Behavior[PersonCommand] =
Behaviors.receiveMessage[PersonCommand] {
case EatIceCream => eatingIceCream(firstName)
case _ => Behaviors.same
}
private def eatingIceCream(firstName: String): Behavior[PersonCommand] =
Behaviors.setup { context =>
Behaviors.withTimers[PersonCommand] { timers =>
context.log.info(s"$firstName has started eating his ice-cream. ")
timers.startSingleTimer(FinishedEatingIceCream, 3.seconds)
Behaviors.receiveMessage {
case FinishedEatingIceCream =>
context.log.info(s"$firstName is done with ice-cream. ")
idle(firstName)
case _ =>
context.log.info(s"$firstName: Sorry, I'm still eating,...")
Behaviors.same
}
}
}
}
“Idle state” 👉
“Eating state” 👉
Commands {

21. object Family {
sealed trait FamilyCommand
final case class AddPerson(firstName: String) extends FamilyCommand
final case class EatCake(firstName: String) extends FamilyCommand
def apply(): Behavior[FamilyCommand] = Behaviors.receive {
case (context, AddPerson(firstName)) =>
context.spawn(Person(firstName), firstName)
Behaviors.same
case (context, EatCake(firstName)) =>
context.child(firstName)
.map(_.asInstanceOf[ActorRef[Person.PersonCommand]])
.foreach(ref => ref ! Person.EatIceCream)
Behaviors.same
case _ => Behaviors.unhandled
}
}
Commands {
Child is created 👉
“EatIceCream” is sent to
child with given name 👉

22. object MainApp extends App {
val system = ActorSystem[Family.FamilyCommand](Family(), "family")
system ! Family.AddPerson("Rudi")
system ! Family.AddPerson("Tinkara")
system ! Family.AddPerson("Oto")
system ! Family.EatCake("Rudi")
system ! Family.EatCake("Tinkara")
system ! Family.EatCake("Rudi")
system ! Family.EatCake("Tinkara")
system ! "drink beer!"
}
👈 💥
Won’t actually compile since AkkaTyped required
proper types and Scala compiler won’t allow this “String”!

23. Akka Streams

24. The Weather
Temperature
Example ☀
💥 Network Problems
💥 500 Error
💥 Missing tag!
💥 Out of memory
💥 Recipient is br0ken
Network is still down!!! 💥

25. object MainApp extends LazyLogging {
def main(args: Array[String]): Unit = {
implicit val system: ActorSystem = ActorSystem("temperature-system")
import system.dispatcher
val changeDetector: ActorRef = system.actorOf(Props(classOf[ChangeDetector]), "change-detector")
Source.tick(1.seconds, 2.seconds, "Tick")
.mapAsync(1) { _ => getMeasurement }
.alsoTo(Sink.foreach(v => logger.info(s"Latest measurement is ${v.getOrElse("none")} ")))
.mapAsync(1)(measurement => changeDetector.ask(measurement)(1.second))
.collect { case change: ChangeDetector.Changed => change }
.runWith(Sink.foreach(change =>
logger.info(s"Temperature change from ${change.from} to ${change.to}, ${direction(change)}.")))
}
private def getMeasurement(implicit system: ActorSystem, ec: ExecutionContext): Future[Measurement] =
for {
response <- Http().singleRequest(HttpRequest(uri = ARSOLjubljanaURL))
nodes <- Unmarshal(response.entity).to[NodeSeq]
measurement = (nodes "t").headOption.flatMap(_.text.toDoubleOption)
} yield measurement
private val direction: ChangeDetector.Changed => String = {
case ChangeDetector.Changed(from, to) if to > from => "up "
case ChangeDetector.Changed(from, to) if to < from => "down "
case _ => "impossible."
}
}
Every 2 seconds send “Tick” 👉
Execute request to Web Service 👉
In parallel write to output 👉
“Ask” actor to detect changes 👉
Only care about actual “changes” 👉
Run and see the changes 👉
This part is for issuing
request, dealing with
response and XML parsing
{

26. val getMeasurementsFlow: Flow[String, Measurement, NotUsed] =
RestartFlow.onFailuresWithBackoff(RestartSettings(10.seconds, 30.seconds, 0.3)) { () =>
Flow[String].mapAsyncUnordered(1) { _ => getMeasurement }
}
Source.tick(1.seconds, 2.seconds, "Tick")
.via(getMeasurementsFlow)
.alsoTo(Sink.foreach(v => logger.info(s"Latest measurement is ${v.getOrElse("none")} ")))
.mapAsync(1)(measurement => changeDetector.ask(measurement)(1.second))
.collect { case change: ChangeDetector.Changed => change }
.runWith(Sink.foreach(change =>
logger.info(s"The temperature has changed. From ${change.from} to ${change.to}, ${direction(change)}.")))
Pass “Tick” to Flow 👉
This Flow is
restarted if
failures occur 👉

28. Akka HTTP*

29. Alpakka
• Data transformation: Parsing lines, JSON Framing, Compression, CSV, Text transcoding,
encoding etc…
• AMQP, Apache Camel, Apache Cassandra, Apache Geode, Apache Kafka, Apache Kudu,
Apache Solr, Avro Parquet, AWS EventBridge, AWS DynamoDB, AWS Kinesis and
Firehose, AWS Lambda, AWS S3, AWS SNS, AWS SQS, Azure Event Hubs, Azure IoT Hub,
Azure Storage Queue, Couchbase, Elasticsearch, Eventuate, File, FS2, FTP, Google
Common, Google Cloud BigQuery, Google Cloud Pub/Sub, Google Cloud Pub/Sub
gRPC, Google Cloud Storage, Google FCM, gRPC, Hadoop Distributed File System -
HDFS, HBase, HTTP, IBM Bluemix Cloud Object Storage, IBM Db2 Event Store, InfluxDB,
IronMQ, JMS, MapR Database, MongoDB, MQTT, MQTT Streaming, OrientDB, Pulsar,
Pravega, Server-sent Events (SSE), Slick (JDBC), Spring Web, TCP, UDP, Unix Domain
Socket, … + more

30. Akka Persistance

31. class SurveyActor(id: UUID) extends PersistentActor with ActorLogging {
override def persistenceId: String = id.toString
var survey: Survey = Survey()
def updateState(event: Event): Unit = {
event match {
case NameSet(name) =>
survey = survey.copy(name = Some(name))
case TextNodeAppended(name) =>
survey = survey.copy(nodes = survey.nodes ++ List(Text(name)))
}
}
override def receiveRecover: Receive = {
case event: Event => updateState(event)
case SnapshotOffer(_, surveySnapshot: Survey) =>
survey = surveySnapshot
}
override def receiveCommand: Receive = {
case SetName(name) =>
persist(NameSet(name)) { event =>
updateState(event)
context.system.eventStream.publish(event)
}
case AppendTextNode(name) =>
persist(TextNodeAppended(name)) { event =>
updateState(event)
context.system.eventStream.publish(event)
}
case GetSurvey =>
sender() ! survey
}
}
sealed trait Command
sealed trait Event
case class SetName(name: String) extends Command
case class NameSet(name: String) extends Event
case class AppendTextNode(name: String) extends Command
case class TextNodeAppended(name: String) extends Event
case object GetSurvey extends Command
final case class Survey(
name: Option[String] = None,
nodes: List[Node] = List.empty[Node])
sealed trait Node
case class Text(name: String) extends Node
object MainApp extends App {
val system: ActorSystem = ActorSystem("surveys")
import system.dispatcher
val s1 = system.actorOf(Props(classOf[SurveyActor], UUID.randomUUID()))
s1 ! SetName("This is my first example")
s1 ! SetName("First Survey V1")
s1 ! AppendTextNode("Hello!")
s1 ! AppendTextNode("This is example of Akka Persistence.")
s1 ! SetName("Short name")
s1.ask(GetSurvey)(20.seconds).onComplete {
case Success(value: Survey) =>
println(value.asJson)
}
}
Execute commands
and persist events
👉
State from events
👉
Recovery and
snapshots
👉

32. Akka Cluster + Discovery

35. Please, give it a try!
@otobrglez
otobrglez@gmail.com
meetup.com/sugslo
scalaslovenia.slack.com