Akka Core

Akka Libraries provide a foundation for designing scalable, resilient, and high-performance systems. They are built around the actor model, which provides a consistent abstraction for concurrent, parallel, and distributed systems.

Key capabilities include:

• Multi-threaded behavior: Avoids low-level concurrency constructs like atomics or locks, managing memory visibility automatically.
• Transparent remote communication: Simplifies networking by allowing components to communicate across systems without manual networking code.
• Clustered, high-availability architecture: Enables elastic scaling (in or out) to support reactive systems.

Akka Libraries serve as the foundation for the Akka SDK (for rapid development with AI assist and automatic clustering) and Akka Automated Operations (a managed solution for auto-elasticity and multi-region high availability).

Akka is a platform for building responsive, resilient, and scalable services. It is composed of three main layers:

1. Akka SDK: Designed for rapid development with AI assistance and automatic clustering. Services built with the SDK are automatically clustered and can be deployed on any infrastructure.
2. Akka Automated Operations: A managed solution for Akka SDK services that handles auto-elasticity and multi-region high availability within your VPC.
3. Akka Libraries: The foundational building blocks used by both the SDK and Automated Operations to provide distributed systems capabilities.

Akka is used for building agentic AI, AI inference, transactional systems, digital twins, IoT, and edge-to-cloud systems.

Akka Cluster provides several high-level tools and patterns for distributed applications:

• Cluster Singleton: Ensures an actor runs as a single instance across the cluster.
• Cluster Sharding: Automatically distributes actors across the cluster nodes.
• Distributed Data (ddata): Provides CRDT-based shared state.
• Distributed Publish Subscribe (pubsub): Enables cluster-wide message broadcasting.
• Group Routers: Allows routing messages to a group of actors distributed across the cluster.
• Reliable Delivery: Provides mechanisms for reliable message delivery between nodes.

The Streams Cookbook provides a collection of 'recipes'—targeted code patterns designed to solve common streaming problems. These recipes serve as:

1. Direct solutions: Code snippets that can be used as-is for small tasks.
2. Starting points: Templates that can be customized for specific business logic.
3. Foundations for Alpakka: Bases for implementing more complex patterns involving Alpakka.

For a complete list of available operators used within these recipes, refer to the operator index.

This documentation covers the Classic Distributed Data API. For new projects or full documentation, it is recommended to use the Typed Distributed Data API instead.

Classic Distributed Data allows you to replicate data across multiple nodes in an Akka cluster using Conflict-free Replicated Data Types (CRDTs). You interact with this data primarily through a Replicator actor.

Beyond the Akka core, several specialized libraries are available to extend functionality for HTTP, gRPC, integration, persistence, and management.

To find the correct version for your project, refer to the Akka libraries versions page. For full SDK documentation, visit doc.akka.io.

Akka Cluster is a fault-tolerant, decentralized peer-to-peer membership service that allows distributed applications to span multiple nodes (typically multiple typed.ActorSystems). It uses a Gossip Protocol and an automatic failure detector to manage membership without a single point of failure or bottleneck.

Key components include:

• Gossip Protocol: Communicates cluster state randomly across nodes.
• Failure Detector: Monitors node reachability using a Phi Accrual implementation.
• Leader: A deterministic role assigned to a node to manage membership state transitions (e.g., moving members from joining to up).
• Seed Nodes: Initial contact points used by new nodes to join the cluster.

By following this tutorial, you will learn how to apply Akka's core principles to a real-world use case, specifically focusing on:

• Actor Hierarchy: Understanding how the parent-child relationship influences actor behavior.
• Actor Granularity: Learning how to decide the appropriate level of detail/scale for creating actors.
• Protocol Definition: How to define communication protocols using messages.
• Conversational Styles: Implementing typical interaction patterns between actors.