Akka in Action shows you how to build message-oriented systems with Akka. This comprehensive, hands-on tutorial introduces each concept with a working example. You'll start with the big picture of how Akka works, and then quickly build and deploy a fully functional REST service out of actors. You'll explore test-driven development and deploying and …
Akka in Action shows you how to build message-oriented systems with Akka. This comprehensive, hands-on tutorial introduces each concept with a working example. You'll start with the big picture of how Akka works, and then quickly build and deploy a fully functional REST service out of actors. You'll explore test-driven development and deploying and scaling fault-tolerant systems. After mastering the basics, you'll discover how to model immutable messages, implement domain models, and apply techniques like event sourcing and CQRS. You'll also find a tutorial on building streaming applications using akka-stream and akka-http. Finally, you'll get practical advice on how to customize and extend your Akka system.
Akka makes it relatively easy to build applications in the cloud or on devices with many cores that efficiently use the full capacity of the computing power available. It's a toolkit that provides an actor programming model, a runtime, and required support tools for building scalable applications.
Inside:Chapter 1. Introducing Akka
Chapter 1. What is Akka?
Chapter 1. Traditional scaling
Chapter 1. Traditional scaling and interactive use: polling
Chapter 1. Scaling with Akka
Chapter 1. Scaling with Akka and failure: asynchronous decoupling
Chapter 1. Actors: one programming model to rule up and out
Chapter 1. Actor operations
Chapter 1. Akka actors
Chapter 2. Up and running
Chapter 2. Fast-forward to the GoTicks.com REST server
Chapter 2. Structure of the app
Chapter 2. The actor that handles the sale: TicketSeller
Chapter 2. Into the cloud
Chapter 3. Test-driven development with actors
Chapter 3. One-way messages
Chapter 3. SendingActor example
Chapter 3. SideEffectingActor example
Chapter 4. Fault tolerance
Chapter 4. Plain old objects and exceptions
Chapter 4. Let it crash
Chapter 4. Actor lifecycle
Chapter 4. Restart event
Chapter 4. Supervision
Chapter 4. Predefined strategies
Chapter 4. Custom strategies
Chapter 5. Futures
Chapter 5. In the future nobody blocks
Chapter 5. Promises are promises
Chapter 5. Futuristic errors
Chapter 5. Combining futures
Chapter 5. Combining futures with actors
Chapter 6. Your first distributed Akka app
Chapter 6. Reasons for a distributed programming model
Chapter 6. Making the GoTicks.com app distributed
Chapter 6. Remote lookup
Chapter 6. Remote deployment
Chapter 6. Multi-JVM testing
Chapter 6. Summary
Chapter 7. Configuration, logging, and deployment
Chapter 7. Using defaults
Chapter 7. Akka configuration
Chapter 7. Logging
Chapter 7. Deploying actor-based applications
Chapter 8. Structural patterns for actors
Chapter 8. Pipes and filters in Akka
Chapter 8. Enterprise integration pattern: scatter-gather
Chapter 8. Implementing the gather component with the aggregator pattern
Chapter 8. Enterprise integration pattern: routing slip
Chapter 9. Routing messages
Chapter 9. Balance load using Akka routers
Chapter 9. Akka pool router
Chapter 9. Akka pool router
Chapter 9. Akka group router
Chapter 9. ConsistentHashing router
Chapter 9. Implementing the router pattern using actors
Chapter 10. Message channels
Chapter 10. Publish-subscribe
Chapter 10. Publish-subscribe
Chapter 10. Specialized channels
Chapter 10. Guaranteed delivery
Chapter 10. Summary
Chapter 11. Finite-state machines and agents
Chapter 11. Implementation of an FSM model
Chapter 11. Implementing the entry actions
Chapter 11. Timers within FSM
Chapter 11. Implement shared state using agents
Chapter 11. Waiting for the state update
Chapter 12. System integration
Chapter 12. Normalizer
Chapter 12. Implementing endpoints using Apache Camel
Chapter 12. Implement a consumer endpoint receiving messages from an external system
Chapter 12. Implement a producer endpoint sending messages to an external system
Chapter 12. Implementing an HTTP interface
Chapter 12. Implementing a REST endpoint with akka-http
Chapter 13. Streaming
Chapter 13. Copying files with sources and sinks
Chapter 13. Materializing runnable graphs
Chapter 13. Processing events with flows
Chapter 13. Handling errors in streams
Chapter 13. Streaming HTTP
Chapter 13. Custom marshallers and unmarshallers for content type and negotiation
Chapter 13. Fan in and fan out with the graph DSL
Chapter 13. Merging flows
Chapter 13. Mediating between producers and consumers
Chapter 13. Rate-detaching parts of a graph
Chapter 14. Clustering
Chapter 14. Cluster membership
Chapter 14. Leaving the cluster
Chapter 14. Clustered job processing
Chapter 14. Work distribution using routers
Chapter 14. Resilient jobs
Chapter 14. Testing the cluster
Chapter 14. Summary
Chapter 15. Actor persistence
Chapter 15. Persisting state without updates
Chapter 15. Persistent actors
Chapter 15. Testing
Chapter 15. Persistence query
Chapter 15. Serialization
Chapter 15. Clustered persistence
Chapter 15. Cluster sharding
Chapter 16. Performance tips
Chapter 16. Performance parameters
Chapter 16. Performance measurement of actors
Chapter 16. Performance measurement of actors
Chapter 16. Collecting processing data
Chapter 16. Improving performance by addressing bottlenecks
Chapter 16. Configure dispatcher
Chapter 16. Changing thread pool size statically
Chapter 16. Using a dynamic thread pool size
Chapter 16. Changing thread releasing
Chapter 17. Looking ahead
Chapter 17. Akka Distributed Data