This resume is also available in English.

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

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

訊息佇列與事件驅動

Message Queues and Event-Driven Design

把同步呼叫改成事件,服務之間就不必同時在線。這篇比較工作佇列與發布訂閱,介紹 Kafka、RabbitMQ、NATS 的核心概念,再談分區與順序、消費者群組、確認與重新投遞、死信佇列、冪等消費者與事件結構的版本演進。

  • Go
  • Microservices
這篇的步驟
  1. 這篇要解決什麼
  2. 第 1 步:命令與事件,佇列與發布訂閱
  3. 第 2 步:Kafka、RabbitMQ、NATS 的核心差異
  4. 第 3 步:分區、順序與消費者群組
  5. 第 4 步:確認、重新投遞與投遞語意
  6. 第 5 步:重試、死信佇列與冪等消費者
  7. 第 6 步:事件結構與版本演進
  8. 第 7 步:在 Go 服務裡組織消費者
  9. 常見陷阱
  10. 重點整理
  11. 下一篇

上一篇〈冪等與分散式鎖〉我們讓重複的請求只生效一次,也提到至少一次投遞讓冪等成為必需;這篇接著把訂單服務的部分流程改成非同步事件,正式引入訊息佇列。

這篇要解決什麼

到目前為止,example.com/shop 的下單流程全是同步呼叫:order 呼叫 inventory,等它回應;再呼叫 payment,等它回應。前面幾篇用逾時、重試、熔斷把這條鏈弄得更耐打,但同步呼叫有幾個根本的限制:

  • 時間耦合:呼叫的那一刻,下游必須在線。付款服務部署重啟的那幾秒,下單就會失敗。
  • 延遲相加:使用者等待的時間是每一跳延遲的總和,下游越多越慢。
  • 扇出困難:訂單付款成功後,要通知使用者、更新報表、通知倉庫出貨、發放點數……每加一個需求,訂單服務就要多呼叫一個服務,也多一個失敗點。
  • 尖峰直接打到底:促銷時流量暴增,每一層都要同時扛住尖峰。

訊息佇列把「送出」和「處理」在時間上拆開:生產者把訊息交給中介(broker)就算完成,消費者在自己方便的時候取出處理。下游暫時掛掉,訊息就在佇列裡等;尖峰來了,佇列當緩衝,消費者照自己的速度消化。代價是系統變成最終一致:下單成功的當下,通知可能還沒寄出、報表還沒更新,而且要處理重複、亂序、失敗重試這些同步呼叫裡不明顯的問題。這篇就是要把這些問題逐一拆開。

第 1 步:命令與事件,佇列與發布訂閱

先釐清兩組常被混用的概念。第一組是訊息的意圖:

  • 命令(command):要求某個服務做某件事,例如 ReserveStock、SendEmail。有明確的接收者,發送者在乎結果。
  • 事件(event):陳述一件已經發生的事實,例如 OrderPlaced、OrderPaid。用過去式命名,發送者不知道也不在乎誰會處理。

事件驅動設計的威力來自第二種:訂單服務只負責宣告「訂單 A-1001 已付款」,通知、報表、出貨各自訂閱,新增一個訂閱者不需要改訂單服務的任何程式碼。這正是〈什麼時候該拆:邊界與拆分策略〉談的低耦合在通訊層面的實現。

第二組是投遞模型:

工作佇列:搶著做 生產者 佇列 工作者 1 工作者 2 工作者 3 訊息 m1 只給工作者 1,m2 只給工作者 2… 發布訂閱:人人一份 訂單服務 主題 orders 庫存服務 通知服務 報表服務 同一則 OrderPlaced,每個訂閱者都收到

圖:左邊的工作佇列,每則訊息只交給其中一個工作者,適合分攤工作;右邊的發布訂閱,每個訂閱者都收到一份,適合事件通知。

  • 工作佇列(point-to-point):多個消費者競爭同一個佇列,每則訊息只被其中一個處理。用來分攤負載,例如寄信、產生縮圖。
  • 發布訂閱(pub/sub):每個訂閱者都收到每一則訊息的副本。用來廣播事件。

實務上兩者經常組合:「訂單事件」用發布訂閱讓庫存、通知、報表各收一份;而庫存服務自己有三個實例,它們之間以工作佇列的方式分攤這一份。Kafka 的消費者群組正是這個組合的具體實現,第 3 步會詳細看。

