Akka Cookbook

Akka Cookbook

By : Vivek Mishra, Héctor Veiga Ortiz

Buy this Book

Akka Cookbook

By: Vivek Mishra, Héctor Veiga Ortiz

Buy this Book

Overview of this book

Akka is an open source toolkit that simplifies the construction of distributed and concurrent applications on the JVM. This book will teach you how to develop reactive applications in Scala using the Akka framework. This book will show you how to build concurrent, scalable, and reactive applications in Akka. You will see how to create high performance applications, extend applications, build microservices with Lagom, and more. We will explore Akka's actor model and show you how to incorporate concurrency into your applications. The book puts a special emphasis on performance improvement and how to make an application available for users. We also make a special mention of message routing and construction. By the end of this book, you will be able to create a high-performing Scala application using the Akka framework.

Title Page

Credits

About the Authors

About the Reviewer

www.PacktPub.com

Customer Feedback

Preface

Free Chapter

Diving into Akka

Introduction

Creating an Akka Scala SBT project from scratch

Creating and understanding ActorSystem

Defining the actor's behavior and state

Sending messages to actors

Asking for a result from an actor

Communication between actors

Creating a custom mailbox for an actor

Prioritizing messages that an actor receives

Creating a control-aware mailbox for an actor

Become/unbecome behavior of an actor

Stopping an actor

Supervision and Monitoring

Introduction

Creating child actors of a parent actor

Overriding the life cycle hooks of an actor

Sending messages to actors and collecting responses

Understanding OneForOneStrategy for actors

Understanding AllForOneStrategy for actors

Monitoring an actor life cycle using DeathWatch

Routing Messages

Introduction

Creating a SmallestMailboxPool of actors

Creating a BalancingPool of actors

Creating a RoundRobinPool of actors

Creating a BroadcastPool of actors

Creating a ScatterGatherFirstCompletedPool of actors

Creating a TailChoppingPool of actors.

Creating a ConsistentHashingPool of actors

Creating a RandomPool of actors

Sending specially handled messages to routers

Creating a dynamically resizable pool of actors

Using Futures and Agents

Introduction

Using a future directly for a simple operation

Using futures with actors

Using futures inside actors

Using for-comprehensions for futures

Handling callback on futures

Creating a simple parallel application using futures

Reducing a sequence of futures

Reading and updating agents

Composing agents monadically

Scheduling Actors and Other Utilities

Introduction

Scheduling an operation at a specified interval

Scheduling an actor's operation at a specified interval

Canceling a scheduled operation of the actor

Creating a circuit breaker to avoid cascading failure

How to introduce logging with actors

Writing unit test for actors

Packaging and deploying the Akka standalone application

Packaging and deploying Akka application inside a Docker container

Configurating Akka applications

Akka Persistence

Introduction

Preparing an actor for persistence

Recovering the state of an actor

Safely shutting down a persistent actor

Reducing recovery time using snapshots

Creating a persistence FSM model

Persisting the state to LevelDB

Persisting the state to Cassandra

Persisting the state to Redis

Understanding event sourcing

Handling failure in event sourcing

Using persistence query

Persistence query for LevelDB

Remoting and Akka Clustering

Introduction

Enabling Akka applications for remoting

Creating remote actors on different machines

Looking up remote actors from different machines

Deploying remote actors programmatically on different nodes

Scaling out your application using remote actors

Creating a chat-based application using remote actors

Enabling Akka clustering for your project

Using Distributed Publish-Subscribe in the cluster

Cluster Sharding

Sharing data between nodes in an Akka cluster

Creating a singleton actor across clusters

Akka Streams

Introduction

Creating simple Akka Streams

How to transform streams and consume them

Creating stream sources, flows, and sinks

Custom stream processing

Error handling in Akka streams

Pipelining and parallelizing streams

Working with streaming I/O

Integrating streams with Akka actors

Working with graphs

Processing RabbitMQ messages with Akka streams

Integrating Akka Streams with Kafka using Reactive Kafka

Akka HTTP

Introduction

Creating a minimal HTTP server using Akka HTTP

Consuming Akka HTTP services using a client-side API

Writing routing DSL for HTTP servers

Understanding the configuration of Akka HTTP

Marshaling and unmarshaling data

Encoding and decoding data

Understanding directives

Exception handling

Uploading a file using Akka HTTP

Building JSON support with Akka HTTP

XML support with Akka HTTP

Understanding Various Akka patterns

Introduction

The Master Slave work pulling pattern

Ordered termination of actors

Shutdown patterns in Akka

Scheduling periodic messages to an actor

Throttling of messages while sending them to an actor

Balancing workload across actors

The aggregator pattern

The CountDownLatch pattern

Finite-state machine

The pausable actor pattern

Enveloping actor

Microservices with Lagom

Introduction

Installing Lagom and creating a Lagom project

Understanding the service locator

Understanding service descriptors

Implementing Lagom services

Consuming services

Testing services

Writing persistent and clustered services

Running Lagom in production

Integrating with Akka

Customer Reviews

5 star

4 star

3 star

2 star

1 star

Looking up remote actors from different machines

It is useful to be able to check whether an actor is running on a remote machine. This can help make sure you don't create duplicate remote actors if they already exist. For this, we will use ActorSelection.

Getting ready

All the prerequisites are the same as before. We will reuse SimpleActor.scala, application-1.conf, and application-2.conf from the previous recipe.

How to do it...

Create a Scala file named LookingUpRemoteApplication.scala in the com.packt.chapter7 package.
Add the following two apps. One app will create an actor remotely; the other will look for the remote actor:

        package com.packt.chapter7
        import akka.actor.{ActorRef, ActorSystem, Props}
        import scala.concurrent.duration._

        object LookingUpActorSelection extends App {
          val actorSystem = ActorSystem("LookingUpActors")
          implicit val dispatcher = actorSystem.dispatcher
          val selection = actorSystem.actorSelection(
        ...

Akka Cookbook

By : Vivek Mishra, Héctor Veiga Ortiz

Akka Cookbook

By: Vivek Mishra, Héctor Veiga Ortiz

Overview of this book

Related Content you might be interested in

Current Title:

Akka Cookbook

Scala Reactive Programming

Learn Scala Programming

Scala Microservices

Looking up remote actors from different machines

Getting ready

How to do it...