REDck is a cloud‑native, storage‑compute separated real‑time OLAP data warehouse derived from ClickHouse that addresses scalability, operational cost, and reliability challenges through a unified metadata service, object‑storage optimizations, multi‑level caching, distributed task scheduling, and two‑phase commit transactions.
Xiaohongshu built REDck, a cloud‑native, storage‑compute separated real‑time OLAP warehouse on ClickHouse, addressing scaling, cost, and reliability challenges through a unified metadata service, object‑storage optimizations, multi‑level caching, distributed task scheduling, bucketing, and exactly‑once transaction support.
This article examines the challenges of maintaining data consistency across micro‑service boundaries, walks through real‑world payment and gifting scenarios, compares classic solutions such as 2PC, saga, TCC, local‑message tables and transaction messages, and finally recommends a pragmatic approach for building reliable distributed transaction mechanisms.
This article provides a comprehensive overview of Seata, a distributed transaction framework that ensures data consistency across microservices through four transaction modes: AT, XA, TCC, and Saga, each with distinct characteristics and use cases.
This article explains the fundamentals of database transactions, the ACID properties, and why distributed transactions are needed, then walks through the implementation details of redo/undo logs, local transactions, CAP and BASE theory, and evaluates five major distributed‑transaction solutions—2PC, TCC, local‑message tables, maximum‑effort notification, and Saga—with concrete examples, pros, and cons.
Seata 1.7.0, positioned as a stability‑focused release, dramatically improves robustness, adds native‑image support, expands Docker images, resolves numerous bugs across JDK, Spring, and database integrations, enhances security, and provides detailed upgrade and deployment guides for enterprise‑grade distributed transactions.
The article details Shopee’s seadt‑SAGA framework—a Go‑based distributed transaction solution that implements the SAGA pattern via two modes, orchestration with a central coordinator and collaboration with embedded logic, explains their state‑machine designs, compares rollback ordering using vector clocks versus sequence numbers, and discusses each mode’s trade‑offs.
This guide introduces Seata Saga’s distributed transaction model, explains its advantages and drawbacks, walks through deployment, JSON state‑machine design, unit‑test exploration, and best‑practice recommendations for reliable microservice orchestration, including compensation strategies, isolation handling, and performance tuning tips.
This article analyzes the challenges of distributed transactions in a micro‑service order system, compares XA, TCC, and SAGA patterns, and details how the open‑source DTM framework is applied to achieve reliable order creation while handling crashes, rollbacks, idempotency, and network anomalies.
This article explains the design principles of Seata-go's TCC mode, how it handles exceptions, and provides step‑by‑step guidance for implementing and using TCC in Go microservices, along with future roadmap insights.
This article explains the fundamentals of single‑ and multi‑data‑source transactions, surveys common distributed transaction models such as 2PC, 3PC, TCC, status‑table and message‑middleware approaches, and then details the implementation of Seata's AT mode with diagrams, code snippets, and lock handling.
This article presents the design philosophy, overall architecture, multi‑tenant sharding strategy, state‑machine workflow, distributed transaction handling, and high‑availability measures of Vivo’s global e‑commerce transaction platform, sharing practical challenges and solutions encountered during its development and ongoing evolution.
The article details vivo’s transition from a monolithic mall to a micro‑service transaction platform, outlining a multi‑tenant architecture with ShardingSphere‑sharded MySQL, Snowflake IDs, Elasticsearch search, configurable state machines, generic delayed tasks, Seata and local‑message distributed transactions, plus high‑availability safeguards, emphasizing pragmatic solution selection.
This article explores the comprehensive design of order business systems, covering background considerations, order lifecycle management, technical solutions such as ID generation, parallel and asynchronous processing, timeout handling, distributed transactions, and data strategies like sharding and synchronization.
This article explores the core features introduced in Seata 1.6.x—including AT‑mode syntax upgrades, multi‑primary‑key support, optimized request/response networking, lock‑strategy modes, and multi‑registry service discovery—explaining how each improvement boosts performance and flexibility for cloud‑native microservices.
This comprehensive guide explores core distributed system concepts—including the CAP theorem and its trade‑offs, BASE consistency, various distributed lock strategies, multiple transaction patterns such as 2PC, 3PC, TCC and Seata, as well as consensus algorithms Paxos and Raft, while also covering idempotency and rate‑limiting techniques.
This article explains the two‑phase commit protocol, describes how Lucene implements it through a dedicated interface, details the preparation, commit, segment handling, deletion policies, and rollback procedures, and provides code snippets illustrating the core logic.
This article explains the two-phase commit protocol for distributed transactions, details its generic workflow, and describes how Apache Lucene implements the protocol through its TwoPhaseCommit interface, including preparation, flushing, commit, segment handling, deletion policies, and rollback mechanisms with illustrative code examples.
This article explains the challenges of distributed transactions in micro‑service architectures and presents Seata's various solutions—including two‑phase commit, XA, AT, TCC, Saga and message‑based approaches—while covering fundamental concepts such as ACID, CAP and BASE.
This article explains the basic concepts of transactions, distinguishes local and distributed transactions, introduces the CAP and BASE theories, and compares major distributed‑transaction solutions such as 2PC, XA, Seata, TCC, reliable‑messaging and maximum‑effort notification, highlighting their trade‑offs.
This article explains the challenges of distributed transactions in microservice architectures, compares two‑phase and three‑phase commit protocols, introduces Alibaba Seata's middleware and its AT mode, and walks through the complete execution flow with code examples and component diagrams.
This article provides a comprehensive technical overview of distributed transactions, covering basic concepts, local and distributed transaction models, the CAP and BASE theories, two‑phase commit (2PC), XA and Seata implementations, TCC patterns, reliable‑message consistency with RocketMQ, and maximum‑effort notification approaches, along with a comparative analysis of each solution.
Seata 1.6.0 release notes detail major enhancements such as Oracle and PostgreSQL multi‑primary‑key support, Dubbo 3 integration, JDK 17 compatibility, ARM64 Docker images, extensive bug fixes, performance optimizations, test updates, contributor acknowledgments, and links to downloads, documentation, and the GitHub repository.
The article explains how the Saga pattern—using either choreography or orchestration—enables reliable distributed transactions across microservices by coordinating local ACID operations, handling compensating actions, and addressing the challenges of consistency, rollback, and scalability.
This article examines common strategies for handling inter‑service call failures in microservice architectures, comparing blocking retries, asynchronous queues, TCC compensation transactions, local message tables, and MQ‑based transactions, and discusses their advantages, drawbacks, and practical implementation considerations.
This article explains the concept of distributed transactions, presents typical microservice scenarios that generate them, and demonstrates a complete implementation using RocketMQ transactional messages and SEATA, including database schema, producer and consumer code, transaction listeners, and idempotent consumption handling.
This article explains the fundamentals of ACID, compares monolithic and distributed transaction models, and details various distributed transaction strategies—including 2PC, 3PC, TCC, local message tables, MQ transactions, max‑effort notifications, Saga, and Seata—highlighting their mechanisms, trade‑offs, and practical considerations.
This article explains the fundamentals of transactions, the challenges of distributed transactions, introduces ACID, CAP and BASE theories, and compares practical solutions such as two‑phase commit, TCC, Seata, reliable message‑based eventual consistency, and maximum‑effort notification, concluding with a comparative analysis of their trade‑offs.
This article explains the evolution from single‑node MySQL databases to master‑slave replication, various replication modes, high‑availability strategies, and both vertical and horizontal sharding techniques, while discussing the associated challenges such as distributed transactions, routing, and operational complexity.
This article explains the fundamentals of single‑source and multi‑source transactions, reviews common distributed‑transaction patterns such as 2PC, 3PC, TCC, transaction‑status tables and message‑queue based eventual consistency, and then details the implementation and isolation mechanisms of Seata’s AT mode for microservice architectures.
This article explains how RocketMQ implements distributed transaction messages using a two‑phase commit model, detailing the problems with RPC and ordinary MQ, the step‑by‑step workflow, relevant code snippets, and how consistency is ensured across microservice subsystems.
This article explains how to perform full, incremental, and binlog‑based data migrations, compares their trade‑offs, and introduces distributed transaction models such as XA, BASE, TCC, and AT, helping developers choose the right strategy for consistency and performance.
This article explains why database sharding (both vertical and horizontal) is needed to overcome performance bottlenecks, outlines practical thresholds for splitting tables, describes vertical and horizontal partitioning techniques, and discusses key issues such as distributed transactions, cross‑node queries, global primary keys, and scaling strategies.
This article examines how vertical and horizontal data partitioning leads to migration and consistency challenges, outlines full, full‑plus‑incremental, and binlog‑based migration strategies, and compares strong‑consistency XA transactions with flexible BASE approaches such as TCC and AT, including their components, workflows, advantages, and drawbacks.
This article explains the evolution from single‑node MySQL to master‑slave replication, various replication modes, high‑availability solutions such as MHA and MGR, and the challenges and techniques of vertical and horizontal sharding for scaling large‑scale internet applications.
This article explains the challenges of distributed transactions in high‑concurrency systems, compares classic two‑phase commit (2PC) with modern message‑queue‑based reliable delivery, outlines their mechanisms, pros and cons, and provides interview‑ready insights and practical implementation tips for Java developers.
This article explains the challenges of maintaining atomicity across multiple downstream services in distributed systems and details how RocketMQ's transactional message feature provides a two‑phase commit mechanism, lifecycle, implementation details, and practical usage to achieve eventual consistency.
This article explains the fundamentals of distributed transactions, including ACID properties, consistency models, sharding strategies, and the two‑phase, three‑phase, and TCC protocols, while discussing CAP and BASE theories and the challenges of implementing reliable distributed databases.
This article analyzes the challenges of distributed transactions in multi‑node systems and compares various solutions—including 2PC, 3PC, TCC, Saga, local message tables, and MQ‑based approaches—detailing their mechanisms, trade‑offs, and practical implementations with concrete examples from order and cart services.
This article explains the challenges of distributed transactions, reviews common solutions such as 2PC, 3PC, TCC, Saga, local message tables, and MQ‑based approaches, and discusses how RocketMQ, Kafka, and RabbitMQ handle transactional messaging, message loss prevention, and duplicate processing.
This article explains the challenges of distributed transactions in multi‑node systems, reviews common solutions such as 2PC, TCC, Saga, and focuses on implementing eventual consistency using message queues, detailing local message tables, MQ‑based transactions, and loss‑prevention techniques across RocketMQ, Kafka, and RabbitMQ.
This article explains the XA specification, demonstrates MySQL XA commands, and shows how Sharding-JDBC integrates XA transactions using Atomikos, including required dependencies, configuration, annotations, and testing steps, while also providing practical code examples and deployment tips.
Seata 1.5 introduces a stronger Enterprise edition with 20% lower latency and 30% higher TPS, a graphical console, SkyWalking transaction tracing, YAML configuration support, and detailed deployment steps for integrating Seata into Pig microservice projects, complete with code examples and database setup.
This article explains the fundamentals of distributed transactions, covering ACID, CAP and BASE theories, and reviews various consistency solutions such as two‑phase commit, three‑phase commit, TCC, local message tables, MQ approaches and the Seata framework, highlighting their advantages and drawbacks.
The article explains how micro‑service architectures create data‑consistency challenges that require distributed transaction strategies, compares strong‑consistency protocols like 2PC/3PC with eventual‑consistency approaches such as TCC and Saga patterns, and discusses their trade‑offs, implementation complexity, and suitability for real‑world scenarios like a points‑based sign‑in system.
This article explains the concepts of database and table sharding, why they are needed, various vertical and horizontal splitting strategies, range and hash partitioning methods, their advantages and drawbacks, timing considerations, common challenges such as transactions and distributed IDs, and introduces popular sharding middleware.
This article provides a comprehensive guide to Sharding-JDBC, covering the challenges of database sharding such as distributed transactions, cross‑node joins, pagination, global key collisions, and demonstrates practical configuration and code examples for vertical and horizontal partitioning using Spring Boot.
This article compiles core architectural concepts—including ROI, SOLID principles, system splitting, isolation, ACID, CAP/BASE, distributed transactions, and capacity estimation—explaining their definitions, practical examples, trade‑offs, and how they guide architects in making informed technical decisions.
The article explains why distributed transactions in micro‑service architectures are hard—due to remote failures, timeouts, and lack of atomic guarantees—and outlines practical approaches such as unique transaction IDs, audit logs, SQL/NoSQL persistence, TCC, Saga or compensation patterns to achieve reliable consistency while balancing availability.
This article explains the fundamentals of distributed transactions, the ACID properties, various consistency models, database sharding strategies, and the two‑phase, three‑phase, and TCC commit protocols, while also discussing CAP, BASE, and practical challenges in large‑scale systems.
This article explains the fundamentals of distributed transactions, the ACID properties, various consistency models (strong, weak, eventual), sharding strategies (vertical and horizontal), the CAP and BASE theories, and the practical implementations of two‑phase, three‑phase, and TCC commit protocols, highlighting their advantages and drawbacks.
This article explains the concepts, methods, advantages, and drawbacks of database sharding, covering vertical and horizontal partitioning, sharding rules, global primary key generation, distributed transaction issues, cross‑node queries, pagination, data migration, and practical case studies, with code examples and diagrams.
This article explains the concept of consistency in distributed transactions, compares strong and weak consistency, relates it to the CAP theorem, and explores theoretical and practical approaches—including XA, NewSQL, and MVCC—to achieve stronger consistency across databases and micro‑services.
The article walks through the challenges of growing data volumes, compares master‑slave, vertical, horizontal, and sharding‑plus‑partitioning architectures, explains their pros and cons, and provides concrete guidance on selecting and implementing a suitable database solution, including middleware options and real‑world case studies.
This article explains the TCC (Try‑Confirm‑Cancel) transaction model, its three practical variants, common pitfalls such as empty rollbacks, idempotency and hanging, and provides step‑by‑step Java code examples for integrating Seata TCC into a Spring Cloud micro‑service order system.
This article provides a comprehensive overview of Seata, covering its origins, supported transaction modes, installation steps, database initialization, detailed configuration for registry and Apollo, client setup, transaction lifecycle components, and scheduled tasks that manage global and branch transaction states.
The article explains why the naïve "save‑then‑publish" pattern in message‑driven microservices can cause data inconsistency, analyzes failure scenarios, and presents the local outbox pattern with transactional guarantees and eventual consistency as a robust solution.
This article explores the challenges of data consistency in distributed systems, explains fundamental concepts such as CAP and BASE, compares industry solutions like 2PC, Saga, TCC, and local message tables, and shares practical insights from payment service refactoring and Alipay's DTS framework.
This article traces Seata’s development from its 2014 origins as Alibaba’s TXC middleware, through its 2016 cloud service launch and 2019 open‑source release, detailing its architecture, module composition, core roles, and the four transaction modes (AT, TCC, Saga, XA) with practical comparisons.
This article explains the fundamentals of database transactions, defines distributed transactions, and provides a comprehensive comparison of classic solutions such as XA, SAGA, TCC, local message tables, transaction messages, maximum‑effort notifications, and AT mode, while also covering exception handling and the sub‑transaction barrier technique.
This article explains rigid (strong consistency) distributed transactions, detailing the XA protocol and the classic two‑phase commit (2PC) and three‑phase commit (3PC) mechanisms, their workflows, advantages, limitations, and practical considerations for database systems.
This article details the evolution of Vivo's e‑commerce product system from a monolithic design to a modular, high‑performance backend, describing architectural changes, challenges such as stability, scalability, and data consistency, and the technical solutions implemented to address them.
This article examines the signs that a database table has reached its limits, explains why vertical and horizontal sharding are needed, offers concrete sizing formulas, compares hash, range and consistent‑hash partitioning, and shares large‑scale case studies from Suning, JD, Meituan, Ant Financial and Taobao.
This article explains the evolution from local to distributed transactions, detailing the XA protocol, the two‑phase commit process, the LCN framework, the TCC model, and the design of business compensation mechanisms for reliable microservice systems.
This article compares common distributed transaction approaches—including Master‑Slave, Master‑Master, two‑phase and three‑phase commit, and Paxos—explains their mechanisms, trade‑offs, and real‑world implementations such as Alibaba’s TCC, GTS, LCN, and TXC, helping architects select the most suitable solution for high‑availability data consistency.
This article explains distributed transactions, covering ACID properties, consistency models, sharding strategies, the CAP and BASE principles, and detailed mechanisms such as two‑phase commit, three‑phase commit, and the TCC pattern, illustrating how to maintain data integrity across multiple databases.
This article explains the fundamentals of distributed transactions, compares classic solutions such as two‑phase commit (XA), SAGA, TCC, local message tables, transaction messages, and maximum‑effort notifications, and presents a sub‑transaction barrier technique to handle network anomalies and ensure idempotency, isolation, and rollback safety.
This article summarizes the author's extensive experience with microservice adoption, covering its benefits, the challenges of stability, service degradation strategies, distributed transaction patterns, data migration techniques, and practical monitoring using APM tools to help teams successfully transform to microservices.
This article presents a Boshi Fund case study showing how RocketMQ’s decoupling, topic/tag best practices, and transactional messaging streamline multi‑system financial customer‑accompaniment, enhance operational efficiency, and enable reliable distributed transactions in online fund‑purchase scenarios.
This article explains the fundamentals of distributed transactions, compares classic solutions such as XA, Saga, TCC, local message tables, and transaction messages, and presents a sub‑transaction barrier technique that gracefully handles idempotency, empty rollbacks, and hanging issues in microservice architectures.
This article explains the fundamentals of distributed transactions, illustrates classic solutions such as two‑phase commit (XA), SAGA, TCC, local message tables, transactional messaging, and maximum‑effort notifications, and introduces a sub‑transaction barrier technique to handle network anomalies in microservice architectures.
This article introduces the fundamental concepts of distributed transactions, explains ACID and BASE properties, and systematically presents classic solutions such as two‑phase commit, SAGA, TCC, local message tables, transaction messages, maximum‑effort notifications, and sub‑transaction barriers for reliable microservice architectures.
This article explains the principles, advantages, and drawbacks of various distributed transaction solutions—including XA two‑phase commit, three‑phase commit, TCC, Saga, and message‑based eventual consistency—while showing how they are implemented in Java/Spring environments and when each should be used.
This article examines common distributed transaction patterns in micro‑service architectures—including blocking retries, asynchronous queues, TCC compensation, local message tables, and MQ transactions—explaining their mechanisms, advantages, drawbacks, and practical implementation details.
This article explores the challenges of distributed transactions, explains database ACID fundamentals, introduces CAP and BASE theories, compares solutions such as two‑phase commit, TCC, local message tables, MQ transactional messages, and the Sagas model, and presents the open‑source .NET CAP framework with its features and implementation details.
This article provides a comprehensive technical overview of financial‑grade database disaster recovery, covering backup and recovery methods, MySQL replication options, automatic failover architectures, distributed transaction protection, and application‑level stress mitigation techniques.
The article classifies common microservice business scenarios, matches each with suitable distributed transaction patterns such as reliable messages, TCC, SAGA, and XA, and demonstrates practical implementations using DTM, SEATA, and RocketMQ with code examples and a feature comparison table.
The article examines common strategies for handling service call failures and maintaining data consistency in microservice architectures, comparing blocking retries, asynchronous queues, TCC compensation transactions, local message tables, and MQ transactions, highlighting their trade‑offs, implementation details, and practical considerations.
This article explains the fundamentals of distributed transactions, introduces the reliable message eventual consistency approach, analyzes its challenges such as atomicity and message reliability, and presents two practical solutions—local message tables and RocketMQ transactional messages—along with their advantages and drawbacks.
This article explains the principles, workflows, advantages and drawbacks of various distributed transaction solutions—including XA two‑phase commit, Java Transaction API, chained transaction managers, three‑phase commit, TCC, reliable message‑based eventual consistency and maximum‑effort notification—while comparing ACID and BASE theories for modern backend systems.
This article examines distributed transaction protocols—including XA two‑phase commit, JTA, three‑phase commit, TCC, and message‑based eventual consistency—detailing their mechanisms, advantages, drawbacks, and practical usage scenarios in modern backend systems.
This article walks through configuring Spring Boot 2.2.11 with Seata 1.3.0, detailing environment setup, dependency configuration, global transaction activation, proxy bean creation, data source proxying, transaction interceptor mechanisms, XID propagation via RestTemplate and Feign, and the complete commit‑and‑rollback workflow.
This article explains the theory behind TCC distributed transactions, describes its three-phase workflow and roles, and provides a complete Python implementation using the DTM framework, including deployment steps, code examples, and handling of both successful commits and rollbacks.
This article explains the fundamentals of distributed transactions, compares classic solutions such as XA, Saga, TCC, local message tables, and transactional messages, discusses their trade‑offs, and introduces advanced techniques like sub‑transaction barriers to handle network anomalies in microservice architectures.
The article explains how to guarantee data consistency across distributed systems by using local transactions, two‑phase commit protocols, message‑queue based eventual consistency, deduplication techniques, and practical RocketMQ transactional messaging code examples in Java.
The article examines how to prevent data inconsistency during cross‑service money transfers by using local transactions, two‑phase commit, and message‑queue based eventual consistency, providing detailed code examples, performance considerations, and practical solutions for large‑scale backend systems.
This article explains how to guarantee data consistency when updating multiple tables or services by using local transactions for single‑node systems, two‑phase commit for distributed databases, and reliable message‑queue patterns—including RocketMQ transactional messages—to achieve eventual consistency and handle duplicate delivery.
This article examines the challenges of distributed transactions in microservice architectures and compares five practical solutions—Seata (2PC), TCC, transactional messaging, local message tables, and a custom Kola approach—highlighting their principles, implementations, advantages, and prerequisites.
This article introduces the open‑source Seata distributed transaction solution, explains its AT, TCC, SAGA and XA modes, describes the TC‑TM‑RM components and workflow, and provides a step‑by‑step Spring Boot demo with Docker, Maven dependencies, configuration, and code examples for a multi‑service purchase scenario.
This article explains why global transactions are required in distributed systems, compares major transaction models such as XA, LCN, TCC, SAGA, and AT, and provides a detailed overview of Seata's architecture, deployment options, configuration, and code examples for implementing the AT mode in microservice environments.
This article explains the performance bottlenecks of relational databases, introduces sharding concepts such as horizontal, vertical, and table partitioning, discusses associated challenges like distributed transactions and global primary keys, and provides practical solutions and tool recommendations for implementing effective database partitioning.
The article explains why traditional two‑phase commit fails in microservice architectures, introduces the Saga pattern as a solution, compares choreography and orchestration implementations, illustrates a step‑by‑step e‑commerce example, and discusses rollback handling, benefits, and drawbacks.
This article introduces Seata, a high‑performance open‑source distributed transaction solution, explains the Seata‑Golang 1.0.0 release and its demo at a Go meetup, details the core AT‑mode architecture, describes the MySQL driver that integrates Seata‑Golang, and outlines future plans for broader database support.
This article explains the HTAP concept, describes AnalyticDB PostgreSQL’s shift from a single‑master to a Multi‑Master design, details the architecture, distributed transaction handling, global deadlock detection, DDL support, fault tolerance, and presents benchmark results that demonstrate linear scalability for real‑time data‑warehouse workloads.
This article explains the XA protocol, its two‑phase and three‑phase commit mechanisms, the limitations of traditional two‑phase commit, and how Seata implements an optimized XA mode on MySQL with detailed code examples and architectural diagrams.
This article introduces Seata's background, explains the causes of data inconsistency in micro‑service architectures, details Seata's three core roles, transaction flow, isolation levels, common pitfalls with code examples, and provides guidance on high‑availability deployment, multi‑node setups, disaster recovery, and hands‑on demos.
This article explains the importance of distributed transactions in micro‑service architectures, reviews ACID properties, compares various solutions such as 2PC/3PC, XA, local message tables, transactional messages, TCC, Saga, and introduces the Seata framework with its AT, TCC, and Saga modes, while also discussing consistency versus consensus with Paxos.
This article explains how to achieve strong consistency for high‑traffic flash‑sale (seckill) scenarios by using distributed transaction principles, flexible transaction models, and Alibaba Cloud RocketMQ transactional messages, providing detailed architectural guidance, implementation steps, code examples, and operational best practices.
This article explains why database performance bottlenecks arise, outlines criteria for deciding when to shard databases and tables, and provides detailed strategies for SQL tuning, table restructuring, horizontal and vertical splitting, single‑ versus multi‑database sharding, as well as handling cross‑database joins, distributed transactions, pagination, and ID generation.
This article explores the fundamentals of distributed transactions in microservice architectures, detailing ACID properties, classic protocols like 2PC/3PC and XA, modern patterns such as TCC, Saga, local message tables, transaction messages, and the Seata framework, while comparing their trade‑offs with Paxos consensus.
