Reactive Applications with Akka.NET

Book Description

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.

Table of Contents

  1. Copyright
  2. Brief Table of Contents
  3. Table of Contents
  4. Preface
  5. Acknowledgments
  6. About this book
  7. About the author
  8. About the cover illustration
  9. Part 1. The road to reactive
    1. Chapter 1. Why reactive?
      1. 1.1. The heart of the Reactive Manifesto
      2. 1.2. Reactive systems vs. reactive programming
      3. 1.3. Applying Akka.NET
      4. 1.4. How does Akka.NET work?
      5. Summary
    2. Chapter 2. Reactive application design
      1. 2.1. Basic reactive system design
      2. 2.2. Reactive e-commerce application with actors
      3. 2.3. Building on reactive foundations
      4. Summary
  10. Part 2. Digging in
    1. Chapter 3. Your first Akka.NET application
      1. 3.1. Setting up an application
      2. 3.2. Actors
      3. 3.3. Deploying an actor
      4. 3.4. Communicating with actors
      5. 3.5. Case study: Actors, concurrency, and phone billing
      6. Summary
    2. Chapter 4. State, behavior, and actors
      1. 4.1. Preparing for the next message
      2. 4.2. Setting appropriate runtime behaviors
      3. 4.3. Finite state machines
      4. 4.4. Case study: State machines, states and events, marketing analytics campaign
      5. Summary
    3. Chapter 5. Configuration, dependency injection, and logging
      1. 5.1. Why do you need configuration?
      2. 5.2. Configuring an actor deployment
      3. 5.3. Dependency injection (DI)
      4. 5.4. Configuring with HOCON
      5. 5.5. Logging
      6. 5.6. Case study: Configuration and distributed systems
      7. Summary
    4. Chapter 6. Failure handling
      1. 6.1. Understanding failures
      2. 6.2. Handling application-level failures
      3. 6.3. Understanding transport-level failures
      4. 6.4. Case study: Supervision, failure, chat bots
      5. Summary
    5. Chapter 7. Scaling in reactive systems
      1. 7.1. Scaling up and scaling out
      2. 7.2. Distributing work
      3. 7.3. Routing strategies
      4. 7.4. Case study: Scaling, throughput, advertising systems
      5. Summary
    6. Chapter 8. Composing actor systems
      1. 8.1. Introducing Akka.NET remoting
      2. 8.2. Preparing to use remoting
      3. 8.3. Communicating with remote actors
      4. 8.4. Elastic scale across machines
      5. 8.5. Failure handling across machines
      6. 8.6. Akka.Remote security
      7. 8.7. Case study: Remoting, network applications, web server, and backend server
      8. Summary
  11. Part 3. Real-life usage
    1. Chapter 9. Testing Akka.NET actors
      1. 9.1. Introducing Akka.TestKit
      2. 9.2. Unit testing actors
      3. 9.3. Integration testing actors
      4. 9.4. Testing distributed applications with MultiNode TestKit
      5. 9.5. Case study: Testing, test-driven development, unit testing
      6. Summary
    2. Chapter 10. Integrating Akka.NET
      1. 10.1. Integrating with ASP.NET
      2. 10.2. Integrating with SignalR
      3. 10.3. Custom integrations with akka.io
      4. 10.4. Case study: IO, integration, IoT applications
      5. Summary
    3. Chapter 11. Storing actor state with Akka.Persistence
      1. 11.1. Understanding event sourcing
      2. 11.2. Using Akka.Persistence
      3. 11.3. Akka.Persistence performance tuning
      4. 11.4. Akka.Persistence performance tuning
      5. 11.5. Case study: Persistence, storage, staged upgrades
      6. Summary
    4. Chapter 12. Building clustered applications with Akka.Cluster
      1. 12.1. Introducing Akka.Cluster
      2. 12.2. Cluster-aware routers
      3. 12.3. Working with cluster gossip
      4. 12.4. Cluster singleton
      5. 12.5. Cluster sharding
      6. 12.6. Distributed publish-subscribe
      7. 12.7. Cluster client
      8. 12.8. Case study: Clustering, scaling, cluster management
      9. Summary
    5. Chapter 13. Akka.NET and reactive programming in production
      1. 13.1. Designing with actors
      2. 13.2. Handling failure
      3. 13.3. Designing for scale
      4. 13.4. Handling configuration
      5. 13.5. Ingesting data
      6. 13.6. Testing
      7. 13.7. Real-time integration
      8. 13.8. Data persistence
      9. 13.9. Cluster scale-out
      10. Conclusion
  12. Index
  13. List of Figures
  14. List of Tables

Product Information

  • Title: Reactive Applications with Akka.NET
  • Author(s): Anthony Brown
  • Release date: March 2019
  • Publisher(s): Manning Publications
  • ISBN: 9781617292989