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

Exception handling

Like all the other Akka modules, Akka HTTP has great exception handling mechanisms. By default, if anything in your route throws an exception, the server returns a 500 response, which means there is an internal server error. This is a useful default behavior; however, you might need to do something more specific and respond in a different way depending on the exception thrown.

In this recipe, we will revisit how to add an exception handler to your routes. This allows you to customize the behavior of your route when exceptions are thrown.

Getting ready

To step through this recipe, we need to import the Hello-Akka project and the required Akka HTTP dependency we added in the previous recipe.

How to do it...

For this recipe, perform the following steps:

First, create a trait where you will define your exception handler. Create a file named RouteExceptionHandler.scala inside the com.packt.chapter9 package. The content should be as follows:

        package com.packt.chapter9

  ...

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

Exception handling

Getting ready

How to do it...