Actor-based message-driven runtime
Akka is an actor-based message-driven runtime for managing concurrency, elasticity and resilience on the JVM with support for both Java and Scala.
In Akka, the communication between services uses asynchronous messaging primitives that optimize for CPU utilization, low latency, high throughput and scalability, and reflects years of hardening, based on contributions from the open source community.
Akka embraces the reality of unplanned errors and adopts a pragmatic “Let It Crash” philosophy using supervision and self-healing to ensure impacted components are reset to a stable state and restarted upon failure.
We're delivering the future of money to over 148 million people worldwide with Akka.PayPal
Based on the actor model
The actor model provides a higher level of abstraction for writing concurrent and distributed systems. It alleviates the developer from having to deal with explicit locking and thread management, making it easier to write correct concurrent, parallel and distributed systems.
Distributed by default
Actors communicate with asynchronous message-passing and are location transparent, which ensures a single unified programming model, with the same semantics, regardless if it is used in a local or distributed context. Allows scaling the system, without changes, from a single process to clusters of hundreds of machines.
Actor supervision hierarchies ensures that every single actor's health is monitored and managed—allowing isolation, detection and recovery from failure, in an fully automated fashion.
When an actor crashes, its parent can either restart it or escalate the failure up to its supervisor, responsible for managing the lifecycle of its children. This enables a clean set of semantics for managing failures in a concurrent, distributed system and allows for writing highly resilient systems that self-heal.
Focus on business logic
Akka, through message-passing, raises the abstraction level from low level plumbing to workflow. This allows you to focus on high-level semantics—communication patterns, how data flows in the application, i.e. the business logic—instead of threads, locks and low level protocols.
The perfect fabric for the Cloud
Stateless, asynchronous, and location transparent, Akka is ideally suited for hybrid cloud architectures and the elastic scaling of cloud platforms. In an experiment with Google, we were able to start a 1000 node Akka cluster on Google Compute Engine (GCE) in less than 4 minutes, which included the time to start the GCE instances.
Streaming back-pressure enabled
Akka Streams is the perfect tool for modelling streaming, data pipelines and workflow, with its built-in support for back-pressure—ensuring steady state through flow control—rich graph DSL for data transformations, and growing ecosystem of drivers for integration (Alpakka project).
Subscription for advanced healing
Network partitions are inevitable when running distributed systems. An annual subscription to Lightbend Reactive Platform enhances Akka cluster resilience and prevents data loss with predefined resolution strategies for recovering unreachable nodes during network partitions.
Subscription for monitoring
An annual subscription to Lightbend Reactive Platform includes expert instrumentation for monitoring Akka. The agent-based approach understands streams, flows, futures, and traces and integrates with existing visualization solutions.