In this session you will learn about how companies ranging from the Fortune 500 to brand new startups are changing the way the build .NET applications to leverage the very latest offerings from Microsoft and the .NET open source community. You'll learn how and why companies are moving their applications onto .NET Core; rearchitecting them to use Akka.NET for fault tolerance, scalability, and the ability to respond to customers in real-time; containerizing them with Docker; putting everything together using Kubernetes for orchestration on-premise or on the cloud with Azure Kubernetes Services. This session will provide an overview of how all of these technologies fit together and why companies are adopting them.

1. Real-time Distributed
Applications with Akka.NET,
Kubernetes, and .NET Core
By Aaron Stannard,
CEO, Petabridge

2. Real-time Apps Becoming
Common
Consumer
• Video games
• Social apps
• Chat and remote work
• Personal data monitoring
(credit, payables, health)
• Collaboration & sharing
Enterprise
• Industrial IOT
• Fleet and vehicle tracking
• Workflow processing
• Fraud & risk analysis
• Dynamic pricing
• Healthcare

3. What Makes an App “Real-
time?”

4. Fastest Response Time?

5. Real-time Application
Challenges
• You’re responsible for the consistency of
your state.
• State has to be moved between nodes
during deployments, scaling, and recovery
from failures.
• Deployment tools need to allow for
movement of state at deploy-time.

6. Roadmap

7. Stateful Application
Programming
Using Akka.NET Actors to
Manage & Distribute State

8. What is an Actor?

9. What is an Actor?

10. IActorRef – Actor References

11. Actors Process One Message at
a Time

12. Processes Usually Contain
Many Actors

13. Child-per-Entity Pattern

14. Actors Simplify State
Management
• Actors are serial message processors –
state can’t be modified concurrently.
• State is always shared via passing
immutable messages, thus no side effects.
• Actors can be easily partitioned into
hierarchies of entities.
• IActorRef, the actor reference, is location
transparent. Messages can be shared
across network boundaries automatically.

15. State Distribution, Scaling,
and Fault Tolerance
Akka.Cluster, Akka.Persistence,
and Akka.Cluster.Sharding

16. Highly Available State with
Akka.Cluster
Each node is its
own ActorSystem

17. What Akka.Cluster Does

18. What is a "Cluster?"

20. State Distribution Techniques
• Consistent hash routing
– All events with same entity ID (hash range)
end up in same server
• Akka.Cluster.Sharding
– Uses consistent hashing, but smarter
handling of partition hand-offs
• Writable Replication
(Akka.DistributedData)
– Have state written to multiple places in
network at same time

21. Consistency Strategy:
guarantee maximum of 1
instance of entity actor across
entire cluster

30. Consistent Hash Partitioning

33. State has to be Moved

34. Akka.Persistence: State
Durability

35. Akka.Persistence: State
Recovery

36. Moving State via
Akka.Persistence

37. Doing it in Production with K8s

38. Why Kubernetes?
• Ubiquitous – runs on-
premise, on the cloud,
etc…
• Robust deployment
models – including
handling for stateful
apps.
• Rich ecosystem.

39. Why Azure Kubernetes
Service?
• Takes only a few
minutes to setup.
• Integrates well with
Azure DevOps.
• Great environment for
learning K8s.

40. Kubernetes Core Concepts
• K8s is an “orchestration” platform – networks
multiple container hosts together into unified
abstraction.
• Applications are deployed to the K8s cluster –
K8s then orchestrates the instantiation of
containers across hosts.
• Applications define via configuration:
– Which parts can be exposed publicly and how.
– How different parts of application can be deployed and
managed.

41. Kubernetes Core Concepts

42. K8s Infrastructure on Azure AKS

43. K8s Key Terms (for
Akka.Cluster)
• “Pod” – represents a single application unit
of execution. Consists of 1 or more Docker
container.
• “Stateful set” – a deployment group of
identical pods working together as a
stateful service.
• “Service” – defines how a stateful set
exposes itself to other services within K8s
and Akka.NET cluster.

45. Akka.Cluster K8s Methodology
• All applications are deployed as stateful
sets
– State is fundamental to how Akka.Cluster
works
• All internal Akka.Cluster functionality is
exposed as “ClusterIp” services
• External / public functionality can exposed
as a “LoadBalancer” service or otherwise
• Petabridge.Cmd used for node exits
• Deployments / rollbacks performed by

46. Akka.Cluster Continuous
Deployment Process

47. Learn it Step by Step
https://petabridge.com/cluster