Learning Akka

Explore actors to see how Akka handles concurrency
Build a fault-tolerant system from the ground up
Understand the key concepts through real-life scenarios

Learning
Explore Akka's version of the actor model
Find out how actors solve concurrency problems
Build applications using Akka’s basic tools
Master different techniques to route messages to the actors in Akka
Change actor behavior on runtime using Become/Unbecome and FSM
Build stateful actors with Akka Persistence
Create your first cluster and discover how it can be used to build a fault-tolerant system
Use various techniques for testing an actor
Set up a stream system to work with Big Data
Expose your application to the web using Akka HTTP
See common actor development patterns in Akka

About
Akka helps you to build scalable, resilient, and fault-tolerant distributed systems that can provide outstanding performance on local machines as well as over remote networks. Employing the actor model, it is possible to leverage these lightweight entities to program highly available, high performance applications. It delivers a powerful scaffolding that can be used to delegate remoting, service failures, and load management so that you can focus solely on your system logic.

Learning Akka delivers a clear and practical introduction to the Akka toolkit, explaining the key components you need to know to get up and running with developing applications of your own.

We will start by looking at the actor model and how it solves concurrency problems. You will learn about the actor system, how to create hierarchical structures in Akka, and how to make routes in order to send messages to other actors. We will look at other use cases such as building an actor that can change its behavior during runtime. You will then create stateful actors, work with a cluster system, and work with remote actors. This course will also take you through testing the application with Akka testkit and making applications available over the web with Akka HTTP. Finally, we’ll employ best practices and you’ll get to know the common actor patterns used for development with Akka.

By the end of this course, you’ll have a great foundation in Akka that will enable you to develop excellent applications and services with the toolkit.

Style and Approach
This video course delivers a methodical, step-by-step explanation of the major components of the Akka toolkit through practical code examples. We put everything together in the last stretch of the course to show you how Akka works in the wild.
Exploring the Actor World
The Course Overview
Understanding the Actor Model
Concepts and Terminology
Let's Create Hello World
Playing with Actors
Actor System and Hierarchical Structure
Actor Components and Lifecycle
Creating an Actor with Props
Talking to an Actor
Supervision and Monitoring
Working with Akka Basic Tools
ActorRef Versus Actor Path Versus Actor Selection
Sending Messages via Router
Replacing Actor Behavior via become/unbecome
Replacing Actor Behavior via FSM
Akka Persistence
Introduction to Akka Persistence
Creating Persistent Actors
Playing with a Persistent Actor
Persistence FSM
Persistence Query
Working with Akka Cluster
Playing with Remote Actors
Building a Cluster
Adding Load Balancer to a Cluster Node
Creating a Singleton Actor in the Cluster
Cluster Sharding
Testing Actors
How to Test an Actor?
Testing a Parent-child Relationship
Testing FSM
Multi Node Testing
Working with Akka Streams
Introduction to Akka Streams
Reactive Tweets
Testing Streams
Working with Graphs
Working with Stream IO
Working with Akka HTTP
Introduction to Akka HTTP
Working with Client-side API
Working with Server-side API
Let's Implement a REST API
Let's Test Our REST API
Working with common Patterns in Akka
Balancing Workload Across Nodes
Throttling Messages
Shutdown Patterns
Ordered Termination
Scheduling Periodic Messages

Видео Learning Akka канала Tea Time