Learning Path: Akka: Building Applications and Microservices
3.1 (12 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.
145 students enrolled
Wishlisted Wishlist

Please confirm that you want to add Learning Path: Akka: Building Applications and Microservices to your Wishlist.

Add to Wishlist

Learning Path: Akka: Building Applications and Microservices

Embrace yourself to learn the art of creating applications and microservices with Akka
3.1 (12 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.
145 students enrolled
Created by Packt Publishing
Last updated 8/2017
English
Current price: $10 Original price: $200 Discount: 95% off
5 hours left at this price!
30-Day Money-Back Guarantee
Includes:
  • 4.5 hours on-demand video
  • 1 Supplemental Resource
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
What Will I Learn?
  • Explore Akka's version of the actor model
  • Find out how actors solve concurrency problems
  • Build stateful actors with Akka Persistence
  • Create microservices using Akka HTTP
  • Write performance tests for your microservices
View Curriculum
Requirements
  • Knowledge of Java and Scala
Description

If you’re looking at building distributed, concurrent, fault-tolerant and scalable applications with ease, Akka is the go-to tool for it.

Akka written in Scala, helps you build distributed systems that provides outstanding performance on local machines as well as over remote networks.

Akka: Building Applications and Microservices with Akka is Packt’s Video Learning Path that is a series of individual video products put together in a logical and stepwise manner such that each video builds on the skills learned in the video before it.

This Learning Path 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. 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.

Then, this Learning Path will make you understand how to build Reactive microservices using Akka and Akka HTTP, which adhere to the principles underlying the Reactive Manifesto. You will delve deeper into concepts such as Responsive, Resilient, Elastic, and Message-Driven and will see how microservices should be designed to adhere to those principles. By the end of this Path, you’ll be well-versed in creating applications and microservices.

The goal of this course is to make you efficient at building applications and microservices with Akka.

This Learning Path is authored by some of the best in the field.

Salma Khater 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, Spray. io, Thrift, Vertx, Django, Rails, and multiple SQL and NoSQL storage systems, for example  MongoDB, Cassandra, Neo4J, Elasticsearch, and PostgreSQL.

Tomasz Lelek is a Software Engineer and Co-Founder of initLearn. He mostly does programming in Java and Scala. He dedicates his time and energy to being better at everything. He is now delving into Big Data Technologies. He is very passionate about everything associated with software development.

Who is the target audience?
  • If you’re a Scala developer looking forward to building distributed, concurrent, fault-tolerant and scalable applications with ease, then this Video Learning Path is for you.
Students Who Viewed This Course Also Viewed
Curriculum For This Course
55 Lectures
04:41:20
+
Learning Akka
42 Lectures 03:17:46

This video provides an overview of the entire course.

Preview 03:22

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.

Understanding the Actor Model
03:20

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

Concepts and Terminology
04:06

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

Let's Create Hello World
03:23

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

Preview 04:35

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.

Actor Components and Lifecycle
03:36

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

Creating an Actor with Props
04:12

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

Talking to an Actor
04:57

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

Supervision and Monitoring
06:00

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.

Preview 05:03

Sending Messages via Router
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.

Replacing Actor Behavior via become/unbecome
04:48

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

Replacing Actor Behavior via FSM
04:47

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.

Preview 04:27

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

Creating Persistent Actors
04:26

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.

Playing with a Persistent Actor
04:21

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

Persistence FSM
06:18

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

Persistence Query
04:24

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

Preview 05:26

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.

Building a Cluster
06:10

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

Adding Load Balancer to a Cluster Node
03:09

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

Creating a Singleton Actor in the Cluster
05:45

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.

Cluster Sharding
05:49

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.

Preview 05:44

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.

Testing a Parent-child Relationship
03:26

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.

Testing FSM
04:24

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.

Multi Node Testing
06:31

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.

Preview 05:37

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

Reactive Tweets
04:54

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

Testing Streams
06:02

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

Working with Graphs
04:56

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

Working with Stream IO
04:16

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

Preview 04:04

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.

Working with Client-side API
05:58

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.

Working with Server-side API
05:01

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

Let's Implement a REST API
05:04

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.

Let's Test Our REST API
03:31

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

Preview 05:34

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.

Throttling Messages
04: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.

Shutdown Patterns
03:26

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.

Ordered Termination
03:44

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

Scheduling Periodic Messages
02:57
+
Building Microservice with AKKA HTTP
13 Lectures 01:23:34

This video provides an overview of the entire course.

Preview 01:27

This videos aims to show what “does system is Responsive” mean.

Responsive
07:54

Resilient
05:22

The aim of this video is to show scale out versus scale up.

Elastic
05:56

This video shows Decouple Microservices that reacts on events.

Message Driven
06:44

The video shows how to make service Responsive.

Putting All Reactive Principles Together
04:36

The video talks about the Akka library.

Preview 09:11

This video shows how to generate the simple Akka/HTTP app.

Introduction to Akka HTTP
07:44

The video shows how to create AkkaMicroservice.

Getting to Know Core API of Akka HTTP
08:02

Implement Controller for submitting an action.

Creating Controllers for our REST Microservice
05:58

Look at the test suite.

Writing Tests for Our Microservice
07:08

We want our app to be stateless, what should we do?

Making Our Service Comply with Reactive Manifesto Principles
05:23

Look at the Gatling Performance test tool.

Writing
08:09
About the Instructor
Packt Publishing
3.9 Average rating
8,109 Reviews
58,319 Students
686 Courses
Tech Knowledge in Motion

Packt has been committed to developer learning since 2004. A lot has changed in software since then - but Packt has remained responsive to these changes, continuing to look forward at the trends and tools defining the way we work and live. And how to put them to work.

With an extensive library of content - more than 4000 books and video courses -Packt's mission is to help developers stay relevant in a rapidly changing world. From new web frameworks and programming languages, to cutting edge data analytics, and DevOps, Packt takes software professionals in every field to what's important to them now.

From skills that will help you to develop and future proof your career to immediate solutions to every day tech challenges, Packt is a go-to resource to make you a better, smarter developer.

Packt Udemy courses continue this tradition, bringing you comprehensive yet concise video courses straight from the experts.