This resume is also available in English.

四、可靠性第 4 / 4 篇 · 全部目錄

專欄 › 四、可靠性 › 第 16 篇

分散式交易:Saga 與 Outbox

Distributed Transactions: Sagas and the Outbox Pattern

訂單、庫存、付款各有自己的資料庫,無法用一個交易包住。這篇說明為什麼不用兩階段提交,比較協調式與編舞式 Saga、設計補償動作,再用交易式 Outbox 與 relay 保證資料和事件一起成功,最後以 inbox 在消費端去重。

  • Go
  • Microservices
這篇的步驟
  1. 這篇要解決什麼
  2. 第 1 步:為什麼不用兩階段提交
  3. 第 2 步:Saga 與補償動作
  4. 第 3 步:協調式與編舞式
  5. 第 4 步:用 Go 實作協調式 Saga
  6. 第 5 步:雙寫問題與交易式 Outbox
  7. 第 6 步:實作 relay
  8. 第 7 步:Inbox 與端到端的一致性
  9. 常見陷阱
  10. 重點整理
  11. 下一篇

上一篇〈訊息佇列與事件驅動〉我們讓服務之間透過事件非同步合作,也處理了重複、亂序與死信;這篇接著回答最後一個問題:一次下單橫跨三個服務、三個資料庫,要怎麼讓它「全部成功或全部撤銷」。

這篇要解決什麼

在單體時代,下單是一個資料庫交易:建立訂單、扣庫存、寫付款紀錄,任何一步失敗就 ROLLBACK,資料庫保證不會留下一半的狀態。〈database/sql、交易與連線池〉介紹的 ACID 讓這件事變得理所當然。

拆成 order、inventory、payment 三個服務之後,依照「每個服務擁有自己的資料」的原則,它們各自有資料庫,彼此不能直接讀寫對方的表。下單變成三個獨立的本地交易,分散在三個資料庫上。這會產生兩類問題:

  1. 跨服務的一致性:庫存已經保留,扣款卻失敗了,保留的庫存要怎麼還回去?訂單要變成什麼狀態?
  2. 資料與訊息的一致性:訂單服務寫入訂單後要發出 order.placed 事件。如果先寫資料庫再發事件,中間當機,事件就沒發出去;如果先發事件再寫資料庫,資料庫寫入失敗,下游卻已經收到一個不存在的訂單的事件。這稱為雙寫問題(dual write)。

這篇用 Saga 解決第一個問題,用交易式 Outbox 解決第二個問題,最後用 inbox 讓消費端安全地處理重複。

問題工具核心想法
跨服務的多步驟流程Saga一連串本地交易,失敗時執行補償
寫資料庫又要發事件交易式 Outbox事件先寫進同一個資料庫,再由 relay 送出
事件可能被送兩次Inbox消費端記錄處理過的事件 ID

第 1 步:為什麼不用兩階段提交

最直覺的想法是:既然一個資料庫有交易,那就找一個能跨多個資料庫的交易。這就是兩階段提交(two-phase commit,2PC):一個協調者先問所有參與者「能提交嗎」(準備階段),每個參與者鎖住相關資料並回答;全部同意之後,協調者再通知所有人提交(提交階段),任何一個不同意就全部回滾。XA 規範與資料庫的 PREPARE TRANSACTION 就是這個機制的實作。

2PC 在理論上提供了真正的原子性,但在微服務架構裡很少被採用,原因有幾個:

  • 阻塞:參與者在準備階段之後必須持有鎖,直到收到協調者的決定。協調者此時當機,參與者既不能提交也不能回滾,資料就一直鎖著,等協調者恢復。
  • 可用性相乘:整個交易要求所有參與者同時在線且健康,任何一個服務的停機都讓下單失敗,這正是微服務想擺脫的時間耦合。
  • 延遲與吞吐:多輪網路往返加上整段期間持有鎖,在高並發下會嚴重限制吞吐量。
  • 技術支援不一:訊息系統、NoSQL、外部付款閘道大多不支援 XA。你不可能要求一個第三方付款服務參與你的兩階段提交。

