Đến nội dung chính
notes.vinhnq.com

Tìm kiếm

System DesignSenior16 phút đọc

Distributed transaction: 2PC, TCC, saga, pivot transaction và transactional outbox

Ôn 10 thẻ
Trong bài này

Cụm bài Microservices trong system design: 1. Ranh giới service · 2. Distributed transaction: 2PC, saga, outbox · 3. Case study: hệ thống liveness

Đặt hàng cần trừ kho ở Inventory, trừ tiền ở Payment, tạo đơn ở Order: ba database, không có BEGIN ... COMMIT chung. Bài này so các cách giữ “tất cả hoặc không gì” xuyên service, chọn cái nào khi nào, và sửa hai hiểu lầm hay gặp. Transaction trong một database đã có ở cụm bài transaction.

1. ACID xuyên service còn lại gì

Ý chính: trong một database, ACID có đủ. Xuyên service, ta cố giữ atomicity; consistency và durability do từng transaction cục bộ lo; isolation gần như mất.

  • Atomicity: tất cả hoặc không gì. Đây là thứ distributed transaction cố đạt.
  • Consistency: dữ liệu thoả mọi ràng buộc trước và sau. Mỗi transaction cục bộ giữ phần của nó. (Khác “consistency” trong CAP: mọi lần đọc thấy lần ghi mới nhất.)
  • Isolation: transaction chạy đồng thời không thấy trạng thái dở dang của nhau. Distributed transaction chạy song song sẽ thấy, vì mỗi bước commit cục bộ ngay.
  • Durability: commit rồi không mất. Từng database lo.

Hai loại: nội bộ (một database phân tán như TiDB tự lo transaction giữa các node) và xuyên database, xuyên service, chủ đề của bài này.

2. Two-phase commit và vì sao vẫn không “mạnh” thật

Ý chính: 2PC có một coordinator hỏi mọi bên “chuẩn bị được không” rồi mới bảo “commit”. Đơn giản và nhất quán khi suôn sẻ, nhưng chậm, kẹt khi coordinator chết, và người đọc vẫn có thể thấy trạng thái lệch giữa hai lần commit.

sequenceDiagram
  participant TM as Coordinator
  participant A as Service A (RM)
  participant B as Service B (RM)
  TM->>A: ghi A - 30
  TM->>B: ghi B + 30
  TM->>A: prepare
  TM->>B: prepare
  A-->>TM: yes (giữ khoá)
  B-->>TM: yes (giữ khoá)
  TM->>B: commit
  TM->>A: commit
Ưu Nhược
Đơn giản với ứng dụng (JTA/XA lo) Giữ khoá từ lúc ghi tới hết pha 2: chậm, tranh chấp cao
Nhất quán mạnh ở trường hợp suôn sẻ Coordinator chết sau prepare: các bên giữ khoá, chờ (blocking)
Ít nguồn hỗ trợ XA: Kafka, Redis, REST API của đối tác thì không

Vì sao “mạnh” chỉ là trên lý thuyết: A = 60, B = 60, chuyển 30 từ A sang B. Coordinator gửi commit tới B trước; B commit, B = 90. Đúng lúc đó client đọc A và B: A vẫn là 60 (chưa nhận commit), B đã 90. Tổng 150, không phải 120. Pha 2 không xảy ra cùng một khoảnh khắc trên mọi bên. Chỉ database phân tán có đồng hồ/timestamp toàn cục (Spanner, TiDB) mới cho snapshot nhất quán qua các node.

3. Thang nhất quán: 2PC, AT, TCC, 2-phase message, saga

Ý chính: càng xuống thang, càng ít khoá toàn cục, đồng thời càng cao, nhưng ứng dụng phải tự làm nhiều hơn và chấp nhận thời gian không nhất quán dài hơn.

