Reactive Applications with Akka.NET
READ NOW
Click any available part of the table of contents to go straight to that part of the book.
This book gives a good solid introduction to Akka.NET.
Developing applications in a reactive style ensures that the experience is always responsive. Akka.NET is a framework for building distributed, message-driven applications which are able to stay responsive for the user even in the face of failure or when faced with more users. It makes it easy for .NET developers to write applications which are able to react to changes in their environment.
Table of Contents takes you straight to the bookdetailed table of contents
Part 1: The road to reactive
1. Why Reactive?
1.1. What does it mean to be reactive?
1.1.1. The heart of the Reactive Manifesto
1.1.2. Reactive systems vs reactive programming
1.2. Applying Akka.NET
1.2.1. Where to use Akka.NET
1.2.2. Where not to use Akka.NET
1.3. How does Akka.NET work?
1.4. What will you learn in this book?
1.5. Conclusion
2. Reactive Application Design
2.1. Basic reactive system design
2.2. Reactive e-commerce application design with actors
2.2.1. A reactive shopping cart
2.2.2. Changing states of actors
2.2.3. Making the purchase
2.2.4. Data transfer between services
2.2.5. Scaling work with routers
2.2.6. Reactive application design patterns summary
2.3. Building on top of the reactive foundations
2.3.1. Publishing the e-commerce application to the world
2.3.2. Storing state within actors
2.3.3. Scaling out across a cluster of machines
2.3.4. Continuing to react to environmental changes
2.3.5. Building on top of the reactive foundations summary
2.4. Summary
Part 2: Digging in
3. Your First Akka.Net Application
3.1. Setting up an application
3.2. Actors
3.2.1. What does an actor embody?
3.2.2. What can an actor do?
3.2.3. Defining an actor
3.2.4. Summary
3.3. Spawning an actor
3.3.1. The actor system
3.3.2. Spawning an actor
3.3.3. Summary
3.4. Communicating with actors
3.4.1. Actor addresses and references
3.4.2. Sending a message
3.4.3. Summary
3.5. Case Study: Actors ? Concurrency ? Phone billing
3.5.1. Summary
4. State, behavior and actors
4.1. Preparing for the next message
4.2. Setting appropriate receive behavior in Akka.NET
4.2.1. Switchable behaviors
4.2.2. Become and Unbecome
4.2.3. Switchable behavior summary
4.3. Finite state machines
4.3.1. Understanding finite state machines
4.3.2. The use in a concurrency model
4.3.3. Converting a finite state machine into an actor
4.3.4. Using the finite state machine actor
4.3.5. Finite state machine summary
4.4. Case Study: State machines ? States + events ? Marketing analytics campaign
4.5. Summary
5. Configuration, Dependency Injection and Logging
5.1. Why do you need configuration?
5.2. Configuring an actor deployment
5.2.1. Understanding Props
5.3. Actor configuration summary
5.4. Dependency injection
5.4.1. Introducing dependency injection
5.4.2. Configuring an inversion of control container
5.4.3. Dependency injection summary
5.5. HOCON ? A human-readable configuration file format
5.5.1. What is HOCON?
5.5.2. Loading configuration into an actor system
5.5.3. HOCON summary
5.6. Logging
5.6.1. Why do you need logging?
5.6.2. Writing to the log
5.6.3. Customising a logger deployment
5.6.4. Logging summary
5.7. Case Study: Configuration ? Distributed systems ? Docker?
5.8. Summary
6. Failure Handling
6.1. Understanding failures
6.2. Handling application-level failures
6.2.1. Responding to application errors
6.2.2. The Akka.NET supervision tree
6.2.3. Failing fast
6.2.4. The actor lifecycle
6.2.5. Watching for the deaths of other actors
6.2.6. Interface-level failures
6.2.7. Application-level failures summary
6.3. Understanding transport-level failures
6.3.1. Writing applications that handle message loss
6.3.2. Transport-level failure summary
6.4. Case Study: supervision ? failure ? chat bots
6.5. Summary
7. Scaling in reactive systems
7.1. Scaling up and scaling out
7.2. Distributing work
7.2.1. Routers
7.2.2. Pools and groups
7.2.3. Distributing work summary
7.3. Routing strategies within Akka.NET
7.3.1. Random routing
7.3.2. Round robin routing
7.3.3. Shortest mailbox queue
7.3.4. Consistent hashing
7.3.5. Scatter gather first completed
7.3.6. Tail chopping router
7.3.7. Routing strategies summary
7.4. Case study: scaling ? throughput ? advertising systems
7.5. Summary
8. Composing actor systems
8.1. Introducing Akka.NET remoting
8.2. Preparing to use remoting
8.2.1. Installing Akka.Remote
8.2.2. Configuring remoting for a project
8.3. Communicating with remote actors
8.3.1. Remote actor system addresses
8.3.2. Sending messages to remote actors
8.3.3. Remote deployment of actors
8.3.4. Remote actor communication summary
8.4. Elastic scale across machines
8.4.1. Configuring a router to use multiple machines
8.5. Failure handling across machines
8.5.1. Supervisor strategies across a network
8.5.2. Remoting deathwatch
8.5.3. Failure handling across machines summary
8.6. Akka.Remote security
8.6.1. Limiting messages able to be sent over the network
8.6.2. Restricting available remote actor targets
8.6.3. Akka.Remote security summary
8.7. Case study: remoting ? network applications ? web server and backend server
8.8. Summary
Part 3: Real-life usage
9. Testing Akka.Net actors
9.1. Introducing Akka.TestKit
9.2. Unit testing actors
9.2.1. Spawning test actors
9.2.2. Validating internal data
9.2.3. Testing FSMs
9.2.4. Unit testing actors summary
9.3. Integration testing actors
9.3.1. Creating test specifications
9.3.2. Asserting message responses
9.3.3. Time-based testing
9.3.4. Test probes
9.3.5. Integration testing actors summary
9.4. Testing distributed applications with the MultiNode Testkit
9.4.1. MultiNode specs
9.4.2. Running code on individual actor systems
9.4.3. Barriers
9.4.4. Testing for network failure
9.4.5. MultiNode Testkit summary
9.5. Case study: testing ? test-driven development ? unit testing
9.6. Summary
10. Integrating Akka.Net
10.1. Integrating with ASP.NET
10.2. Integrating with SignalR
10.2.1. Communicating through an actor
10.2.2. Connecting to the user?s web browser
10.2.3. Integrating with SignalR summary
10.3. Custom integrations with Akka.IO
10.3.1. Creating a listen server
10.3.2. Sending data through Akka.IO
10.3.3. Akka.IO Summary
10.4. Case study: IO ? integration ? IoT applications
10.5. Summary
11. Storing actor state with Akka.Persistence
11.1. Understanding event sourcing
11.2. Using Akka.Persistence
11.2.1. Writing persistent actors
11.2.2. Configuring a journal
11.2.3. Using Akka.Persistence summary
11.3. Akka.Persistence performance tuning
11.3.1. Snapshot stores
11.3.2. Async write journals
11.4. Akka.Persistence performance tuning
11.4.1. At-least-once delivery
11.4.2. Upgrade strategies for applications using event sourcing
11.5. Case study: persistence ? storage ? staged upgrades
11.6. Summary
12. Building clustered applications with Akka.Cluster
12.1. Introducing Akka.Cluster
12.2. Cluster aware routers
12.2.1. Creating cluster aware router groups
12.2.2. Creating cluster aware router pools
12.2.3. Cluster-aware routers summary
12.3. Working with cluster gossip
12.3.1. Retrieving the cluster state
12.3.2. Handling cluster gossip messages
12.3.3. Working with cluster gossip messages summary
12.4. Cluster singleton
12.5. Cluster sharding
12.5.1. Creating a new shard
12.5.2. Communicating with actors in a shard
12.5.3. Handling passivation within shards
12.5.4. Akka.Cluster.Sharding summary
12.6. Distributed publish and subscribe
12.6.1. Topic-based messaging
12.6.2. Point-to-point messaging
12.6.3. Distributed publish/subscribe summary
12.7. Cluster client
12.8. Case study: clustering ? scaling ? cluster management
12.9. Summary
13. Applying Akka.Net and reactive programming to a production problem
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
13.10. Conclusion
About the Technology
Reactive Applications with Akka.NET begins with an overview of reactive and a sample application written in the reactive style. You'll learn concepts of the actor model and what these mean in a real-world reactive context. This hands-on book builds on fundamental concepts to teach you how to create reliable and resilient applications. You'll also learn useful Akka.NET features for building real-world applications. By the end of the book, you'll be able to look at a problem domain and understand how to create applications which are able to withstand the demands of a modern day application.
What's inside
- Real-world applications of Akka.NET and reactive applications
- Designing an Internet of Things architecture with reactive in mind
- Building applications to handle the demands of the modern era of software
- Integrating Akka.NET with your existing .NET stack
- Deploying Akka.NET applications to the cloud
Manning Early Access Program (MEAP)
Read chapters as they are written, get the finished eBook as soon as it’s ready, and receive the pBook long before it's in bookstores.
- customers also bought these items
- Microservices in .NET Core
- Akka in Action
- Entity Framework Core in Action
- .NET Core in Action
- C# in Depth, Fourth Edition
- Rx.NET in Action
- customers also bought these items
- Get Programming with F#
- Microservices in .NET Core
- Concurrency in .NET
- Functional Programming in C#
- C# in Depth, Fourth Edition
- ASP.NET Core in Action
placing your order...
Don't refresh or navigate away from the page.FREE domestic shipping on three or more pBooks
Essential reference to using Akka.NET.
An excellent in depth and practical book which should be read by anyone who is interested in developing and designing next generation concurrent applications.