所以微服務的主流選擇是放棄跨服務的原子性與隔離性,改成最終一致:每一步都是可靠的本地交易,用補償動作處理失敗,系統在一段時間後達到一致的狀態。這就是 Saga。

第 2 步:Saga 與補償動作

Saga 這個詞來自 1987 年一篇資料庫論文,原本用來處理長時間執行的交易。它的定義很簡單:一個 Saga 是一連串本地交易 T1、T2……Tn,每個 Ti 都有對應的補償動作 Ci;如果 Tk 失敗,就依反向順序執行 Ck-1……C1。

套到下單流程:

步驟服務正向動作補償動作
T1order建立訂單,狀態 pending訂單改成 cancelled
T2inventory保留庫存釋放保留量
T3payment扣款退款
T4order訂單改成 paid(最後一步,不需要)
正向步驟(各自是本地交易) T1 建立訂單 status = pending T2 保留庫存 庫存服務 T3 扣款 ✗ 付款被拒 T4 標記 paid 沒有執行 補償(反向執行,必須冪等) C1 取消訂單 status = cancelled C2 釋放庫存 歸還保留量 失敗後往回走 補償不是「回滾」:訂單紀錄還在,只是狀態變成取消;中間狀態別人看得到

圖:扣款失敗時,Saga 往回走,先釋放庫存,再把訂單標記為 cancelled;T4 沒有被執行。

補償動作和資料庫回滾有本質上的差異,這是理解 Saga 的關鍵:

  • 補償不是讓資料消失,而是新增一個「抵銷」的業務動作。訂單紀錄還在,只是狀態變成 cancelled;退款是一筆新的金流紀錄,不是刪掉扣款紀錄。這對稽核與對帳其實是好事。
  • 補償必須冪等,因為它可能被重試;補償必須最終會成功,因為 Saga 沒有「補償失敗」這個出口。補償遇到暫時性錯誤就持續重試,真的無法完成時要進入人工處理的流程,而不是放著不管。
  • 不是所有動作都能補償。寄出的 Email 收不回來,已出貨的包裹也不能憑空消失。這類動作要排在 Saga 的最後面,等確定不會再需要回頭時才執行。

這引出了步驟排序的原則。Saga 裡有一個關鍵步驟(pivot):在它之前的步驟都可以補償,在它之後的步驟都要設計成「只會成功」(可以一直重試直到成功)。下單流程中,扣款通常就是關鍵步驟:扣款之前的保留庫存可以釋放,扣款之後的確認訂單、通知、出貨都只需要重試。把容易失敗的步驟(例如付款被拒)往前排、把難以補償的步驟往後排,就能讓 Saga 在大多數情況下單純許多。

第 3 步:協調式與編舞式

Saga 有兩種組織方式:

協調式(Orchestration) 下單協調者 記住 Saga 狀態 訂單 庫存 付款 命令+回覆 + 流程集中在一處,好讀好查 + 補償順序清楚 − 協調者要高可用、要持久化狀態 編舞式(Choreography) 訂單服務 庫存服務 付款服務 OrderPlaced StockReserved PaymentCompleted + 服務之間耦合低,沒有中心 + 步驟少時很自然 − 流程散在各服務,難追、易成環

圖:協調式由一個協調者依序對各服務下命令並等待回覆;編舞式沒有中心,各服務聽到上一步的事件後自己決定下一步。

協調式(orchestration):有一個協調者(可以是訂單服務裡的一個元件,也可以是獨立的工作流程引擎)明確地記住 Saga 的狀態,依序對各服務發出命令,根據回覆決定下一步或開始補償。流程定義集中在一處,好讀、好測試、好追蹤,「這張訂單卡在哪一步」查協調者的狀態表就知道。代價是協調者本身要可靠:狀態必須持久化,當機重啟後要能從中斷處繼續。