Mô hình Cách làm ngắn Khi nào hợp
2PC / XA Coordinator, prepare rồi commit, khoá suốt quá trình Ít bên, cùng hỗ trợ XA, tải thấp
AT (Seata) Mỗi bên commit cục bộ ngay, framework tự ghi undo log để rollback; giữ “global lock” trên dòng đã sửa Muốn gần 2PC mà ít sửa code, các bên là DB quan hệ
TCC Mỗi bên có 3 API: Try (giữ chỗ tài nguyên), Confirm (dùng chỗ đã giữ), Cancel (nhả) Tài nguyên giữ chỗ được: tiền, tồn kho, ghế
2-phase message (DTM) Gửi “message chuẩn bị”, commit transaction cục bộ, rồi xác nhận message; broker hỏi ngược nếu không nhận được xác nhận Một bước cục bộ + các bước sau chắc chắn thành công
Saga Chuỗi transaction cục bộ, lỗi thì chạy compensation ngược lại Nhiều bước, nhiều service, chấp nhận eventual consistency
TCC chi tiết: ba bẫy kinh điển

Ví dụ trừ tiền: Try chuyển 100 từ available sang frozen; Confirm trừ frozen; Cancel trả frozen về available. Ba bẫy:

  • Empty rollback: Try chưa tới (mạng chậm) mà Cancel đã tới. Cancel phải nhận ra “chưa có Try” và không làm gì, nhưng ghi lại là đã cancel.
  • Suspension (treo): Cancel chạy xong, rồi Try đến muộn và giữ tiền mãi mãi. Try phải kiểm tra “đã cancel chưa” và từ chối.
  • Idempotency: Confirm/Cancel có thể được gọi lại nhiều lần; phải ra cùng kết quả.

Cách chung: một bảng trạng thái (global_tx_id, branch_id, state) với unique, mọi API đọc/ghi bảng này trong cùng transaction cục bộ. DTM và Seata có sẵn “barrier” làm việc này.

Vì sao saga phổ biến trong microservices: eventual consistency thường chấp nhận được (tạo đơn xong, người dùng không quan tâm kho cập nhật sau 1 giây; bước thanh toán trễ một chút cũng ổn), và saga không giữ khoá toàn cục nên chịu tải cao, scale tốt.

4. Saga: orchestration hay choreography

Ý chính: orchestration có một bộ điều phối ra lệnh từng bước; choreography để mỗi service nghe event và tự làm phần mình. Ít bước, ít nhánh thì choreography gọn; nhiều bước, nhiều nhánh thì orchestration dễ hiểu và dễ debug hơn.

Saga có lợi: không khoá toàn cục, không chặn, và phục hồi được từng phần (lỗi ở bước 4 thì bù bước 1–3). Cái giá: eventual consistency, phức tạp, mọi bước và mọi compensation phải idempotent.

Orchestration Choreography
Điều khiển Order Processor gọi lần lượt Warehouse, Payment, Loyalty Warehouse nghe OrderPlaced, phát StockReserved; Payment nghe StockReserved…
Ưu Dễ debug: trạng thái saga ở một chỗ; luồng đọc được Không có điểm trung tâm; mỗi đội chỉ xử lý luồng event vào
Nhược Máy trạng thái khó bảo trì; logic dồn về orchestrator Khó debug, không có trạng thái toàn cục; luồng ẩn trong subscription

5. Pivot transaction

Ý chính: chia các bước saga thành ba loại để biết bước nào phải viết compensation, bước nào phải retry tới khi xong.

Ví dụ saga tạo đơn đồ ăn:

Bước Service Transaction Compensation Loại
1 Order createOrder() (PENDING) rejectOrder() Bù được
2 Consumer verifyConsumerDetails() — (chỉ đọc) Bù được
3 Kitchen createTicket() rejectTicket() Bù được
4 Accounting authorizeCreditCard() — Pivot
5 Kitchen approveTicket() — Retry tới khi xong
6 Order approveOrder() — Retry tới khi xong
  • Bù được (compensatable): trước pivot, phải có cách hoàn tác.
  • Pivot: bước quyết định đi hay dừng. Thành công thì saga chắc chắn chạy tới cuối.
  • Retry được (retriable): sau pivot, không được thất bại vĩnh viễn; nếu lỗi thì retry (idempotent) tới khi thành công.

Mẹo thiết kế: đặt bước dễ thất bại nhất (thanh toán) làm pivot hoặc sớm, và các bước khó bù (gửi email, gọi đối tác không huỷ được) sau pivot.

6. Saga thiếu isolation: lost update và dirty read

Ý chính: vì mỗi bước commit ngay, saga khác có thể đọc hoặc ghi đè trạng thái dở dang. Bù bằng các “countermeasure” ở tầng thiết kế.

