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 階。每一階只用前面講過的東西。

  1. 1message一張單
  2. 2topic哪一本存檔
  3. 3offset書頁上的書籤
  4. 4partition拆成幾冊
  5. 5consumer group一個部門分冊讀
  6. 6sequential IO只往最後一頁寫
  7. 7segment寫滿換新本
  8. 8leader / follower正本與抄本
  9. 9ISR跟得上的抄本
  10. 10ack收據要等幾人
  11. 11delivery semantics先夾書籤還是先做
  12. 12Signal vs Message廣播 vs 掛號信

第 1–3 階 · 一張單寫進存檔本

要回答:誰寫、誰讀、讀到哪?

第 4–7 階 · 存檔本越來越厚

要回答:怎麼拆、怎麼分工、怎麼存得快?

第 8–10 階 · 怕存檔本燒掉

要回答:抄幾份、要等誰點頭?

第 11–12 階 · 讀的人當機、Triton 的判斷

要回答:會掉還是會重複?真的需要這一套嗎?

全程只用一家店:喵喵便當(虛構)

服務生 = producer一張單 = message廚師、會計、倉管 = consumer點單夾 = 傳統 MQ訂單存檔本(像報紙存檔)= topic書籤 = offset正本與抄本 = replica

每爬 3–4 階,有一頁「到這裡你已經會了」。

延伸基礎第 1 階 · message懂的人可以跳過

  1. message
  2. topic
  3. offset
  4. partition
  5. consumer group
  6. sequential IO
  7. segment
  8. leader / follower
  9. ISR
  10. ack
  11. delivery semantics
  12. Signal vs Message

服務生寫好單,要站在廚房門口等嗎?

① 先想像

中午一口氣來了 5 張單,廚房做一張要 2 分鐘。服務生可以站在門口等,也可以把單夾上點單夾就走。

你猜猜看:服務生站著等,5 張單全部做完,他要站多久?

③ 這叫做 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,哪裡可以簡化」。

📖 原書 Figure 1Popular distributed message queues(依原書內容重繪;原圖是產品 logo,商標不重繪,只畫線框與 alt 對 logo 的描述)

內文點名的產品: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懂的人可以跳過

  1. message
  2. topic
  3. offset
  4. partition
  5. consumer group
  6. sequential IO
  7. segment
  8. leader / follower
  9. ISR
  10. ack
  11. delivery semantics
  12. 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,還是給所有訂閱的人?

📖 原書 Figure 2Key components in a message queue(依原書內容重繪)

📖 原書 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懂的人可以跳過

  1. message
  2. topic
  3. offset
  4. partition
  5. consumer group
  6. sequential IO
  7. segment
  8. leader / follower
  9. ISR
  10. ack
  11. delivery semantics
  12. Signal vs Message

每個人一張書籤:讀到哪,夾到哪

① 先想像

訂單本一頁一筆,頁碼從 0 往上加。會計處理到第 6 頁,夾一張書籤;倉管比較快,書籤夾在第 13 頁。

你猜猜看:會計的書籤夾在第 6 頁(0–6 都處理完了)。他下次從第幾頁讀?

③ 這叫做 offset、commit

offset:頁碼,訊息在本子裡的位置,只會往上加。commit:把書籤夾好,記下「我處理到這裡了」。

④ 跟這章的關係

原書每個 consumer 自己記 offset(Figure 14、21)。書籤先夾、還是事情先做,第 44 頁會決定會不會掉單。

② 動手玩:同一本訂單本,兩張書籤

到這裡你已經會了小結 1 / 4

  1. message
  2. topic
  3. offset
  4. partition
  5. consumer group
  6. sequential IO
  7. segment
  8. leader / follower
  9. ISR
  10. ack
  11. delivery semantics
  12. Signal vs Message

到這裡你已經會了:一張單寫進存檔本

下一階要解決的問題

訂單本越寫越厚:一個櫃子放不下,一位倉管也讀不完。怎麼辦?

延伸基礎第 4 階 · partition懂的人可以跳過

  1. message
  2. topic
  3. offset
  4. partition
  5. consumer group
  6. sequential IO
  7. segment
  8. leader / follower
  9. ISR
  10. ack
  11. delivery semantics
  12. Signal vs Message

訂單本太厚:拆成 4 冊,依客人編號分

① 先想像

一本訂單本,一個櫃子放不下。老闆拆成 4 冊:客人編號除以 4 的餘數,決定寫進哪一冊。

你猜猜看:42 號客人一天點了 3 次。這 3 筆單會在幾冊裡?

③ 這叫做 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 讀不完,要怎麼拆?

