What you will learn in Akka in Action, Second Edition
Chapter by chapter
Concepts explained in this book
- projectionA database projection is a component that consumes persisted events and maintains a queryable relational representation of selected domain data.
- actorAn actor is an independent computational entity in the actor model that encapsulates state and behavior and communicates through asynchronous messages.
- askThe ask pattern is an actor interaction pattern that sends a request and produces a future or callback-based response, including failure when no response arrives within a deadline.
- actor behaviorAn actor behavior defines how an actor processes its next message and what behavior it uses afterward.
- seed nodeA seed node is a configured cluster node that provides an initial contact point for joining or starting the cluster.
- messageA message is an immutable unit of data exchanged between actors to request processing or communicate an event.
- actor modelThe actor model structures concurrent computation as isolated actors that encapsulate state and behavior and communicate through asynchronous messages.
- AkkaAkka is an open-source toolkit for building concurrent, distributed, and resilient applications on the JVM using actor-based abstractions.
- cluster nodeA cluster node is an individual computing instance that participates as a member of a distributed cluster.
- stateState is the mutable or persistent information that represents an actor's current condition and influences its behavior.
- configurationDeclarative settings that control the behavior and deployment of an Akka application.
- Akka TestKitActorTestKit is an Akka testing utility that provides an actor test environment, including facilities for creating actors and test probes.
- offsetAn offset is a position marker identifying how far a stream consumer has progressed through an ordered sequence of records.
- tellTell is an Akka messaging operation that asynchronously sends a message to an actor without waiting for a reply.
- fault toleranceFault tolerance is the ability of a system to continue operating and preserve important services when components or operations fail.
- asynchronous programmingAn asynchronous operation initiates work without requiring the initiator to wait for its completion.
- cluster shardingakka-cluster-sharding is the Akka library module that provides clustered sharding functionality.
- journalA journal is an append-oriented store that preserves events in write order and supports retrieving them in that order.
- lifecycleA lifecycle is the progression of a system component through defined operational states from startup to removal or termination.
- ShardedDaemonProcessShardedDaemonProcess is an Akka component that maintains a fixed set of daemon-process actors distributed across cluster nodes and rebalances them as cluster membership changes.
- finite-state machineA state machine is a computational model whose behavior depends on a finite or otherwise defined current state and its transitions.
- actor referenceAn ActorRef is an Akka reference that identifies an actor and provides the means to send messages to it without exposing the actor object itself.
- fault isolationFault isolation is the containment of a component failure so that the failed component can be terminated without necessarily stopping unrelated components.
- separation of concernsSeparation of concerns is the division of software into parts whose responsibilities are distinct and independently manageable.
- serializationMarshalling is the conversion of in-memory data or objects into a representation suitable for transmission in a communication protocol.
- ActorSystemAn Akka ActorSystem is the runtime container and entry point for creating and managing actors, their execution, and lifecycle.
- Akka ManagementAkka Management is a toolkit for operating Akka applications by exposing management, health, and cluster-control capabilities.
- group routerA group router is an Akka router whose routees are created externally and discovered through receptionist registrations under a service key.
- file watcherA file watcher is a process or actor that tracks file changes and directs newly added files to another component for processing.
- timeoutTimeout is an Akka value that represents the maximum duration allowed for an asynchronous operation before it is treated as timed out.
- recoveryA recovery strategy is a planned response that restores operation or limits the effects of a fault or failure.
- TestProbeTestProbe is an Akka Typed test utility that receives messages from actors and provides operations for inspecting and asserting them.
- restart strategyA restart strategy terminates and recreates a failed actor while retaining its actor reference and mailbox for subsequent message processing.
- actor protocolAn actor protocol is the set of message types and communication rules that defines how an actor can be addressed.
- routeeA routee is an actor that a router can select as the destination for a message.
- protocol bufferProtocol Buffers is a language-neutral schema format and serialization mechanism for structured data with generated language bindings.
- eventsByTagThe eventsByTag stream is a Persistence Query stream that emits persisted events associated with a specified tag.
- akka-management-cluster-bootstrapCluster Bootstrap is an Akka mechanism that discovers network nodes and uses them to form a cluster without static node configuration.
- at-least-once deliveryAt-least-once delivery is a processing guarantee in which records may be delivered or processed more than once because retries can repeat work.
- worker actorA worker actor processes an assigned individual piece of a larger task and may return a result to a coordinating actor.
- concurrencyThe property of structuring processes so that they can function simultaneously or overlap in time without requiring simultaneous execution.
- BehaviorTestKitBehaviorTestKit is an Akka Typed testing utility that runs actor behavior under test and exposes generated effects, messages, and log output for inspection.
- PersistenceIdA persistence ID is a stable unique identifier for a persistent entity's durable state and event stream.
- shard regionA shard region is an Akka Cluster Sharding component on a node that routes messages to entities and contains or communicates with shards.
- entityA sharding entity is an actor instance identified and placed by cluster sharding, with at most one instance active in the cluster.
- eventAn event is a stored record of a state-changing outcome generated by a persistent actor after processing a command.
- Persistence QueryPersistenceQuery is the Akka API component that provides access to a configured ReadJournal implementation.
- ClusterAkka Cluster is the Akka module that coordinates actors and runtime nodes into a distributed cluster.
- timerA timer is a scheduling mechanism that sends a specified message after a configured delay, typically once or repeatedly.
- effectAn Akka Typed test effect is a recorded representation of an actor-context action such as spawning, stopping, or scheduling.
- EntityTypeKeyEntityTypeKey is an Akka Cluster Sharding identifier that represents an entity type and is used to create or address sharded entities.
- remote procedure callA remote procedure call is a communication mechanism that invokes an operation in another process or system as though it were a local procedure.
- mapAsyncUnorderedmapAsyncUnordered is an Akka Streams operator that applies asynchronous processing with bounded parallelism while emitting results as they complete rather than preserving input order.
- behavior functionA behavior function is a function that defines how an actor processes messages and determines its subsequent behavior.
- masterA master is an application actor that coordinates worker actors, sends them processing tasks, and aggregates their results.
- partitioning keyA partition key is a value used to deterministically assign an entity or actor to a distribution partition.
- stop strategyA stop strategy is a supervision decision that terminates a failed actor so that it no longer processes messages.
- actor supervisionActor supervision is a fault-management pattern in which parent actors monitor child actors and respond to their failures.
- container imageA Docker image is an immutable package containing an application, its dependencies, and the metadata needed to create a Docker container.
- discoveryDiscovery is a mechanism for locating actors, services, or cluster nodes across available network destinations.
- split brain resolverSplitBrainResolverProvider is an Akka cluster provider that configures split-brain resolution behavior for downing decisions.
- server streamingServer streaming is a remote procedure call pattern in which one client request produces multiple server responses.
- Akka PersistenceAkka Persistence is an Akka module for building actors whose state can be durably stored and recovered from persisted events or snapshots.
- Alpakka KafkaAlpakka Kafka is an Alpakka connector library that integrates Akka Streams with Apache Kafka for producing and consuming records.
- consistent hashingConsistent hashing is a hashing algorithm that assigns keys to a changing set of nodes while minimizing key reassignment when nodes are added or removed.
- event sourcingEvent sourcing is a persistence technique that stores state changes as an ordered sequence of events and reconstructs current state by replaying them.
- JavaAppPackagingJavaAppPlugin is an sbt-native-packager plugin that provides packaging and deployment support for Java applications.
- exceptionAn exception is an abnormal computational condition that interrupts normal program processing and can trigger failure handling.
- sealed traitA sealed trait is a Scala trait whose permitted direct subtype cases are restricted so the compiler can check pattern-match exhaustiveness.
- blockingBlocking I/O is input or output whose calling execution path waits until the operation completes or fails.
- ReadJournalReadJournal is an Akka Persistence Query interface that provides methods for reading events from a journal.
- SerdeA SerDe is a serializer-deserializer component that converts structured data to and from a storable or transferable representation.
- Kubernetes DeploymentA Kubernetes Deployment is a workload resource that declaratively manages replicated pods and their rollout configuration.
- scalabilityScalability is the ability of a system to adapt to changes in resource demand without negatively affecting performance.
- commandA command is a protocol message type representing a request that can be sent to an actor.
- receptionistThe Akka receptionist is a service registry that lets actors register under keys and lets other actors subscribe to discover those registrations.
- persistent actorA persistent actor is an actor whose state is durably recorded so it can be recovered after failures and restarts.
- cluster singletonA cluster singleton is an actor pattern that maintains one actor instance across an entire cluster and relocates it after node failure.
- Cluster HTTP submoduleAkka Management Cluster HTTP is an Akka Management module that exposes HTTP endpoints for reading and modifying cluster-node state.
- restartWithBackoffrestartWithBackoff is an Akka supervision strategy that restarts an actor after exponentially increasing delays bounded by configured minimum and maximum backoff intervals.
- DockerPluginDockerPlugin is an sbt-native-packager format plugin that builds a project artifact as a Docker image.
- implicit argumentAn implicit argument is a Scala method argument that the compiler can automatically supply from a compatible implicit value.
- non-cpu-bound serviceA non-CPU-bound service is an external operation whose latency is dominated by waiting rather than local processor computation.
- JdbcProjectionJdbcProjection is an Akka Projection component that processes event streams and writes projected data to a JDBC-accessible database.
- Akka gRPCAkka gRPC is an Akka library that generates and supports gRPC clients and servers for Scala and Java applications.
- sourceA Source is an Akka Streams processing stage that emits elements and has a materialized value.
- handlerAn event handler is a function that applies a persisted event to an actor's state during normal processing or recovery replay.
- sequence numberA sequence number is an ascending ordinal identifying an event's position within an entity's event stream.
- futureSourcefutureSource is an Akka Streams source operation that creates a source from a future producing another source.
- RestartSourceRestartSource is an Akka Streams source factory that recreates an upstream source after failure according to configured restart settings.
- aggregatorAn aggregator is an actor or component that combines multiple processing results associated with the same original message.
- hash valueA hash code is a deterministic numeric value computed from input data for use in partitioning or lookup.
- hash functionA hashing algorithm is an algorithm that deterministically maps input data to hash values.
- virtual nodeA virtual node is a logical position in a consistent-hashing partition that is assigned to a physical routee.
- fallback configurationA fallback configuration is a lower-precedence configuration that supplies values missing from a higher-precedence configuration.
- producer settingproducerSettings is an Akka Kafka configuration object or builder describing producer connection and behavior settings.
- ProducerRecordProducerRecord is a Kafka record type containing the data and destination topic information that a producer sends to Kafka.
- let it crashThe let-it-crash principle is a fault-tolerance approach in which failed components are allowed to terminate so that supervision can restart or replace them.
- JacksonCborSerializercbor-jackson is a serialization binding that encodes data in CBOR using Jackson-based Akka serialization support.
- directiveAn Akka HTTP directive is a reusable routing component that extracts request information, applies conditions, or provides route behavior.
- exactly-once deliveryEffectively-once delivery is a processing guarantee that combines at-least-once processing with deduplication so that duplicate processing has one externally visible effect.
- CommittableMessageConsumerMessage.Committable is an Akka Kafka type for an element that carries offset or acknowledgement information suitable for committing.
- CommittableOffsetCommittableOffset is an Alpakka Kafka handle representing a consumed record position that can be committed.
- ServiceKeyServiceKey is an Akka Typed identifier used to register and discover actors that provide a particular service protocol.
- ConfigFactoryConfigFactory is the Typesafe Config API object that loads and constructs configuration values from resources, files, URLs, and system properties.
- apply methodAn apply method is a specially named Scala method that can be invoked using the enclosing object's name as call syntax.
- EventEnvelopeAn EventEnvelope is a persistence-query data structure containing a journal event together with metadata such as its offset and persistence identifier.
- side effectA side effect is an externally observable operation, such as an HTTP request or database insertion, performed in addition to updating persistent state.
- manager actorA manager actor splits incoming work, delegates pieces to worker actors, and receives their completion notifications.
- exponential backoffA backoff strategy delays successive retries or restarts after failures, typically by progressively increasing the delay.
- akka-http-spray-jsonSprayJsonSupport is an Akka HTTP trait that supplies JSON marshalling and unmarshalling support based on Spray JSON.
- data access objectA data access object is an application-layer object that encapsulates operations for accessing a data store.
- database access abstractionA software abstraction that isolates application logic from the details of database operations.
- stateless systemAn architectural property in which a server does not retain application state between requests.
- snapshotA snapshot is a persisted representation of a persistent actor's state at a point in its event history that accelerates recovery.
- synchronous testingSynchronous actor testing is a sequential technique for testing an actor in isolation in a controlled environment without exercising asynchronous interactions.
- monitoringFailure monitoring is the observation of actors for termination or failure signals so that recovery actions can be taken.
- PreRestartPreRestart is an Akka Typed lifecycle signal delivered to an actor before the actor is removed for restart.
- acknowledgmentAn acknowledgment is a message or signal confirming that a sent message or operation has been received or processed.
- at-most-once deliveryAn at-most-once delivery guarantee means each record is delivered zero or one time, so records may be lost but are not redelivered.
- flowThe Flow API is the Akka Streams API for constructing linear pipelines that transform elements between sources and sinks.
- partitionA partition is an ordered subdivision of a Kafka topic to which records are assigned and within which offsets identify record positions.
- Behaviors.failedBehaviors.failed is an Akka Typed factory for a failed actor behavior that stops message processing until the actor is restarted or terminated.
- Source.queueSource.queue is an Akka Streams source-construction operation that exposes a queue for asynchronously adding elements to a running stream.
- EventSourcedBehaviorEventSourcedBehavior is an Akka Persistence behavior that processes commands, persists events, and rebuilds state by replaying those events.
- upsertAn upsert is a database operation that inserts a record when no matching record exists and updates the matching record otherwise.
- Akka StreamsAkka Streams is an Akka library for processing bounded or unbounded streams of data with asynchronous, backpressured pipelines.
- Consumer.committableSourceConsumer.committableSource is an Alpakka Kafka source that emits records together with committable offset information for at-least-once processing.
- joining stateThe joining state is the cluster membership state assigned to a node that has requested to join but is not yet fully admitted.
- fault-tolerant workloadA fault-tolerant application is software designed to continue providing acceptable operation despite component failures.
- poisoned mailboxA poisoned mailbox is an actor mailbox in which a repeatedly failing message prevents subsequent messages from being processed.
- supervisor behaviorSupervisor behavior is recovery logic that observes actor failures and selects a predefined response for the failed actor.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.