Lost update: saga “Tạo đơn” đang chạy thì saga “Huỷ đơn” bắt đầu và ghi đè trạng thái. Cách xử lý:

  • Semantic lock: bước 1 của “Tạo đơn” đặt trạng thái APPROVAL_PENDING. Saga “Huỷ đơn” thấy trạng thái *_PENDING thì hoặc chờ, hoặc thất bại ngay để client retry (khuyên dùng: đơn giản, không giữ tài nguyên).
  • Version: kiểm tra version/điều kiện trạng thái khi cập nhật (UPDATE ... WHERE id = ? AND version = ?), giống optimistic lock.
  • Cập nhật giao hoán (commutative): thiết kế thao tác mà thứ tự không quan trọng, ví dụ cộng/trừ số dư thay vì ghi đè số dư.

Dirty read: một saga đọc dữ liệu đã commit cục bộ nhưng saga toàn cục chưa xong (có thể sẽ bị bù). Cách xử lý:

  • Đổi thứ tự: đưa bước làm tăng rủi ro (cộng tiền, cộng điểm) ra sau pivot, bước giảm rủi ro (trừ, giữ chỗ) lên trước. Như vậy người đọc thấy trạng thái “thận trọng”.
  • Đọc lại (re-read): trước khi ghi, đọc lại xem dữ liệu còn như lúc đầu không, nếu đổi thì huỷ và bắt đầu lại.

7. Hai hiểu lầm

Ý chính: distributed transaction không làm hệ thống nhanh hơn, và outbox hay event sourcing không phải là distributed transaction.

Hiểu lầm 1: dùng distributed transaction để tăng TPS. Mục tiêu của nó là đúng (atomicity), không phải nhanh. Nó chỉ tăng TPS khi dữ liệu đã được chia (shard, tách service) và ít tranh chấp khoá: lúc đó nhiều node làm song song. Khi tranh chấp cao (mọi giao dịch chạm cùng tài khoản), thêm node chỉ thêm vòng mạng và thời gian giữ khoá.

Hiểu lầm 2: outbox và event sourcing giải quyết distributed transaction.

  • Event sourcing là một cách lưu trữ: lưu chuỗi sự kiện thay vì trạng thái hiện tại, dựng lại trạng thái bằng cách phát lại, có “cỗ máy thời gian” xem trạng thái ở bất kỳ thời điểm nào. Nó không làm nhiều service commit cùng nhau.
  • Transactional outbox giải bài dual write: ghi DB rồi gửi Kafka là hai hệ, crash ở giữa thì một bên có một bên không. Outbox ghi message vào bảng outbox trong cùng transaction với dữ liệu nghiệp vụ; một relay (polling hoặc CDC như Debezium) đọc bảng và đẩy lên broker, ít nhất một lần. Vì sao emit trước hay bọc transaction đều hỏng, và outbox với Debezium chạy thật: dual write, exactly-once và thứ tự.
flowchart LR
  subgraph Tx[Transaction cục bộ của Account A]
    W1[Bước 1: Trừ số dư A] --> W2[Bước 2: INSERT outbox]
    W2 --> W3[Bước 3: Commit]
  end
  W3 --> RL[Bước 4: Relay đọc outbox]
  RL --> MQ[[Message queue]]
  MQ --> CB[Bước 5: Service B nhận]
  CB --> CB2[Bước 6: Cộng số dư B, ghi processed_id, commit]

Kết hợp outbox (bên gửi) với consumer idempotent (bên nhận, khử trùng theo message id) ta được “local message table”: một saga choreography hai bước đáng tin cậy. Chi tiết consumer idempotent ở idempotency với Kafka.

Outbox trong Spring Boot
@Transactional
public void withdraw(long accountId, long amount, UUID transferId) {
  accountRepo.debit(accountId, amount);                     // UPDATE ... WHERE balance >= ?
  outboxRepo.save(new OutboxEvent(transferId, "account",    // cùng transaction
      accountId, "MoneyWithdrawn", toJson(accountId, amount)));
}
  • Relay bằng polling: @Scheduled mỗi 200 ms SELECT ... FROM outbox WHERE sent_at IS NULL ORDER BY id LIMIT 500 FOR UPDATE SKIP LOCKED, gửi Kafka (acks=all), đánh dấu sent_at. Đơn giản; trễ cỡ chu kỳ poll.
  • Relay bằng CDC: Debezium đọc WAL/binlog, Outbox Event Router đẩy theo aggregate_type. Trễ thấp, không tải DB bằng polling, cần vận hành Kafka Connect.
  • Key message = aggregate_id để giữ thứ tự theo tài khoản. Dọn bảng outbox định kỳ (partition theo ngày rồi drop).
  • Bên nhận: bảng processed_message(message_id PRIMARY KEY) insert trong cùng transaction với việc cộng tiền; trùng thì bỏ qua.

