apache/incubator-seata
Incubator Seata
Seata is a distributed transaction coordinator designed to ensure data consistency and atomicity across microservices. It provides a centralized framework for managing global transactions, preventing partial data updates across different databases and services.
The project implements multiple transaction modes to balance consistency and performance. This includes an automatic mode that uses rollback logs to coordinate compensation without modifying business logic, a try-confirm-cancel pattern for resources lacking native ACID support, and a saga orchestration engine for managing long-lived business processes through eventual consistency. It also supports strict atomic execution for databases that implement the XA protocol.
The system features a decoupled compute-storage architecture to enable horizontal scaling of coordinator nodes and a distributed configuration center for real-time synchronization across clusters. It includes capabilities for multi-tenant isolation, namespace environment separation, and a visual workflow designer for modeling transaction sequences.
The framework integrates with various RPC frameworks and uses gRPC for bidirectional streaming between clients and coordinators.
Features
- Distributed Transaction Management - Ensures data consistency across multiple microservices by coordinating global commits and rollbacks.
- Undo Log-Based Rollbacks - Records local data changes to automatically generate and apply undo operations upon transaction failure.
- Transaction Identifier Propagation - Passes global transaction identifiers across microservice boundaries through RPC integration for call-chain tracking.
- Eventual Consistency Orchestrators - Orchestrates consistency across long-lived microservice transactions to ensure eventual data alignment.
- RPC Frameworks - Integrates distributed transaction management across various RPC frameworks to maintain consistency between service architectures.
- Automatic Compensation Mechanisms - Ensures data consistency in relational databases by automatically applying compensation operations during global rollbacks.
- Distributed Transaction Coordinators - Manages global transactions across microservices to ensure data consistency and atomicity.
- Automatic Compensation Coordination - Implements an automatic mode that uses rollback logs to coordinate compensation without modifying business logic.
- Saga Coordinators - Coordinates long-running processes as a sequence of local transactions with corresponding compensating actions.
- Two-Phase Commit Protocols - Ensures atomicity across multiple services by managing a global prepare phase followed by synchronized commit or rollback.
- Try-Confirm-Cancel Implementations - Handles distributed transactions using the Try-Confirm-Cancel pattern for resources lacking native ACID support.
- Database Operation Interceptors - Intercepts database operations to inject distributed transaction logic without requiring changes to business code.
- Consistency Frameworks - Maintains synchronized state across different databases and services using automated compensation and rollback logs.
- Try-Confirm-Cancel Patterns - Implements the Try-Confirm-Cancel pattern to manage distributed consistency by reserving resources in a try phase.
- Distributed Atomic Transactions - Uses the XA protocol to ensure strict atomicity across supported databases.
- Decoupled Compute and Storage Scaling - Separates the transaction coordinator logic from session state storage to enable independent horizontal scaling.
- Global Transaction Session Persistence - Stores global transaction session information using local files, relational databases, Redis, or Raft.
- gRPC Data Streaming - Uses gRPC for high-performance bidirectional data streaming between clients and coordinators.
- Registrar-Based Node Discoveries - Locates available coordinator nodes by querying a naming server using cluster metadata and load balancing.
- Distributed Configuration Management - Provides a centralized store for managing configuration key-value pairs across a server cluster.
- Custom TCC Implementations - Allows the definition of custom prepare, commit, and rollback logic for resources lacking native ACID support.
- Registry-Based Service Discovery - Uses a naming server as a registry to resolve the network locations of coordinator nodes.
- gRPC Implementations - Provides high-performance bidirectional data streaming using gRPC and protobufs for cross-language communication.
- Transactional Queues - Ensures atomicity between local transactions and message delivery by including production as a participant in global transactions.
- XA Transaction Managers - Ensures strong consistency for databases supporting the XA protocol through two-phase commit.
- Data Source Proxying - Intercepts data source operations to coordinate distributed transactions across different storage modes.
- User-Defined Transaction Logic - Provides a mechanism to execute custom prepare, commit, and rollback behaviors for resources lacking native ACID support.
