Learning Akka

Explore the Akka toolkit to build highly scalable and robust applications
3.9 (67 ratings) Instead of using a simple lifetime average, Udemy calculates a
course's star rating by considering a number of different factors
such as the number of ratings, the age of ratings, and the
likelihood of fraudulent ratings.
417 students enrolled
$19
$75
75% off
Take This Course
  • Lectures 42
  • Length 3.5 hours
  • Skill Level Beginner Level
  • Languages English
  • Includes Lifetime access
    30 day money back guarantee!
    Available on iOS and Android
    Certificate of Completion
Wishlisted Wishlist

How taking a course works

Discover

Find online courses made by experts from around the world.

Learn

Take your courses with you and learn anywhere, anytime.

Master

Learn and practice real-world skills and achieve your goals.

About This Course

Published 2/2016 English

Course Description

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.

About The Author

Salma is a senior software engineer with over 5 years of professional experience in development and deploying applications on the JVM using both functional and object-oriented paradigms including Scala and Java. She is specialized in designing and engineering real-time applications and distributed systems based on Akka and using frameworks and libraries like Play2, Thrift, Vertx, Django, Rails, and multiple SQL and NoSQL storage systems, for example MongoDB, Cassandra, Neo4J, Elasticsearch, and PostgreSQL.

She contributed in architecting and implementing a large real-time platform based on Akka cluster and WebSockets. She has gained experience in leading a number of agile teams to the successful delivery of several key projects.

Now, She is working on Big data application and contributing in architecting and implementing the core system based on Scala and Akka.

What are the requirements?

  • 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.
  • Software version required: Akka 2.x

What am I going to get from this course?

  • 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

What is the target audience?

  • For Scala developers who are interested in building concurrent, scalable, and fault-tolerant applications with Akka, this course delivers the knowledge needed to do just that.

What you get with this course?

Not for you? No problem.
30 day money back guarantee.

Forever yours.
Lifetime access.

Learn on the go.
Desktop, iOS and Android.

Get rewarded.
Certificate of completion.

Curriculum

Section 1: Exploring the Actor World
03:22

This video provides an overview of the entire course.

03:20

To start working with Akka and Actors, we need to understand what the Actor Model is and why we use the Actor Model on concurrent programs

04:06

To get our hands dirty with web development in Akka, we first need to get ourselves introduced to Akka concepts and terminologies.

03:23

In this video, we'll take our first steps in creating our first Akka project.

Section 2: Playing with Actors
04:35

In this video, we will talk about Actor System and the structure for actors to understand the actor relationships better.

03:36

Like us, every actor has different stages and phases it goes through. We need to master them before going ahead and implementing them in our workflow.

04:12

We've been introduced to the lifecycle; now let's take this a step further and understand actor creation.

04:57

Communication between actors is what we'll be looking at in this video.

06:00

We saw how communication between actors works, but let's take a deeper look at dependency relationships and failure responses in this video.

Section 3: Working with Akka Basic Tools
05:03

To be able to work with actors, we need to grasp the basics of how to identify and locate actors. In this video, we will see these methods to do just that.

05:47

It is important to ensure that a sent message reaches its intended destination without any errors. To know this functionality better, let's get introduced to routing in Akka.

04:48

We've now come to a stage where it is important to understand change in actor behavior at runtime. We'll do this using become and unbecome.

04:47

Let's jump to the next method of changing actor behavior at runtime — FSM.

Section 4: Akka Persistence
04:27

To increase the efficiency of our actors, we need to understand persistence in Akka. This video is dedicated to get us started on the persistence front.

04:26

Let's see how to implement persistence in Akka by implementing a Persistent Actor in this video.

04:21

The power of persistence lies in how we can recover the state of our actors. Let's play around with snapshots and the recovery mode to understand them better.

06:18

As we go ahead, let's look at the implementation of Persistent Actor that can replace its behavior via FSM.

04:24

Persistence Query is powerful enough to fulfill the query needs of our app. Let's get introduced to it in this video.

Section 5: Working with Akka Cluster
05:26

In real life, your application might get divided in multiple nodes. For this, we need to deal with remote actors.

06:10

In Scala projects, you need to design your application across a cluster. To do this, we will introduce the Akka cluster and build a simple cluster.

03:09

In your cluster, you need to balance work over nodes. So, we will introduce how we can add load balancer to your cluster.

05:45

In some cases, you want to run instances from specific actors. To do so, we will introduce a Cluster Singleton.

05:49

Sometimes, you have many stateful actors that together consume more resources, so you need to distribute them across several nodes in the Cluster without having to care about their physical location in the Cluster.

Section 6: Testing Actors
05:44

The Actor class is not like a normal class and actors do their work asynchronously. So, we can't test it like a normal class. Hence, we will introduce some ways to test the actor logic.

03:26

When you have parent and child actors, you need to test each actor without another actor. So, we will introduce a dependency-injection to test the parent and child actor.

04:24

When you have an FSM actor in your application, you want to test if you implement state machine correctly or not. So, we will introduce how to test the FSM actor logic.

06:31

When you implement remote actor's runs on different nodes, you want to test how these nodes will act. So we will introduce Multi Node test kit.

Section 7: Working with Akka Streams
05:37

When you start dealing with processing big data, you will face two main problems, Blocking and Back pressure. So, we will introduce Akka Streams to solve your problems.

04:54

To understand the Akka Stream, we will implement the reactive tweets application.

06:02

We want to write unit tests for any code line you wrote. So, we will introduce different ways to test your streams.

04:56

Not everything can be expressed as a linear sequence of Akka streams. So, we will introduce Flow Graphs.

04:16

If you want to use files as a source or sink, we will introduce Akka Stream IO.

Section 8: Working with Akka HTTP
04:04

In some cases, we want your application to interact with the external world. So, we will introduce the Akka HTTP Module.

05:58

In some cases, your application needs to consume data from external services. So, we will introduce the Akka HTTP Client-side API and the different levels on it.

05:01

In some cases, your application wants to provide services for the external world. So, we will introduce the Akka HTTP Server-side API and the different levels on it.

05:04

To understand the server-side API. We will implement more complex examples.

03:31

When you provide a service for the external world, you will need to implement test cases for it. So, we will implement test cases for our REST API that was implemented in the previous video as an example of how to use the akka-http-test kit.

Section 9: Working with Common Patterns in Akka
05:34

In this video, we will introduce Balancing Workload Across Nodes pattern.

04:26

What if your application sends HTTP requests to an external service and you want to limit the number of requests during a specific period? Here, we will introduce the Throttling Messages pattern to control the rate of messages sent.

03:26

In Akka, we don't have a flag, configuration setting, or callback function; we can register for it to tell Akka to shutdown the actor system when the app is finished. We will introduce the pattern to control when the actor system should terminate.

03:45

What if you have children actors and you want to terminate them on a specific order after the parent terminated? We will introduce the Ordered Termination pattern.

02:57

If you want to schedule messages that send every interval in actor, we will introduce the scheduling periodic messages pattern.

Students Who Viewed This Course Also Viewed

  • Loading
  • Loading
  • Loading

Instructor Biography

Packt Publishing, Tech Knowledge in Motion

Over the past ten years Packt Publishing has developed an extensive catalogue of over 2000 books, e-books and video courses aimed at keeping IT professionals ahead of the technology curve. From new takes on established technologies through to the latest guides on emerging platforms, topics and trends – Packt's focus has always been on giving our customers the working knowledge they need to get the job done. Our Udemy courses continue this tradition, bringing you comprehensive yet concise video courses straight from the experts.

Ready to start learning?
Take This Course