編舞式(choreography):沒有中心,每個服務訂閱上一步的事件並發出自己的事件。訂單服務發出 OrderPlaced,庫存服務聽到後保留庫存並發出 StockReserved,付款服務聽到後扣款並發出 PaymentCompleted,訂單服務聽到後把訂單改成 paid。失敗時,付款服務發出 PaymentFailed,庫存服務與訂單服務各自聽到後執行補償。

面向協調式編舞式
流程定義集中在協調者分散在各服務的事件處理
耦合協調者知道所有參與者服務只知道事件
可追蹤性高,查一張狀態表低,要靠分散式追蹤拼湊
新增步驟改協調者新服務訂閱事件,但補償邏輯可能要改多處
風險協調者變成肥大的中心循環依賴、沒人看得懂完整流程
適合步驟多、補償複雜的核心流程步驟少、彼此獨立的反應式流程

一個常見的實務組合是:下單這種核心交易流程用協調式,讓補償順序清楚可控;而「訂單付款後要通知、累積點數、更新報表」這種周邊反應用編舞式,各服務自由訂閱 order.paid 事件。

第 4 步:用 Go 實作協調式 Saga

協調者的核心邏輯其實很短:依序執行步驟,記錄已完成的步驟;任何一步失敗就反向執行已完成步驟的補償。下面的程式在記憶體中模擬這個流程,示範一張成功的訂單與一張付款被拒的訂單:

package main

import (
	"context"
	"errors"
	"fmt"
)

// Step 是 Saga 的一步:正向動作+補償動作
type Step struct {
	Name       string
	Action     func(ctx context.Context, s *OrderSaga) error
	Compensate func(ctx context.Context, s *OrderSaga) error // nil 表示不需要補償
}

// OrderSaga 是一次下單 Saga 的狀態,實務上每一步之後都要寫進資料庫
// Status 沿用 Order 的狀態:pending / paid / cancelled
type OrderSaga struct {
	OrderID       string
	ReservationID string
	PaymentID     string
	Status        string
	Log           []string
}

func (s *OrderSaga) logf(format string, a ...any) {
	s.Log = append(s.Log, fmt.Sprintf(format, a...))
}

var ErrDeclined = errors.New("付款被拒")

// Run 依序執行;任何一步失敗,就把已完成的步驟反向補償
func Run(ctx context.Context, s *OrderSaga, steps []Step) error {
	for i, st := range steps {
		if err := st.Action(ctx, s); err != nil {
			s.logf("✗ %s 失敗:%v,開始補償", st.Name, err)
			for j := i - 1; j >= 0; j-- {
				if steps[j].Compensate == nil {
					continue
				}
				// 補償必須冪等,而且要一直重試到成功(這裡省略重試)
				if cerr := steps[j].Compensate(ctx, s); cerr != nil {
					s.Status = "needs_manual_fix"
					return fmt.Errorf("補償 %s 失敗: %w(原因: %v)", steps[j].Name, cerr, err)
				}
			}
			s.Status = "cancelled"
			return err
		}
		s.logf("✓ %s", st.Name)
	}
	s.Status = "paid"
	return nil
}

func orderSteps(cardOK bool) []Step {
	return []Step{
		{
			Name:       "建立訂單(pending)",
			Action:     func(_ context.Context, s *OrderSaga) error { s.Status = "pending"; return nil },
			Compensate: func(_ context.Context, s *OrderSaga) error { s.logf("↺ 訂單標記為 cancelled"); return nil },
		},
		{
			Name: "保留庫存",
			Action: func(_ context.Context, s *OrderSaga) error {
				s.ReservationID = "rsv-" + s.OrderID
				return nil
			},
			Compensate: func(_ context.Context, s *OrderSaga) error {
				s.logf("↺ 釋放庫存保留 %s", s.ReservationID)
				return nil
			},
		},
		{
			Name: "扣款",
			Action: func(_ context.Context, s *OrderSaga) error {
				if !cardOK {
					return ErrDeclined
				}
				s.PaymentID = "pay-" + s.OrderID
				return nil
			},
			Compensate: func(_ context.Context, s *OrderSaga) error {
				s.logf("↺ 退款 %s", s.PaymentID)
				return nil
			},
		},
		{
			Name:   "確認訂單(paid)",
			Action: func(_ context.Context, s *OrderSaga) error { return nil },
		},
	}
}