📖 原書 Figure 5Partitions:Topic-A 的訊息分到 Partition-1、Partition-2(依原書內容重繪)

📖 原書 訊息依 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懂的人可以跳過

  1. message
  2. topic
  3. offset
  4. partition
  5. consumer group
  6. sequential IO
  7. segment
  8. leader / follower
  9. ISR
  10. ack
  11. delivery semantics
  12. Signal vs Message

倉管部有 2 個人,怎麼分工讀 4 冊?

① 先想像

規定:一冊只交給部門裡的一個人,不然兩人搶著做,同一冊的順序就亂了。會計部是另一個部門,自己再讀一次。

你猜猜看:4 冊,倉管部來了 5 個人。會有幾個人沒事做?

③ 這叫做 consumer group、rebalance

consumer group:一個部門;部門之間各讀各的。rebalance:有人加入或離開,部門重新分冊。

④ 跟這章的關係

原書 Figure 7 在下一頁;有人當機時怎麼重分,第 27 頁。

② 動手玩:調倉管部的人數

原書 Step 2Consumer group · Figure 7

一個 partition,在同一組裡只能給一個 consumer

這一步要解決的問題部門裡好幾個人一起讀,怎麼分工才不會把同一冊的順序弄亂?

📖 原書 Figure 7Consumer groups(依原書內容重繪;誰連到哪個 partition,alt 沒寫,依內文「group 2 的 consumer 3 讀不到 topic B」排)

📖 原書 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 存訊息之外,「哪冊放哪、誰讀到哪、誰當總管」要記在哪裡?

📖 原書 Figure 8High-level design(依原書內容重繪)

📖 原書 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懂的人可以跳過

  1. message
  2. topic
  3. offset
  4. partition
  5. consumer group
  6. sequential IO
  7. segment
  8. leader / follower
  9. ISR
  10. ack
  11. delivery semantics
  12. Signal vs Message

只往最後一頁寫,為什麼比較快?

① 先想像

倉庫裡的帳本很重。每一筆都要翻到某一頁插進去,時間都花在翻;只往最後一頁接著寫,筆不用離開紙。

你猜猜看:每「翻到某一頁」要 10 毫秒,寫一筆要 0.1 毫秒。100 筆、每筆都要翻頁,要多久?

③ 這叫做 sequential IO、random IO

sequential IO:照順序一路往後讀寫。random IO:每次跳到不同位置,時間大多花在「找」。

④ 跟這章的關係

原書把訊息存成只往後加的檔案,就是要吃到 sequential IO(下一頁)。Triton 也同意(第 61 頁)。

② 動手玩:寫 N 筆要多久?(示意數字)

—這種寫法的總時間—兩種差幾倍

原書 Step 3Design deep dive · Data storage

三個關鍵選擇,以及訊息要存在哪裡

這一步要解決的問題訊息要存兩週、每秒大量寫也大量讀:存在資料庫,還是普通檔案?

📖 原書 為了高吞吐 + 長保留,三個設計選擇

  1. On-disk data structure:利用旋轉硬碟極好的循序存取效能,加上現代作業系統積極的 disk cache
  2. Message data structure:訊息從 producer 到 queue 到 consumer 一路不修改,減少昂貴的複製
  3. 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懂的人可以跳過

  1. message
  2. topic
  3. offset
  4. partition
  5. consumer group
  6. sequential IO
  7. segment
  8. leader / follower
  9. ISR
  10. ack
  11. delivery semantics
  12. Signal vs Message

寫滿一本換新本;過期的整本丟掉

① 先想像

訂單本只能往後寫,不撕頁。一天寫滿一本,就換新的;舊本子只拿來查。規定保留兩週。

你猜猜看:要清掉兩週前的訂單,最省事的做法是?

③ 這叫做 segment、retention

segment:一本一本的檔案;正在寫的叫 active,其他只讀。retention:保留期限,過了就整本刪。

④ 跟這章的關係

原書 Figure 9–10 在下一頁;保留期就是面試官說的兩週。

② 動手玩:一天一本

1櫃子裡有幾本第 1 天最舊的一本0已整本丟掉

原書 Step 3WAL 與 segment · Figure 9–10

只往尾巴寫,寫滿一段就換一個新檔

這一步要解決的問題檔案不能無限長;過期的舊訊息要怎麼清,才不會拖慢正在寫的那一段?

📖 原書 Figure 9Append new messages(依原書內容重繪)

動手試:一個 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

  1. message
  2. topic
  3. offset
  4. partition
  5. consumer group
  6. sequential IO
  7. segment
  8. leader / follower
  9. ISR
  10. ack
  11. delivery semantics
  12. Signal vs Message

