Reactive Applications with Akka.NET

Reactive Applications with Akka.NET

by Anthony Brown
Released March 2019
Publisher(s): Manning Publications
ISBN: 9781617292989

Read it now on the O’Reilly learning platform with a 10-day free trial.

O’Reilly members get unlimited access to books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.

Start your free trial

Book description

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.

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.

Quotes
An introduction to how we're going to write software in the future.
- Dror Helper, CodeValue

An excellent resource for learning how to get the best out of Akka.NET, and a book I'd recommend to anyone wanting to build reactive applications in .NET.
- Chris Allan, Magnitude Software

A practical guide to thinking reactively with Akka.NET.
- Adrian Bilauca, Totalsoft, a Logo Company

A complete book on how to build actor-based applications.
- Lucian Enache, LEGO Systems A/S

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