Learning Path: Akka: Building Applications And Microservices

Embrace yourself to learn the art of creating applications and microservices with Akka

What you'll 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

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.

Overview
Section 1: Learning Akka

Lecture 1 The Course Overview

Lecture 2 Understanding the Actor Model

Lecture 3 Concepts and Terminology

Lecture 4 Let's Create Hello World

Lecture 5 Actor System and Hierarchical Structure

Lecture 6 Actor Components and Lifecycle

Lecture 7 Creating an Actor with Props

Lecture 8 Talking to an Actor

Lecture 9 Supervision and Monitoring

Lecture 10 ActorRef Versus Actor Path Versus Actor Selection

Lecture 11 Sending Messages via Router

Lecture 12 Replacing Actor Behavior via become/unbecome

Lecture 13 Replacing Actor Behavior via FSM

Lecture 14 Introduction to Akka Persistence

Lecture 15 Creating Persistent Actors

Lecture 16 Playing with a Persistent Actor

Lecture 17 Persistence FSM

Lecture 18 Persistence Query

Lecture 19 Playing with Remote Actors

Lecture 20 Building a Cluster

Lecture 21 Adding Load Balancer to a Cluster Node

Lecture 22 Creating a Singleton Actor in the Cluster

Lecture 23 Cluster Sharding

Lecture 24 How to Test an Actor?

Lecture 25 Testing a Parent-child Relationship

Lecture 26 Testing FSM

Lecture 27 Multi Node Testing

Lecture 28 Introduction to Akka Streams

Lecture 29 Reactive Tweets

Lecture 30 Testing Streams

Lecture 31 Working with Graphs

Lecture 32 Working with Stream IO

Lecture 33 Introduction to Akka HTTP

Lecture 34 Working with Client-side API

Lecture 35 Working with Server-side API

Lecture 36 Let's Implement a REST API

Lecture 37 Let's Test Our REST API

Lecture 38 Balancing Workload Across Nodes

Lecture 39 Throttling Messages

Lecture 40 Shutdown Patterns

Lecture 41 Ordered Termination

Lecture 42 Scheduling Periodic Messages

Section 2: Building Microservice with AKKA HTTP

Lecture 43 The Course Overview

Lecture 44 Responsive

Lecture 45 Resilient

Lecture 46 Elastic

Lecture 47 Message Driven

Lecture 48 Putting All Reactive Principles Together

Lecture 49 Introduction to Akka

Lecture 50 Introduction to Akka HTTP

Lecture 51 Getting to Know Core API of Akka HTTP

Lecture 52 Creating Controllers for our REST Microservice

Lecture 53 Writing Tests for Our Microservice

Lecture 54 Making Our Service Comply with Reactive Manifesto Principles

Lecture 55 Writing

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.

without You and Your Support We Can’t Continue
Thanks for Buying Premium From My Links for Support
Click >>here & Visit My Blog Daily for More Udemy Tutorial. If You Need Update or Links Dead Don't Wait Just Pm Me or Leave Comment at This Post