第 2 步:Kafka、RabbitMQ、NATS 的核心差異

市面上的訊息系統很多,這三個最常被拿來比較,它們的設計哲學差異很大:

面向KafkaRabbitMQNATS(JetStream)
核心模型分區的只附加日誌交換器路由到佇列主題(subject)+可選的持久化串流
訊息被消費後保留到保存期限,可重播確認後從佇列刪除Core 不保存;JetStream 依保存策略保留
消費進度消費者群組自己記 offsetbroker 追蹤每則訊息的確認消費者(consumer)記錄確認進度
順序分區內有序單一佇列單一消費者時有序串流內有序
路由彈性以主題與分區為主很強(direct、topic、fanout、headers)主題萬用字元
適合高吞吐事件串流、重播、多個獨立消費者工作佇列、複雜路由、逐則確認輕量、低延遲、請求回應與事件兼具

Kafka 最重要的特性是日誌可以重播:訊息被讀過之後不會消失,新的服務上線時可以從頭讀一遍歷史事件,建立自己的資料;發現處理有錯,修好程式後可以把 offset 撥回去重新處理。RabbitMQ 則是傳統的訊息中介,訊息一旦被確認就從佇列移除,路由規則非常靈活。NATS 的核心(Core NATS)是「最多一次」的純發布訂閱,沒有持久化;JetStream 在其上加了持久化串流、確認與重播。

選擇時與其比較效能數字,不如回答幾個問題:需要重播歷史嗎?需要複雜的路由嗎?團隊有沒有能力維運一個 Kafka 叢集?雲端供應商有沒有現成的託管服務?接下來的概念大多以 Kafka 的術語說明,因為它把分區、offset、消費者群組這些概念攤得最清楚,但背後的原則適用於所有系統。

第 3 步:分區、順序與消費者群組

單一佇列的吞吐量有上限,所以 Kafka 把一個主題切成多個分區(partition),每個分區是一條獨立的、只能在尾端附加的日誌,每則訊息在分區內有一個遞增的位置編號,稱為 offset。分區可以分散在不同的 broker 上,平行寫入與讀取。

主題 orders(4 個分區,key = 訂單編號) 分區 0 分區 1 分區 2 分區 3 0 1 2 3 0 1 2 ← order-1 的三個事件依序在這 0 1 0 1 2 群組 A:庫存服務 消費者 A1 分區 0、1 消費者 A2 分區 2、3 群組 B:通知服務 只有一個消費者 B1 讀全部 4 個分區 • 同一個分區內有順序,跨分區沒有 • 一個分區同時只給群組裡的一個消費者 • 不同群組各自記 offset,互不影響 • 消費者比分區多時,多的那個會閒著

圖:主題 orders 有四個分區;群組 A(庫存服務)的兩個消費者各分到兩個分區,群組 B(通知服務)只有一個消費者,讀全部分區;兩個群組各自記錄自己的 offset。

分區帶來一個關鍵限制:順序只在單一分區內成立。如果訂單 A-1001 的 OrderPlaced 落在分區 0、OrderCancelled 落在分區 2,消費者可能先處理取消、再處理建立,結果一張已取消的訂單又被當成新訂單。解法是用分區鍵(key):生產者為每則訊息指定 key,相同 key 透過雜湊永遠落在同一個分區。以訂單編號當 key,同一張訂單的所有事件就保證依序處理;不同訂單之間沒有順序,但通常也不需要。

消費者群組(consumer group)決定誰讀哪個分區:

  • 同一個群組裡,一個分區同一時間只分配給一個消費者,這保證了分區內的順序,也達成工作佇列的效果。
  • 不同群組彼此獨立,各自記錄 offset,這達成發布訂閱的效果。
  • 消費者數量多於分區數時,多出來的消費者會閒置。分區數是平行度的上限,規劃時要預留成長空間,因為之後增加分區會改變 key 對應的分區,破壞既有的順序假設。
  • 消費者加入或離開時,群組會重新平衡(rebalance),分區可能換到另一個消費者手上。這代表「某則訊息之前在哪個消費者處理過」這種資訊不能只存在消費者的記憶體裡。

提示:熱點鍵會讓分區不平均。如果某個大客戶的事件佔了一半流量,用客戶編號當 key 就會讓一個分區特別忙。選 key 時要同時考慮「需要順序的範圍」與「流量分布」,範圍越小越好。

第 4 步:確認、重新投遞與投遞語意