func main() {
	ctx := context.Background()
	for _, tc := range []struct {
		id     string
		cardOK bool
	}{{"A-1001", true}, {"A-1002", false}} {
		s := &OrderSaga{OrderID: tc.id}
		err := Run(ctx, s, orderSteps(tc.cardOK))
		fmt.Printf("訂單 %s → %s(err=%v)\n", s.OrderID, s.Status, err)
		for _, l := range s.Log {
			fmt.Println("  " + l)
		}
	}
}

輸出:

訂單 A-1001 → paid(err=<nil>)
  ✓ 建立訂單(pending)
  ✓ 保留庫存
  ✓ 扣款
  ✓ 確認訂單(paid)
訂單 A-1002 → cancelled(err=付款被拒)
  ✓ 建立訂單(pending)
  ✓ 保留庫存
  ✗ 扣款 失敗:付款被拒,開始補償
  ↺ 釋放庫存保留 rsv-A-1002
  ↺ 訂單標記為 cancelled

這個範例刻意保持簡單,正式環境還需要補上幾件事:

  • 持久化 Saga 狀態:每完成一步就把狀態(目前步驟、各步驟的結果、保留編號與付款編號)寫進資料庫。協調者重啟後掃描未完成的 Saga,從中斷的地方繼續往前或往回走。
  • 處理「結果不明」:扣款請求逾時,不知道到底扣了沒有。範例只補償了失敗步驟「之前」的步驟,但結果不明時,失敗的那一步也要當成可能成功:用冪等鍵重新查詢或重試扣款,確定沒扣才補償,或直接執行冪等的退款(對不存在的扣款退款是無操作)。這就是為什麼〈冪等與分散式鎖〉要求每一步都可安全重試。
  • 補償的重試:範例在補償失敗時直接標記 needs_manual_fix,實務上應該先以退避持續重試,超過一段時間才轉人工並發出告警。
  • 期限:整個 Saga 也要有截止時間,例如保留的庫存超過十五分鐘未付款就自動釋放,避免永遠卡在 pending。

步驟之間的呼叫可以是同步的 gRPC,也可以是透過訊息佇列的命令與回覆。用訊息的好處是協調者不必等待下游在線,壞處是又回到了雙寫問題:協調者要「更新 Saga 狀態」又要「發出下一個命令」。這正是下一步的 Outbox 要解決的。

第 5 步:雙寫問題與交易式 Outbox

回到訂單服務建立訂單並發出事件的場景。不論先後順序怎麼排,「寫資料庫」和「發訊息」是兩個不同的系統,沒有辦法放進同一個交易:

  • 先提交資料庫、再發布訊息:發布前當機,訂單存在但事件永遠不會發出,庫存不會被保留。
  • 先發布訊息、再提交資料庫:提交失敗或回滾,下游收到一個根本不存在的訂單的事件。
  • 在資料庫交易「裡面」發布訊息:交易還沒提交訊息就出去了,交易若回滾,問題同上;而且消費者可能比交易提交更早去查資料,查到舊資料。

交易式 Outbox(transactional outbox)的解法是:既然只有一個資料庫能保證原子性,那就把事件也寫進同一個資料庫。訂單服務在同一個本地交易中寫入 orders 表與 outbox 表;交易提交了,事件就一定存在;交易回滾了,事件就一定不存在。之後由一個獨立的 relay 程序把 outbox 裡尚未發布的事件讀出來,送到訊息代理,成功後標記為已發布。

