How Akka Cluster Works: Demo Project with Split Brain Resolver

Automatically recover downed nodes and network partitions

Watch on YouTube

As we continue our How Akka Cluster Works series, it’s time to bring in some powerful features for handling the unavoidable challenges of distributed systems. From node failures to network partitions and split brain scenarios, clustered applications are under regular attack from a variety of mysterious sources. 

Project 2 in our series is based on this Akka Cluster sample project, we look at the dynamics behind failure and recovery with Akka Cluster, especially looking at the difference between DIY recovery and automated recovery with Split Brain Resolver. We demo how SBR handles node failures and network partitions to keep your application cluster as healthy as it can be so that services can restart safely when Kubernetes restarts pods.

What you’ll learn in this video:

• Review of Akka Cluster dashboard and node lifecycles
• What happens when nodes/clusters suffer network issues
• Visualizing the automated resolution strategies of Split Brain Resolver

What you need to get started:

• Git
• Java 8+
• Maven
• Sample project: https://github.com/mckeeh3/akka-typed-java-cluster-sbr

What's Next?

See more "How Akka Works" tutorials:

• Our latest webinar: https://www.lightbend.com/blog/interactive-demo-akka-cluster-nodes-under-attack-visualized
• Video / Demo: https://www.lightbend.com/blog/akka-cluster-quickstart-dashboard-part-1-getting-started
• Full Project: https://www.lightbend.com/blog/how-to-distribute-application-state-with-akka-cluster-part-1-getting-started

We also invite you to visit the Akka website for in-depth documentation, and if you feel like it's time to explore opportunities with Lightbend, you can schedule a demo for your team:

SCHEDULE A DEMO

Author

Hugh McKee

Developer Advocate, Lightbend, Inc.

Twitter: @mckeeh3

Hugh McKee is a developer advocate at Lightbend. He has had a long career building applications that evolved slowly, that inefficiently utilized their infrastructure, and were brittle and prone to failure. Hugh has learned from his past mistakes, battle scars, and a few wins. And the learning never stops. Now his focus is on helping other developers and architects build resilient, scalable, reactive, distributed systems. Hugh frequently speaks at conferences. He is the author of Designing Reactive Systems: The Role Of Actors In Distributed Architecture (O'Reilly).