消費者處理訊息時,最重要的決定是什麼時候確認(ack)。在 Kafka 裡確認的形式是提交 offset,代表「這個位置之前的訊息我都處理完了」;在 RabbitMQ 裡是對每則訊息送出 ack。

  • 先確認再處理:處理到一半當機,訊息已經被確認,就永遠丟了。這是最多一次。
  • 處理完再確認:處理完但確認前當機,重啟後會再收到同一則訊息。這是至少一次。

上一篇〈冪等與分散式鎖〉已經說明,大多數業務選擇至少一次,再用冪等處理吸收重複。重複的來源不只是當機:消費者處理太久,超過 broker 判定存活的時限,會被踢出群組並觸發重新平衡,另一個消費者接手同一個分區,從上次提交的 offset 開始讀,處理到一半的訊息就被處理了兩次。RabbitMQ 也一樣,連線中斷時未確認的訊息會重新排回佇列。生產端同樣會產生重複:送出訊息後沒收到 broker 的確認,生產者重送,broker 裡就有兩份(Kafka 的冪等生產者設定可以消除這一段的重複,但消除不了消費端的重複)。

以 Go 使用 Kafka 為例,關鍵是關閉自動提交,處理成功(或明確送進死信佇列)之後才提交:

// 片段:使用 github.com/segmentio/kafka-go
func consume(ctx context.Context, handle func(context.Context, kafka.Message) error) error {
	r := kafka.NewReader(kafka.ReaderConfig{
		Brokers: []string{"kafka:9092"},
		GroupID: "inventory",      // 同一個群組名稱 = 同一組消費者分攤分區
		Topic:   "orders.events",
	})
	defer r.Close()

	dlq := &kafka.Writer{Addr: kafka.TCP("kafka:9092"), Topic: "orders.events.dlq"}
	defer dlq.Close()

	for {
		m, err := r.FetchMessage(ctx) // FetchMessage 不會自動提交;ReadMessage 會
		if err != nil {
			return err // ctx 取消時也會從這裡離開
		}
		if herr := handle(ctx, m); herr != nil {
			// 重試已在 handle 內做過;仍失敗就連同原因送進死信佇列,不卡住整個分區
			werr := dlq.WriteMessages(ctx, kafka.Message{
				Key:     m.Key,
				Value:   m.Value,
				Headers: append(m.Headers, kafka.Header{Key: "x-error", Value: []byte(herr.Error())}),
			})
			if werr != nil {
				return werr // 連 DLQ 都寫不進去:不要提交,重啟後再處理一次
			}
		}
		if err := r.CommitMessages(ctx, m); err != nil {
			return err
		}
	}
}

生產端則要記得指定 key,並要求所有同步副本確認,例如 &kafka.Writer{Addr: kafka.TCP("kafka:9092"), Topic: "orders.events", Balancer: &kafka.Hash{}, RequiredAcks: kafka.RequireAll},寫入時把訂單編號放進 kafka.Message.Key。

第 5 步:重試、死信佇列與冪等消費者

處理失敗的訊息要怎麼辦?先套用〈逾時、重試與熔斷〉的錯誤分類:

  • 暫時性錯誤(資料庫連線中斷、下游 503):在消費者內退避重試幾次,通常就會成功。
  • 永久性錯誤(格式錯誤、引用了不存在的訂單、程式的 bug):重試幾次結果都一樣,這種訊息常被稱為毒訊息(poison message)。

毒訊息在有序的分區裡特別危險:消費者卡在它身上不斷重試,後面所有訊息都動不了,整個分區停擺。解法是死信佇列(dead-letter queue,DLQ):重試超過上限或判定為永久錯誤時,把訊息連同錯誤原因、重試次數、原始分區與 offset 一起送到另一個主題,然後提交 offset 繼續往下處理。DLQ 需要監控與告警,由人或工具檢查原因,修好之後重播回主題。

主題 orders 消費者 冪等處理 成功:ack/提交 offset 之後不會再收到這則 退避後重試 暫時性錯誤 失敗 再投遞 死信佇列 orders.dlq 保留原訊息+錯誤原因+次數 超過 N 次或格式錯誤 修好程式或資料後,由人工或工具重播回主題

圖:暫時性錯誤退避後重試;超過次數或無法處理的訊息送進死信佇列,修好後重播回主題。