訂單服務的資料庫 同一個本地交易 INSERT orders INSERT outbox 一起提交,或一起不存在 Relay 輪詢或 CDC 訊息代理 庫存服務 inbox 表 事件 ID 去重 發布成功後標記已送出 relay 可能重送 → 至少一次投遞;消費端靠 inbox 做到「效果上只處理一次」

圖:訂單與 outbox 在同一個本地交易寫入;relay 讀出未發布的事件送到訊息代理;庫存服務用 inbox 表依事件 ID 去重。

-- 訂單服務的 outbox 表
CREATE TABLE outbox (
    id           bigserial   PRIMARY KEY,           -- 也決定發布順序
    event_id     uuid        NOT NULL UNIQUE,       -- 對外的事件 ID,消費者用來去重
    aggregate_id text        NOT NULL,              -- 分區鍵:訂單編號
    type         text        NOT NULL,              -- 例如 order.placed
    payload      jsonb       NOT NULL,
    created_at   timestamptz NOT NULL DEFAULT now(),
    published_at timestamptz                         -- NULL 代表還沒送出
);
CREATE INDEX outbox_unpublished ON outbox (id) WHERE published_at IS NULL;

-- 建立訂單:業務資料與事件在同一個交易
BEGIN;
INSERT INTO orders (id, user_id, total, status)
VALUES ('A-1001', 42, 129900, 'pending');
INSERT INTO outbox (event_id, aggregate_id, type, payload)
VALUES (gen_random_uuid(), 'A-1001', 'order.placed',
        '{"order_id":"A-1001","user_id":42,"total":129900}');
COMMIT;

-- 庫存服務的 inbox 表:事件 ID 去重與業務寫入同一個交易
CREATE TABLE inbox (
    event_id     uuid        PRIMARY KEY,
    processed_at timestamptz NOT NULL DEFAULT now()
);

BEGIN;
INSERT INTO inbox (event_id) VALUES ($1) ON CONFLICT DO NOTHING;
-- 上一行影響 0 列 → 處理過了:ROLLBACK,然後照樣確認這則訊息
UPDATE inventory
SET    reserved = reserved + $3
WHERE  sku = $2 AND stock - reserved >= $3;
COMMIT;

在 Go 裡,這兩個 INSERT 就是同一個 *sql.Tx 上的兩次 ExecContext,寫在 internal/order/repository.go 裡;service 層呼叫一個「建立訂單並記錄事件」的 repository 方法,不需要知道訊息系統的存在。這讓訂單服務在建立訂單時完全不依賴訊息代理是否在線:代理暫時掛掉,事件就安全地待在 outbox 裡等。

第 6 步:實作 relay

relay 有兩種常見做法:

  • 輪詢(polling publisher):定期查詢 published_at IS NULL 的列,依 id 排序取一批,逐一發布後更新。實作簡單、只需要 SQL;缺點是有輪詢延遲,而且頻繁查詢會增加資料庫負擔。
  • 變更資料擷取(CDC,例如 Debezium):讀取資料庫的交易日誌(PostgreSQL 的 WAL、MySQL 的 binlog),把 outbox 表的新增轉成訊息。延遲低、不需要輪詢,但多了一套要維運的元件。

輪詢版的 relay 核心大致如下:

// 片段:PostgreSQL + database/sql;publish 由訊息佇列的用戶端實作(例如 kafka-go 的 Writer)
type outboxRow struct {
	ID      int64
	EventID string
	Key     string
	Type    string
	Payload []byte
}

