訊息佇列與事件驅動
Message Queues and Event-Driven Design
把同步呼叫改成事件,服務之間就不必同時在線。這篇比較工作佇列與發布訂閱,介紹 Kafka、RabbitMQ、NATS 的核心概念,再談分區與順序、消費者群組、確認與重新投遞、死信佇列、冪等消費者與事件結構的版本演進。
這篇的步驟
上一篇〈冪等與分散式鎖〉我們讓重複的請求只生效一次,也提到至少一次投遞讓冪等成為必需;這篇接著把訂單服務的部分流程改成非同步事件,正式引入訊息佇列。
這篇要解決什麼
到目前為止,example.com/shop 的下單流程全是同步呼叫:order 呼叫 inventory,等它回應;再呼叫 payment,等它回應。前面幾篇用逾時、重試、熔斷把這條鏈弄得更耐打,但同步呼叫有幾個根本的限制:
- 時間耦合:呼叫的那一刻,下游必須在線。付款服務部署重啟的那幾秒,下單就會失敗。
- 延遲相加:使用者等待的時間是每一跳延遲的總和,下游越多越慢。
- 扇出困難:訂單付款成功後,要通知使用者、更新報表、通知倉庫出貨、發放點數……每加一個需求,訂單服務就要多呼叫一個服務,也多一個失敗點。
- 尖峰直接打到底:促銷時流量暴增,每一層都要同時扛住尖峰。
訊息佇列把「送出」和「處理」在時間上拆開:生產者把訊息交給中介(broker)就算完成,消費者在自己方便的時候取出處理。下游暫時掛掉,訊息就在佇列裡等;尖峰來了,佇列當緩衝,消費者照自己的速度消化。代價是系統變成最終一致:下單成功的當下,通知可能還沒寄出、報表還沒更新,而且要處理重複、亂序、失敗重試這些同步呼叫裡不明顯的問題。這篇就是要把這些問題逐一拆開。
第 1 步:命令與事件,佇列與發布訂閱
先釐清兩組常被混用的概念。第一組是訊息的意圖:
- 命令(command):要求某個服務做某件事,例如
ReserveStock、SendEmail。有明確的接收者,發送者在乎結果。 - 事件(event):陳述一件已經發生的事實,例如
OrderPlaced、OrderPaid。用過去式命名,發送者不知道也不在乎誰會處理。
事件驅動設計的威力來自第二種:訂單服務只負責宣告「訂單 A-1001 已付款」,通知、報表、出貨各自訂閱,新增一個訂閱者不需要改訂單服務的任何程式碼。這正是〈什麼時候該拆:邊界與拆分策略〉談的低耦合在通訊層面的實現。
第二組是投遞模型:
圖:左邊的工作佇列,每則訊息只交給其中一個工作者,適合分攤工作;右邊的發布訂閱,每個訂閱者都收到一份,適合事件通知。
- 工作佇列(point-to-point):多個消費者競爭同一個佇列,每則訊息只被其中一個處理。用來分攤負載,例如寄信、產生縮圖。
- 發布訂閱(pub/sub):每個訂閱者都收到每一則訊息的副本。用來廣播事件。
實務上兩者經常組合:「訂單事件」用發布訂閱讓庫存、通知、報表各收一份;而庫存服務自己有三個實例,它們之間以工作佇列的方式分攤這一份。Kafka 的消費者群組正是這個組合的具體實現,第 3 步會詳細看。
第 2 步:Kafka、RabbitMQ、NATS 的核心差異
市面上的訊息系統很多,這三個最常被拿來比較,它們的設計哲學差異很大:
| 面向 | Kafka | RabbitMQ | NATS(JetStream) |
|---|---|---|---|
| 核心模型 | 分區的只附加日誌 | 交換器路由到佇列 | 主題(subject)+可選的持久化串流 |
| 訊息被消費後 | 保留到保存期限,可重播 | 確認後從佇列刪除 | Core 不保存;JetStream 依保存策略保留 |
| 消費進度 | 消費者群組自己記 offset | broker 追蹤每則訊息的確認 | 消費者(consumer)記錄確認進度 |
| 順序 | 分區內有序 | 單一佇列單一消費者時有序 | 串流內有序 |
| 路由彈性 | 以主題與分區為主 | 很強(direct、topic、fanout、headers) | 主題萬用字元 |
| 適合 | 高吞吐事件串流、重播、多個獨立消費者 | 工作佇列、複雜路由、逐則確認 | 輕量、低延遲、請求回應與事件兼具 |
Kafka 最重要的特性是日誌可以重播:訊息被讀過之後不會消失,新的服務上線時可以從頭讀一遍歷史事件,建立自己的資料;發現處理有錯,修好程式後可以把 offset 撥回去重新處理。RabbitMQ 則是傳統的訊息中介,訊息一旦被確認就從佇列移除,路由規則非常靈活。NATS 的核心(Core NATS)是「最多一次」的純發布訂閱,沒有持久化;JetStream 在其上加了持久化串流、確認與重播。
選擇時與其比較效能數字,不如回答幾個問題:需要重播歷史嗎?需要複雜的路由嗎?團隊有沒有能力維運一個 Kafka 叢集?雲端供應商有沒有現成的託管服務?接下來的概念大多以 Kafka 的術語說明,因為它把分區、offset、消費者群組這些概念攤得最清楚,但背後的原則適用於所有系統。
第 3 步:分區、順序與消費者群組
單一佇列的吞吐量有上限,所以 Kafka 把一個主題切成多個分區(partition),每個分區是一條獨立的、只能在尾端附加的日誌,每則訊息在分區內有一個遞增的位置編號,稱為 offset。分區可以分散在不同的 broker 上,平行寫入與讀取。
圖:主題 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 需要監控與告警,由人或工具檢查原因,修好之後重播回主題。
圖:暫時性錯誤退避後重試;超過次數或無法處理的訊息送進死信佇列,修好後重播回主題。
要注意的是,把訊息送進 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 保證資料與事件一起成功。