要注意的是,把訊息送進 DLQ 就破壞了這個 key 的順序:A-1001 的 OrderPaid 進了 DLQ,接下來的 OrderShipped 會先被處理。如果業務不能接受,可以在送進 DLQ 時記下這個 key,後續同 key 的訊息也一併暫存,等問題解決再依序處理。是否值得這個複雜度,取決於業務對順序的要求。

另一個重點是冪等消費者。每則事件要有唯一 ID(由生產者產生,重送時不變),消費者在處理業務的同一個資料庫交易裡記錄「這個 ID 處理過了」,重複收到就跳過。去重狀態必須放在資料庫,而不是消費者的記憶體,因為重新平衡後,分區可能換到另一個實例手上。

下面的程式把這一步與第 3 步的概念放在一起模擬:四個分區、以訂單編號當 key、兩個消費者組成一個群組、暫時性錯誤重試、毒訊息送進 DLQ,以及生產者重送造成的重複事件被冪等地跳過:

package main

import (
	"errors"
	"fmt"
	"hash/fnv"
	"sync"
)

type Event struct {
	ID      string // 事件唯一 ID,消費者用它去重
	Key     string // 分區鍵:同一張訂單的事件落在同一個分區
	Type    string
	Payload string
}

// Topic 是一個有 n 個分區的主題;每個分區是只能附加的日誌
type Topic struct {
	partitions [][]Event
}

func NewTopic(n int) *Topic { return &Topic{partitions: make([][]Event, n)} }

func (t *Topic) Publish(e Event) int {
	h := fnv.New32a()
	h.Write([]byte(e.Key))
	p := int(h.Sum32() % uint32(len(t.partitions)))
	t.partitions[p] = append(t.partitions[p], e)
	return p
}

var ErrTransient = errors.New("暫時失敗")
var ErrPoison = errors.New("無法處理的訊息")

// Consumer 是消費者群組裡的一員,負責被分配到的分區
type Consumer struct {
	name       string
	maxRetries int
	seen       map[string]bool // 已處理過的事件 ID(實務上放資料庫,見 inbox 表)
	committed  map[int]int     // 每個分區已提交的 offset
	dlq        *[]Event
	mu         *sync.Mutex
	log        []string
}

func (c *Consumer) Run(t *Topic, parts []int, handle func(Event, int) error) {
	for _, p := range parts {
		for off := c.committed[p]; off < len(t.partitions[p]); off++ {
			e := t.partitions[p][off]
			c.process(p, off, e, handle)
			c.committed[p] = off + 1 // 處理完(成功或送進 DLQ)才提交
		}
	}
}

func (c *Consumer) process(p, off int, e Event, handle func(Event, int) error) {
	if c.seen[e.ID] {
		c.log = append(c.log, fmt.Sprintf("p%d@%d %s %s:重複投遞,跳過", p, off, e.Key, e.Type))
		return
	}
	for attempt := 1; ; attempt++ {
		err := handle(e, attempt)
		if err == nil {
			c.seen[e.ID] = true
			c.log = append(c.log, fmt.Sprintf("p%d@%d %s %s:第 %d 次成功", p, off, e.Key, e.Type, attempt))
			return
		}
		if errors.Is(err, ErrPoison) || attempt == c.maxRetries {
			c.mu.Lock()
			*c.dlq = append(*c.dlq, e)
			c.mu.Unlock()
			c.log = append(c.log, fmt.Sprintf("p%d@%d %s %s:%v,送進死信佇列", p, off, e.Key, e.Type, err))
			return
		}
	}
}

