Akka cookbook : make your application fast, concurrent, and reactive through exciting recipes / Héctor Veiga Ortiz, Piyush Mishra.

Format:

Book

Author/Creator:

Ortiz, Héctor Veiga, author.

Mishra, Piyush, author.

Language:

English

Subjects (All):

Scala (Computer program language).

Application software--Development.

Application software.

Java (Computer program language).

Physical Description:

1 online resource (382 pages) : illustrations

Edition:

1st edition

Place of Publication:

Birmingham, England ; Mumbai, [India] : Packt Publishing, 2017.

System Details:

text file

Biography/History:

Mishra Vivek: Vivek Mishra is an IT professional with more than nine years of experience in various technologies like Java, J2ee, Hibernate, SCA4J, Mule, Spring, Cassandra, HBase, MongoDB, REDIS, Hive, Hadoop. He has been a contributor for open source like Apache Cassandra and lead committer for Kundera(JPA 2. 0 compliant Object-Datastore Mapping Library for NoSQL Datastores like Cassandra, HBase, MongoDB and REDIS). Mr Mishra in his previous experience has enjoyed long lasting partnership with most recognizable names in SCM, Banking and finance industries, employing industry standard full software life cycle methodologies Agile and SCRUM. He is currently employed with Impetus infotech pvt. ltd. He has undertaken speaking engagements in cloud camp and Nasscom Big data seminar and is an active blogger and can be followed at mevivs. wordpress. comVeiga Ortiz Hector: Hector Veiga Ortiz is a software engineer specializing in real-time data integration. Recently, he has focused his work on different cloud technologies (such as AWS) to develop and run scalable, resilient, and high performing applications that are able to handle high volume, real-time data in diverse protocols and formats. To accomplish this task, he has been focusing his work on messaging systems such as Akka. He has also been working on microservice architectures with frameworks such as Lightbends Lagom. Additionally, he has a strong foundation in messaging broker knowledge, such as RabbitMQ and AMQP. Also, Hector has a masters degree in telecommunication engineering from the Universidad Politecnica de Madrid and a masters degree in information technology and management from the Illinois Institute of Technology. He currently works at HERE Technologies as part of the global traffic data integrations team and is actively developing scalable applications to consume data from several different sources. He heavily utilizes Akka to address the scalability and processing requirements. In the past, Hector worked at Xaptum Technologies, a company dedicated to M2M technologies. Moreover, he has also contributed to the Akka project on a couple of occasions and is an active StackOverflow user on the akka tag. Hector has also worked as a technical reviewer on the books RabbitMQ Cookbook and RabbitMQ Essentials by Packt Publishing.

Summary:

Learn how to use the Akka framework to build effective applications in Scala About This Book Covers a discussion on Lagom—the newest launched Akka framework that is built to create complex microservices easily The recipe approach of the book allows the reader to know important and independent concepts of Scala and Akka in a seamless manner Provides a comprehensive understanding of the Akka actor model and implementing it to create reactive web applications Who This Book Is For If you are a Scala developer who wants to build scalable and concurrent applications, then this book is for you. Basic knowledge of Akka will help you take advantage of this book. What You Will Learn Control an actor using the ContolAware mailbox Test a fault-tolerant application using the Akka test kit Create a parallel application using futures and agents Package and deploy Akka application inside Docker Deploy remote actors programmatically on different nodes Integrate Streams with Akka actors Install Lagom and create a Lagom project In Detail 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. Style and approach This highly practical recipe-based approach will allow you to build scalable, robust, and reactive applications using the Akka framework. Downloading the example code for this book. You can download the example code files for all Packt books you have purchased from your account at http://www.PacktPub.com. If you purchased this book elsewhere, you can visit http://www.PacktPub.com/support and register to have the code file.

Contents:

Cover

Copyright

Credits

About the Authors

About the Reviewer

www.PacktPub.com

Customer Feedback

Table of Contents

Preface

Chapter 1: Diving into Akka

Introduction

Creating an Akka Scala SBT project from scratch

Getting ready

How to do it...

Creating and understanding ActorSystem

How it works...

Why we need ActorSystem

Defining the actor's behavior and state

There's more...

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

Chapter 2: Supervision and Monitoring

What is fault tolerance?

What is a component?

How Akka fits in between all of them?

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

How to do it.

How it works...

Monitoring an actor life cycle using DeathWatch

Chapter 3: Routing Messages

Where to use routers

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

Chapter 4: Using Futures and Agents

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

Getting ready.

How to do it...

Composing agents monadically

How to do it..

Chapter 5: Scheduling Actors and Other Utilities

Scheduling an operation at a specified interval

How to do it…

How it works…

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

Chapter 6: Akka Persistence

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

How it works….

Understanding event sourcing

Handling failure in event sourcing

Using persistence query

Persistence query for LevelDB

Chapter 7: Remoting and Akka Clustering

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

How it works

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

See also

Chapter 8: Akka Streams

Creating simple Akka Streams

How to transform streams and consume them

Creating stream sources, flows, and sinks

How it works.

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

Chapter 9: Akka HTTP

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

Chapter 10: Understanding Various Akka patterns

Introduction.

The Master Slave work pulling pattern.

Notes:

Includes index.

Description based on online resource; title from PDF title page (ebrary, viewed June 23, 2017).

ISBN:

1-78528-836-9

OCLC:

990194373