App data resides in the place where it was created. Snapshots and data changes are persisted for resilience.
Data and logic together
Clustering from within
Our architectural first principles treat the app, not the database, as the system of record for data. Apps cluster from within to optimize access to logic and data.
Apps are in-mem DBs, recoverable, and movable
Apps bundle their transactional data and logic together to eliminate coherence risks. Apps can recover state through event sourcing. Apps have location transparency for execution in environments close to end users.
Apps have multiple read-write instances
Apps can have multiple instances for increasing throughput horizontally and optimizing efficiency. Data is automatically sharded across instances. Write instances replicate and converge modifications to data - like Google docs for your app’s data.
Apps execute across hybrid environments
Apps securely self-organize through masterless clustering with built-in split brain resolution. Apps can federate across clouds, regions, or data centers through reliable gRPC and brokerless messaging.
0 → infinity → 0
Akka apps are microservices that embed an Akka runtime that distributes data everywhere it needs to be. Apps scale along four dimensions to ensure elasticity and resilience.
Scale compute
Actors
- Location transparency
- Message passing
- Single threaded concurrency
Scale data
Data sharding and in-mem re-balancing
- Apps act as in-memory databases
- Data sharded across nodes
- Continual data re-balancing
Scale servers
Masterless clustering & multi-R/W data
- Scale-to-zero rebalancing
- 0ms cold start
- Replicated R/W instances serving same data
Scale regions
Active-Active Synchronization
- Continuous DR
- CRDT replication
- Traffic segregation
Akka runtime
Multi-Master Replication: your app data everywhere it runs, with conflict auto-resolution.
0 → ∞ → 0
Distributing from within
Akka apps are microservices that embed an Akka runtime that distributes data everywhere it needs to be. Apps scale along four dimensions to ensure elasticity and resilience.
Akka apps shard data and segregate queries while applying dynamic compute separately to each entity and view component type.
Replicate and migrate without downtime
Replication
Single Region, Pinned
For data sovereignty
Multi-Region, Replicated Read
For global HA
Operators pin a writable instance to a single region with read-only replicas in other regions.
Multi-Region, Replicated Write
For continuous, WAN-based DR
Writable instances in all regions with replicated changes.
Migrations
Start With One Place
Design, build and deploy apps within a single location.
Regional Migration
Add regions for apps to replicate across.
Custodial Migration
Retire an application in one place after movement to a second.Mix Akka-managed regions with self-managed.
Version & Schema Updates
Apps self-adapt to schema changes with end user traffic rerouting.
Infrastructure Upgrades
Promote read-only regions to writable for rolling infra updates.
Sharded data
App data is partitioned across in-memory, durable nodes. Akka routes user requests to the correct instance.
Data rebalancing
Data shards are re-balanced as the number of runtime nodes changes.
Query elasticity
Data queries are offloaded to separate compute. Services scale their entity and view components separately.
Always recover
Akka apps can auto-recover by persisting state changes. Your app’s state changes are captured as replayable, sequential snapshots and events. The event store is Akka-managed infrastructure that grows and shrinks as needed.
Integration ready
Synchronize
For unreliable environments and digital twins.
Apps synchronize and rationalize their state with a peer instance without concern for data volume, sequence, or network connectivity.
Share
For advertising changes with interested peers.
Apps advertise and broadcast state changes over brokerless, reliable messaging that other apps can subscribe to.
Stream
For continuous real-time data processing.
Apps merge, map, transform, shift, and calculate data in real time with a continuous operating model.
Synthesize
For transforming operational data into analytics.
Apps define projections which modify, push, and propagate data changes into other Akka apps or 3rd party data systems, especially analytics warehouses.
Embedded expertise
Responsive by Design means we build with the proven design patterns from the Reactive Principles - endorsed by 33,000+ experts that signed the Reactive Manifesto. And, we bake them into your services and the Akka runtime so you don’t have to learn or implement them.
Separation of concerns
Joyful Inner Loop
Build aligned teams of delighted developers with an inner loop that abstracts domain logic from distributed dependencies.
Domain separation...
Keep your business logic yours. Build and test domain code like your first 'Hello, World' program. Akka's components inject intelligence at build with an inner loop that moves as fast as your fingers.
without, polluted domain logic
Decorating domain code or calling APIs to distribute data or improve resilience creates technical debt, cross-team friction, and coherence leaks.
Dev like a monolith. Deploy as m10e.
Chained Network Services
Your devs create & debug chained, networked services locally without dependency setup complexities. It’s like having the best of both worlds.
Single Service
Devs leverage their preferred IDE and build tools to create and test stateful services locally. Docker is the only runtime dependency!
Multiple Services
Teams work independently. Akka generates local sandboxes to test your service with its networked dependencies.
DevOps / GitOps Ready
Akka apps are packaged as Docker images and ready for rolling or canary deployments.