到這裡你已經會了:存檔本變厚之後

下一階要解決的問題

一則訊息長什麼樣?服務生怎麼送進來、會計怎麼拿出去、有人當機時誰來重新分工?

原書 Step 3Message data structure · Table 1

一則訊息長這樣:producer、queue、consumer 都照同一份合約

這一步要解決的問題producer、broker、consumer 都要看得懂同一張單子:單子該長什麼樣、要寫進哪一冊?

📖 原書 訊息的資料結構是高吞吐的關鍵:它是 producer、MQ、consumer 之間的合約。只要有一方不同意,訊息就得被改寫,牽涉昂貴的複製,嚴重拖累效能。

📖 原書 Table 1

Field NameData Type
keybyte[]
valuebyte[]
topicstring
partitioninteger
offsetlong
timestamplong
sizeinteger
crcinteger

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

一次送一大包:吞吐變高,但要等湊滿

這一步要解決的問題一則一則送,網路來回的成本會吃掉吞吐。一次送一大包,要付出什麼代價?

📖 原書 Figure 13The choice of the batch size(依原書內容重繪;圓點是下方滑桿的位置)
0這條連線每秒最多送幾則
0一則訊息平均多等多久

示意模型(數字不是原書的):每次 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)在哪一台?

📖 原書 Figure 11Routing layer(依原書內容重繪)

📖 原書 第一個做法:加一層 routing layer,所有訊息先到這層,再轉給「正確」的 broker;有 replication 時,正確的 broker 就是 leader replica。Figure 11 要送到 topic A 的 partition 1:

  1. Producer 把訊息送到 routing layer
  2. Routing layer 從 metadata storage 讀 replica distribution plan,存在本地 cache;把訊息轉給 partition 1 的 leader replica,在 broker 1
  3. Leader 收下訊息,follower replica 從 leader 拉資料
  4. 「夠多」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 自己照書籤來拿?

📖 原書 Figure 14Consumer flow(依原書內容重繪)

📖 原書 Consumer 指定自己在 partition 裡的 offset,收到從那個位置開始的一塊 event。兩個 consumer 進度不同,互不影響。

📖 原書 結論:大多數 MQ 選 pull。

📖 原書 Push 還是 pull?

Push:broker 推給 consumerPull: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,再去拿資料

這一步要解決的問題新來的倉管要找誰報到?分到哪幾冊?從哪一頁開始讀?

📖 原書 Figure 15Pull model(依原書內容重繪)
  1. 📖 原書 新 consumer 要加入 group 1、訂閱 topic A。它對 group 名稱做 hash 找到對應的 broker;同一組的 consumer 都連到同一台,這台叫這個 group 的 coordinator。
  2. coordinator 確認 consumer 已加入,分配 partition 2 給它。分配策略有 round-robin(輪流發)、range(一段一段分)等。
  3. consumer 從 last consumed offset 開始拉訊息,這個 offset 由 state storage 管理。
  4. 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

這一步要解決的問題有人加入、離開或當機,部門要重新分冊:誰來點名、誰來排?

📖 原書 Figure 16Coordinator of consumer groups(依原書內容重繪)

📖 原書 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 18New consumer joins(依原書內容重繪)

📖 原書 Figure 18:2 個 consumer、4 個 partition,B 加入

  1. 一開始只有 A,消費全部 partition,和 coordinator 保持 heartbeat
  2. B 送出加入請求
  3. coordinator 知道要 rebalance,用被動方式通知:等 A 的 heartbeat 來,才叫 A 重新加入
  4. 大家都重新加入後,coordinator 選一個當 leader,通知所有人選舉結果
  5. leader 產生分配計畫送給 coordinator;follower 向 coordinator 問計畫
  6. 各自開始消費新分到的 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 一起當機不見?

📖 原書 Figure 21Last consumed offset of consumer groups(依原書內容重繪)

📖 原書 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、選總管,三件事能不能交給一個專門的服務?

📖 原書 Figure 22ZooKeeper(依原書內容重繪)

📖 原書 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懂的人可以跳過

  1. message
  2. topic
  3. offset
  4. partition
  5. consumer group
  6. sequential IO
  7. segment
  8. leader / follower
  9. ISR
  10. ack
  11. delivery semantics
  12. Signal vs Message

訂單本只有一份,燒掉就沒了:請兩位抄寫員

① 先想像

老闆請甲、乙兩位抄寫員,各抄一份放在別的櫃子。新的單只寫進「正本」,抄寫員從正本照抄。

你猜猜看:為什麼新單只寫正本,不是三份一起寫?