func main() {
	t := NewTopic(4)
	events := []Event{
		{"e1", "order-1", "OrderPlaced", "v1"},
		{"e2", "order-2", "OrderPlaced", "v1"},
		{"e3", "order-1", "OrderPaid", "v1"},
		{"e4", "order-3", "OrderPlaced", "broken"},
		{"e5", "order-2", "OrderPaid", "v1"},
		{"e3", "order-1", "OrderPaid", "v1"}, // 生產者重送:同一個事件 ID 又來一次
	}
	for _, e := range events {
		p := t.Publish(e)
		fmt.Printf("發布 %s %-11s → 分區 %d\n", e.Key, e.Type, p)
	}

	handle := func(e Event, attempt int) error {
		if e.Payload == "broken" {
			return ErrPoison
		}
		if e.ID == "e2" && attempt < 2 {
			return ErrTransient // 第一次失敗、重試後成功
		}
		return nil
	}

	var dlq []Event
	var mu sync.Mutex
	// 兩個消費者組成一個群組,四個分區平均分給它們
	assign := map[string][]int{"consumer-A": {0, 2}, "consumer-B": {1, 3}}
	consumers := []*Consumer{}
	var wg sync.WaitGroup
	for _, name := range []string{"consumer-A", "consumer-B"} {
		c := &Consumer{name: name, maxRetries: 3, seen: map[string]bool{}, committed: map[int]int{}, dlq: &dlq, mu: &mu}
		consumers = append(consumers, c)
		wg.Add(1)
		go func() { defer wg.Done(); c.Run(t, assign[name], handle) }()
	}
	wg.Wait()

	for _, c := range consumers {
		fmt.Printf("[%s 負責分區 %v]\n", c.name, assign[c.name])
		for _, l := range c.log {
			fmt.Println("  " + l)
		}
	}
	fmt.Printf("死信佇列:%d 筆\n", len(dlq))
}

執行結果(兩個消費者是並行的,但各自的分區內順序固定):

發布 order-1 OrderPlaced → 分區 1
發布 order-2 OrderPlaced → 分區 0
發布 order-1 OrderPaid   → 分區 1
發布 order-3 OrderPlaced → 分區 3
發布 order-2 OrderPaid   → 分區 0
發布 order-1 OrderPaid   → 分區 1
[consumer-A 負責分區 [0 2]]
  p0@0 order-2 OrderPlaced:第 2 次成功
  p0@1 order-2 OrderPaid:第 1 次成功
[consumer-B 負責分區 [1 3]]
  p1@0 order-1 OrderPlaced:第 1 次成功
  p1@1 order-1 OrderPaid:第 1 次成功
  p1@2 order-1 OrderPaid:重複投遞,跳過
  p3@0 order-3 OrderPlaced:無法處理的訊息,送進死信佇列
死信佇列:1 筆

可以觀察到:order-1 的三則事件都落在分區 1,依序處理;生產者重送的 e3 因為 ID 已處理過而被跳過;order-3 的壞訊息進了 DLQ,但分區 3 的 offset 照樣往前推進,沒有卡住。這個範例把去重集合放在消費者的記憶體裡只是為了簡化,正式環境要換成資料庫的 inbox 表。

第 6 步:事件結構與版本演進

事件一旦發出去,就成了服務之間的公開合約,而且比 API 更難修改:Kafka 會保留歷史事件,消費者可能在幾個月後重播;不同的消費者以不同的節奏部署,新舊版本的事件與新舊版本的消費者會同時存在。

設計事件時,先準備一個固定的信封(envelope),把每個事件都需要的中繼資料和業務內容分開:

# 事件信封(以 YAML 表示;實際傳輸常用 JSON 或 Protocol Buffers)
id: 01JCX8Z3T6Q8M4N2V7K5R9W1AB # 事件唯一 ID,消費者用它去重;重送時不變
type: order.paid # 事件類型,過去式
version: 2 # data 的結構版本
occurred_at: '2026-11-15T10:00:00Z'
source: order # 發出事件的服務
subject: A-1001 # 分區鍵:同一張訂單的事件依序處理
trace_id: 4bf92f3577b34da6a3ce929d0e0e4736 # 串起追蹤,見可觀測性那篇
data:
  order_id: A-1001
  user_id: 42
  total: 129900 # int64,以分為單位,和 Order.Total 一致
  currency: TWD # v2 新增的選填欄位;舊消費者會忽略它

版本演進的核心原則是相容性:

  • 向後相容(新消費者讀得懂舊事件):新增欄位時要有預設值或可為空,新程式讀到沒有這個欄位的舊事件也能處理。
  • 向前相容(舊消費者讀得懂新事件):舊程式遇到不認識的欄位要忽略,而不是報錯。Go 的 encoding/json 預設就會忽略未知欄位;Protocol Buffers 也會保留未知欄位。
  • 不可以刪除必填欄位、改變欄位的型別或意義、重複使用已刪除欄位的名稱或編號。〈gRPC 與 Protocol Buffers〉談過的欄位編號規則在事件上同樣適用。

真的需要不相容的修改時,不要原地修改,而是發布新的事件類型或新的主題(例如 order.paid.v2),生產者在過渡期同時發布兩種,等所有消費者都遷移完畢再停掉舊的。規模較大時,可以引入 schema registry,在生產者發布時就檢查新結構是否和舊版相容,把破壞合約的修改擋在部署之前。