func relayOnce(ctx context.Context, db *sql.DB, publish func(context.Context, outboxRow) error) (int, error) {
	tx, err := db.BeginTx(ctx, nil)
	if err != nil {
		return 0, err
	}
	defer tx.Rollback() // 已提交時是無操作

	// FOR UPDATE SKIP LOCKED:多個 relay 實例不會拿到同一批;需要嚴格依序時只跑一個實例
	rows, err := tx.QueryContext(ctx, `
		SELECT id, event_id, aggregate_id, type, payload
		FROM outbox
		WHERE published_at IS NULL
		ORDER BY id
		LIMIT 100
		FOR UPDATE SKIP LOCKED`)
	if err != nil {
		return 0, err
	}
	var batch []outboxRow
	for rows.Next() {
		var r outboxRow
		if err := rows.Scan(&r.ID, &r.EventID, &r.Key, &r.Type, &r.Payload); err != nil {
			rows.Close()
			return 0, err
		}
		batch = append(batch, r)
	}
	rows.Close()
	if err := rows.Err(); err != nil {
		return 0, err
	}

	sent := 0
	for _, r := range batch {
		if err := publish(ctx, r); err != nil {
			break // 停在這裡,保留順序;已送出的先標記,剩下的下一輪再試
		}
		if _, err := tx.ExecContext(ctx,
			`UPDATE outbox SET published_at = now() WHERE id = $1`, r.ID); err != nil {
			return 0, err
		}
		sent++
	}
	return sent, tx.Commit()
}

這段程式在 cmd/order/main.go 裡以一個 goroutine 定期呼叫(例如每 200ms,沒有資料時拉長間隔),並且接上〈context:取消、逾時與資料傳遞〉的取消機制,關機時停止。

仔細看 relay 的失敗模式:如果 publish 成功了,但在 tx.Commit() 之前程序當機,這批事件的 published_at 沒有被寫入,下一輪會再發布一次。Outbox 保證的是「事件至少被發布一次」,不是恰好一次。這不是缺陷,而是設計上的取捨:寧可重複也不要遺漏,重複交給消費端處理。

還有幾個實務細節:

  • 順序:依 id 排序、單一 relay 實例、遇到失敗就停下,可以保持發布順序;多個實例搭配 SKIP LOCKED 能提高吞吐,但同一張訂單的事件可能被不同實例以不同順序送出。需要兩者兼顧時,可以按 aggregate_id 雜湊分片,每個分片一個 relay。
  • 事件 ID 在寫入 outbox 時就決定,而不是發布時才產生,這樣重複發布的事件帶著相同的 ID,消費者才能去重。
  • 清理:已發布的列要定期刪除或搬到歷史表,避免 outbox 無限成長拖慢查詢。
  • 監控:最舊一筆未發布事件的年齡是很好的指標,它持續上升代表 relay 卡住了。

第 7 步:Inbox 與端到端的一致性

relay 會重送、訊息佇列會重新投遞,所以消費者一定會收到重複的事件。上面 SQL 裡的 inbox 表就是消費端的對策:在處理業務的同一個本地交易裡,先插入事件 ID;插入成功才繼續執行業務邏輯,插入失敗代表處理過了,直接確認訊息即可。因為 inbox 紀錄與業務寫入一起提交或一起回滾,不會出現「做了但沒記」或「記了但沒做」。

把整條鏈串起來看:

  1. 訂單服務在一個本地交易中寫入訂單與 outbox,原子性由資料庫保證。
  2. relay 把 outbox 發布到訊息代理,至少一次,可能重複。
  3. 訊息代理把事件投遞給庫存服務,至少一次,可能重複。
  4. 庫存服務在一個本地交易中寫入 inbox 與業務資料,冪等由唯一約束保證。

至少一次的投遞加上冪等的處理,得到的就是效果上的恰好一次。整個系統裡沒有任何一個元件做到「恰好一次投遞」,但最終結果是正確的。Saga 的每一步也可以用同樣的方式串起來:協調者更新 Saga 狀態時,把下一個命令寫進 outbox;參與者收到命令時,用 inbox 去重,處理完把回覆寫進自己的 outbox。