③ 這叫做 leader、follower

leader:正本,唯一接新訊息的那份。follower:抄本,從 leader 拉資料來抄。每一份都叫 replica。

④ 跟這章的關係

就是第 1 章 replication 的 master / slave(第 1 章簡報第 14 頁)。原書每冊三份(下一頁)。

② 動手玩:正本燒掉會掉什麼?

原書 Step 3Replication · Figure 23

每個 partition 三份,分在不同 broker;只寫 leader

這一步要解決的問題硬碟壞了,那一冊就沒了。要抄幾份、放在哪裡、寫進哪一份?

📖 原書 Figure 23Replication(依原書內容重繪;alt 說 producer 寫到 broker-3 的 Topic-A Partition-1,與內文的分布計畫不合,依內文:亮色是 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懂的人可以跳過

  1. message
  2. topic
  3. offset
  4. partition
  5. consumer group
  6. sequential IO
  7. segment
  8. leader / follower
  9. ISR
  10. ack
  11. delivery semantics
  12. Signal vs Message

抄寫員請假落後了,還算不算數?

① 先想像

正本寫到第 15 頁。甲抄到 14、乙抄到 13,丙剛請假回來,只抄到 11。規定:落後不超過 3 頁才算「跟得上」。

你猜猜看:甲、乙、丙,誰算跟得上?

③ 這叫做 ISR、committed offset

ISR(in-sync replicas):跟得上的那幾份。committed offset:ISR 每一份都抄到的那頁,確定安全。

④ 跟這章的關係

原書 Figure 24(下一頁)就是這個例子,數字一樣:committed offset 是 13。

② 動手玩:落後不超過 3 頁才算數

原書 Step 3In-sync replicas · Figure 24

跟得上的 replica 才算數:ISR

這一步要解決的問題抄本有快有慢。要等誰抄好,才能說這則訊息安全了?

📖 原書 Figure 24How ISR works(依原書內容重繪;各 replica 收到的最後一筆照 alt:14、13、11)

📖 原書 訊息只寫 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懂的人可以跳過

  1. message
  2. topic
  3. offset
  4. partition
  5. consumer group
  6. sequential IO
  7. segment
  8. leader / follower
  9. ISR
  10. ack
  11. delivery semantics
  12. Signal vs Message

交單給櫃台:收據要等幾個人點頭?

① 先想像

服務生把單交給正本櫃台。櫃台可以馬上給收據、自己寫好再給,或等跟得上的抄寫員都抄好才給。

你猜猜看:正本 1 秒寫好,甲 3 秒、乙 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 收到,才算「送到了」?

📖 原書 Figure 25ack=all(依原書內容重繪)

📖 原書 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 各會掉哪幾則?

–producer 平均等 ack(tick)0遺失0其中「已 ack 卻遺失」0重送(可能重複)

規則(照原書)

  • 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)燒掉了,上面那些冊子怎麼補回三份?

📖 原書 Figure 28Broker node crashes(依原書內容重繪;alt 對初始分布的描述與內文不一致,依內文的三份計畫畫)

📖 原書 三份計畫

