Sign In Start Free Trial

Akka Cookbook

By : Mishra, Héctor Veiga Ortiz

4.2 (10)

Akka Cookbook

4.2 (10)

By: Mishra, Héctor Veiga Ortiz

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.

Preface

Preface

What this book covers

What you need for this book

Who this book is for

Sections

Conventions

Reader feedback

Customer support

Free Chapter

Diving into Akka

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

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

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

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

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

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

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

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

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

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

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

4.2 (10)

5 star

70%

4 star

0

3 star

10%

2 star

20%

1 star

0

The aggregator pattern

The aggregator pattern is mainly used to collect data from different sources, package that data together, and then proceed to do something with the aggregated outcome. A good example is retrieving account balances from multiple accounts. Once you have all the required information, you package and deliver it together to, for example, a mobile device or an API.

In this recipe, we will look at how to use the Aggregator trait, which provides the means to achieve the behavior we explained in the previous paragraphs. The Aggregator trait is also part of the akka-contrib module. To demonstrate this, we will create a social network feed aggregator. This aggregator actor will ask other actors for the latest posts in various social networks from a given user. Since accessing the real APIs of social networks is out of the scope of this recipe, we will just simulate it using some other actors...

Search

Your notes and bookmarks