Index
A
- acks, Acks
- actor hierarchies, Bulkheading-Bulkheading
- Actor Model, The Actor Model-Conclusion, Akka Actor, Akka’s Implementation of the Actor Model-Changing behavior
- communication through messages, Actors Can Communicate Only Through Messages-Actors Can Communicate Only Through Messages
- compared to object-oriented programming, All Computation Is Performed Within an Actor
- computation required within actors, All Computation Is Performed Within an Actor-All Computation Is Performed Within an Actor, Everything Is an Actor
- everything represented by actors, All Computation Is Performed Within an Actor, Everything Is an Actor-Everything Is an Actor
- functional programming used within, Defining Clear Boundaries-Defining Clear Boundaries
- implementing, criteria for, Deconstructing the Actor Model-Everything Is an Actor
- mapping DDD concepts to, Components of DDD
- scalability with, Scalability, Follow the Actor Model
- when to use, Uses of the Actor Model-Conclusion
- actor reference (ActorRef), Akka Actor
- direct injection of, Constructor Dependency Injection
- for repositories, Repositories
- sending as a message, Actor reference as a message
- actor selection (actorSelection), actorSelection via Path-Conclusion
- actor systems, Actors Can Create Child Actors, Actor Systems
- actors, Preface, Akka Actor-Child Actors
- address of, Actors Can Communicate Only Through Messages, Actors Can Create Child Actors, Remoting: Actors on Different JVMs
- Ask pattern with, Ask Pattern and Alternatives-Alternatives to Ask
- behavior of, changing, Actors Can Change Their State or Behavior-Actors Can Change Their State or Behavior, Akka Actor, Changing behavior
- behavior of, type for (see Akka Typed)
- bounded contexts as, Bounded Contexts
- child actors, Actors Can Create Child Actors-Actors Can Create Child Actors, Child Actors-Child Actors, Creating new actors
- communication between (see messages)
- computation required within, All Computation Is Performed Within an Actor-All Computation Is Performed Within an Actor, Everything Is an Actor
- creating, Constructor Dependency Injection
- designing, Starting Small-Conclusion
- Entities mapped to, Domain Entities
- errors handled by, Child Actors
- finite-state machine actors, Changing behavior
- isolation of, All Computation Is Performed Within an Actor
- local actors, Akka Is Distributed by Design
- master and worker actors, Work Pulling-Work Pulling
- modeling finite-state machines using, Actors Can Change Their State or Behavior, When Is the Actor Model Appropriate?
- parent (supervisor) actors, Child Actors, Aggregates and Aggregate Roots
- path as reference to, actorSelection via Path
- remote actors, Akka Is Distributed by Design, Remoting: Actors on Different JVMs
- (see also clustering; remoting)
- replyTo actor, Alternatives to Ask
- repositories as, Repositories
- representing everything in a system, All Computation Is Performed Within an Actor, Everything Is an Actor-Everything Is an Actor
- services as, Domain Services
- sharding, Sharding in Akka-Sharding in Akka
- state of, changing, Actors Can Change Their State or Behavior-Actors Can Change Their State or Behavior, Akka Actor
- state of, encapsulating, Encapsulating State in Actors-Mixing Futures with Actors
- traits for, Akka’s Actors in the Actor Model, The Akka Typed Project
- using within Actor Model, Deconstructing the Actor Model
- wrapper actor, Mixing Futures with Actors, Ask Pattern and Alternatives
- address of actor, Actors Can Communicate Only Through Messages, Actors Can Create Child Actors
- aggregate roots, Aggregates and Aggregate Roots-Aggregates and Aggregate Roots, Sharding Aggregate Roots-Sharding Aggregate Roots
- aggregates, Aggregates and Aggregate Roots-Repositories
- Akka, What Is Akka?-Akka Is Distributed by Design
- active development of, Akka Is Under Active Development
- Actor Model (see Actor Model; actors)
- availability (see availability)
- clustering (see clustering)
- consistency (see consistency)
- data flow (see data flow)
- distributed development using, Akka Is Distributed by Design, Bounded Contexts, Increase Parallelism
- domain-driven design (see DDD)
- fault tolerance (see fault tolerance)
- languages supported by, Akka Is Open Source
- performance (see performance)
- remoting (see remoting)
- scalability (see scalability)
- support for, Akka Components
- testing (see TestKit)
- Akka Circuit Breaker, Controlling Failures by Using Circuit Breakers-Controlling Failures by Using Circuit Breakers, Graceful Degradation
- Akka Cluster, Isolating Failure by Using Akka Cluster
- Akka cluster sharding, Isolating Failure by Using Akka Cluster
- Akka HTTP, Akka HTTP, Akka HTTP
- Akka Persistence, At Least Once, Cluster Singleton, Persistence, Fatal errors in the JVM
- Akka Streams, Akka Streams, Akka Streams-Using Akka Streams
- back pressure, Back Pressure in Akka Streams
- example using, Using Akka Streams-Using Akka Streams
- flow, Flow
- junctions, Junctions
- RunnableGraph, RunnableGraph-RunnableGraph
- sink, Sink-Sink
- source for, Source-Source
- Akka Typed, The Akka Typed Project
- Apache Kafka queuing system, Work Pulling
- application status pages, Health Checks and Application Status Pages-Health Checks and Application Status Pages
- ask method, Ask
- Ask pattern, Ask Pattern and Alternatives-Alternatives to Ask
- asynchronous nature of reality, Reality Is Eventually Consistent-Reality Is Eventually Consistent
- At Least Once delivery, At Least Once-At Least Once, Fatal errors in the JVM, Dealing with External Service Failures
- At Most Once delivery, At Most Once
- autodowning, Cluster leader
- availability, Availability-Watchdog Tools
- cluster-aware routers for, Cluster-Aware Routers-Cluster-Aware Routers
- distributed data for, Distributed Data-Distributed Data
- during deployment, Deployment-Blue/Green Deployment
- for microservices, Microservices Versus Monoliths
- for monolithic applications, Microservices Versus Monoliths
- operational monitoring for, Crash Recovery/Operational Monitoring-Watchdog Tools
B
- back pressure, Back Pressure, Back Pressure in Akka Streams
- balancing dispatchers, Balancing Dispatcher
- bang (see tell method)
- become operation, Akka Actor, Changing behavior, Encapsulating State by Using become-Encapsulating State by Using become
- behavior of actors
- changing, Actors Can Change Their State or Behavior-Actors Can Change Their State or Behavior, Akka Actor, Changing behavior
- type for (see Akka Typed)
- Bishop, Peter (“Universal Modular Actor Formalism for Artificial Intelligence”), Deconstructing the Actor Model
- blocking bounded mailboxes, Bounded Mailboxes
- blocking operations
- isolating, Isolate Blocking Operations
- reducing, Reduce or Isolate Blocking Sections
- blue/green deployment, Blue/Green Deployment
- books and publications
- about Actor Model, Deconstructing the Actor Model
- about domain-driven design, Distributed Domain-Driven Design
- bottlenecks, isolating, Isolating Bottlenecks
- (see also performance)
- bounded contexts, Bounded Contexts-Conclusion, Graceful Degradation-Graceful Degradation, Bounded Contexts as Microservices
- bounded mailboxes, Bounded Mailboxes-Bounded Mailboxes
- bulkheading, Bulkheading-Bulkheading
C
- calling-thread dispatchers, Calling-Thread Dispatcher
- CAP theorem, Consistency Boundary
- child actors, Actors Can Create Child Actors-Actors Can Create Child Actors, Child Actors-Child Actors, Creating new actors
- circuit breakers (see Akka Circuit Breaker)
- cluster sharding, Cluster sharding-Distributed domains with cluster sharding, Cluster Sharding and Consistency-Using Cluster Sharding for Consistency
- actors in, Sharding in Akka-Sharding in Akka
- aggregate roots, Sharding Aggregate Roots-Sharding Aggregate Roots
- consistency with, Consistency Boundary-Consistency Boundary, Using Cluster Sharding for Consistency-Using Cluster Sharding for Consistency
- distribution of shards, Shard Distribution
- passivation with, Passivation
- persistence with, Persistence
- scalability boundary in, Scalability Boundary
- shard key, Sharding, Shard Key Generation
- cluster singleton, Cluster Singleton-Cluster Singleton, Staged Deployment/Rolling Restarts
- cluster-aware routers, Cluster-Aware Routers-Cluster-Aware Routers
- clustering, Clustering: Automatic Management of Membership-Cluster singleton
- (see also remoting)
- convergence in, Clustering: Automatic Management of Membership
- distributed domain with, Distributed domains with cluster sharding
- examples of, Clustering: Automatic Management of Membership
- leader for, Cluster leader
- management of, Clustering: Automatic Management of Membership
- rebalancing of, Cluster leader
- seed nodes for, Clustering: Automatic Management of Membership
- singleton for, Cluster singleton
- split-brain situation in, Cluster leader
- unreachable nodes in, Clustering: Automatic Management of Membership
- commands, Commands Versus Events-Commands Versus Events
- concurrency
- Actor Model for, When Is the Actor Model Appropriate?
- with actors, Mixing Futures with Actors
- compared to parallelism, Concurrency Versus Parallelism
- with futures, Mixing Futures with Actors-Mixing Futures with Actors
- potential problems with, Starting Small, Encapsulating State by Using Fields, Mixing Futures with Actors
- with routers, Routers-Routers
- slow consumer problem, Mailboxes-Rate Monitoring
- with streams, Streams-Streams
- traits handling, Encapsulating State by Using Fields
- ConductR tool, Fatal errors in the JVM
- Conflict-Free Replicated Data Types (CRDTs), Distributed Data
- consistency, Consistency and Scalability-Strong Versus Eventual Consistency
- affecting scalability, Cluster Sharding and Consistency
- cluster sharding with, Cluster Sharding and Consistency-Using Cluster Sharding for Consistency
- eventual, Scalability
- global, Conclusion, Why Globally Consistent Distributed State Doesn’t Scale
- immediate compared to eventual, Strong Versus Eventual Consistency
- parallelism affecting, Consistency and Scalability
- of transactions, Transactions and Consistency
- consistency boundary, Consistency Boundary-Consistency Boundary
- constructor dependency injection, Constructor Dependency Injection
- contact information for this book, How to Contact Us
- contexts, bounded (see bounded contexts)
- contrib library, Contrib
- conventions used in this book, Conventions Used in This Book
- convergence, in clustering, Clustering: Automatic Management of Membership
- crash recovery, Child Actors, Dealing with Failures-Fatal errors in the JVM, Crash Recovery/Operational Monitoring-Watchdog Tools
- (see also fault tolerance)
- CRDTs (Conflict-Free Replicated Data Types), Distributed Data
D
- data flow, Good Data Flow-Using Akka Streams
- Akka Streams, Akka Streams-Using Akka Streams
- back pressure for, Back Pressure
- mailbox size, potential problems with, Mailboxes-Bounded Mailboxes
- performance characteristics of, Throughput Versus Latency-Throughput Versus Latency
- routers for, Routers-Routers
- streams for, Streams-Streams
- work pulling for, Work Pulling-Work Pulling
- data replication, Distributed Data
- data, distributed (see distributed data)
- DDD (domain-driven design), Distributed Domain-Driven Design-Components of DDD
- adaptability increased by, The Benefits of DDD
- aggregates and aggregate roots, Aggregates and Aggregate Roots-Aggregates and Aggregate Roots
- bounded contexts, Bounded Contexts-Conclusion
- domain services, Domain Services
- Entities, Domain Entities
- factories, Factories and Object Creation
- mapping to Actor Model, Components of DDD
- repositories, Repositories-Repositories
- Value Objects, Domain Value Objects
- DDDD (distributed domain-driven design), Akka Is Distributed by Design, Bounded Contexts, Increase Parallelism
- Decider, in supervisor strategy, Nonfatal exceptions
- degradation, graceful, Graceful Degradation-Graceful Degradation
- delivery guarantees, Delivery Guarantees-Cluster Singleton
- dependency injection, constructor, Constructor Dependency Injection
- deployment, Deployment-Blue/Green Deployment
- dispatchers, Dispatchers-Increase Parallelism
- additional, when to use, When to Use Your Own Dispatchers-When to Use Your Own Dispatchers
- balancing, Balancing Dispatcher
- calling-thread, Calling-Thread Dispatcher
- pinned, Pinned Dispatcher
- standard, The Standard Dispatcher-The Standard Dispatcher
- distributed data, Distributed Data-Distributed Data
- distributed domain, Distributed domains with cluster sharding
- distributed domain-driven design (DDDD), Akka Is Distributed by Design, Bounded Contexts, Increase Parallelism
- domain, DDD Overview
- domain experts, DDD Overview
- Domain Model, DDD Overview-DDD Overview
- domain objects
- collections of (see aggregates)
- creating (see factories)
- Entities, Domain Entities
- Value Objects, Domain Value Objects
- domain services, Domain Services
- domain-driven design (see DDD)
E
- elasticity, Scalability
- encapsulation of actor state, Encapsulating State in Actors-Mixing Futures with Actors
- Entities, Domain Entities
- errors, handling (see crash recovery; fault tolerance)
- Escalate directive, Nonfatal exceptions
- Evans, Eric (“Domain-Driven Design”), Distributed Domain-Driven Design
- event bus, Child Actors, Publish/subscribe
- events, Commands Versus Events-Commands Versus Events
- lifecycle events, Clustering: Automatic Management of Membership, The Akka Typed Project
- persistence using, Persistence, Increase Parallelism
- eventual consistency, Strong Versus Eventual Consistency, Scalability
- Exactly Once delivery, Exactly Once Doesn’t Exist (But Can Be Approximated)-How Do You Approximate Exactly Once Delivery?
- exceptions, Exceptions, Dealing with Exceptions (Let It Crash)-Fatal errors in the JVM
- (see also fault tolerance)
- exclamation mark (!), tell operator, Tell
- external service failures, External Service Failures, Dealing with External Service Failures-Dealing with External Service Failures
- (see also fault tolerance)
F
- factories, Factories and Object Creation
- fallback points, Fatal errors in the JVM
- fatal errors, Fatal Errors in the JVM, Fatal errors in the JVM-Fatal errors in the JVM
- fault tolerance, Fault Tolerance-Conclusion
- exceptions, Exceptions, Dealing with Exceptions (Let It Crash)-Fatal errors in the JVM
- expectations for, Fault Tolerance-Fault Tolerance
- graceful degradation, Graceful Degradation, Graceful Degradation-Graceful Degradation
- handling failures, Fault Tolerance-Fault Tolerance, Dealing with Failures-Conclusion
- isolating failures, Isolating Failures-Controlling Failures by Using Circuit Breakers
- “let it crash”, Child Actors, Dealing with Failures-Fatal errors in the JVM
- types of failures, Types of Failures-Operating System and Hardware-Level Failures
- fields, mutable, Encapsulating State by Using Fields-Encapsulating State by Using Fields
- fine-grained microservices, Fine-Grained Microservices
- finite-state machine
- actors for, creating, Changing behavior
- modeling, Actors Can Change Their State or Behavior, When Is the Actor Model Appropriate?
- flow, for Akka Streams, Flow
- forward method, Alternatives to Ask
- functional programming, within Actor Model, Defining Clear Boundaries-Defining Clear Boundaries
- futures, Mixing Futures with Actors-Mixing Futures with Actors
G
- global consistency, Conclusion, Why Globally Consistent Distributed State Doesn’t Scale, Fault Tolerance, Graceful Degradation
- global state, Avoid Global State
- gossip protocol, Clustering: Automatic Management of Membership
- graceful degradation, Graceful Degradation, Graceful Degradation-Graceful Degradation
H
- hardware-level failures, Operating System and Hardware-Level Failures, Graceful Degradation-Graceful Degradation, Conclusion
- (see also fault tolerance)
- health checks, Health Checks and Application Status Pages-Health Checks and Application Status Pages
- Hewitt, Carl (“Universal Modular Actor Formalism for Artificial Intelligence”), Deconstructing the Actor Model
- high-water marks, High-Water Marks
- HTTP status pages, Health Checks and Application Status Pages-Health Checks and Application Status Pages
- HTTP, Akka (see Akka HTTP)
I
- immediate consistency, Strong Versus Eventual Consistency
- immutable data structures, Akka Is Open Source
- isolation of actors, All Computation Is Performed Within an Actor
J
- junctions, for Akka Streams, Junctions
- JVM (Java Virtual Machine)
- distributed, communicating across (see clustering; remoting)
- tuning, Isolating Bottlenecks
L
- latency, Throughput Versus Latency-Throughput Versus Latency
- leader, of cluster, Cluster leader
- “let it crash”, Child Actors, Dealing with Failures-Fatal errors in the JVM
- lifecycle events, Clustering: Automatic Management of Membership, The Akka Typed Project
- Lightbend ConductR tool, Fatal errors in the JVM
- local actors, Akka Is Distributed by Design
- location transparency, Bounded Contexts, Location Transparency
- logging, Logging
M
- mailboxes, Actors Can Communicate Only Through Messages-Actors Can Communicate Only Through Messages, Message Passing, Streams
- (see also messages)
- bounded, Bounded Mailboxes-Bounded Mailboxes
- size of, monitoring, Performance
- size of, potential problems with, Mailboxes-Bounded Mailboxes
- unbounded, Unbounded Mailboxes
- managers, repositories as, Repositories
- .map, using with futures, Mixing Futures with Actors
- master actors, Work Pulling-Work Pulling
- memory
- Ask pattern using, At Least Once
- cluster singleton pattern using, Cluster Singleton
- metrics involving, Metrics
- out-of-memory error for mailboxes, Mailboxes-Bounded Mailboxes
- passivation using, Passivation
- persistence using, Persistence, Increase Parallelism
- message protocol, Domain Value Objects, Commands Versus Events-Commands Versus Events
- messages, Akka Actor-Child Actors, Message Passing-Publish/subscribe, Commands Versus Events
- (see also commands; data flow; events; mailboxes)
- actor behavior determining handling of, Akka Actor, Changing behavior
- actor references as, Actor reference as a message
- actors handling, increasing, Engage More Actors on Processing the Messages
- as asynchronous, Akka Actor
- At Least Once delivery, At Least Once-At Least Once, Fatal errors in the JVM, Dealing with External Service Failures
- At Most Once delivery, At Most Once
- back pressure for, Back Pressure, Back Pressure in Akka Streams
- for cluster lifecycle events, Clustering: Automatic Management of Membership
- cluster singleton for, Cluster Singleton-Cluster Singleton
- delivery guarantees for, Delivery Guarantees-Cluster Singleton
- Exactly Once delivery, Exactly Once Doesn’t Exist (But Can Be Approximated)-How Do You Approximate Exactly Once Delivery?
- expected response for, Ask
- factories sending to new instances, Factories and Object Creation
- lifecycle events represented by, The Akka Typed Project
- location transparency of, Location Transparency
- mailbox for (see mailboxes)
- ordering of, kept with streams, Streams
- ordering of, not kept with routers, Routers
- processing of, Actors Can Communicate Only Through Messages
- processing time, monitoring, Performance
- processing time, reducing, Make the Message Process in Less Time
- publishing, Child Actors, Publish/subscribe
- repositories sending to aggregates, Repositories
- requirements for, in Actor Model, Actors Can Communicate Only Through Messages-Actors Can Communicate Only Through Messages
- sent over network, Remoting: Actors on Different JVMs
- sent to cluster shards, Cluster sharding
- sent to cluster singleton, Cluster singleton
- sent with tell method, Tell
- serialization of, Remoting: Actors on Different JVMs
- subscribing to, Child Actors, Publish/subscribe
- testing, TestKit
- Value Objects mapped to, Domain Value Objects
- within actor systems, Actor Systems
- work pulling for, Work Pulling-Work Pulling
- metrics, Metrics-Metrics
- microservices, Bounded Contexts, Microservices Versus Monoliths-Microservices Versus Monoliths
- (see also services)
- automated upgrades with, Staged Deployment/Rolling Restarts
- bounded contexts as, Bounded Contexts as Microservices
- fine-grained, Fine-Grained Microservices
- graceful degradation with, Graceful Degradation-Graceful Degradation
- monitoring
- operational, Crash Recovery/Operational Monitoring-Watchdog Tools
- queue-size monitoring, Queue-Size Monitoring
- rate monitoring, Rate Monitoring
- request load, Scalability, Monitor and Tune
- monolithic applications, Microservices Versus Monoliths-Microservices Versus Monoliths
- mutable fields, Encapsulating State by Using Fields-Encapsulating State by Using Fields
N
- nonblocking bounded mailboxes, Bounded Mailboxes
- nonfatal exceptions, Nonfatal exceptions-Nonfatal exceptions
- notification of application status, Watchdog Tools
O
- objects
- domain (see domain objects)
- encapsulating state, Encapsulating State by Using “State” Containers-Encapsulating State by Using “State” Containers
- Observed Remove Set (ORSet), Distributed Data
- online resources (see website resources)
- OOP (object-oriented programming), All Computation Is Performed Within an Actor
- open source, Akka as, Akka Is Open Source
- operating system failures, Operating System and Hardware-Level Failures, Conclusion
- (see also fault tolerance)
- operational monitoring, Crash Recovery/Operational Monitoring-Watchdog Tools
- ORSet (Observed Remove Set), Distributed Data
- OSGi model, Akka OSGi
- out-of-memory error, Mailboxes-Bounded Mailboxes
P
- parallelism
- compared to concurrency, Concurrency Versus Parallelism
- consistency affected by, Consistency and Scalability
- increasing, Increase Parallelism
- parent (supervisor) actors, Child Actors, Aggregates and Aggregate Roots
- passivation, Passivation
- path, referring to actors by, actorSelection via Path
- performance, Performance-Increase Parallelism
- bottlenecks, isolating, Isolating Bottlenecks
- dispatchers, Dispatchers-Increase Parallelism
- latency, Throughput Versus Latency-Throughput Versus Latency
- measurement tools, Performance
- parallelism for (see parallelism)
- relationship to scalability, Scalability-Scalability
- throughput, Throughput Versus Latency-Throughput Versus Latency
- tuning, Tuning Akka-Engage More Actors on Processing the Messages
- persistence, Persistence, Increase Parallelism
- persistent queues, Dealing with External Service Failures
- Phi Accrual failure detection, Clustering: Automatic Management of Membership
- pinned dispatchers, Pinned Dispatcher
- Pipe pattern, Mixing Futures with Actors-Mixing Futures with Actors
- Promise object, Alternatives to Ask
- Props object, The Akka Typed Project, Constructor Dependency Injection
- protocol objects, Commands Versus Events
Q
- question mark (?), ask operator, Ask
- queue-size monitoring, Queue-Size Monitoring
- queuing systems, Work Pulling
- (see also work pulling)
R
- RabbitMQ queuing system, Work Pulling
- rate monitoring, Rate Monitoring
- Reactive Application Development, Preface
- Reactive applications, Akka Is Distributed by Design
- Reactive Manifesto, Akka Is Distributed by Design
- Reactive Streams, Akka Streams
- (see also Akka Streams)
- reality, asynchronous nature of, Reality Is Eventually Consistent-Reality Is Eventually Consistent
- rebalancing of cluster, Cluster leader
- receive methods, The Akka Typed Project
- remote actors, Akka Is Distributed by Design
- remoting, Remoting: Actors on Different JVMs
- (see also clustering)
- replicator, Distributed Data
- replyTo actor, Alternatives to Ask
- repositories, Repositories-Repositories
- resources (see books and publications; website resources)
- Restart directive, Nonfatal exceptions
- restarting applications, Fatal errors in the JVM, Watchdog Tools
- RESTful web services, Akka HTTP
- Resume directive, Nonfatal exceptions
- rolling restarts, Staged Deployment/Rolling Restarts
- routers, Routers-Routers, Cluster-Aware Routers-Cluster-Aware Routers
- RunnableGraph, for Akka Streams, RunnableGraph-RunnableGraph
S
- Scala, Akka written in, Akka Is Open Source
- scalability, Scalability-Monitor and Tune
- Actor Model for, Scalability, Follow the Actor Model
- blocking operations, isolating, Isolate Blocking Operations
- cluster sharding with, Cluster Sharding and Consistency, Scalability Boundary
- compared to elasticity, Scalability
- consistency affecting, Cluster Sharding and Consistency
- global consistency incompatible with, Why Globally Consistent Distributed State Doesn’t Scale
- global state, avoiding, Avoid Global State
- horizontal and vertical, Scalability
- monitoring with, Scalability, Monitor and Tune
- relationship to performance, Scalability-Scalability
- sequential operations, avoiding, Avoid Sequential Operations
- shared state, avoiding, Avoid Shared State
- scalability boundary, Scalability Boundary
- seed nodes, Clustering: Automatic Management of Membership
- sequential operations, avoiding, Avoid Sequential Operations
- serialization, Remoting: Actors on Different JVMs
- service-level agreement (SLA), failure to meet, Failing to Meet a Service-Level Agreement, Controlling Failures by Using Circuit Breakers
- (see also fault tolerance)
- services
- bounded contexts as, Bounded Contexts-Conclusion
- domain (see domain services)
- shard key, Sharding, Shard Key Generation
- sharding of clusters (see cluster sharding)
- shared kernel, Bounded Contexts as Microservices
- shared state, Avoid Shared State
- singleton, cluster, Cluster singleton
- sink, for Akka Streams, Sink-Sink
- SLA (service-level agreement), failure to meet, Failing to Meet a Service-Level Agreement, Controlling Failures by Using Circuit Breakers
- (see also fault tolerance)
- slow consumer problem
- back pressure for, Back Pressure
- mailbox settings for, Mailboxes-Rate Monitoring
- work pulling for, Work Pulling-Work Pulling
- source, for Akka Streams, Source-Source
- split-brain situation, in clustering, Cluster leader
- staged deployment, Staged Deployment/Rolling Restarts
- state
- changing, Actors Can Change Their State or Behavior-Actors Can Change Their State or Behavior, Akka Actor
- encapsulating, Encapsulating State in Actors-Mixing Futures with Actors
- maintaining, Actor Model for, When Is the Actor Model Appropriate?
- persisting, Persistence
- state objects, Encapsulating State by Using “State” Containers-Encapsulating State by Using “State” Containers
- status pages, Health Checks and Application Status Pages-Health Checks and Application Status Pages
- Steiger, Richard (“Universal Modular Actor Formalism for Artificial Intelligence”), Deconstructing the Actor Model
- Stop directive, Nonfatal exceptions
- storage (see repositories)
- streams, Streams-Streams
- supervisor actors (see parent actors)
- supervisor strategy (supervisorStrategy), Nonfatal exceptions-Nonfatal exceptions
T
- tell method, Tell
- “Tell, Don’t Ask” principle, Repositories
- TestKit, TestKit-TestKit
- threads (see dispatchers)
- throughput, Throughput Versus Latency-Throughput Versus Latency
- timeouts, potential problems with, Problems with Ask
- traits, Akka’s Actors in the Actor Model, The Akka Typed Project
- concurrency handled with, Encapsulating State by Using Fields
- repositories as, in Scala, Repositories
- transactions, Transactions and Consistency
- tuning, Isolating Bottlenecks-Engage More Actors on Processing the Messages
- (see also performance)
- Typed project, Akka (see Akka Typed)
U
- ubiquitous language, DDD Overview
- unbecome operation, Changing behavior
- unbounded mailboxes, Unbounded Mailboxes
- “Universal Modular Actor Formalism for Artificial Intelligence” (Hewitt; Bishop; Steiger), Deconstructing the Actor Model
V
- Value Objects, Domain Value Objects
- Vaughn, Vernon (“Implementing Domain-Driven Design”), Distributed Domain-Driven Design
- vector clocks, Clustering: Automatic Management of Membership
W
- watchdog tools, Watchdog Tools
- website resources
- for this book, How to Contact Us
- Reactive Manifesto, Akka Is Distributed by Design
- work pulling, Work Pulling-Work Pulling
- worker actors, Work Pulling-Work Pulling
- wrapper actor, Mixing Futures with Actors, Ask Pattern and Alternatives
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.