System Design Interview Vol. 2 · 第 4 章Triton 覆蓋度:🟢 高Triton 線
Distributed Message Queue
一則訊息:誰收、留多久、會不會掉?
原書從零設計一個 Kafka 式的系統:topic 切成 partition、broker 把訊息用 WAL 寫進磁碟、consumer group 自己來拉、用 ISR 和 ACK 換耐久性,再加上三種送達語意。Triton 不反對這套設計,他反對的是「每個系統都需要它」:「Kafka不是rabbitMQ的evolution結果」,而且「如果系統還沒到每秒1K Message的,kafka對你會是overkill。」
給文組
全程只用一家虛構的「喵喵便當」:點單夾 vs 訂單存檔本,一階一階爬 12 個概念。頁首標 延伸基礎 的頁是補基礎,懂的人可以跳過。
給工程師
第 5–49 頁完整講原書(36 張圖和章末心智圖全部重繪、Table 1 照錄),第 51 頁起是 Triton 的觀點,最後一頁列出所有出處(materials/core)與頁碼對照。
標籤怎麼看
📖 原書 🗣️ Triton 本人說 🔭 依 Triton 原則推論 📝 上課筆記
先用生活理解點單夾 vs 報紙存檔
點單夾上的單,拿走就沒了;報紙可以一直翻回去看
🧾 點單夾 = 傳統 message queue
服務生把單夾上去,哪個廚師有空就拿走一張。一張單只會給一個廚師,拿走、做完就丟掉。夾子上的單越少越好,代表廚房跟得上。RabbitMQ、ActiveMQ 是這一類。
📰 報紙存檔 = event streaming platform
報社每天出刊,舊報紙保留兩週。會計、倉管各自有一張書籤,看到哪裡記到哪裡;誰想重看,就把書籤往回翻。Kafka、Pulsar 是這一類。
原書要設計的是報紙存檔:訊息要保留、可以重複讀、要照順序。這些都是點單夾本來不需要的功能,也是設計變複雜的原因。
學習地圖本章的概念階梯
今天爬 12 階。每一階只用前面講過的東西。
- 1message一張單
- 2topic哪一本存檔
- 3offset書頁上的書籤
- 4partition拆成幾冊
- 5consumer group一個部門分冊讀
- 6sequential IO只往最後一頁寫
- 7segment寫滿換新本
- 8leader / follower正本與抄本
- 9ISR跟得上的抄本
- 10ack收據要等幾人
- 11delivery semantics先夾書籤還是先做
- 12Signal vs Message廣播 vs 掛號信
第 1–3 階 · 一張單寫進存檔本
要回答:誰寫、誰讀、讀到哪?
第 4–7 階 · 存檔本越來越厚
要回答:怎麼拆、怎麼分工、怎麼存得快?
第 8–10 階 · 怕存檔本燒掉
要回答:抄幾份、要等誰點頭?
第 11–12 階 · 讀的人當機、Triton 的判斷
要回答:會掉還是會重複?真的需要這一套嗎?
全程只用一家店:喵喵便當(虛構)
每爬 3–4 階,有一頁「到這裡你已經會了」。
延伸基礎第 1 階 · message懂的人可以跳過
- message
- topic
- offset
- partition
- consumer group
- sequential IO
- segment
- leader / follower
- ISR
- ack
- delivery semantics
- Signal vs Message
服務生寫好單,要站在廚房門口等嗎?
① 先想像
中午一口氣來了 5 張單,廚房做一張要 2 分鐘。服務生可以站在門口等,也可以把單夾上點單夾就走。
你猜猜看:服務生站著等,5 張單全部做完,他要站多久?
5 × 2 = 10 分鐘,這段時間外面沒人招呼客人。夾上點單夾,服務生馬上就能走;廚房還是要做 10 分鐘。
③ 這叫做 message、producer / consumer
message:一張帶著工作內容的單子。producer:寫單、送單的人;consumer:拿單來做的人。
④ 跟這章的關係
中間的點單夾就是 message queue(第 1 章簡報第 30 頁)。這章要設計一個超大、不會掉單的點單夾。
② 動手玩:同樣 5 張單,兩種做法
原書開場為什麼要 message queue · Figure 1
把系統拆成小積木,中間用 queue 傳話
這一步要解決的問題系統拆成很多小積木之後,彼此要怎麼傳話,才不會一個慢、全部跟著等?
📖 原書 現代架構把系統拆成小而獨立、介面清楚的積木,message queue 負責它們之間的溝通與協調。四個好處:
- Decoupling:去掉元件之間的緊密耦合,各自可以獨立更新
- Improved scalability:producer 和 consumer 依流量各自擴展,例如尖峰時多加幾個 consumer
- Increased availability:系統某一部分離線,其他元件還能繼續跟 queue 互動
- Better performance:非同步溝通變簡單,producer 丟了就走,consumer 有空再拿,彼此不用等
📖 原書 Message queue vs event streaming platform
嚴格說 Kafka、Pulsar 不是 message queue,是 event streaming platform。但兩邊的功能越來越接近:RabbitMQ 加了可選的 streaming,支援重複消費、長時間保留,底層用 append-only log;Pulsar 主要對手是 Kafka,也能當一般的 MQ 用。
本章要設計的 MQ 會額外支援長時間保留、重複消費這類 streaming 才有的功能,所以比較複雜;原書會標出「如果面試只問傳統 MQ,哪裡可以簡化」。
內文點名的產品:event streaming 有 Kafka、Pulsar;message queue 有 RocketMQ、ActiveMQ、RabbitMQ、ZeroMQ。
原書 Step 1釐清需求
面試一開始:要的是點單夾,還是報紙存檔?
這一步要解決的問題要的是點單夾,還是會保留、能重看的存檔本?先問清楚,才知道要做多複雜。
📖 原書 應徵者 × 面試官
| 應徵者問 | 面試官答 |
|---|---|
| 訊息的格式和平均大小?只有文字?可以有多媒體? | 只有文字,大小通常在 KB 等級 |
| 訊息可以被重複消費嗎? | 可以,不同 consumer 可以重複消費。這是額外功能:傳統 MQ 送達後就不保留,不能重複消費 |
| 消費順序要和生產順序一樣嗎? | 要。額外功能:傳統 MQ 通常不保證順序 |
| 資料要持久化嗎?保留多久? | 要,假設保留兩週。額外功能:傳統 MQ 不保留訊息 |
| 要支援多少 producer 和 consumer? | 越多越好 |
| 要支援哪種送達語意?at-most-once、at-least-once、exactly once? | 一定要 at-least-once;理想上全部支援、可設定三種的差別第 44 頁細講 |
| 目標吞吐量和端到端延遲? | log aggregation 這類用途要高吞吐;傳統 MQ 用途要低延遲 |
📖 原書 如果是傳統 MQ
RabbitMQ 這類對保留的要求沒那麼強:訊息放在記憶體,留到被消費為止;有 on-disk overflow,但容量比 streaming 平台小好幾個數量級;通常不保證順序。這些差異會讓設計簡單很多。
📖 原書 Functional requirements
- Producer 送訊息到 queue;consumer 從 queue 消費
- 訊息可以被重複消費,也可以只消費一次
- 歷史資料可以被截掉(truncate)
- 訊息大小在 KB 等級
- 能照加入 queue 的順序送給 consumer
- 送達語意(at-least-once、at-most-once、exactly-once)由使用者設定
📖 原書 Non-functional requirements
- 高吞吐或低延遲,依用途設定
- Scalable:天生分散式,撐得住訊息量突然暴增
- Persistent and durable:寫在磁碟上,並複製到多個節點
延伸基礎第 2 階 · topic懂的人可以跳過
- message
- topic
- offset
- partition
- consumer group
- sequential IO
- segment
- leader / follower
- ISR
- ack
- delivery semantics
- Signal vs Message
一張單,會計要看、倉管也要看
① 先想像
喵喵便當把每張單抄進「訂單本」,退款另外記在「退款本」。會計兩本都要看,倉管只看訂單本。
你猜猜看:一筆新訂單寫進「訂單本」,會計和倉管都訂了這本。幾個人看得到它?
存檔本不是點單夾(拿走就沒了),是大家都能翻的本子。訂了這本的人都看得到。
③ 這叫做 topic、publish-subscribe
topic:一本有名字的存檔本,同一類訊息寫在一起。publish-subscribe:寫進 topic,訂了這本的人都收到。
④ 跟這章的關係
原書下一頁的 pub-sub 就是這樣。點單夾那種「一張只給一人」叫 point-to-point。
② 動手玩:誰訂了哪一本?
會計收到
倉管收到
原書 Step 2基本元件與兩種 messaging model · Figure 2–4
Producer、queue、consumer:一對一,還是一對多?
這一步要解決的問題Producer 送出一則,應該只給一個 consumer,還是給所有訂閱的人?
📖 原書 Producer 把訊息送到 queue;consumer 訂閱 queue 並消費訊息;message queue 是中間的服務,讓兩邊可以各自運作、各自擴展。producer 和 consumer 都是 client/server 模型裡的 client,MQ 是 server,透過網路溝通。
📖 原書 Point-to-point
傳統 MQ 常見。訊息送到 queue,只被一個 consumer 消費;可以有多個 consumer 在等,但每則訊息只會給其中一個。consumer 確認(acknowledge)消費完,訊息就從 queue 移除,沒有資料保留。原書的設計會保留兩週,可以模擬 point-to-point,但更自然對應到 pub-sub。
📖 原書 Publish-subscribe
先引入 topic:組織訊息的分類,名稱在整個 MQ 服務裡唯一,訊息送到、讀自特定 topic。訊息送到 topic,所有訂閱這個 topic 的 consumer 都會收到。原書兩種都支援:pub-sub 用 topic 實作,point-to-point 用 consumer group 模擬。
原書 Step 2 · 動手玩Point-to-point · Pub-sub · Consumer group
同一則 message,誰會收到?
這一步要解決的問題三種送法,同一則 message 各會到誰手上?自己按按看。
文組翻譯
- Point-to-point:點單夾。兩個廚師搶單,一張單只給一個人,做完就丟。
- Publish-subscribe:公告欄。貼一張公告,每個訂閱的人都看得到。
- Consumer group:兩個部門都訂了同一份報紙。部門之間各拿一份;部門裡面的人分工,同一則只有一個人處理(第 14 頁細講)。
📖 原書 原書的設計同時支援兩種模型:topic 給你 pub-sub;把所有 consumer 放進同一個 consumer group,就等於 point-to-point(第 15 頁)。原書舉的分組例子是一組做 billing、一組做 accounting。
延伸基礎第 3 階 · offset懂的人可以跳過
- message
- topic
- offset
- partition
- consumer group
- sequential IO
- segment
- leader / follower
- ISR
- ack
- delivery semantics
- Signal vs Message
每個人一張書籤:讀到哪,夾到哪
① 先想像
訂單本一頁一筆,頁碼從 0 往上加。會計處理到第 6 頁,夾一張書籤;倉管比較快,書籤夾在第 13 頁。
你猜猜看:會計的書籤夾在第 6 頁(0–6 都處理完了)。他下次從第幾頁讀?
書籤記的是「最後處理完的那頁」,下一次從 7 開始。倉管有自己的書籤,互不影響。
③ 這叫做 offset、commit
offset:頁碼,訊息在本子裡的位置,只會往上加。commit:把書籤夾好,記下「我處理到這裡了」。
④ 跟這章的關係
原書每個 consumer 自己記 offset(Figure 14、21)。書籤先夾、還是事情先做,第 44 頁會決定會不會掉單。
② 動手玩:同一本訂單本,兩張書籤
到這裡你已經會了小結 1 / 4
- message
- topic
- offset
- partition
- consumer group
- sequential IO
- segment
- leader / follower
- ISR
- ack
- delivery semantics
- Signal vs Message
到這裡你已經會了:一張單寫進存檔本
- 寫單的是 producer,拿單來做的是 consumer;中間的 message queue 讓服務生不用站著等廚房。
- 同一類訊息寫進同一本 topic,訂了的人都看得到(publish-subscribe);點單夾則是一張只給一人。
- 每個人用一張書籤(offset)記讀到哪;可以倒回去重看,彼此不影響。
下一階要解決的問題
訂單本越寫越厚:一個櫃子放不下,一位倉管也讀不完。怎麼辦?
延伸基礎第 4 階 · partition懂的人可以跳過
- message
- topic
- offset
- partition
- consumer group
- sequential IO
- segment
- leader / follower
- ISR
- ack
- delivery semantics
- Signal vs Message
訂單本太厚:拆成 4 冊,依客人編號分
① 先想像
一本訂單本,一個櫃子放不下。老闆拆成 4 冊:客人編號除以 4 的餘數,決定寫進哪一冊。
你猜猜看:42 號客人一天點了 3 次。這 3 筆單會在幾冊裡?
42 ÷ 4 餘 2,三筆都寫進第 2 冊,而且照時間排好。不同冊之間,就沒有誰先誰後了。
③ 這叫做 partition、broker
partition:一本 topic 拆出來的一冊,冊內照順序。broker:放冊子的櫃子,就是一台機器。
④ 跟這章的關係
就是第 1 章的 sharding(第 1 章簡報第 34 頁)。原書 Figure 5–6 在下一頁。
② 動手玩:客人點餐,寫進哪一冊?
原書 Step 2Topics, partitions, and brokers · Figure 5–6
一個 topic 太大,就切成幾個 partition 分給 broker
這一步要解決的問題一本 topic 大到一台機器放不下、一個 consumer 讀不完,要怎麼拆?
📖 原書 訊息依 topic 持久化。一個 topic 的資料量大到一台 server 撐不住怎麼辦?用 partition(sharding):把 topic 切成幾個 partition,訊息平均送進去。partition 平均分散在 cluster 的各台 server 上,這些 server 叫 broker。partition 在 broker 間的分布是擴展性的關鍵;要加大 topic 的容量,就加 partition。
- 每個 partition 是一條 FIFO(先進先出)queue,所以 partition 內的順序保得住。訊息在 partition 裡的位置叫 offset。
- Producer 送訊息,其實是送到 topic 的某一個 partition。訊息有可選的 message key(例如 user ID),同一個 key 的訊息一定進同一個 partition;沒有 key 就隨機挑一個。
- Consumer 訂閱 topic 時,從一個或多個 partition 拉資料。多個 consumer 訂閱同一個 topic 時,各負責一部分 partition,這些 consumer 組成這個 topic 的 consumer group。
文組翻譯:就是第 12 頁的分冊。訂單本拆成 4 冊(partition),放在不同的櫃子(broker);同一位客人(message key)的單永遠進同一冊,所以先點的先處理。
延伸基礎第 5 階 · consumer group懂的人可以跳過
- message
- topic
- offset
- partition
- consumer group
- sequential IO
- segment
- leader / follower
- ISR
- ack
- delivery semantics
- Signal vs Message
倉管部有 2 個人,怎麼分工讀 4 冊?
① 先想像
規定:一冊只交給部門裡的一個人,不然兩人搶著做,同一冊的順序就亂了。會計部是另一個部門,自己再讀一次。
你猜猜看:4 冊,倉管部來了 5 個人。會有幾個人沒事做?
一冊只給一人,4 冊最多分給 4 人,第 5 人閒著。想要更多人一起讀,要先多拆幾冊。
③ 這叫做 consumer group、rebalance
consumer group:一個部門;部門之間各讀各的。rebalance:有人加入或離開,部門重新分冊。
④ 跟這章的關係
原書 Figure 7 在下一頁;有人當機時怎麼重分,第 27 頁。
② 動手玩:調倉管部的人數
原書 Step 2Consumer group · Figure 7
一個 partition,在同一組裡只能給一個 consumer
這一步要解決的問題部門裡好幾個人一起讀,怎麼分工才不會把同一冊的順序弄亂?
📖 原書 Consumer group 是一起消費 topic 的一組 consumer。每組可以訂閱多個 topic、各自維護自己的 offset。Group 1 訂 topic A;group 2 訂 topic A 和 B。topic A 被兩組訂閱,同一則訊息被多個 consumer 消費,這就是 pub-sub。
📖 原書 問題:同一組平行讀可以提高吞吐,但如果 consumer 1 和 2 都讀 partition 1,partition 1 的消費順序就保證不了。解法是加一條限制:一個 partition 在同一組裡只能被一個 consumer 消費。所以 consumer 數比 partition 多,就會有人分不到;Figure 7 裡 group 2 的 consumer 3 讀不到 topic B,因為已經給了 consumer 4。
📖 原書 有了這條限制,把所有 consumer 放同一組就等於 point-to-point。partition 是最小的儲存單位,可以事先開夠多 partition,之後只要加 consumer 就能擴展。
動手試:partition 1 的六則訊息
原書 Step 2High-level architecture · Figure 8
高階架構:broker 管資料,旁邊有三種儲存和一個協調服務
這一步要解決的問題broker 存訊息之外,「哪冊放哪、誰讀到哪、誰當總管」要記在哪裡?
📖 原書 Clients
- Producer:把訊息推到特定 topic
- Consumer group:訂閱 topic、消費訊息
📖 原書 Core service and storage
- Broker:放多個 partition,每個 partition 放 topic 的一部分訊息
- Data storage:訊息依 partition 存在這裡
- State storage:consumer 的狀態
- Metadata storage:topic 的設定與屬性
📖 原書 Coordination service
- Service discovery:哪些 broker 還活著
- Leader election:選一台 broker 當 active controller,整個 cluster 只有一個,負責分配 partition
- 常用 Apache ZooKeeper 或 etcd 來選 controller
白話:metadata=關於資料的資料(每本幾冊、留多久);controller=總管;ZooKeeper / etcd=專門幫一群機器投票、記重要設定的軟體。
延伸基礎第 6 階 · sequential IO懂的人可以跳過
- message
- topic
- offset
- partition
- consumer group
- sequential IO
- segment
- leader / follower
- ISR
- ack
- delivery semantics
- Signal vs Message
只往最後一頁寫,為什麼比較快?
① 先想像
倉庫裡的帳本很重。每一筆都要翻到某一頁插進去,時間都花在翻;只往最後一頁接著寫,筆不用離開紙。
你猜猜看:每「翻到某一頁」要 10 毫秒,寫一筆要 0.1 毫秒。100 筆、每筆都要翻頁,要多久?
100 × (10 + 0.1) ≈ 1 秒。只往後寫:翻一次就好,10 + 100 × 0.1 = 20 毫秒,快 50 倍。
③ 這叫做 sequential IO、random IO
sequential IO:照順序一路往後讀寫。random IO:每次跳到不同位置,時間大多花在「找」。
④ 跟這章的關係
原書把訊息存成只往後加的檔案,就是要吃到 sequential IO(下一頁)。Triton 也同意(第 61 頁)。
② 動手玩:寫 N 筆要多久?(示意數字)
原書 Step 3Design deep dive · Data storage
三個關鍵選擇,以及訊息要存在哪裡
這一步要解決的問題訊息要存兩週、每秒大量寫也大量讀:存在資料庫,還是普通檔案?
📖 原書 為了高吞吐 + 長保留,三個設計選擇
- On-disk data structure:利用旋轉硬碟極好的循序存取效能,加上現代作業系統積極的 disk cache
- Message data structure:訊息從 producer 到 queue 到 consumer 一路不修改,減少昂貴的複製
- Favor batching:小 I/O 是高吞吐的敵人。producer 批次送、MQ 用更大的批次寫、consumer 盡量批次拿
📖 原書 MQ 的流量長什麼樣
- 寫很多、讀也很多
- 沒有 update、delete(傳統 MQ 平常不持久化,只有落後時才會寫,追上後會有「刪除」;這裡講的是 streaming 平台)
- 以循序讀寫為主
📖 原書 Option 1:Database
Relational DB:一個 topic 一張表,訊息一筆一 row;NoSQL:一個 topic 一個 collection,訊息一筆一 document。存得下,但很難設計出在大規模下同時撐住大量寫和大量讀的資料庫,跟這個存取模式不合,可能成為瓶頸。
📖 原書 Option 2:Write-ahead log(WAL)✓
WAL 就是一個只能往後加(append-only)的普通檔案,MySQL 的 redo log、ZooKeeper 的 WAL 都是。純循序讀寫,硬碟的循序效能很好,旋轉硬碟容量大又便宜。原書推薦把訊息存成磁碟上的 WAL 檔。
📖 原書 A note on disk performance:「旋轉硬碟很慢」是誤解,慢的只有隨機存取。只要資料結構設計成循序存取,RAID(多顆硬碟 striping)的現代硬碟可以輕鬆做到每秒數百 MB 讀寫,對這個需求綽綽有餘,成本也划算。現代 OS 會把所有空閒記憶體拿來 cache 磁碟資料,WAL 也吃到這個好處。
延伸基礎第 7 階 · segment懂的人可以跳過
- message
- topic
- offset
- partition
- consumer group
- sequential IO
- segment
- leader / follower
- ISR
- ack
- delivery semantics
- Signal vs Message
寫滿一本換新本;過期的整本丟掉
① 先想像
訂單本只能往後寫,不撕頁。一天寫滿一本,就換新的;舊本子只拿來查。規定保留兩週。
你猜猜看:要清掉兩週前的訂單,最省事的做法是?
一本裡全是同一天的單,整本丟最快,也不會動到正在寫的那本。
③ 這叫做 segment、retention
segment:一本一本的檔案;正在寫的叫 active,其他只讀。retention:保留期限,過了就整本刪。
④ 跟這章的關係
原書 Figure 9–10 在下一頁;保留期就是面試官說的兩週。
② 動手玩:一天一本
原書 Step 3WAL 與 segment · Figure 9–10
只往尾巴寫,寫滿一段就換一個新檔
這一步要解決的問題檔案不能無限長;過期的舊訊息要怎麼清,才不會拖慢正在寫的那一段?
動手試:一個 partition 的 WAL(每個 segment 放 4 則)
📖 原書 新訊息加在 partition 的尾巴,offset 單調遞增。最簡單的做法是用 log 檔的行號當 offset。
📖 原書 但檔案不能無限長,所以切成 segment:新訊息只寫進 active segment;active segment 到一定大小就開一個新的 active segment,舊的變成 inactive。inactive segment 只服務讀取。超過保留期限或容量上限的舊 segment 可以整個截掉。
📖 原書 同一個 partition 的 segment 檔放在名為 Partition-{:partition_id} 的資料夾。
文組翻譯:就是第 19 頁的「寫滿一本換新本」。舊本子只拿來查,不再改;過了保留期限,最舊的那本整本丟掉,不用一頁一頁撕。
到這裡你已經會了小結 2 / 4
- message
- topic
- offset
- partition
- consumer group
- sequential IO
- segment
- leader / follower
- ISR
- ack
- delivery semantics
- Signal vs Message
到這裡你已經會了:存檔本變厚之後
- 一本 topic 太厚就拆成幾冊(partition),放在不同的櫃子(broker);同一位客人永遠進同一冊,冊內有順序。
- 一個部門(consumer group)裡,一冊只給一人讀;人比冊多,多的人閒著。
- 只往最後一頁寫(sequential IO)很快;寫滿換一本(segment),過期整本丟。
下一階要解決的問題
一則訊息長什麼樣?服務生怎麼送進來、會計怎麼拿出去、有人當機時誰來重新分工?
原書 Step 3Message data structure · Table 1
一則訊息長這樣:producer、queue、consumer 都照同一份合約
這一步要解決的問題producer、broker、consumer 都要看得懂同一張單子:單子該長什麼樣、要寫進哪一冊?
📖 原書 訊息的資料結構是高吞吐的關鍵:它是 producer、MQ、consumer 之間的合約。只要有一方不同意,訊息就得被改寫,牽涉昂貴的複製,嚴重拖累效能。
📖 原書 Table 1
| Field Name | Data Type |
|---|---|
| key | byte[] |
| value | byte[] |
| topic | string |
| partition | integer |
| offset | long |
| timestamp | long |
| size | integer |
| crc | integer |
Data schema of a message
其他欄位
- Topic:屬於哪個 topic
- Partition:屬於哪個 partition 的 ID
- Offset:在 partition 裡的位置;topic + partition + offset 三個欄位找到一則訊息
- Timestamp:存進來的時間
- Size:大小
- CRC:cyclic redundancy check,確保原始資料完整
- 需要時可加選用欄位,例如 tag,用來過濾(第 47 頁)
📖 原書 Reminder
訊息的 key/value 和 KV store 的 key-value 不一樣:KV store 的 key 唯一、用 key 找 value;訊息的 key 不必唯一,有時甚至不是必填,也不用 key 找 value。
📖 原書 Message key 決定 partition
沒有 key → 隨機挑 partition;有 key → hash(key) % numPartitions。要更彈性,producer 可以自訂 mapping 演算法。key 不等於 partition 編號:key 通常帶業務資訊(字串或數字),partition 編號是 MQ 內部概念,不該直接露給 client。Message value 是 payload,可以是純文字或壓縮過的二進位區塊。
原書 Step 3Batching · Figure 13
一次送一大包:吞吐變高,但要等湊滿
這一步要解決的問題一則一則送,網路來回的成本會吃掉吞吐。一次送一大包,要付出什麼代價?
示意模型(數字不是原書的):每次 request 固定成本 2 ms,每則多 0.02 ms;訊息每秒進來 1,000 則,要等湊滿一批才送。
📖 原書 這個設計到處都在批次:producer、consumer、MQ 本身。這一節談 MQ 內的批次。批次很重要,因為:
- OS 可以把多則訊息合成一個網路 request,攤平昂貴的網路來回
- broker 用大塊寫 append log,循序寫的區塊更大、OS 維護的 disk cache 也是連續大塊,循序吞吐高很多
📖 原書 吞吐和延遲是取捨:當傳統 MQ 用、延遲重要時,調小 batch,磁碟效能會差一點;調成重吞吐時,每個 topic 可能要更多 partition,彌補較慢的循序寫入吞吐。
📖 原書 Producer 端也一樣(Figure 13):batch 大,吞吐高,但要等湊滿,延遲高;batch 小,送得早、延遲低,但吞吐差。producer 依用途調整。
文組翻譯:宅配車每來一件就出車,客人收得快但油錢爆炸;等湊滿一車才出車,很省,但第一件要等很久。
原書 Step 3Producer flow · Figure 11–12
Producer 要連哪台 broker?先加一層 routing,再把它收進 client
這一步要解決的問題服務生的單要交給哪一台櫃子?那一冊的正本(leader)在哪一台?
📖 原書 第一個做法:加一層 routing layer,所有訊息先到這層,再轉給「正確」的 broker;有 replication 時,正確的 broker 就是 leader replica。Figure 11 要送到 topic A 的 partition 1:
- Producer 把訊息送到 routing layer
- Routing layer 從 metadata storage 讀 replica distribution plan,存在本地 cache;把訊息轉給 partition 1 的 leader replica,在 broker 1
- Leader 收下訊息,follower replica 從 leader 拉資料
- 「夠多」replica 同步後,leader commit(寫入磁碟),訊息才能被消費,然後回應 producer
要 leader 和 follower 是為了容錯(正本與抄本,第 32 頁起)。缺點:多一層就多網路延遲;也沒考慮批次。
📖 原書 改良(Figure 12):routing 收進 producer,並加一個 buffer,都裝在 producer 的 client library。好處:少一跳、延遲低;producer 可以自訂要送哪個 partition;buffer 在記憶體裡累積訊息、一次送一大批,吞吐高。batch 大小是吞吐 vs 延遲的取捨(第 23 頁)。
原書 Step 3Consumer flow · Figure 14 · Push vs pull
Consumer 說「從第幾號開始給我」,broker 回一整塊
這一步要解決的問題訊息要由 broker 推給 consumer,還是 consumer 自己照書籤來拿?
📖 原書 Consumer 指定自己在 partition 裡的 offset,收到從那個位置開始的一塊 event。兩個 consumer 進度不同,互不影響。
📖 原書 結論:大多數 MQ 選 pull。
📖 原書 Push 還是 pull?
| Push:broker 推給 consumer | Pull:consumer 向 broker 拉 | |
|---|---|---|
| 優點 | 低延遲:broker 一收到就推 | consumer 自己控制速度:一組即時處理,另一組批次處理 消費比生產慢時,可以加 consumer,或之後再追上 適合批次:一次拉走目前位置之後所有訊息(或到設定上限),適合積極批次 |
| 缺點 | 消費比生產慢時,consumer 會被壓垮 處理能力不同的 consumer 很難處理,因為速度由 broker 決定 | broker 沒訊息時,consumer 還是一直拉,浪費資源。解法:很多 MQ 支援 long polling,拉的時候可以等一段時間看有沒有新訊息 |
📖 原書 push 模式下 broker 不知道 consumer 能不能馬上處理;一次推一則,consumer 卡住時,新訊息只會在 buffer 裡等。
文組翻譯:push 是外送員不管你在不在家,一直把便當塞到門口;pull 是你自己去便利商店取貨,餓了才去,一次拿三個。
原書 Step 3Pull model 的流程 · Figure 15
新 consumer 加入 group:先找 coordinator,再去拿資料
這一步要解決的問題新來的倉管要找誰報到?分到哪幾冊?從哪一頁開始讀?
- 📖 原書 新 consumer 要加入 group 1、訂閱 topic A。它對 group 名稱做 hash 找到對應的 broker;同一組的 consumer 都連到同一台,這台叫這個 group 的 coordinator。
- coordinator 確認 consumer 已加入,分配 partition 2 給它。分配策略有 round-robin(輪流發)、range(一段一段分)等。
- consumer 從 last consumed offset 開始拉訊息,這個 offset 由 state storage 管理。
- consumer 處理訊息,然後把 offset commit 給 broker。處理和 commit 的先後順序決定送達語意(第 45 頁)。
📖 原書 名字很像,但不是同一個
Consumer group coordinator 協調的是一個 consumer group;Figure 8 的 coordination service(ZooKeeper、etcd)協調的是整個 broker cluster。
原書 Step 3Consumer rebalancing · Figure 16–17
有人加入、離開、當機,就要重新分 partition
這一步要解決的問題有人加入、離開或當機,部門要重新分冊:誰來點名、誰來排?
📖 原書 Consumer rebalancing 決定哪個 consumer 負責哪些 partition。發生時機:consumer 加入、離開、當機,或 partition 數量調整。
📖 原書 Coordinator 是其中一台 broker,負責跟 consumer 溝通完成 rebalance:收 consumer 的 heartbeat(定期回報「我還活著」,第 12 章簡報第 29 頁),管理它們在各 partition 的 offset。
- 每個 consumer 屬於一個 group,對 group 名稱 hash 找到專屬的 coordinator;同組的都連到同一台
- coordinator 維護已加入的 consumer 名單;名單一變,就選一個新的 group leader
- 新 leader 產生新的 partition 分配計畫,回報給 coordinator,coordinator 再廣播給組裡其他 consumer
- 分散式系統裡 consumer 會遇到網路問題、當機、重啟…… coordinator 那邊看到的就是沒有 heartbeat,於是觸發 rebalance 重新分派(Figure 17)
原書 Step 3 · 動手玩加入、離開、當機
4 個 partition,consumer 從 1 個變 5 個會怎樣?
這一步要解決的問題4 冊、倉管從 1 人變 5 人:誰讀哪幾冊?有人當機時,他的冊子會空多久?
看什麼
- 分配用 round-robin:partition 1、3 給第一個、2、4 給第二個,跟原書 Figure 18 一樣
- 加到第 5 個:4 個 partition 只夠 4 個人,第 5 個閒著(第 15 頁的限制)
- 正常離開會先送 LeaveGroup,coordinator 馬上知道
- 當機不會說再見:coordinator 要等 heartbeat 逾時才發現,這段時間它的 partition 沒人讀
📖 原書 原書在 Scalability 也說:consumer group 之間彼此隔離,加減一整組很容易;組內靠 rebalance 處理加入、移除、當機,consumer 的擴展與容錯就靠這兩個機制(第 40 頁)。
原書 Step 3三種 rebalance 情境 · Figure 18–20
加入、離開、當機:前半不同,後半一樣
這一步要解決的問題三種情況,coordinator 和 consumer 之間到底一來一回說了什麼?
📖 原書 Figure 18:2 個 consumer、4 個 partition,B 加入
- 一開始只有 A,消費全部 partition,和 coordinator 保持 heartbeat
- B 送出加入請求
- coordinator 知道要 rebalance,用被動方式通知:等 A 的 heartbeat 來,才叫 A 重新加入
- 大家都重新加入後,coordinator 選一個當 leader,通知所有人選舉結果
- leader 產生分配計畫送給 coordinator;follower 向 coordinator 問計畫
- 各自開始消費新分到的 partition
📖 原書 Figure 19:A 要關機,主動離開
A 請求離開 group;coordinator 等 B 的 heartbeat 來時叫 B 重新加入;之後同 Figure 18。
📖 原書 Figure 20:A 當機
A 沒有送 heartbeat;coordinator 在指定時間內收不到,就把 A 標成死亡,觸發 rebalance;之後同上。
原書 Step 3State storage · Metadata storage · Figure 21
每一組讀到哪裡,要記在一個可靠的地方
這一步要解決的問題每個部門讀到哪一頁(書籤)要記在哪裡,才不會跟著 consumer 一起當機不見?
📖 原書 Metadata storage
存 topic 的設定與屬性:partition 數量、保留期限、replica 分布。很少改、量小,但一致性要求高。ZooKeeper 是好選擇。
📖 原書 State storage 存兩樣東西
- partition 和 consumer 的對應
- 每個 consumer group 在每個 partition 的 last consumed offset:Figure 21 裡 group 1 是 6、group 2 是 13
group 1 的 consumer 依序消費,commit offset 6,代表 6 和之前的都消費過了。consumer 當機,同組的新 consumer 從 state storage 讀 last consumed offset 接著做。
存取模式
- 讀寫頻繁,但量不大
- 常更新、很少刪
- 隨機讀寫
- 資料一致性很重要
很多儲存方案都可以。考量一致性和快速讀寫,ZooKeeper 這類 KV store 是很好的選擇。Kafka 已經把 offset 從 ZooKeeper 搬到 Kafka broker 本身,原書附了參考資料。
原書 Step 3ZooKeeper · Figure 22
把 metadata、state、協調都交給 ZooKeeper,broker 只管訊息
這一步要解決的問題metadata、state、選總管,三件事能不能交給一個專門的服務?
📖 原書 ZooKeeper 是分散式系統的基本服務,提供階層式的 key-value store,常用來做分散式設定、同步服務、naming registry。用它來簡化設計:
- Metadata storage 和 state storage 搬進 ZooKeeper
- Broker 只需要維護訊息的 data storage
- ZooKeeper 協助 broker cluster 的 leader election
文組翻譯:倉庫(broker)只負責堆貨。「哪一區歸誰管、每家廠商領到第幾箱、誰是今天的倉庫主任」這些登記,全部交給樓上的管理室(ZooKeeper)。
📖 原書 對照上一頁:原書也提到 Kafka 已經把 offset 存回 broker,ZooKeeper 不是唯一解。
延伸基礎第 8 階 · leader / follower懂的人可以跳過
- message
- topic
- offset
- partition
- consumer group
- sequential IO
- segment
- leader / follower
- ISR
- ack
- delivery semantics
- Signal vs Message
訂單本只有一份,燒掉就沒了:請兩位抄寫員
① 先想像
老闆請甲、乙兩位抄寫員,各抄一份放在別的櫃子。新的單只寫進「正本」,抄寫員從正本照抄。
你猜猜看:為什麼新單只寫正本,不是三份一起寫?
三個人同時各寫,第 7 頁可能這份是 A 單、那份是 B 單。只有一人寫、其他人照抄,三份才會一模一樣。
③ 這叫做 leader、follower
leader:正本,唯一接新訊息的那份。follower:抄本,從 leader 拉資料來抄。每一份都叫 replica。
④ 跟這章的關係
就是第 1 章 replication 的 master / slave(第 1 章簡報第 14 頁)。原書每冊三份(下一頁)。
② 動手玩:正本燒掉會掉什麼?
原書 Step 3Replication · Figure 23
每個 partition 三份,分在不同 broker;只寫 leader
這一步要解決的問題硬碟壞了,那一冊就沒了。要抄幾份、放在哪裡、寫進哪一份?
📖 原書 分散式系統裡硬體問題很常見,硬碟壞了資料就沒了。Replication 是達成高可用的經典解法。
📖 原書 Figure 23 每個 partition 有 3 個 replica,分在不同 broker。亮色的是 leader,其他是 follower。Producer 只送到 leader;follower 持續從 leader 拉新訊息;同步到「夠多」replica 後,leader 才回 ack 給 producer(「夠多」怎麼定義見下一頁)。
📖 原書 Replica distribution plan
- Topic A · Partition 1:3 replicas,leader 在 broker 1,follower 在 broker 2、3
- Topic A · Partition 2:3 replicas,leader 在 broker 2,follower 在 broker 3、4
- Topic B · Partition 1:3 replicas,leader 在 broker 3,follower 在 broker 4、1
誰訂計畫?靠 coordination service 選出一台 broker 當 leader,由它產生計畫、存進 metadata storage,所有 broker 照計畫做。原書推薦 Designing Data-Intensive Applications 第 5 章。
延伸基礎第 9 階 · ISR懂的人可以跳過
- message
- topic
- offset
- partition
- consumer group
- sequential IO
- segment
- leader / follower
- ISR
- ack
- delivery semantics
- Signal vs Message
抄寫員請假落後了,還算不算數?
① 先想像
正本寫到第 15 頁。甲抄到 14、乙抄到 13,丙剛請假回來,只抄到 11。規定:落後不超過 3 頁才算「跟得上」。
你猜猜看:甲、乙、丙,誰算跟得上?
甲落後 1、乙落後 2,都在 3 頁內;丙落後 4,暫時不算,追上了再加回來。
③ 這叫做 ISR、committed offset
ISR(in-sync replicas):跟得上的那幾份。committed offset:ISR 每一份都抄到的那頁,確定安全。
④ 跟這章的關係
原書 Figure 24(下一頁)就是這個例子,數字一樣:committed offset 是 13。
② 動手玩:落後不超過 3 頁才算數
原書 Step 3In-sync replicas · Figure 24
跟得上的 replica 才算數:ISR
這一步要解決的問題抄本有快有慢。要等誰抄好,才能說這則訊息安全了?
📖 原書 訊息只寫 leader,follower 從 leader 同步,問題是怎麼保持同步。In-sync replicas(ISR) 是跟 leader「同步中」的 replica,定義看 topic 設定:例如 replica.lag.max.messages 是 4,代表 follower 落後 leader 不超過 3 則就不會被踢出 ISR。leader 預設就是 ISR。
- leader 的 committed offset 是 13;又寫進兩則還沒 commit。committed offset 代表這個位置和之前的訊息已同步到 ISR 裡所有 replica
- replica-2、replica-3 跟上了,在 ISR 裡,可以拉新訊息
- replica-4 沒在設定的落後時間內跟上,不在 ISR;追上後可以再加回來
📖 原書 為什麼要 ISR?它反映效能和耐久性的取捨。最安全是等所有 replica 都同步才 ack,但一個慢的 replica 會拖慢、甚至卡死整個 partition。ISR 怎麼判定:通常每個 partition 的 leader 計算每個 replica 落後自己多少來追蹤 ISR 名單(原書附 Kafka 的參考實作)。
延伸基礎第 10 階 · ack懂的人可以跳過
- message
- topic
- offset
- partition
- consumer group
- sequential IO
- segment
- leader / follower
- ISR
- ack
- delivery semantics
- Signal vs Message
交單給櫃台:收據要等幾個人點頭?
① 先想像
服務生把單交給正本櫃台。櫃台可以馬上給收據、自己寫好再給,或等跟得上的抄寫員都抄好才給。
你猜猜看:正本 1 秒寫好,甲 3 秒、乙 4 秒抄好。等大家都抄好才給收據,服務生要等幾秒?
要等最慢的乙,所以 4 秒。等得越多越久,但正本燒掉時也越不怕。
③ 這叫做 ack、ACK=0 / 1 / all
ack:收據,「收到了」的回覆(第 10 章簡報第 19 頁)。ACK=0 / 1 / all:不等/等 leader/等所有 ISR。
④ 跟這章的關係
原書 Figure 25–27 在下一頁。
② 動手玩:第 2 秒正本櫃台失火
原書 Step 3ACK 設定 · Figure 25–27
ACK=all、1、0:要等幾個人點頭才算寄到?
這一步要解決的問題producer 送出之後,要等幾份 replica 收到,才算「送到了」?
📖 原書 Producer 可以選擇等到 K 個 ISR 收到訊息才收 ack,K 可設定。
ACK=all
所有 ISR 都收到才 ack。要等最慢的 ISR,送一則比較久,但耐久性最強。
ACK=1
leader 寫入就 ack,不等同步,延遲較低。leader 在 ack 之後、follower 複製之前馬上掛掉,訊息就掉了。適合偶爾掉資料可以接受的低延遲系統。
ACK=0
producer 一直送,不等任何 ack,也從不重試。延遲最低,代價是可能掉訊息。適合收集 metrics、log:量大、偶爾掉一點沒關係。
📖 原書 可設定的 ACK 讓我們用耐久性換效能。
原書 Step 3 · 動手玩ACK 與 leader 當機
送出 8 則,送到一半 leader 當機,會掉哪幾則?
這一步要解決的問題同樣送 8 則、同一個時間點 leader 當機,三種 ACK 各會掉哪幾則?
規則(照原書)
- leader 收到 1 tick 後寫入;兩個 ISR follower 各自晚 1–4 tick 拉到
- ACK=0:送了就算,不等、不重試
- ACK=1:leader 寫入就 ack
- ACK=all:所有 ISR 都有了才 ack
- leader 當機:收到最多的 follower 接任;沒 ack 的,ACK=1/all 的 producer 逾時後重送
文組翻譯:寄掛號。ACK=0 是丟進郵筒就走;ACK=1 是櫃台收了就給收據,但包裹還沒送到倉庫;ACK=all 是三個倉庫都入庫才給收據。櫃台失火時,只有 ACK=1 會出現「有收據、包裹卻燒掉」。
原書 Step 3Consumer 讀哪一份 · Scalability
Consumer 也只讀 leader;四個元件各自怎麼擴展
這一步要解決的問題consumer 該讀正本還是抄本?producer、consumer、broker、partition 各自怎麼加機器?
📖 原書 為什麼 consumer 讀 leader,不讀 ISR?
- 設計和維運簡單
- 一個 partition 在一個 group 裡只給一個 consumer,連到 leader 的連線數有上限
- 只要 topic 不是超熱門,連到 leader 的連線通常不多
- topic 很熱,就加 partition 和 consumer
例外:consumer 和 leader 在不同 data center,讀取效能差,這時讓 consumer 讀最近的 ISR 是值得的(原書附 Kafka KIP-392)。
📖 原書 Scalability:Producer、Consumer
Producer 比 consumer 簡單很多,不用 group 協調;加減 producer instance 就能擴展。
Consumer:consumer group 彼此隔離,加減一組很容易;組內靠 rebalance 處理加入、移除、當機(第 28 頁)。consumer group + rebalance 就達成 consumer 的擴展與容錯。
📖 原書 Scalability:Broker、Partition
Broker:先看 broker 當機怎麼復原(下一頁 Figure 28),再看加減 broker(Figure 29)。
Partition:為了擴展 topic、調整吞吐、平衡可用性和吞吐,可能要改 partition 數(Figure 30–31)。
原書 Step 3Broker 當機 · Figure 28
Broker 3 當機:先少一份,controller 再補回三份
這一步要解決的問題一台櫃子(broker)燒掉了,上面那些冊子怎麼補回三份?
📖 原書 三份計畫
| 初始 | broker 3 掛了 | 新計畫 | |
|---|---|---|---|
| A · P1 | 1(L)、2、3 | 1(L)、2 | 1(L)、2、4 |
| A · P2 | 2(L)、3、4 | 2(L)、4 | 2(L)、4、1 |
| B · P1 | 3(L)、4、1 | 4、1 | 4(L)、1、2 |
broker controller 偵測到 broker 3 掛了,為剩下的 broker 產生新計畫。新的 replica 當 follower,追上 leader。
📖 原書 讓 broker 容錯的考量
- 最少 ISR 數:producer 要收到幾個 replica 才算 commit 成功。越多越安全,但要平衡延遲
- 同一個 partition 的 replica 不能放在同一台:那台掛了就全掛,也浪費資源
- 一個 partition 的 replica 全掛,資料就永遠沒了。replica 數量和位置是安全、成本、延遲的取捨;跨 data center 更安全但延遲和成本高很多。data mirroring 可以跨 DC 複製,超出本章範圍
原書 Step 3新增 broker · Figure 29
新增 broker:先多複製一份,追上了再刪舊的
這一步要解決的問題新增一台 broker,要怎麼把冊子搬過去,又不掉資料?
📖 原書 最簡單的做法:加減 broker 時重新分配 replica。但有更好的做法:broker controller 可以暫時允許比設定檔更多的 replica,新 broker 追上後,再移除不需要的。
- 初始:3 個 broker、2 個 partition,每個 partition 3 份
- 加入 broker 4。controller 把 partition 2 的分布改成 broker (2, 3, 4);broker 4 的新 replica 開始從 leader broker 2 複製。這時 partition 2 暫時超過 3 份
- broker 4 追上後,broker 1 上多餘的 partition 2 被優雅地移除
📖 原書 這樣加 broker 時不會掉資料;移除 broker 也可以用類似流程。
文組翻譯:換新的保險箱,不是先把舊的清空再搬,而是先把東西複製一份放進新的,確認無誤再清掉舊的。中間有一段時間東西有四份,比較貴,但不會掉。
原書 Step 3增減 partition · Figure 30–31
加 partition 很簡單;減 partition 要等保留期過了
這一步要解決的問題冊數要改:加冊為什麼很簡單?減冊為什麼不能馬上回收空間?
📖 原書 partition 數改變時,producer 跟任一 broker 溝通後就會被通知,consumer 會觸發 rebalance,所以對 producer 和 consumer 都安全。接下來看資料儲存層。
增加(Figure 30)
- 已持久化的訊息還在舊 partition,不用搬資料
- 加了 partition-3 之後,新訊息會存到 3 個 partition
- 所以加 partition 擴展 topic 很直接
減少(Figure 31)
- partition-3 除役,新訊息只到 partition-1、2
- 除役的 partition-3 不能馬上刪:consumer 可能還在讀。要等設定的保留期過了,資料才截掉、空間才釋放。減 partition 不是回收空間的捷徑
- 過渡期間 producer 只送 2 個 partition,consumer 仍可讀 3 個;保留期到了,consumer group 要 rebalance
到這裡你已經會了小結 3 / 4
- message
- topic
- offset
- partition
- consumer group
- sequential IO
- segment
- leader / follower
- ISR
- ack
- delivery semantics
- Signal vs Message
到這裡你已經會了:不怕存檔本燒掉
- 每一冊有正本和抄本(leader / follower);新訊息只寫 leader,follower 照抄。
- 跟得上的抄本叫 ISR;ISR 每一份都有的那頁(committed offset)才確定安全。
- 收據要等幾人(ACK=0 / 1 / all):等越多越慢,但越不會「拿了收據,單卻不見」。
下一階要解決的問題
寫的那一端顧好了。讀的那一端也會當機:書籤先夾,還是事情先做?
延伸基礎第 11 階 · delivery semantics懂的人可以跳過
- message
- topic
- offset
- partition
- consumer group
- sequential IO
- segment
- leader / follower
- ISR
- ack
- delivery semantics
- Signal vs Message
會計入帳:先夾書籤,還是先入帳?
① 先想像
會計讀到第 42 頁,要做兩件事:在帳上記一筆、把書籤夾到 42。做到一半停電,重開後從書籤的下一頁讀。
你猜猜看:先夾書籤、再入帳,兩步中間停電。重開後,第 42 頁入帳了幾次?
書籤已經在 42,重開後從 43 讀,42 那筆沒人入帳。反過來先入帳再夾書籤,就會入帳 2 次。
③ 這叫做 at-most once、at-least once
at-most once:最多一次,可能掉。at-least once:至少一次,可能重複。不掉也不重複叫「剛好一次」,最難。
④ 跟這章的關係
原書 Figure 32–34 在下一頁。重複了怎麼辦:讓重做也安全(idempotency,第 10 章簡報第 20 頁)。
② 動手玩:處理第 42 頁
原書 Step 3Data delivery semantics · Figure 32–34
最多一次、至少一次、剛好一次
這一步要解決的問題producer 和 consumer 都可能當機。原書提供哪三種保證?各要怎麼設定?
📖 原書 Exactly once:最難
對使用者最友善,但系統效能和複雜度代價高。用途:金融相關(付款、交易、會計),特別是不能重複、下游服務或第三方又不支援 idempotency 的時候。原書沒有展開實作方式。
📖 原書 At-most once:可能掉,不會重送
- producer 非同步送,不等 ack(ack=0),失敗不重試
- consumer 拉到訊息,先 commit offset 再處理。commit 後當機,訊息不會再被消費
- 用途:monitoring metrics,掉一點可以接受
📖 原書 At-least once:不會掉,可能重複
- producer 同步、或非同步加 callback 送,ack=1 或 ack=all;失敗或逾時就一直重試
- consumer 處理成功才 commit offset。處理失敗會重新消費,不會掉;處理完但 commit 失敗,重啟後會再消費,造成重複
- 用途:重複不是大問題,或 consumer 端能 dedupe。例如每則訊息帶唯一 key,寫 DB 時拒絕重複資料
原書 Step 3 · 動手玩在不同地方當機
訂單 #42 的入帳訊息,最後被處理了幾次?
這一步要解決的問題同一筆入帳訊息,在不同地方當機,最後被處理了幾次?
關鍵只有一個:先 commit 還是先處理?
consumer 有三步:拉訊息、處理、commit offset。at-most once 的順序是「拉 → commit → 處理」,第 2 步後當機,訊息已經被記成讀過,卻沒處理 → 掉了。at-least once 是「拉 → 處理 → commit」,第 2 步後當機,重啟會再拉一次 → 重複。producer 那一端也一樣:不重試會掉,重試會重複。
🔭 依 Triton 原則推論 Exactly once 這個分頁的做法不是原書的(原書沒寫):用原書在 at-least once 提到的「唯一 key + DB 拒絕重複」,並把處理結果和 offset 寫在同一個 RDBMS transaction。理由是 Triton 的「同一台主機上的兩份資料用一個 TX;不同主機就避不了 2PC」(100、123),見第 59 頁。
原書 Step 3Advanced features · Message filtering · Figure 35
付款系統只要結帳和退款:在 broker 端用 tag 過濾
這一步要解決的問題付款系統只要結帳和退款,其他訂單活動都不想收。要在哪裡過濾?
📖 原書 topic 裝同一類訊息,但有些 consumer group 只要某些子類。例如訂單系統把所有訂單活動送到一個 topic,付款系統只在意 checkout 和 refund。
- 每種需求開一個 topic?簡單,但:其他系統要別的子類怎麼辦?同樣訊息存好幾份浪費資源;每來一個新需求 producer 就要改,producer 和 consumer 又綁在一起了
- consumer 全部拉回來自己濾:彈性大,但多了不必要的流量
- 在 broker 端過濾:比較好,但要小心。過濾若要解密或反序列化,會拖慢 broker;訊息有敏感資料時,也不該在 MQ 裡被讀出來
📖 原書 所以 broker 的過濾邏輯不該解開 payload,過濾用的資料放在訊息的 metadata,例如每則訊息附 tag。多個 tag 就能多維度過濾,一串 tag 能滿足大部分需求;要支援數學公式之類的複雜邏輯,broker 得有語法解析器或腳本執行器,對 MQ 太重了。consumer 依指定的 tag 訂閱(原書參考 RocketMQ)。
原書 Step 3Delayed & scheduled messages · Figure 36
30 分鐘沒付款就關單:先寄一則「30 分鐘後才送達」的訊息
這一步要解決的問題「30 分鐘後檢查有沒有付款」這種事,要怎麼讓訊息晚一點才送到?
按「建立訂單」:30 分鐘壓縮成 6 秒。
📖 原書 有時要讓訊息延後一段時間才送給 consumer。例如訂單建立後 30 分鐘沒付款就要關單:馬上送一則延遲的驗證訊息(檢查是否已付款),但 30 分鐘後才送到 consumer。consumer 收到時檢查付款狀態,沒付款就關單,付了就忽略這則訊息。
📖 原書 跟即時訊息不同,延遲訊息先送到 broker 端的暫存區,時間到了再送進 topic。核心是暫存區和計時功能:
- 暫存區可以是一個或多個特殊 topic
- 計時功能超出範圍,兩種常見做法:① 預先定義延遲等級的專用 delay queue。例如 RocketMQ 不支援任意精度的延遲,只支援這些等級:1s 5s 10s 30s 1m 2m 3m 4m 6m 8m 9m 10m 20m 30m 1h 2h;② Hierarchical time wheel
📖 原書 Scheduled message:在排定的時間送給 consumer,整體設計和延遲訊息非常像。
原書 Step 4Wrap up · Chapter summary
面試還有時間,可以再聊三件事
這一步要解決的問題主體設計完,面試還有時間:還有哪些可以多聊?
原書最後一句:「Congratulations on getting this far! Now give yourself a pat on the back. Good job!」
📖 原書 Protocol
定義節點之間交換資訊、傳資料的規則、語法、API。在分散式 MQ 裡,protocol 要能:涵蓋生產、消費、heartbeat 等所有活動;有效傳送大量資料;驗證資料的完整與正確。常見的有 AMQP 和 Kafka protocol。
📖 原書 Retry consumption
有些訊息消費失敗要重試。為了不擋住後面進來的訊息,怎麼在一段時間後再重試?一個想法:把失敗的訊息送到專用的 retry topic,之後再消費。
📖 原書 Historical data archive
假設有依時間或容量的保留機制,consumer 要重播已經被截掉的歷史訊息怎麼辦?可以用 HDFS 或 object storage 這類大容量儲存放歷史資料。
延伸基礎第 12 階 · Signal vs Message懂的人可以跳過
- message
- topic
- offset
- partition
- consumer group
- sequential IO
- segment
- leader / follower
- ISR
- ack
- delivery semantics
- Signal vs Message
車站廣播和掛號信:掉了一則,差在哪?
① 先想像
車站廣播「列車即將進站」,沒聽到也沒關係,看一眼月台就知道。掛號信不一樣:裡面是要辦的事,掉了就沒人辦。
你猜猜看:喵喵便當後台的「有新訂單!」小紅點漏了一次,店家損失什麼?
訂單本身已經存好了,小紅點只是提醒。提醒掉了,自己去查就補回來。
③ 這叫做 Signal、Message
Signal:要快、掉了沒太大差的提醒。Message:帶著工作內容、絕對不能掉的訊息。
④ 跟這章的關係
這是 Triton 判斷「要哪一種 MQ」的第一個問題(第 53 頁)。第 12 章用門鈴和包裹講過(第 12 章簡報第 40 頁)。
② 動手玩:喵喵便當的六件事,是廣播還是掛號信?
Triton 不同意138 · 情境差異
「Kafka不是rabbitMQ的evolution結果」
📖 原書 題目叫 MQ,答案是 Kafka
面試官要重複消費、保證順序、保留兩週、producer 和 consumer「越多越好」,於是整章在設計 Kafka:partition、WAL、consumer group、ISR。
公平地說,原書開頭就承認 Kafka 嚴格說不是 MQ,也一直標出「傳統 MQ 可以簡化的地方」。但讀完整章,很容易留下「分散式 MQ 就該長這樣、RabbitMQ 是舊版」的印象。
你猜猜看:原書整章在設計 Kafka。Kafka 是 RabbitMQ 的「升級版」嗎?
RabbitMQ 像有專人分信的郵局,什麼都能做;Kafka 像只能直走、但可以一直加車道的高速公路。高速公路不是郵局的「升級版」。
🗣️ Triton 本人說 兩個不同的工具
「要小心過份簡化的知識,就會像高度精製的食物一樣 對身體不一定是好的」「Kafka不是rabbitMQ的evolution結果 應該說:rabbitMQ跟kafka的關係,某程度上就跟postgreSQL和HBase一樣相似。」
「RabbitMQ你可以用到很很複雜的功能,這是像Kafka給不了你的。(其router功能強得變態)但是,RabbitMQ的強大功能性,也是大幅限制了其scalibility 所以,像linkedin這種大型social platform,他們才要從零開始建一套滿足他們功能需求,但又能無限scalibility的Kafka」
「你可以把kafka看成:把RabbitMQ大量功能砍掉,特化scalibility的MQ」
138-喵談 rabbitMQ 和 kafka.md
🗣️ Triton 本人說 兩邊的名詞怎麼對應
「chatroom 是對應 RabbitMQ exchange / Kafka topic」「每一個 App. Server 對應 RabbitMQ queue / Kafka consumer group」「RabbitMQ Exchange 和 topic 之間,是使用 fanout 機制」062 · 第 20 頁
🔭 推論 原書的 topic + consumer group,在 RabbitMQ 就是 fanout exchange + 每組一個 queue。
Triton 的判斷標準動手算 · 138 的 1K 線
我需要 Kafka 嗎?
你猜猜看:第 10 章的通知系統一天 1,000 萬則推播。平均每秒幾則?
10,000,000 ÷ 86,400 秒 ≈ 116。Triton 的線畫在每秒 1K,也就是一天 8,640 萬則。🔭 大部分公司的系統離這條線很遠。
「就先給結論:如果系統還沒到每秒1K Message的,kafka對你會是overkill。」🗣️ Triton 本人說 138-喵談 rabbitMQ 和 kafka.md
「高效能系統,不是拿一些跑起來快一點點的語言來寫便好,更不是隨隨便便引入kafka / Hadoop這些用來解決超大量數據的工具!」🗣️ Triton 本人說 150
🔭 推論 1K 這條線是 138 的原話;三個勾選框的判斷是把 078(Signal vs Message)和 185(什麼時候該用 MQ)的原則套進來的,每個結論都標了出處。
Triton 補充078 · 真正的 MQ 要做到什麼
先寫進硬碟才說成功,收到「工作完成」才刪
你猜猜看:MQ 收到一則不能掉的 Message,什麼時候才可以跟 producer 說「成功」?
先寫進硬碟才回成功;consumer 回報「工作完成」之後才刪。就是掛號信:先登記入庫才給收據,簽收了才銷單。
「MQ的M是Message(廢話)所謂的Message – 就是帶著工作內容的的訊息 – 相對上能等一下才完成的工作 – 一定要跑完一次 所以正常的MQ Server – 會把收到的Message先存到HDD,然後才回應成功 – 會等待收件者回傳「工作完成」,才真的把訊息刪掉 – 如果收件者趴掉,則把訊息丟給其他的 channel listener」🗣️ Triton 本人說 078-mq-intro.pdf.md · 第 7 頁「溫習一下」
「Signal – 要高度即時性 – 丟失沒太大差 Message – 可以排隊一個一個工作慢慢來~ – 絕對不能丟失」「Redis的 PubSub 簡單而言:把 persistence刪掉的 MQ … 可以用在 Signal的傳遞」🗣️ Triton 本人說 078 · 第 8、10 頁
🔭 推論 把 Triton 的要求對到原書的旋鈕
| Triton 的 Message 要求 | 原書對應的設定 |
|---|---|
| 「先存到HDD,然後才回應成功」 | WAL 寫磁碟 + ACK=1 或 all。ACK=0 不等回應,不算 |
| 「等待收件者回傳『工作完成』,才真的把訊息刪掉」 | at-least once:處理完才 commit offset。原書的 log 留兩週,「刪」變成「把 offset 往前移」 |
| 「如果收件者趴掉,則把訊息丟給其他的 channel listener」 | heartbeat 逾時 → rebalance,新 consumer 從 last consumed offset 接手 |
| Signal:「丟失沒太大差」 | ACK=0 + at-most once:原書自己舉的用途就是 metrics、logging |
| Signal 的 RabbitMQ:no ack、斷線自動刪 queue | 沒有保留、沒有 offset,等於 point-to-point 而且不持久化 |
生活版:第 50 頁的車站廣播(Signal)和掛號信(Message)。
🗣️ Signal 用的 RabbitMQ 設定:「有固定長度的 queue length」「當 consumer disconnect 時, queue 自動消滅」「高 prefetch count」「no acknowledgement」062 · 第 21 頁「MQ 延伸」(聊天室的即時推送)
Triton 不同意030 · 088 · 拿 Redis 當 queue
Redis 不是 MQ:斷電會掉、只住一台、追不上就爆 RAM
你猜猜看:拿 Redis(資料全放在記憶體)當 queue。尖峰時 consumer 追不上,會怎樣?
Redis 快,是因為所有資料都放得進記憶體。queue 一直變長,記憶體就不夠了。Triton 還列了另外三個理由。
白話:sidekiq=架在 Redis 上的背景工作套件;persistence=斷電也不會不見;hotspot=大家都擠向同一台(第 4 章簡報第 30 頁)。
🗣️ 「Redis不是 MQ Server 有人會試圖以 redis的 Streams作為簡單版的 MQ Server 問題1:如果 consumer很慢,越來越多 unprocessed data留在 redis? 問題2: redis failure後果? 問題3: async IO?」088 · 第 7 頁;「專業應用請用 RabbitMQ – Redis 沒法做到 blocking – 沒法保證工作(成功跑了一次+單一執行緒) – 更沒法保障data loss」086 · 第 18 頁
🗣️ Triton 本人說 為何強烈不鼓勵 sidekiq 這種方案
- 「sidekiq是基建於redis的,然後redis本身沒法做到high persistence(斷電後redis會有data loss的)(Kafka / rabbitmq都有mirroring / quorum機制保護)」
- 「sidekiq是使用redis的list/sorted set data structure,然後一個data structure只會存放於單台的redie上,那很容易造成cluster的local hotspot。」
- 「redis的超高效能,是建基於「所有data都足夠放到RAM內」如果你的consumer消化速度追不上producer生產速度 你的redis很容易就會爆炸掉。rabbitmq / Kafka是使用HDD來存放buffer的。HDD的大小遠遠比RAM大。」
- 「你的application有bug的風險遠比kafka / rabbitmq有bug大~~~」
030-Redis 不能當 queue 原因.md
Triton 不同意030 第 3 點 · 動手算
consumer 追不上時:放在 RAM 的 queue 會爆,放在硬碟的只是變長
🔭 動手算:consumer 追不上時,queue 多久塞滿?
示意:每則 1 KB(原書的訊息大小等級),Redis 可用 RAM 16 GB、MQ 可用硬碟 4 TB。容量是假設,比例才是重點。
🗣️ Triton 沒有說 Redis 永遠不能排隊:「如果你的應用比較簡單, Redis 某程度上也能當作MQ 使用」073 · 第 31 頁。不能掉的工作才不行。
對照原書
原書把訊息存成磁碟上的 WAL(第 18 頁),在這一點上和 Triton 完全一致:「rabbitmq / Kafka是使用HDD來存放buffer的」(030 第 3 點)。
文組翻譯
點單夾放在小桌上(RAM),桌子滿了,新的單就沒地方放;存檔本放在倉庫(硬碟),倉庫大好幾百倍,尖峰過了 consumer 再慢慢追上。
Triton 補充012 · 065 · 020 · 拿 RDBMS 當 queue
原書否決 DB 的理由,和 Triton 的理由不一樣
📖 原書 Option 1:Database 不理想
理由是存取模式:很難設計一個在大規模下同時撐住大量寫、大量讀的資料庫,可能成為系統瓶頸(第 18 頁)。
🗣️ Triton 本人說 但「狀態」要放 DB,MQ 只負責通知
第三方服務不支援 callback、只能輪詢時:「建立一個outstanding_tasks的table(不使用redis的原因是怕redis當掉後data loss有工作變成孤兒)」,進階版「並且把create_time作為message丟進message queue server中」;做完的工作「把其ID丟到message queue,然後讓另一個worker來做後續工作,做完後才刪掉對應的outstanding_tasks。」結論:「message queue可以讓你做出優雅而且高穩定性系統。」020-MQ解法.md
🗣️ Triton 本人說 用 RDBMS 作為 Inter-process communication
「RDBMS內有 REDO LOG, UNDO LOG, Lock Manager, 這些都是為了維護資料的完整性和正確性。 – 單純用來暫存 IPC數據 ,會浪費 CPU和 Storage IO的 – 最簡單的 IPC,可以使用 Redis 中的 List,進階的請用 rabbitMQ」012 · 常犯錯誤
「Database-as-IPC … 特徵 – 數據的生命週期超級短的 … – 一旦數據使用了,這些數據便不再有價值 – (不一定)會有不停查詢資料庫的Request … 解決方案:使用像 rabbitMQ的軟體來傳播訊息」065 · 第 46 頁
「Database-as-IPC 是很嚴重的 anti-pattern ,但是如果有很少量的 data exchange ,還算可以接受」073 · 第 36 頁
🔭 推論 合起來看
短命的訊息不放 RDBMS(浪費 redo/undo/lock);但不能掉的工作狀態放 RDBMS 的一張表,MQ 只傳「有新工作了」。這樣 MQ 就算掉了一則,表還在,worker 重啟時「對outstanding_tasks整個拿便好」。原書的設計把狀態和訊息都塞進 MQ,所以 MQ 必須自己做到 ISR、ACK=all、exactly once。
Triton 補充185 · 什麼時候才該用 MQ
MQ 只是把 request 先收起來,熱門商品的上限沒變
你猜猜看:一萬人搶同一個便當的最後庫存。先把 request 丟進 MQ 再慢慢處理,最後一個人會比較快拿到結果嗎?
MQ 只是換一個地方排隊。瓶頸是資料庫裡那一筆庫存,右邊動手算。
「把工作先丟MQ再慢慢處理,一般而且有3個原因:1 這Request需要拿大量資源,而且很可能跑很久,不適合在App. Server上直接來跑。(例子:報表類的工作)2 這工作是慢慢做也死不了人的,我想把MQ當成一個buffer,讓peak hours的工作可以在non-peak hours時來做。(例子:user profiling的分析)3 你家主管不知從那邊聽到MQ好棒棒高大上,強迫你來用MQ。」🗣️ Triton 本人說 185-電商用 queue-.md
🗣️ 好處:「把Request input丟進MQ這個過程,是embarrassing parallel problem。配上像Kafka這樣子的架構,你可以接近無限地擴大MQ的處理能力」。壞處1:「不管你Application層長怎樣。你最終會受限的還是單一Record其在DB層的處理上限。你的MQ只是把Request先存起來,系統對單一商品的處理能力其實沒變過。」185
🔭 動手算:一萬人搶同一個商品
🔭 推論 壞處4就是原書 hash(key) % numPartitions 加上「一個 partition 在組裡只給一個 consumer」的直接後果:熱門 key 所在的 partition 塞住,同一個 partition 的冷門 key 也跟著排隊(第 22、15 頁)。每秒改幾次是示意值,真實數字要壓測。
🗣️ 壞處4:「不管是by Hash(ItemId)還是by (item.CategoryId),一般而言都是一組worker負責一組商品的。當一個商品在熱賣時,其他同群組商品的客戶也會被影響而一起排隊。」185
Triton 補充把 MQ 放上 production
原書沒講的維運細節:timeout、blocking、連線上限
🗣️ 一則 message 的工作要短
「智障架構1 … 把目標用戶的範圍寫進Message,然後收到Message的 Worker,從資料庫中撈用戶 Firebase Tokens,再慢慢傳 Notification Design flaws – 這樣子,跟 Firebase的溝通就只有單線程 你想用戶 1小時後才收到推送嗎 – Worker工作所需時間跟用戶數量正比 你怎決定MQ Server等待 ACK的 Timeout?」078 · 第 13 頁
🔭 推論 對到原書:consumer 處理一批要很久,commit 就晚;中間被判定逾時而 rebalance,接手的人會從舊 offset 重做,at-least once 的重複就變多。
🗣️ 沒工作時不要空轉
「Queue中沒有 Message 時, Consumer 會被 blocking ,不佔用 CPU」「一份訊息,在同一時間內只會讓一個 Consumer收到」「你可以視 Queue中的剩餘 Message 量,動態決定增減Worker Server」073 · 第 32、35 頁
後端自我測驗第 11 題:「你知道如何善用MessageQueue的blocking機制,寫出一個background worker,在沒有工作時那個worker接近不使用CPU嗎?」113
🔭 跟原書 pull 模式的 long polling 是同一個問題、同一個方向。
🗣️ MQ 是 stateful,也要被保護
「stateful component是指像:postgresql database / kafka / rabbitMQ」,HA 的整個切換流程「有數不清的地方可以出錯,請使用像AWS RDS multi-AZ這些別人建好的方案,而不要輕易自己」017
「其實不止database要這樣子保護的,redis也要,rabbitMQ也要,amazon SQS其實也要的~」155 · connection 上限;HYPEBEAST 把 RabbitMQ 搬上 k8s 後:「Amazon internal-ELB has idle timeout 60s – Our mongodb / MQ connection raise exception every 60 sec.」046
🔭 推論 017 談的是 PostgreSQL;套到 MQ:原書整章的 ISR、controller、rebalance 都是自己做 HA,一般公司優先用代管服務。
Triton 補充123 · 100 · 原書沒寫的 exactly once
「怎樣只exactly扣用戶一次錢」:每一個當機點都要想過
你猜猜看:系統先呼叫 Stripe 向信用卡收費,再把訂單狀態改成「成功」。兩步中間當機,重開後從頭重做,會怎樣?
狀態還沒改,重做時又收一次。反過來先改狀態再收費,當機就變成沒收到錢:正好是前面的兩種送達語意。
白話:Stripe=幫網站刷信用卡的金流公司;2PC(two-phase commit)=跨兩台機器的資料,先各自準備好、再一起確認才算完成。
「如果這二份data是存放在不同的machine上,而你是需要做到strong consistency的(即是說:不能扣了錢但是沒給用戶商品)那麼2pc(或是其變種)是不能避免的 以下例子,你就是看到串金流系統時,怎樣只exactly扣用戶一次錢。」「你用event-sourcing,也是避不了這堆問題的」🗣️ Triton 本人說 100-二份data是存放在不同的machine上(2pc).md
🗣️ 錯誤寫法一:先呼叫 Stripe 收費、再 update status → 「用戶便會被收了雙份的錢」。錯誤寫法二:先 update status、再收費 → 「讓用戶沒被收費」。123-喵談 2pc.md
🔭 推論 這兩種錯誤寫法,就是原書的兩種語意:先做事再記帳 = at-least once(重複),先記帳再做事 = at-most once(遺失)。Triton 的解法不是靠 MQ 保證,而是讓「重做」這件事本身安全:Stripe 的 capture 從 true 改成 true 不會再收一次錢。
Triton 補充123 · 動手試四個當機點
不管在哪裡當機,都只收一次錢:因為每一步重做都安全
動手試:Passkit 的四步收費,在哪裡當機?
對照原書
原書說 exactly once「下游不支援 idempotency 時特別重要」(第 45 頁)。Passkit 的做法是反過來:讓下游(Stripe 的 capture)重做也安全,就能用 at-least once 加安全重做,做到「只收一次錢」。
🗣️ dedupe 也要成本:「Deduplication需要 locking和 response 暫存, 需要一個高效能的 Redis – 要看閣下的需求,才能決定是否值得」071 · 第 37 頁;「有些MQ 不保證絕對性的 FIFO 和 no-duplicate ,使用上請 注意(例子: Amazon SQS )」073 · 第 31 頁
Triton 同意原書做對的地方
循序寫、批次、順序要付出代價、延遲訊息:這些 Triton 都同意
✅ 循序 IO、append-only
「Random IO是Sequential IO的1 / 10效能也沒有。」104「MQ工作是write append,是Seq. IO不是Random IO,效能可以很高的。」185
SSTable「一旦建立後就永不改動( immutable)」080,和原書的 inactive segment 只讀不改同一個道理。
✅ 批次,但記得 buffer 會掉
HYPEBEAST 的 event receiver:「Pack multiple events to one SQS Message to save money」076;「write buffering和write aggregation,這些高階技能才是高效能系統的關鍵。」150
但在 AS 記憶體 buffer:「這方案如果AS斷電會有data loss風險」「沒10K RPS前別做這種事」117。🔭 原書 Figure 12 的 producer buffer 也一樣:還在 buffer 裡的訊息,producer 一當機就沒了。
✅ 順序 = 一條線排隊
撮合引擎用「FIFO MQ by CommodityID」;講義的「Misconception on high performance」那頁:以為「The event-based architecture has no LOCK」,其實「The is a LOCK on MQ FIFO channel to maintain data integrity」084。🔭 等於原書「同一 key 進同一 partition、一個 partition 只給一個 consumer」。
✅ 協調交給專門軟體
談 lock server:「專業應用請用 Zookeeper / etcd」086。🔭 原書用 ZooKeeper / etcd 做 controller 選舉、存 metadata,方向一致。
✅ 延遲訊息是真需求
HYPEBEAST 把 RabbitMQ 放上 k8s,「Why not AWS SQS: – We need delayed Messaging.」046
✅ 大量 log 用專門的串流
log 不放 DB:「小型系統使用 txt 檔案,大型系統使用專門作logging的軟體(例子: Amazon Kinesis)」065。🔭 原書要支援的 log aggregation,正是 Kafka 這類平台該出場的地方。
到這裡你已經會了小結 4 / 4
- message
- topic
- offset
- partition
- consumer group
- sequential IO
- segment
- leader / follower
- ISR
- ack
- delivery semantics
- Signal vs Message
到這裡你已經會了:讀的人當機、Triton 的判斷
- 先夾書籤再做事會掉(at-most once),先做事再夾書籤會重複(at-least once);剛好一次要靠「重做也安全」。
- 先分清楚是 Signal(廣播,掉了沒差)還是 Message(掛號信,一定要做完一次)。
- Triton:Kafka 不是 RabbitMQ 的進化版;每秒不到 1K 則,原書這一整套是 overkill。
12 階全部走完了
下一頁用一句話收尾;再下一頁是名詞小卡,給大家課後複習。
一句話記住
先問每秒幾則、掉了會不會死人;
沒到 1K,點單夾就夠了。
原書對的地方
- WAL + segment,循序寫磁碟、整段刪
- 批次換吞吐,batch size 是吞吐和延遲的取捨
- key → partition 保順序,一個 partition 一個 consumer
- ISR + ACK、commit 時機決定 at-most / at-least once
Triton 不同意 / 原書沒講
- Kafka 不是 RabbitMQ 的進化版,<1K msg/s 是 overkill
- Redis / sidekiq 當 queue:斷電會掉、hotspot、追不上就爆 RAM
- MQ 提高不了熱門紀錄的上限,購物別丟 MQ
- exactly once 靠的是安全重做(2PC),不是 MQ 的魔法
Triton 的做法
- 先分 Signal 還是 Message
- Message 用真 MQ:寫進 HDD 才回成功、完成才刪
- 不能掉的狀態放 RDBMS(outstanding_tasks),MQ 當門鈴
- 一則 message 的工作要短;worker 用 blocking 等工作
本章名詞小卡課後複習用 · 每個名詞一句白話
今天出現的名詞,一句話講完
給工程師的重點出處與標籤
引述來源(materials/core)與原書對照
Triton 本人的講義 / 文章
- 138-喵談 rabbitMQ 和 kafka.md — Kafka 不是 RabbitMQ 的 evolution、PostgreSQL vs HBase 的比喻、router 功能、LinkedIn、<1K msg/s overkill、「把RabbitMQ大量功能砍掉,特化scalibility的MQ」
- 078-mq-intro.pdf.md — 第 7 頁 MQ 先存 HDD 才回成功、工作完成才刪;第 8 頁 Signal vs Message;第 10 頁 Redis PubSub;第 13 頁 ACK timeout 訂不出來
- 030 Redis / sidekiq 不能當 queue 的四個原因 · 088 第 7 頁 Redis 不是 MQ Server · 086 第 18 頁 MQ 專業請用 RabbitMQ、第 17 頁 Zookeeper / etcd
- 012 RDBMS 當 IPC · 065 第 46–47 頁 Database-as-IPC、log 用 Kinesis · 073 第 31–36 頁 MQ 名詞、blocking、Redis 某程度可當 MQ、SQS 不保證 FIFO / no-duplicate、Database-as-IPC 少量可接受
- 185 用 MQ 的三個原因、Kafka 可近乎無限擴展、seq IO、單一 record 上限不變、Hash(ItemId) 同組排隊 · 020 outstanding_tasks + MQ
- 062 第 20–21 頁 exchange / topic、queue / consumer group、fanout、Signal 用的 RabbitMQ 設定 · 123 Passkit 的 Stripe 2PC 與四個當機點 · 100 不同機器避不了 2PC · 071 dedupe 需要 Redis
- 017 kafka / rabbitMQ 是 stateful、用別人建好的 HA、過份簡化的知識 · 155 rabbitMQ、SQS 也要保護 · 046 ELB idle timeout、We need delayed Messaging · 113 第 11 題 · 084 FIFO MQ by CommodityID、LOCK on MQ FIFO channel · 104 random vs seq IO · 080 SSTable immutable · 076 多個 event 包成一則 SQS message · 150 別隨便引入 kafka · 117 AS buffer 會掉資料
不引用:188、190、191、194、195(AI 生成的「Triton 題庫 / 指南」,裡面也提到 Kafka)。
一個可以直接問自己的問題
你的 queue 尖峰每秒幾則?裡面的每一則,是掉了沒差的 Signal,還是一定要跑完一次的 Message?
原書對照
Alex Xu & Sahn Lam, System Design Interview Vol.2 Ch.4。開場、MQ vs event streaming 與 Figure 1(第 5 頁);Step 1 需求與傳統 MQ 的調整(6);基本元件、messaging models 與 Figure 2–4(8–9);Topics / partitions / brokers 與 Figure 5–6(13);Consumer group 與 Figure 7(15);High-level architecture 與 Figure 8(16);Deep dive 三個選擇、Data storage、disk performance(18);WAL、segment 與 Figure 9–10(20);Message data structure 與 Table 1(22);Batching 與 Figure 13(23);Producer flow 與 Figure 11–12(24);Consumer flow、push vs pull 與 Figure 14(25);Pull model 與 Figure 15(26);Consumer rebalancing 與 Figure 16–20(27–29);State storage、Metadata storage 與 Figure 21(30);ZooKeeper 與 Figure 22(31);Replication 與 Figure 23(33);ISR 與 Figure 24(35);ACK 與 Figure 25–27(37–38);讀 leader、Scalability(39);Broker 與 Figure 28–29(40–41);Partition 與 Figure 30–31(42);Delivery semantics 與 Figure 32–34(45–46);Message filtering 與 Figure 35(47);Delayed / scheduled 與 Figure 36(48);Wrap up 與心智圖(49)。36 張圖與心智圖都依圖說與 alt 重繪,不是原圖;Figure 1 是 logo,只畫線框。
循序漸進(文組版)的頁面
學習地圖(第 3 頁);延伸基礎 12 階:message(4)、topic(7)、offset(10)、partition(12)、consumer group(14)、sequential IO(17)、segment(19)、leader / follower(32)、ISR(34)、ack(36)、delivery semantics(44)、Signal vs Message(50);小結(11、21、43、62);名詞小卡(64)。喵喵便當是虛構的示範情境;翻頁 10 ms、抄寫秒數等是示意數字,不是實測值。