Video description
In Video Editions the narrator reads the book while the content, figures, code listings, diagrams, and text appear on the screen. Like an audiobook that you can also watch as a video.
Akka solves the big problems of distributed systems, from multithreading and concurrency to scalability and failure. Learn how to use it effectively.
In Akka in Action, Second Edition you will learn how to:
- Create basic programs with Akka Typed
- Work with clusters to build robust, fault-tolerant programs
- Use Akka with Kubernetes
- Build microservices with Akka
- Create and maintain distributed state with strong consistency guarantees
- Employ actor-based concurrency and parallelism
- Test Akka software
Akka in Action, Second Edition teaches you to use Akka Typed to solve common problems of distributed systems. You’ll learn how to bring together all of Akka’s moving parts to design and implement highly scalable and maintainable software. Extensively revised by Akka contributor Francisco López-Sancho Abraham, this new edition demonstrates Akka’s complex concepts through engaging hands-on examples. Discover the power of the Actor Model, how Akka works with Kubernetes, and how to utilize Akka modules to create microservices that are reliable and fault tolerant.
About the Technology
For large software systems, the action is in the “-ilities.” Scalability. Reliability. Maintainability. Capability. Akka, toolkit for building distributed message-driven applications, delivers on the “ilities.” And recent innovations, including Akka Typed, ensure that this amazing platform will remain the best way to build and deploy distributed Java and Scala applications for years to come.
About the Book
Akka in Action, Second Edition is your guide to building message-centric distributed applications systems. This new edition covers all features of Akka, including Akka Typed. You’ll learn to create microservices using Akka’s powerful suite of tools, Akka Sharding, Persistence, Streams, Persistence Query, Projections, and gRPC. Practical examples taken directly from industry guide you through clustering, deploying to Kubernetes, and taking full advantage of Akka’s Actors-based approach to concurrency.
What's Inside
- Work with clusters to build robust, fault-tolerant programs
- Maintain distributed systems with strong consistency guarantees
- Utilize concurrency and parallelism
- Test Akka software
About the Reader
For readers comfortable with Java and Scala.
About the Authors
Francisco Lopez Sancho-Abraham is a senior consultant at Lightbend, and a principal engineer on the Akka Team. Raymond Roestenburg, Rob Bakker, and Rob Williams are the authors of the first edition of Akka in Action.
Quotes
Akka in Action is the best source for a deep yet practical and hands-on introduction to Akka. In it, Francisco discusses everything from the foundational distributed systems stuff to how to integrate it with the more recent high-level modules like Alpakka and Akka Streams. Highly recommended.
- Jonas Bonér, Lightbend
All you need to start with Akka and the Actor Model.
- Rares Tausancea, ING
A gem that few books can match when it comes to Actors, CQRS, and Event Sourcing. For Scala and Java developers, it’s an essential read.
- Sebastian Harko, IBM
Delivers a powerful combination of easy-to-follow lessons on the Akka ecosystem and well-timed discussions on important topics in modern computing.
- John Ackley, Carnegie Learning
Table of contents
- Chapter 1. Introducing Akka
- Chapter 1. Actors: A quick overview
- Chapter 1. Two approaches to scaling: Setting up the example
- Chapter 1. Traditional scaling
- Chapter 1. Scaling with Akka
- Chapter 1. Actors: One programming model to rule up and out
- Chapter 1. Akka actors
- Chapter 1. Summary
- Chapter 2. Up and running
- Chapter 2. Starting to code
- Chapter 2. Keeping state with a variable
- Chapter 2. Keeping state with behaviors
- Chapter 2. Scheduling a message
- Chapter 2. Summary
- Chapter 3. One actor is no actor
- Chapter 3. Asking and expecting a reply
- Chapter 3. Ask with a payload
- Chapter 3. Summary
- Chapter 4. Akka test kit
- Chapter 4. Sync testing
- Chapter 4. Async testing
- Chapter 4. Summary
- Chapter 5. Fault tolerance
- Chapter 5. Actor lifecycle events: Signals
- Chapter 5. Supervision strategies and signals
- Chapter 5. Watching signals from an actor
- Chapter 5. Back to the initial use case
- Chapter 5. Summary
- Chapter 6. Discovery and routing
- Chapter 6. The built-in integration router pattern
- Chapter 6. Balancing load using built-in routers
- Chapter 6. Implementing the router pattern using actors
- Chapter 6. Summary
- Chapter 7. Configuration
- Chapter 7. Akka configuration
- Chapter 7. Multiple systems
- Chapter 7. Configuration in tests
- Chapter 7. Summary
- Chapter 8. Clustering
- Chapter 8. Why use clustering?
- Chapter 8. Akka Management and the Cluster HTTP extension
- Chapter 8. Clustered job processing
- Chapter 8. Resilient job
- Chapter 8. Summary
- Chapter 9. Sharding and persistence
- Chapter 9. Persistence
- Chapter 9. Customizing the persistent entity
- Chapter 9. Running example
- Chapter 9. Summary
- Chapter 10. Streams, persistence queries, and projections
- Chapter 10. Akka Persistence Query
- Chapter 10. Projections
- Chapter 10. Projections in action
- Chapter 10. Summary
- Chapter 11. Akka ports
- Chapter 11. Akka gRPC
- Chapter 11. Summary
- Chapter 12. Real-world example: An Akka betting house
- Chapter 12. The ports
- Chapter 12. Summary
- Chapter 13. Clustering, part 2
- Chapter 13. Clustering with the Kubernetes API
- Chapter 13. Split Brain Resolver
- Chapter 13. Cluster singletons
- Chapter 13. Summary
- Chapter 14. Connecting to systems with Alpakka
- Chapter 14. Pushing to Kafka
- Chapter 14. Effectively-once delivery
- Chapter 14. Alpakka CSV
- Chapter 14. Summary
- Chapter 15. Akka betting house, part 2
- Chapter 15. Configuration
- Chapter 15. Deployment
- Chapter 15. Summary
- Chapter 16. Akka Streams, part 2
- Chapter 16. Connecting to an actor
- Chapter 16. Dealing with exceptions
- Chapter 16. Adding elements dynamically to a stream
- Chapter 16. Summary
- Appendix B. Microservices and architectural principles
- Appendix B. Architectural principles
Product information
- Title: Akka in Action, Second Edition, Video Edition
- Author(s):
- Release date: August 2023
- Publisher(s): Manning Publications
- ISBN: None
You might also like
video
Akka in Action video edition
"The most readable and up-to-date treatment of Akka I have seen." Kevin Esler, TimeTrade Systems Akka …
book
Akka in Action
Akka in Action is a comprehensive tutorial on building message-oriented systems using Akka. The book takes …
video
A Hands-On Guide to Akka with Scala
Akka is a toolkit that simplifies the process of building concurrent, distributed, and fault-tolerant applications and …
book
Mastering Akka
Master the art of creating scalable, concurrent, and reactive applications using Akka About This Book This …