Bài tập

Bài 1: Saga đặt hàng thương mại điện tử

Đề: đặt hàng gồm: tạo đơn, giữ tồn kho, trừ tiền ví (hoặc thẻ), cộng điểm thưởng, tạo vận đơn với đối tác giao hàng (không huỷ được sau khi tạo). Thiết kế saga: thứ tự bước, pivot, compensation, choreography hay orchestration, xử lý khi user bấm huỷ giữa chừng.

Lời giải Bài 1

Thứ tự và loại bước:

  1. Order: tạo đơn PENDING (semantic lock). Bù: REJECTED.
  2. Inventory: giữ tồn kho (TCC-style: reserved += qty). Bù: nhả giữ chỗ.
  3. Payment: trừ tiền. Pivot. Lỗi (không đủ tiền) → bù bước 2, 1.
  4. Inventory: xác nhận trừ kho (reserved → sold). Retry tới khi xong.
  5. Loyalty: cộng điểm. Đặt sau pivot vì là bước tăng giá trị (tránh dirty read: điểm cộng rồi bị thu lại). Retry.
  6. Shipping: tạo vận đơn với đối tác. Không huỷ được nên phải sau pivot. Retry có idempotency key gửi đối tác.
  7. Order: CONFIRMED.

Điều phối: 6–7 bước, có bước gọi đối tác chậm và cần theo dõi từng đơn → orchestration (một Order Saga lưu trạng thái trong DB hoặc Temporal). Giao tiếp giữa orchestrator và service qua Kafka command/reply, mỗi service dùng outbox + consumer idempotent.

Huỷ giữa chừng: đơn đang PENDING → API huỷ trả 409 Conflict, thử lại sau (semantic lock, fail-fast). Đơn đã CONFIRMED → saga “Huỷ đơn” riêng: huỷ vận đơn nếu đối tác cho phép, hoàn tiền (giao dịch mới), trả kho, trừ điểm.

Timeout: mỗi bước có hạn chờ; quá hạn ở trước pivot thì bù, sau pivot thì cảnh báo và retry.

Ghi nhớ

  • Giải thích được vì sao distributed transaction đồng thời vi phạm isolation, và ACID-C khác CAP-C.
  • Vẽ được 2PC và chỉ ra vì sao client vẫn đọc được trạng thái lệch giữa hai lần commit.
  • Xếp được 2PC, AT, TCC, 2-phase message, saga theo mức nhất quán và nói khi nào dùng mỗi cái.
  • Phân loại được bước saga thành bù được, pivot, retry được.
  • Kể được cách bù lost update và dirty read trong saga, và outbox giải bài gì.

Câu hỏi phỏng vấn

Mid

2PC hoạt động thế nào và nhược điểm là gì?

Coordinator gửi prepare tới mọi bên, tất cả trả lời yes thì gửi commit, có bên no thì rollback; nhược điểm là giữ khoá suốt hai pha và bị kẹt khi coordinator chết sau prepare.

Thêm: không phải hệ nào cũng hỗ trợ XA (Kafka, REST API của đối tác), và độ trễ tăng theo bên chậm nhất.

Transactional outbox giải quyết vấn đề gì?

Dual write: ghi DB và gửi message là hai hệ, crash ở giữa làm mất một bên. Outbox ghi message vào bảng trong cùng transaction với dữ liệu, rồi relay đẩy lên broker.

Kết quả là at-least-once, nên bên nhận phải idempotent. Outbox không làm nhiều service commit cùng nhau.

Compensation trong saga khác rollback thế nào?

Rollback xoá như chưa từng xảy ra trong một database; compensation là một transaction nghiệp vụ mới đảo ngược hiệu ứng, ví dụ giao dịch hoàn tiền.