還有一個設計選擇:事件要帶多少資料?事件通知(event notification)只帶 ID,消費者需要細節時再回頭查詢,事件小、但會產生回查的耦合與負載;事件攜帶狀態轉移(event-carried state transfer)把消費者需要的資料都放進事件,消費者可以完全不依賴生產者,但事件變大,而且資料有過時的可能。訂單事件通常採後者,帶上金額與品項,讓通知與報表服務不必回頭呼叫訂單服務。

第 7 步:在 Go 服務裡組織消費者

最後談談消費者在專案結構中的位置。依〈分層架構與依賴注入〉的分層,訊息消費者和 HTTP 處理器是同一層:它們都是「把外部輸入轉成對 service 的呼叫」的轉接層。所以庫存服務可以在 internal/inventory/ 下新增一個 consumer.go,負責解碼事件、檢查版本、呼叫 service.go 裡的業務方法,而業務邏輯本身完全不知道請求是從 HTTP 還是訊息來的。

幾個實務建議:

  • 一個分區一個 goroutine 依序處理,需要更高平行度時增加分區,而不是在分區內開多個 goroutine 打亂順序。如果訊息之間真的沒有順序要求,可以按 key 雜湊到多個 worker,同 key 仍在同一個 worker。
  • 處理時間要有上限。每則訊息的處理都用 context.WithTimeout 包住,避免一則訊息卡住整個分區,也避免超過 broker 的存活時限而觸發重新平衡。
  • 關機時先停止拉取、處理完手上的訊息、提交 offset,再關閉連線。這是〈設定與優雅關閉〉要談的內容,對消費者特別重要,否則每次部署都會造成一批重複處理。
  • 監控消費延遲(consumer lag):最新 offset 和已提交 offset 的差距。lag 持續增加代表消費速度跟不上生產速度,是擴充消費者或排查問題的訊號。

常見陷阱

  • 自動提交 offset:訊息一讀到就提交,處理失敗或當機時訊息就丟了,實際上變成最多一次。
  • 沒有指定分區鍵:同一張訂單的事件散落在不同分區,取消比建立先被處理。
  • 以為整個主題有序:只有分區內有序;需要順序的範圍要用 key 收斂到同一個分區。
  • 消費者沒有冪等:至少一次投遞、重新平衡、生產者重送,都會讓同一則事件被處理多次。
  • 去重狀態放在消費者記憶體:重新平衡後分區換手,新的消費者不知道哪些處理過。
  • 毒訊息無限重試:一則壞訊息卡住整個分區;要有重試上限與死信佇列,並且監控 DLQ。
  • 在分區內開多個 goroutine 並行處理:提交 offset 時無法確定前面的訊息是否都完成了,順序也被打亂。
  • 原地修改事件結構:刪欄位或改型別,讓還沒升級的消費者或重播的舊事件全部壞掉。
  • 把命令偽裝成事件:SendEmailToUser 這種「事件」其實綁定了唯一的接收者,失去了事件解耦的意義。
  • 在資料庫交易裡直接發布訊息:交易回滾了訊息卻已送出,或交易提交了訊息卻沒送出;這是下一篇要解決的問題。

重點整理

  • 訊息佇列把送出與處理在時間上拆開,換來解耦、削峰與擴充性,代價是最終一致與重複、亂序、失敗處理的複雜度。
  • 命令有明確接收者,事件陳述已發生的事實;工作佇列分攤工作,發布訂閱廣播事件,消費者群組結合兩者。
  • 順序只在分區內成立,用分區鍵把需要順序的事件收斂到同一個分區;分區數是平行度的上限。
  • 處理完再確認,接受至少一次投遞,並用事件 ID 加資料庫去重實作冪等消費者。
  • 暫時性錯誤退避重試,毒訊息送進死信佇列,DLQ 需要監控與重播流程。
  • 事件是公開合約:固定信封、只做相容的修改、不相容時發布新版本,必要時用 schema registry 把關。

下一篇

訊息讓服務之間可以非同步合作,但還有一個缺口:訂單服務要「寫資料庫」又要「發事件」,兩者無法放在同一個交易裡,任何一邊失敗都會造成不一致。下一篇〈分散式交易:Saga 與 Outbox〉會用 Saga 協調跨服務的流程,並用交易式 Outbox 保證資料與事件一起成功。