最後要誠實面對 Saga 缺少的那一個字母:隔離性。Saga 的中間狀態對外可見,其他請求可能看到「庫存已保留、但還沒扣款」的訂單,或在補償執行前讀到即將被撤銷的資料。常見的對策包括:

  • 語意鎖(semantic lock):用狀態欄位標示「處理中」,例如訂單的 pending。其他流程看到 pending 就知道它還沒定案,例如不允許對 pending 的訂單申請退貨。
  • 交換律的更新:讓更新可以任意順序套用,例如用「增減保留量」而不是「設定成某個值」。
  • 重讀確認:在關鍵步驟前重新讀取並檢查資料沒有被改過,類似樂觀鎖的版本號。
  • 調整步驟順序:把容易失敗的檢查往前排,降低需要補償的機率,也縮短中間狀態存在的時間。

這些對策都有成本,需要依業務判斷哪些不一致可以容忍、可以容忍多久。對於付款這種對錯誤零容忍的流程,還需要定期對帳來發現遺漏,〈支付常見問題:重複扣款、回呼與對帳〉會深入這個主題。

常見陷阱

  • 在微服務之間硬上 2PC:協調者一當機,所有參與者的資料就被鎖住,而且外部服務根本不支援。
  • 把補償當成回滾:補償是新的業務動作,會留下紀錄,也可能失敗;它必須冪等,並且持續重試直到成功。
  • 把不可補償的步驟排在前面:先寄出「訂單成立」通知再扣款,扣款失敗就收不回來了。
  • Saga 狀態只存在記憶體:協調者重啟後不知道哪些 Saga 走到一半,庫存永遠被保留著。
  • 結果不明時當成失敗:扣款逾時就直接補償前面的步驟,卻沒處理「其實扣款成功了」的可能,結果貨沒出、錢卻扣了。
  • 在資料庫交易裡直接發訊息:回滾後訊息已經送出,或消費者在提交前就去查資料。
  • outbox 的事件 ID 在發布時才產生:重送的事件 ID 不同,消費者無法去重。
  • 以為 Outbox 是恰好一次:relay 在發布後、標記前當機就會重送;消費端一定要有 inbox 或其他冪等機制。
  • 多個 relay 實例卻假設順序不變:SKIP LOCKED 提高吞吐,但同一個 key 的事件可能亂序。
  • outbox 從不清理:表越來越大,輪詢查詢越來越慢,relay 延遲跟著上升。
  • 忽略隔離性:其他流程讀到 Saga 的中間狀態並據此做決定;要用語意鎖或狀態檢查明確表達「尚未定案」。

重點整理

  • 每個服務擁有自己的資料庫之後,跨服務無法用單一交易;2PC 會阻塞、降低可用性,也不被外部系統支援。
  • Saga 是一連串本地交易加上反向補償;補償是業務動作,必須冪等並最終成功;不可補償的步驟排在關鍵步驟之後。
  • 協調式集中流程、容易追蹤,適合核心交易;編舞式低耦合,適合周邊反應;兩者常混合使用。
  • 協調者要持久化 Saga 狀態、處理結果不明的步驟、為整個 Saga 設定期限。
  • 交易式 Outbox 把事件和業務資料寫在同一個本地交易,由 relay 以輪詢或 CDC 發布,保證至少一次。
  • Inbox 在消費端以事件 ID 去重;至少一次投遞加冪等處理,等於效果上的恰好一次。
  • Saga 沒有隔離性;用語意鎖、交換律更新、重讀確認與步驟排序降低中間狀態帶來的風險。

下一篇

到這裡,訂單系統已經能在下游故障、重複投遞與部分失敗下保持正確,但當一張訂單卡在 pending,我們還很難回答「它停在哪一個服務、哪一步、為什麼」。下一篇〈可觀測性:日誌、指標、追蹤〉會用結構化日誌、指標與分散式追蹤,讓整條跨服務的流程看得見。