初始broker 3 掛了新計畫
A · P11(L)、2、31(L)、21(L)、2、4
A · P22(L)、3、42(L)、42(L)、4、1
B · P13(L)、4、14、14(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,要怎麼把冊子搬過去,又不掉資料?

📖 原書 Figure 29Add new broker node(依原書內容重繪;alt 寫初始時 Broker-1 只有 Partition-2,與內文「3 個 broker、2 個 partition、每個 3 份」不合,依內文)

📖 原書 最簡單的做法:加減 broker 時重新分配 replica。但有更好的做法:broker controller 可以暫時允許比設定檔更多的 replica,新 broker 追上後,再移除不需要的。

  1. 初始:3 個 broker、2 個 partition,每個 partition 3 份
  2. 加入 broker 4。controller 把 partition 2 的分布改成 broker (2, 3, 4);broker 4 的新 replica 開始從 leader broker 2 複製。這時 partition 2 暫時超過 3 份
  3. broker 4 追上後,broker 1 上多餘的 partition 2 被優雅地移除

📖 原書 這樣加 broker 時不會掉資料;移除 broker 也可以用類似流程。

文組翻譯:換新的保險箱,不是先把舊的清空再搬,而是先把東西複製一份放進新的,確認無誤再清掉舊的。中間有一段時間東西有四份,比較貴,但不會掉。

原書 Step 3增減 partition · Figure 30–31

加 partition 很簡單;減 partition 要等保留期過了

這一步要解決的問題冊數要改:加冊為什麼很簡單?減冊為什麼不能馬上回收空間?

📖 原書 Figure 30Partition increase(依原書內容重繪)

📖 原書 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

  1. message
  2. topic
  3. offset
  4. partition
  5. consumer group
  6. sequential IO
  7. segment
  8. leader / follower
  9. ISR
  10. ack
  11. delivery semantics
  12. Signal vs Message

到這裡你已經會了:不怕存檔本燒掉

下一階要解決的問題

寫的那一端顧好了。讀的那一端也會當機:書籤先夾,還是事情先做?

延伸基礎第 11 階 · delivery semantics懂的人可以跳過

  1. message
  2. topic
  3. offset
  4. partition
  5. consumer group
  6. sequential IO
  7. segment
  8. leader / follower
  9. ISR
  10. ack
  11. delivery semantics
  12. Signal vs Message

會計入帳:先夾書籤,還是先入帳?

① 先想像

會計讀到第 42 頁,要做兩件事:在帳上記一筆、把書籤夾到 42。做到一半停電,重開後從書籤的下一頁讀。

你猜猜看:先夾書籤、再入帳,兩步中間停電。重開後,第 42 頁入帳了幾次?

③ 這叫做 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 都可能當機。原書提供哪三種保證?各要怎麼設定?

    📖 原書 Figure 32At-most once(依原書內容重繪)

    📖 原書 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 過濾

      這一步要解決的問題付款系統只要結帳和退款,其他訂單活動都不想收。要在哪裡過濾?

      📖 原書 Figure 35Message filtering by tags(依原書內容重繪;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 分鐘後檢查有沒有付款」這種事,要怎麼讓訊息晚一點才送到?

      📖 原書 Figure 36Delayed messages(依原書內容重繪)

      按「建立訂單」: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

      面試還有時間,可以再聊三件事

      這一步要解決的問題主體設計完,面試還有時間:還有哪些可以多聊?

      📖 原書 Chapter summary本章心智圖(依原書內容重繪;alt 把 delivery semantics 放在 Step 4,依內文它屬於 Step 3 deep dive)

      原書最後一句:「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懂的人可以跳過

      1. message
      2. topic
      3. offset
      4. partition
      5. consumer group
      6. sequential IO
      7. segment
      8. leader / follower
      9. ISR
      10. ack
      11. delivery semantics
      12. 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 的「升級版」嗎?

      🗣️ 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 萬則推播。平均每秒幾則?

      「就先給結論:如果系統還沒到每秒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 說「成功」?

      「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 追不上,會怎樣?

      白話: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 這種方案

      1. 「sidekiq是基建於redis的,然後redis本身沒法做到high persistence(斷電後redis會有data loss的)(Kafka / rabbitmq都有mirroring / quorum機制保護)」
      2. 「sidekiq是使用redis的list/sorted set data structure,然後一個data structure只會存放於單台的redie上,那很容易造成cluster的local hotspot。」
      3. 「redis的超高效能,是建基於「所有data都足夠放到RAM內」如果你的consumer消化速度追不上producer生產速度 你的redis很容易就會爆炸掉。rabbitmq / Kafka是使用HDD來存放buffer的。HDD的大小遠遠比RAM大。」
      4. 「你的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再慢慢處理,一般而且有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

        1. message
        2. topic
        3. offset
        4. partition
        5. consumer group
        6. sequential IO
        7. segment
        8. leader / follower
        9. ISR
        10. ack
        11. delivery semantics
        12. Signal vs Message

        到這裡你已經會了:讀的人當機、Triton 的判斷

        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 等工作

        本章名詞小卡課後複習用 · 每個名詞一句白話

        今天出現的名詞,一句話講完

        message一張帶著工作內容的單子
        producer / consumer寫單送單的人/拿單來做的人
        message queue(MQ)點單夾:先放著,後面的人照順序拿
        event streaming platform像報紙存檔:保留、可重看、照順序(Kafka)
        point-to-point一張單只給一個人,拿走就沒了
        publish-subscribe(pub-sub)寫進一本,訂了的人都收到
        topic一本有名字的存檔本,同一類訊息寫在一起
        offset、commit頁碼/把書籤夾好
        partition一本 topic 拆出來的一冊,冊內照順序
        broker放冊子的櫃子,也就是一台機器
        message key決定寫進哪一冊的欄位,例如客人編號
        consumer group、rebalance一個部門,部門內一冊只給一人/重新分冊

        給工程師的重點出處與標籤

        引述來源(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、抄寫秒數等是示意數字,不是實測值。

        ← → 翻頁 · S 講者備註 · D 深/淺色
        1 / 1目錄