Reactive Applications with Akka.NET
1st Edition
Published on 5. March 2019
280 pages
978-1-63835-565-6 (ISBN)
Description
Summary
Reactive Applications with Akka.NET is a hands-on book that builds on fundamental concepts to teach you how to create reliable and resilient applications in the reactive style.
Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications.
About the Technology
Enterprise-scale software needs to be unfailingly reliable, consistently performant under unpredictable loads, and easy to scale and maintain. Reactive applications guarantee these qualities through clear isolation of system components and message-based communication. Akka.NET ports the battle-tested Akka Actors toolkit from the JVM, radically simplifying the concurrency and asynchronous message handling at the heart of a reactive system.
About the Book
Reactive Applications with Akka.NET teaches you to write high-performance, concurrent systems without explicitly managing threads and locking. You'll experience the power of Akka.NET and the Actors concurrency model by exploring a real-world case study in each chapter. As you go further, you'll start to grok the power of asynchronous communication in a distributed environment and take on practical tasks like deploying, debugging, and establishing performance guarantees.
What's Inside
About the Reader
Readers should be comfortable with C# or F# and the .NET framework.
About the Author
Anthony Brown is a .NET consultant specializing in F# and reactive systems.
Table of Contents
Reactive Applications with Akka.NET is a hands-on book that builds on fundamental concepts to teach you how to create reliable and resilient applications in the reactive style.
Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications.
About the Technology
Enterprise-scale software needs to be unfailingly reliable, consistently performant under unpredictable loads, and easy to scale and maintain. Reactive applications guarantee these qualities through clear isolation of system components and message-based communication. Akka.NET ports the battle-tested Akka Actors toolkit from the JVM, radically simplifying the concurrency and asynchronous message handling at the heart of a reactive system.
About the Book
Reactive Applications with Akka.NET teaches you to write high-performance, concurrent systems without explicitly managing threads and locking. You'll experience the power of Akka.NET and the Actors concurrency model by exploring a real-world case study in each chapter. As you go further, you'll start to grok the power of asynchronous communication in a distributed environment and take on practical tasks like deploying, debugging, and establishing performance guarantees.
What's Inside
- Reactive application design
- Dealing with application-level failures
- Integrating Akka.NET with other frameworks
- Applying reactive programming to the real world
About the Reader
Readers should be comfortable with C# or F# and the .NET framework.
About the Author
Anthony Brown is a .NET consultant specializing in F# and reactive systems.
Table of Contents
PART 1 THE ROAD TO REACTIVE
- Why reactive?
- Reactive application design
PART 2 DIGGING IN
- Your first Akka.NET application
- State, behavior, and actors
- Configuration, dependency injection, and logging
- Failure handling
- Scaling in reactive systems
- Composing actor systems
PART 3 REAL-LIFE USAGE
- Testing Akka.NET actors
- Integrating Akka.NET
- Storing actor state with Akka.Persistence
- Building clustered applications with Akka.Cluster
- Akka.NET and reactive programming in production
More details
Other editions
Additional editions
Anthony Brown
Reactive Applications with Akka.NET
Book
04/2018
Manning Publications
€42.00
Shipment within 10-20 days
Person
Anthony Brown is a .NET consultant specializing in F# and reactive systems.
Content
- Intro
- Copyright
- Brief Table of Contents
- Table of Contents
- Preface
- Acknowledgments
- About this book
- About the author
- About the cover illustration
- Part 1. The road to reactive
- Chapter 1. Why reactive?
- 1.1. The heart of the Reactive Manifesto
- 1.2. Reactive systems vs. reactive programming
- 1.3. Applying Akka.NET
- 1.4. How does Akka.NET work?
- Summary
- Chapter 2. Reactive application design
- 2.1. Basic reactive system design
- 2.2. Reactive e-commerce application with actors
- 2.3. Building on reactive foundations
- Summary
- Part 2. Digging in
- Chapter 3. Your first Akka.NET application
- 3.1. Setting up an application
- 3.2. Actors
- 3.3. Deploying an actor
- 3.4. Communicating with actors
- 3.5. Case study: Actors, concurrency, and phone billing
- Summary
- Chapter 4. State, behavior, and actors
- 4.1. Preparing for the next message
- 4.2. Setting appropriate runtime behaviors
- 4.3. Finite state machines
- 4.4. Case study: State machines, states and events, marketing analytics campaign
- Summary
- Chapter 5. Configuration, dependency injection, and logging
- 5.1. Why do you need configuration?
- 5.2. Configuring an actor deployment
- 5.3. Dependency injection (DI)
- 5.4. Configuring with HOCON
- 5.5. Logging
- 5.6. Case study: Configuration and distributed systems
- Summary
- Chapter 6. Failure handling
- 6.1. Understanding failures
- 6.2. Handling application-level failures
- 6.3. Understanding transport-level failures
- 6.4. Case study: Supervision, failure, chat bots
- Summary
- Chapter 7. Scaling in reactive systems
- 7.1. Scaling up and scaling out
- 7.2. Distributing work
- 7.3. Routing strategies
- 7.4. Case study: Scaling, throughput, advertising systems
- Summary
- Chapter 8. Composing actor systems
- 8.1. Introducing Akka.NET remoting
- 8.2. Preparing to use remoting
- 8.3. Communicating with remote actors
- 8.4. Elastic scale across machines
- 8.5. Failure handling across machines
- 8.6. Akka.Remote security
- 8.7. Case study: Remoting, network applications, web server, and backend server
- Summary
- Part 3. Real-life usage
- Chapter 9. Testing Akka.NET actors
- 9.1. Introducing Akka.TestKit
- 9.2. Unit testing actors
- 9.3. Integration testing actors
- 9.4. Testing distributed applications with MultiNode TestKit
- 9.5. Case study: Testing, test-driven development, unit testing
- Summary
- Chapter 10. Integrating Akka.NET
- 10.1. Integrating with ASP.NET
- 10.2. Integrating with SignalR
- 10.3. Custom integrations with akka.io
- 10.4. Case study: IO, integration, IoT applications
- Summary
- Chapter 11. Storing actor state with Akka.Persistence
- 11.1. Understanding event sourcing
- 11.2. Using Akka.Persistence
- 11.3. Akka.Persistence performance tuning
- 11.4. Akka.Persistence performance tuning
- 11.5. Case study: Persistence, storage, staged upgrades
- Summary
- Chapter 12. Building clustered applications with Akka.Cluster
- 12.1. Introducing Akka.Cluster
- 12.2. Cluster-aware routers
- 12.3. Working with cluster gossip
- 12.4. Cluster singleton
- 12.5. Cluster sharding
- 12.6. Distributed publish-subscribe
- 12.7. Cluster client
- 12.8. Case study: Clustering, scaling, cluster management
- Summary
- Chapter 13. Akka.NET and reactive programming in production
- 13.1. Designing with actors
- 13.2. Handling failure
- 13.3. Designing for scale
- 13.4. Handling configuration
- 13.5. Ingesting data
- 13.6. Testing
- 13.7. Real-time integration
- 13.8. Data persistence
- 13.9. Cluster scale-out
- Conclusion
- Index
- List of Figures
- List of Tables
