What is Akka

Entities are microservices that act as their own in-memory, durable database with strongly consistent transactions. Entity state is sharded horizontally, replicated across regions, and persisted.

// Custom key-value storage
class <<my class>> extends KeyValueEntity 

// Storage for custom state and event types
class <<my class>> extends EventSourcedEntity

// Key value state update
effects()
  .updateState(newCounter)
  .thenReply(newCounter)

// Event driven state changes
effects()
  .persist(event)
  .thenReply(<< return_status >>)

// Event driven state changes
switch (event) {
  case << event_type >> -> << event_handler >>
  case << event_type >> -> << event_handler >>
}

Workflows are long-running, multi-step business processes that can be point-in-time recovered. Workflows are Saga orchestrators for distributed transactions.

// Custom state definitions for workflows
class TransferWorkflow extends Workflow <TransferState>  

// Define the order of steps to be taken
workflow()
  .addStep(withdraw)
  .addStep(deposit, maxRetries(2)) 

// Timeouts and failover for steps or workflows
workflow()
  .timeout(ofSeconds(5)) 
  .failoverTo("failover-handler", maxRetries(0))

// Chainable definitions for steps
step("withdraw") 
  .asyncCall(<< invoke_other_Akka_components >>) 
  .andThen(<< transition_to_next_wf_step >>)

// Effects tell Akka what operations to perform
effects()
  .updateState(<< update_status_of_workflow >>)
  .transitionTo(<< next_workflow_step >>)
  .thenReply("we are running now")

effects().error("workflow shouldn’t start")
effects().reply(currentState())

Timers enable the scheduling of calls for future execution. Timers are used to set timeouts and for verifying the completion status of processes without polling or blocking.

// Schedule up to 50,000 timers with durable response
timerScheduler.startSingleTimer(
  timerName(<>), 
  Duration.ofSeconds(10), 
  componentClient
     .forTimedAction()
     .method(<< timer_handler_method >>))

// Define custom timers and handlers
class OrderTimedAction extends TimedAction {
  effects().asyncDone(<< timer_handler >>)
}

// Guaranteed to run at least once
// Can be scheduled to run at a future time
// Can be cancelled
// Automatically removed upon successful completion
// Rescheduled upon failure with retry limits

Views are aggregations of data that can be queried. Views enable complex reads of data to be independently executed and scaled apart from write operations. Views updates are triggered by events, messages, and state changes.

// Query a View with data from a single entity
@Query("”” SELECT id, name FROM customers 
           WHERE name = :customerName “”") 

// Update a view from a Topic
@Consume.FromTopic(“<< topic_name >>”)

// Parameterized queries
@Query("SELECT id FROM << view_type >> 
  WHERE name = :<< parameter_name >>") 
    queryMethod (String << parameter_name >>) {}

// Multiple results can generate collections or streams
// View indexes created based upon query structure

// Query filter predicates - logical operators
// Query filter predicates - comparison operators
// Query filter predicates - array operators

// Query pattern matching
SELECT * FROM customers WHERE name LIKE 'Bob%'

// Text, numerical, boolean, byte, & timestamps

// Sorting and paging results
SELECT * FROM customers 
  WHERE name = :name 
  AND age > :min_age 
  ORDER BY age DESC

// Joins, multiple tables, and projections

Producers and consumers enable stream-based interaction between Akka services and the outside world. 

// Stream state change events from entities
@Consume.FromEventSourcedEntity(<< akka_entity_name >>) 
@Consume.FromKeyValueEntity(<< akka_entity_name >>) 

// Consume an event with a custom event handler
onEvent(<< entity_event >>) { 
  return switch (event) {
    case << event_type >> -> << handle_event >>
    case << event_type >> -> << handle_event >>
  };
}

// Effects are Akka instructions how to handle an event
effects().done()
effects().ignore()

// Produce a new event with an effect
effects().produce(<< new_event >>, << metadata >>)

// Send events to other Akka services
@Produce.ServiceStream(id = << my_event_stream_name >>) 
@Acl(allow = @Acl.Matcher(service = "*"))

// Views can consume events and update state
effects().updateRow(<< new_state >>)

// Consume and produce CloudEvents from Pub/Sub topics
@Consume.FromTopic(value = “<< topic_name >>“)
@Produce.ToTopic(“<< topic_name >>“)

Interactions between services, components, and the outside world are asynchronous event streams programmed with a simple, procedural style.

// Asynchronously invoke other components
componentClient.<< component_name >> 
  .method(<< your_component_method >>)
  .invokeAsync();

Elastic to workload changes

Akka operating environments perform cold start and automatic adjustment of app instances as traffic spikes or idles.

Logs, metrics and traces visualized within a per-service dashboard or exported to your preferred observability tooling.

Resilient to failures

Akka automatically snapshots app instances and executes change data capture of individual state changes for entities. Akka replays snapshots and entity events sequentially to automate restoration after a failure.  

Akka apps run in an Akka operating environment, which provides automation for elasticity, agility, and resilience. Your apps can deploy into environments managed by us or you. Federate your private regions with public regions available at Akka.io to enable cross-region replication.

Akka provides managed services and self-hosted software that automates the lifecycle of your applications enabling them to maintain their own SLA. Akka environments orchestrate microservices, handle elasticity scaling events, configure gateways and proxies as topologies change, and manage persistence access for entities, events and views.

Operate apps across clouds and geos

Multi-Master Replication of app data across regions with automated cutovers leverage location transparency to enable apps to move from one location to another without users experiencing downtime. 

Zero-downtime upgrades, cloud-to-cloud, serverless to BYOC, and repatriation migrations are all supported.

Freedom to move

Avoid lock-in and downtime during migrations. Akka apps move from one location to another without users experiencing downtime through replication of data across regions with automated cutovers. Support for cloud upgrades, cloud-to-cloud migrations, Serverless to BYOC, and repatriation migrations.

Clustering from within

The Akka runtime executes as an embedded kernel. Akka clustering, also from within, enables your apps to discover, join, participate, and leave a cluster automatically and across networking boundaries.

The Akka runtime

• Scheduling: compute, threads
• Data: flows, shards, replication
• Communication: cluster membership, I/O
• Resilience: self-healing actions, split brain resolution
• Akka creates a ring of physical nodes to execute instances
• Akka places instances in more than 1 bucket for redundancy
• Akka monitors service request traffic to add / remove nodes
• Akka rebalances instances and data as ring size changes