Người khác có thể đã thấy trạng thái trước khi bù, compensation có thể thất bại và phải idempotent.

Senior

Saga orchestration hay choreography? Bạn chọn thế nào?

Ít bước tuyến tính thì choreography (ít thành phần, đội độc lập); nhiều bước, có nhánh, timeout, cần audit thì orchestration với engine workflow.

Choreography khó thấy luồng tổng thể và khó debug; orchestration dồn logic vào một chỗ và phụ thuộc khả năng scale của orchestrator. Luồng quá phức tạp có thể là dấu hiệu ranh giới service sai.

Pivot transaction là gì và ảnh hưởng thiết kế saga ra sao?

Là bước quyết định đi hay dừng: thành công thì saga phải chạy tới cuối. Trước nó mọi bước phải bù được, sau nó mọi bước phải retry được.

Hệ quả: đặt bước dễ thất bại (thanh toán) làm pivot, đẩy bước không huỷ được (gọi đối tác, gửi email) và bước tăng giá trị (cộng điểm) ra sau pivot.

Saga thiếu isolation. Bạn chống lost update thế nào?

Semantic lock: bước đầu đặt trạng thái *_PENDING, saga khác thấy trạng thái này thì thất bại nhanh để client retry, hoặc chờ.

Bổ sung: kiểm tra version khi cập nhật, thiết kế thao tác giao hoán (cộng/trừ thay vì ghi đè), và đổi thứ tự bước để giảm dirty read.

Đồng nghiệp đề xuất dùng distributed transaction để tăng TPS. Bạn phản hồi thế nào?

Distributed transaction để giữ đúng (atomicity), không để nhanh; nó chỉ tăng TPS khi dữ liệu đã được chia và ít tranh chấp khoá.

Nếu các giao dịch tranh nhau cùng tài nguyên, thêm node chỉ thêm vòng mạng và thời gian giữ khoá. Hỏi lại nút thắt thật là gì (tranh chấp, I/O, CPU) rồi mới chọn shard, cache hay đổi thiết kế.

Khi nào bạn dùng TCC thay vì saga?

Khi tài nguyên giữ chỗ được (tiền, tồn kho, ghế) và không muốn người khác thấy trạng thái “đã trừ rồi hoàn”: Try giữ chỗ, Confirm dùng, Cancel nhả.

Đổi lại mỗi service phải viết ba API và xử lý empty rollback, suspension, idempotency. Saga dễ cài hơn khi bước không giữ chỗ được hoặc chấp nhận trạng thái trung gian hiện ra.

Từ vựng tiếng Anh

Term Phát âm Nghĩa Ví dụ câu tiếng Anh dùng trong phỏng vấn
two-phase commit /tuː feɪz kəˈmɪt/ commit hai pha “Two-phase commit holds locks across both phases.”
coordinator /koʊˈɔːr.dən.eɪ.t̬ɚ/ bộ điều phối “If the coordinator dies after prepare, participants are stuck.”
saga /ˈsɑː.ɡə/ chuỗi transaction cục bộ có bù “We modeled checkout as a saga with four local transactions.”
compensating transaction /ˈkɑːm.pən.seɪ.t̬ɪŋ trænˈzæk.ʃən/ transaction bù “A refund is the compensating transaction for a charge.”
pivot transaction /ˈpɪv.ət trænˈzæk.ʃən/ bước quyết định “Payment is our pivot transaction, so later steps must be retriable.”
orchestration /ˌɔːr.kəˈstreɪ.ʃən/ điều phối tập trung “Orchestration keeps the saga state in one place.”
choreography /ˌkɔːr.iˈɑː.ɡrə.fi/ tự phối hợp qua event “With choreography, each service reacts to events.”
semantic lock /sɪˈmæn.t̬ɪk lɑːk/ khoá bằng trạng thái nghiệp vụ “APPROVAL_PENDING acts as a semantic lock on the order.”
dual write /ˈduː.əl raɪt/ ghi hai hệ “The outbox pattern removes the dual-write problem.”
eventual consistency /ɪˈven.tʃu.əl kənˈsɪs.tən.si/ nhất quán sau cùng “Users accept eventual consistency for loyalty points.”

Ghi chép dựa trên khoá System Design (Ronin Engineer), viết lại theo cách hiểu của mình.