System Design Interview Vol. 2 · 第 5 章Triton 覆蓋度:🟡 中Triton 線

Metrics Monitoring and Alerting
系統的體溫計和警鈴

原書帶你從零設計一套給大公司內部用的監控系統:pull 或 push、Kafka、時間序列資料庫、降採樣、警報流程。Triton 沒有設計過這種系統,他的立場很實際:這種東西用買的,你該花力氣的是「知道要看哪幾條線」。

給文組

全程只用一間病房(仁心醫院 5 樓,虛構),一階一階爬 12 個概念。頁首標 延伸基礎 的頁是補基礎,懂的人可以跳過。最後有一個「哪條線會先告訴你」的值班遊戲。

給工程師

原書 22 張圖、5 個表和章末心智圖全部重繪;最後一頁列出所有出處(materials/core)與頁碼對照。

標籤怎麼看

📖 原書 🗣️ Triton 本人說 🔭 依 Triton 原則推論 💬 討論串 📅 2026 補充

先用生活理解監視器 vs 病歷

病房裡的監視器,和護理站的病歷

75心跳(次/分)0.0 秒連續超過 120正常護理站

監視器一直在畫線:心跳、血壓、血氧。它不知道病人為什麼心跳變快,它只負責在數字不對的時候響。

想知道為什麼,要翻病歷:幾點給了什麼藥、病人說了什麼。病歷很詳細,但沒有人會一直盯著病歷看。

這章的分工

  • Metrics = 監視器上的數字,每幾秒一筆,量小、即時、可以畫圖、可以響鈴
  • Logs = 病歷,事情的經過,量大、事後查
  • 警鈴不是「一超過就響」,是「持續超過一段時間才響」,不然病人咳一下護理站就要跑一趟

學習地圖本章的概念階梯

今天爬 12 階。每一階只用前面講過的東西。

  1. 1metric量一個數字
  2. 2time series每分鐘量一次體溫
  3. 3label床號標籤
  4. 4TSDB一欄一欄抄的記錄簿
  5. 5pull / push巡房 vs 手環
  6. 6message queue先排隊的暫存箱
  7. 7aggre­gation合成一個數字
  8. 8down­sampling舊資料變粗
  9. 9retention到期整格清掉
  10. 10threshold超過多久才叫人
  11. 11dedupe同一件事只叫一次
  12. 12bottleneck最慢的那一站

第 1–4 階 · 一筆數字怎麼記

要回答:1,000 萬條線,存在哪?

第 5–7 階 · 數字怎麼送到護理站

要回答:10 萬台機器,誰去收?

第 8–9 階 · 存一年不爆倉

要回答:舊資料怎麼變小、怎麼丟?

第 10–12 階 · 叫人與找原因

要回答:何時叫醒人?Triton 看哪幾條線?

全程只用一間病房:仁心醫院 5 樓(虛構)

一張病床 = 一台 server床邊監視器 = metrics source護理站 = 監控系統體溫記錄簿 = TSDB病歷 = log值班醫師的手機 = 警報通道

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

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

  1. metric
  2. time series
  3. label
  4. TSDB
  5. pull / push
  6. message queue
  7. aggregation
  8. downsampling
  9. retention
  10. threshold
  11. dedupe
  12. bottleneck

護理師該記「37.8」,還是記「病人說頭好痛」?

① 先想像

12 床的監視器每分鐘量一次體溫,一天量 1,440 次。護理師另外會在病歷上寫下發生了什麼事。

你猜猜看:一天 1,440 個體溫數字,和 1,440 句病歷,哪個佔的紙比較多?

③ 這叫做 metric、log

metric:每隔一段時間量一次的一個數字。log:一句描述「發生了什麼事」的文字紀錄。

④ 跟這章的關係

原書這章只做 metrics(監視器),log 排除在外。兩者為什麼要分開,第 45 頁聽 Triton 講。

② 動手玩:各記幾筆看看


      
0數字佔的 bytes0病歷佔的 bytes—電腦能自動判斷「要不要響鈴」嗎

白話:byte=電腦存一個英文字母的空間;一個中文字約 3 bytes(第 2 章簡報第 6 頁)。

原書 Step 1釐清需求 · Figure 1

面試一開始:監控「什麼」、給「誰」用、留「多久」

這一步要解決的問題監控「什麼」?給誰用?留多久?沒先問清楚,後面的儲存和警報都會設計錯。

📖 原書 應徵者 × 面試官

應徵者問面試官答
給誰用?像 Facebook、Google 這種大公司內部用,還是做成 Datadog、Splunk 那種 SaaS?只給內部用
要收哪些 metrics?系統運作指標:CPU load、記憶體、磁碟空間這種低階的,也包括每秒 request 數、web pool 裡有幾台 server 在跑這種高階的。商業指標不在範圍內
要監控的基礎設施多大?1 億 DAU、1,000 個 server pool、每個 pool 100 台機器
資料留多久?1 年
長期儲存可以降低解析度嗎?新資料留 7 天;7 天後可以彙整成 1 分鐘解析度留 30 天;30 天後再彙整成 1 小時解析度
支援哪些警報通道?Email、電話、PagerDuty、webhook(HTTP endpoint)
要收 log 嗎(error log、access log)?不用
要支援分散式追蹤(distributed tracing)嗎?不用
📖 原書 Figure 1市面上受歡迎的監控與警報服務(原圖是 8 個產品 logo;logo 是商標不重繪,改成名稱方塊示意)

📖 原書 原書提醒:「監控系統」對不同公司意思差很多。面試官心裡想的如果只是基礎設施指標,你就不要設計一套以 web server error log、access log 為主的系統。這章要設計的是一個像 Figure 1 這些產品、給大公司內部用的服務。

白話:DAU=每天至少用一次的人數;server pool=一組做同一件事的機器;SaaS=租來用的線上服務;PagerDuty=專門打電話、傳簡訊叫醒值班工程師的服務;webhook=出事時自動呼叫你指定的網址。

原書 Step 1需求與假設

1,000 個 pool × 100 台 × 100 個指標 ≈ 1,000 萬條線

這一步要解決的問題到底要監控多少東西?先把「幾條線、每秒幾個點」算出來。

📖 原書 高階需求與假設

  • 被監控的基礎設施是大規模的:1 億 DAU
  • 1,000 個 server pool、每 pool 100 台、每台 100 個 metrics → 約 1,000 萬個 metrics
  • 資料保存 1 年。保留政策:原始資料 7 天、1 分鐘解析度 30 天、1 小時解析度 1 年
  • 可監控各種指標,例如 CPU 使用率、request 數、記憶體使用率、message queue 裡的訊息數

📖 原書 非功能需求 · 不做的事

  • Scalability:metrics 和警報量增加時能擴展
  • Low latency:dashboard 和警報的查詢延遲要低
  • Reliability:高可靠,不能漏掉重要警報
  • Flexibility:技術一直變,pipeline 要能輕鬆換上新技術
  • 不做:Log monitoring(ELK:Elasticsearch、Logstash、Kibana 很流行)、Distributed tracing(追蹤一個 request 穿過各個服務的路徑)

動手算:1,000 萬條線,每秒寫多少點?

收集間隔
10,000,000time series(線)1,000,000每秒寫入的資料點86.4 B每天的資料點

🔭 示意 原書沒給收集間隔;10 秒取自原書 Table 4 的「10 秒解析度」。原書在 access pattern 段寫「每天約 1,000 萬筆 metrics 被寫入」,但 1,000 萬是線的條數,不是每天的點數;照 10 秒一點算,一天約 864 億點。

原書 Step 2Fundamentals · Figure 2

監控系統的五個零件

這一步要解決的問題一套監控系統由哪幾個零件組成?先看全貌,後面再一個一個放大。

📖 原書 Figure 2系統的五個組件(依原書內容重繪;點方塊看說明)

文組翻譯:仁心醫院 5 樓

  • ① 收集:床邊監視器每分鐘量體溫、心跳
  • ② 傳輸:數字傳回護理站
  • ③ 儲存:寫進體溫記錄簿,查得到上個月
  • ④ 警報:體溫持續超標,呼叫值班醫師
  • ⑤ 視覺化:護理站大螢幕上的曲線。人看圖比看數字表快多了

延伸基礎第 2 階 · time series懂的人可以跳過

  1. metric
  2. time series
  3. label
  4. TSDB
  5. pull / push
  6. message queue
  7. aggregation
  8. downsampling
  9. retention
  10. threshold
  11. dedupe
  12. bottleneck

每分鐘量一次體溫,一天記下幾筆?

① 先想像

12 床的體溫每分鐘記一筆:08:00 36.8、08:01 36.9……排成一串,就能畫成一條曲線。

你猜猜看:每分鐘量一次,一天會記下幾筆?

③ 這叫做 time series、data point

time series:一串照時間排好的(時間, 數值)。data point:串裡的一筆。

④ 跟這章的關係

原書說 metrics 通常記成 time series。原書的規模是 1,000 萬條這樣的線(第 6 頁)。

② 動手玩:多久量一次?

1,440一天記下的筆數39.0記到的最高體溫抓到了11:20 那次發燒

原書 Step 2Data model · Figure 3 · Table 1–2

一條線 = 名稱 + 標籤 + 一串(時間, 數值)

這一步要解決的問題一個數字要怎麼寫下來,之後才查得到、畫得出來?

📖 原書 Figure 3CPU load:i631 在 20:00 的值是 0.29(依原書內容重繪;曲線形狀為示意)
範例 1:production server i631 在 20:00 的 CPU load 是多少?

📖 原書 Table 1 這一個點寫成表格

metric_namecpu.load
labelshost:i631,env:prod
timestamp1613707265
value0.29

📖 原書 Table 2 每一條 time series 包含

名稱型別
一個 metric nameString
一組 tags / labels<key:value> 配對的 list
一組數值與時間戳<value, timestamp> 配對的 array

📖 原書 Metrics 通常記成 time series:一組帶時間戳的數值。一條線由名稱唯一識別,也可以再加一組 labels。文組版:「體溫・5 樓・12 床」是名稱和標籤,底下是每分鐘一筆的體溫(第 8 頁)。

延伸基礎第 3 階 · label懂的人可以跳過

  1. metric
  2. time series
  3. label
  4. TSDB
  5. pull / push
  6. message queue
  7. aggregation
  8. downsampling
  9. retention
  10. threshold
  11. dedupe
  12. bottleneck

「體溫」兩個字不夠:是哪一床的體溫?

① 先想像

護理站螢幕上寫「體溫 39.0」,大家第一句一定問:哪一床?所以每條線都要貼標籤,例如「床號=12」。

你猜猜看:5 樓有 20 床,每床量體溫。依「床號」分開,有幾條體溫線?

③ 這叫做 label、cardinality

label(也叫 tag):貼在線上的小標籤,例如 bed=12。cardinality:一個標籤有幾種可能的值。

④ 跟這章的關係

原書說 label 要「低 cardinality」。每多一個標籤,線的條數就乘上它的值有幾種(第 11 頁)。

② 動手玩:替「體溫」貼標籤

20最多可能有幾條線護理站看得完狀態

原書 Step 2Data model · line protocol · labels

範例 2:us-west 所有 web server 最近 10 分鐘的平均 CPU

這一步要解決的問題想查「某一區所有機器」的平均,資料要怎麼標記?

📖 原書 Line protocol


      

概念上,從儲存撈出 metric name 是 CPU.load、region label 是 us-west 的資料,把每行最後的數值平均。這種格式叫 line protocol,是市面上很多監控軟體的常見輸入格式,例如 Prometheus 和 OpenTSDB。

原書的例子裡每一行時間戳都是 1613707265,這裡照錄。

動手玩:多加一個 label,線會變成幾條?

你猜猜看:cpu.load 已經依 host 分成 10 萬條線。再加一個 user_id(1 億種)的 label,最多會變成幾條?

一條線 = 一組 label 值的組合。勾選要加在 cpu.load 上的 labels:

100,000這個 metric 的 time series 數OK對照 Figure 5 的 unique series 上限

📖 原書 好的時間序列資料庫能依 labels(有些資料庫叫 tags)快速彙總大量資料,例如 InfluxDB 會在 labels 上建 index。關鍵是每個 label 都要是低 cardinality(可能的值很少)。這個功能對視覺化很重要,用通用資料庫要花很大力氣才做得到。

原書 Step 2Data access pattern · Figure 4

寫入一直很重,讀取一陣一陣

這一步要解決的問題這套系統是讀得多,還是寫得多?這決定要選哪一種資料庫。

📖 原書 Figure 4Data access pattern:y 軸每一列是一條 time series,x 軸是時間(依原書內容重繪)
0已寫入的點

📖 原書 寫入很重:任何時刻都有大量 time series 在寫入。原書說每天約 1,000 萬個 operational metrics 被寫入,而且很多以高頻收集,所以流量「無疑是 write-heavy」。

📖 原書 讀取是 spiky:視覺化和警報服務都會查資料庫,依圖表和警報的存取模式,讀取量可能突然爆發。

換句話說:系統持續承受很重的寫入,讀取則是尖峰型的。

文組翻譯:監視器每分鐘都在寫,從不休息;但只有病人出狀況時,醫師、護理師才一起擠到螢幕前翻曲線。

白話:write-heavy=寫得比讀得多;spiky=平常很少、偶爾突然爆一大波。

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

  1. metric
  2. time series
  3. label
  4. TSDB
  5. pull / push
  6. message queue
  7. aggregation
  8. downsampling
  9. retention
  10. threshold
  11. dedupe
  12. bottleneck

記錄簿要一列一列抄,還是一欄一欄抄?

① 先想像

一般表格每一列寫「時間|體溫」。換個抄法:所有時間抄成一排、所有體溫抄成一排。同一排的數字長得很像。

你猜猜看:時間那一排是 08:00、08:01、08:02……從第二格起,最省事要寫什麼?

③ 這叫做 TSDB、columnar

TSDB(time-series database):專門存 time series 的資料庫。columnar(欄式):同一欄的資料放在一起存。

④ 跟這章的關係

原書不用 MySQL,選 TSDB(第 14 頁);第 31 頁的「只存差多少」就是這一招。

② 動手玩:同樣 8 筆,三種抄法


      
80要寫的字數100%相對一列一列

白話:MySQL=最常見的一般用途資料庫,什麼都能存,但不是專為時間序列設計的。

原書 Step 2Data storage system · Figure 5

不要自己做,也不要拿 MySQL 硬撐:用時間序列資料庫

這一步要解決的問題每秒上百萬筆寫入,要存在哪一種資料庫?

📖 原書 為什麼不用通用資料庫

  • MySQL 這類 RDBMS:理論上可以,但到這個規模要專家級調校。滾動視窗的移動平均要寫很難讀的 SQL(第 30 頁);每個 tag 都要加 index;持續重寫入下表現不好
  • NoSQL:Cassandra、Bigtable 都能存 time series,但要非常懂它的內部才設計得出好 schema。有現成的工業級 TSDB,就沒必要
  • TSDB:同樣資料量用少很多台機器;有比 SQL 好用的查詢介面;有些還內建 retention 和彙總

📖 原書 有哪些

OpenTSDB(分散式,但基於 Hadoop / HBase,維運複雜)、Twitter 的 MetricsDB、Amazon Timestream。依 DB-engines,最受歡迎的是 InfluxDB 和 Prometheus:都靠 in-memory cache 加磁碟儲存。面試時不需要懂 TSDB 內部(除非履歷上寫了),重點是知道 metrics 本質上是 time series,可以選 InfluxDB 這類資料庫。

白話:RDBMS=用表格存資料、用 SQL 問話的資料庫(MySQL 是一種);NoSQL=不用表格的另一大類;index=書後面的索引;in-memory cache=放在記憶體、讀得很快的暫存。TSDB 是第 13 頁那本「一欄一欄抄」的記錄簿。

📖 原書 Figure 5InfluxDB benchmarking:三個等級的硬體與吞吐(原圖是一張表的圖片,依 alt 重繪)

原書內文:8 核心、32GB RAM 的 InfluxDB 每秒可處理超過 250,000 筆寫入。

原書 Step 2High-level design · Figure 6

高階設計:一條寫入的路,一條查詢的路

這一步要解決的問題五個零件怎麼接起來?寫入一條路、查詢一條路。

📖 原書 Figure 6High-level design(依原書內容重繪;原圖把 PagerDuty 寫成 PageDuty,照錄)

Metrics source:application server、SQL 資料庫、message queue 等

Metrics collector:收集 metrics、寫進 TSDB

Time-series DB:存 time series,有專用查詢介面,在 labels 上維護 index

Query service:讓查詢變簡單。TSDB 選得好,它就只是很薄的一層,甚至可以直接用 TSDB 自己的查詢介面取代

Alerting / Visualization:送警報到各種目的地;把 metrics 畫成各種圖表

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

  1. metric
  2. time series
  3. label
  4. TSDB
  5. pull / push
  6. message queue
  7. aggregation
  8. downsampling
  9. retention
  10. threshold
  11. dedupe
  12. bottleneck

到這裡你已經會了:一筆數字怎麼記

下一階要解決的問題

1,000 萬條線散在 10 萬台機器上。數字要怎麼收回護理站?

延伸基礎第 5 階 · pull / push懂的人可以跳過

  1. metric
  2. time series
  3. label
  4. TSDB
  5. pull / push
  6. message queue
  7. aggregation
  8. downsampling
  9. retention
  10. threshold
  11. dedupe
  12. bottleneck

護理師巡房量,還是手環自己傳?

① 先想像

方法一:護理師照名單,每隔幾分鐘巡一圈、一床一床量。方法二:每位病人戴手環,自己把數字傳回護理站。

你猜猜看:剛住進一位新病人,可是護理師的巡房名單還沒更新。巡房時會怎樣?

③ 這叫做 pull、push

pull:收資料的一方定時照名單去拿(巡房)。push:被量的一方自己把資料送上來(手環)。

④ 跟這章的關係

原書兩種都講,再用 Table 3 比優缺點(第 23 頁)。巡房名單誰來更新,第 19 頁回答。

② 動手玩:同一間病房,兩種收法

0 / 5護理站有資料的床每 3 秒收一輪。

原書 Step 3Metrics collection · Figure 7–8

收集:偶爾掉一點沒關係;pull 還是 push?

這一步要解決的問題數字要怎麼從十萬台機器收上來?先看 pull。

📖 原書 Figure 7Metrics collection flow:這一節談虛線框裡的部分(依原書內容重繪)

📖 原書 像 counter、CPU 使用率這種 metrics,偶爾掉資料不是世界末日,client 可以 fire and forget。收集有兩種方式:pull 或 push。「哪個比較好」是例行辯論,沒有明確答案。

📖 原書 · Pull 專門的 metrics collector 定期透過 HTTP 從執行中的應用程式拉 metrics。collector 要知道所有 service endpoint 的完整清單。

最天真的做法:在 collector 上放一個檔案,記下每個 endpoint 的 DNS/IP。簡單,但 server 經常新增移除的大環境很難維護,也容易漏收新機器。好消息:Service Discovery(etcd、Zookeeper 等)可靠、可擴展:服務自己註冊,清單變動時通知 collector。

原書 Step 3Pull model · Figure 9–10

Collector 怎麼知道要去拉誰:問 service discovery

這一步要解決的問題機器一直增減,collector 怎麼知道該去拉誰?

📖 原書 Figure 9Service discovery 存著「何時、去哪收」的設定(依原書內容重繪)

📖 原書 Pull 的三個步驟

  1. Collector 從 Service Discovery 拿到各 endpoint 的設定 metadata:pulling interval、IP 位址、timeout 和 retry 參數等
  2. Collector 透過預先定義的 HTTP endpoint(例如 /metrics)拉資料。要暴露這個 endpoint,服務通常要加一個 client library。Figure 10 的服務是 Web Servers
  3. (選擇性)Collector 向 Service Discovery 註冊變更通知,endpoint 變動時收到更新;或者定期輪詢變動

文組翻譯:護理師巡房前,先跟住院處拿最新的床位名單(誰住進來、誰出院、每幾分鐘巡一次)。名單一變,住院處會通知護理站。第 17 頁漏掉的新病人,就是這樣補回來的。

白話:metadata=描述資料的資料(這裡是「去哪、多久、等多久」);timeout=等多久沒回應就算失敗;client library=裝進服務裡的一小包現成程式。

原書 Step 3Collector pool · Figure 11

一台 collector 拉不完幾千台:用 consistent hashing 分工

這一步要解決的問題好幾台 collector 一起拉,怎麼不重複、也不漏掉?

📖 原書 Figure 114 台 collector、6 台 server;Collector 2 負責 server 1 和 server 5(依原書內文重繪;原圖 alt 描述不清楚,以內文為準)

📖 原書 在我們的規模,一台 collector 處理不了幾千台 server,要用一個 collector pool。多台 collector 常見的問題:好幾台去拉同一個來源,產生重複資料。所以 collector 之間要有協調機制。

📖 原書 一種做法:每台 collector 負責 consistent hash ring 上的一段,每台被監控的 server 依它的唯一名稱 hash 到環上。這樣每台 source server 只會被一台 collector 處理。

Consistent hashing 本身見 Vol.1 第 5 章那份簡報第 11 頁:把機器排在一個圓環上,從自己的位置順時針走,碰到的第一台就是負責你的。

原書 Step 3Push model · Figure 12–13

Push:每台機器裝一個 agent,自己把數字送上來

這一步要解決的問題換個方向:讓每台機器自己把數字送上來。

📖 原書 Figure 12各種來源直接把 metrics 推給 collector(依原書內容重繪)

📖 原書 Push model 通常在每台被監控的 server 裝一個 collection agent:長時間執行的軟體,收集這台機器上服務的 metrics,定期推給 collector。agent 也可以先在本地彙總(尤其是簡單的 counter)再送,有效減少送出的資料量。

📖 原書 推送流量太高、collector 回錯誤拒收時,agent 可以在本地留一小塊 buffer(可能存在本地磁碟),稍後重送。但如果 server 在 auto-scaling group 裡經常被換掉,本地暫存的資料在 collector 落後時可能就跟著機器一起不見。

📖 原書 為了不讓 collector 落後,collector 要放在前面有 load balancer 的 auto-scaling 叢集裡,依 collector 機器的 CPU load 自動增減(Figure 13)。

白話:buffer=暫存區;load balancer=帶位員,把來的資料分給不同 collector(第 1 章簡報第 12 頁);auto-scaling=忙時自動多開機器、閒時關掉(第 11 頁)。

原書 Step 3 · 動手玩Pull vs push

新機器上線、短命的 job、有人當機:兩種模式各怎麼反應?

這一步要解決的問題新機器、短命的 job、當機:兩種收法,誰比較不會漏?

發生了什麼

選一個模式,然後按上面的按鈕。每 3 秒收集一次。

📖 原書 誰在用

  • Pull:Prometheus
  • Push:Amazon CloudWatch、Graphite
  • 原書:面試時,知道兩邊的優缺點比選出贏家重要(下一頁 Table 3)

白話:batch job=跑完就結束的一次性工作,例如半夜結帳。

原書 Step 3Table 3 · Pull vs push

原書的比較表:沒有贏家,大公司兩種都要

這一步要解決的問題pull 和 push 到底誰好?原書用一張表比六件事。

你猜猜看:有個 batch job 只活 2 秒就結束,collector 每 10 秒才來拉一次。哪一種收法比較不會漏掉它的數字?

PullPush
Easy debuggingApp server 上給 pull 用的 /metrics endpoint 隨時可以打開來看,甚至在你的筆電上就能看。Pull 勝。如果 collector 沒收到 metrics,問題可能出在網路。
Health checkApp server 沒回應 pull,馬上知道它是不是掛了。Pull 勝。如果 collector 沒收到 metrics,問題可能出在網路。
Short-lived jobs有些 batch job 活不夠久,來不及被拉。Push 勝。(pull 可以加 push gateway 補救)
Firewall / 複雜網路要拉,就要所有 metrics endpoint 都連得到。多資料中心時可能有問題,要更複雜的網路基礎建設。Collector 前面有 load balancer 和 auto-scaling group,就能從任何地方收資料。Push 勝。
Performance通常用 TCP。通常用 UDP,傳輸延遲較低。反方論點:建立 TCP 連線的成本,比起送 metrics payload 很小。
Data authenticity要收的 app server 事先寫在設定檔裡,收到的資料保證是真的。任何 client 都能推給 collector。可以用白名單或要求驗證來解決。

白話:TCP=會確認對方收到的寄法(像掛號);UDP=丟了就算的寄法(像平信);firewall=擋外人連進來的門禁;serverless=不用自己管機器、雲端幫你跑程式。

📖 原書 pull 或 push 是例行辯論,沒有明確答案。大型組織大概兩種都要支援,尤其 serverless 越來越普及:有些環境根本沒辦法裝 agent 來推資料。

原書 Step 3Scale the transmission pipeline · Figure 14–15

資料庫掛了怎麼辦?中間加一個 Kafka

這一步要解決的問題TSDB 停機的那幾分鐘,送來的資料會不會掉?

📖 原書 Figure 14Metrics transmission pipeline(依原書內容重繪)
0掉掉的點0暫存在 Kafka0寫進 TSDB資料點一直在流。切換兩張圖,各按一次停機比較。

📖 原書 不管 push 或 pull,collector 都是一個 auto-scaling 的叢集,收進大量資料。風險是:TSDB 不能用時,資料會掉。解法:collector 把資料送進 Kafka 這類 queue,再由 consumer 或 Storm、Flink、Spark 這類串流處理服務寫進 TSDB。

📖 原書 優點:Kafka 是高可靠、可擴展的分散式訊息平台;把資料收集和資料處理解耦;資料庫不能用時,資料留在 Kafka 裡,不會掉。

第 6 階複習 · message queue:工作先排隊、之後慢慢處理的暫存箱(第 1 章簡報第 30 頁)。Kafka 是最常見的一種;consumer=從隊伍裡拿資料出來處理的程式;解耦=前後兩段各做各的,一段停了不拖垮另一段。

原書 Step 3Scale through Kafka · Figure 16 · 替代方案

Kafka 怎麼擴展:依 metric 名稱分 partition

這一步要解決的問題一個 Kafka 也會塞:怎麼分攤?不用 Kafka 行不行?

📖 原書 Figure 16Kafka partition:每個 partition 放一種 metric(依原書內容重繪)

📖 原書 利用 Kafka 內建的 partition

  • 依吞吐需求設定 partition 數量
  • 依 metric 名稱分 partition,consumer 就能依 metric 名稱彙總
  • 再用 tags / labels 進一步細分
  • 把 metrics 分類並排優先順序,重要的先處理

白話:partition=把一條隊伍拆成好幾條平行的隊伍,各自有人處理。

📖 原書 Kafka 的替代方案

維護一套 production 規模的 Kafka 不是小事,面試官可能會質疑。也有大型監控系統不用中間的 queue:Facebook 的 Gorilla 是 in-memory TSDB,設計成即使部分網路故障,寫入仍然高可用。可以主張這樣的設計和中間放一個 Kafka 一樣可靠。

延伸基礎第 7 階 · aggregation懂的人可以跳過

  1. metric
  2. time series
  3. label
  4. TSDB
  5. pull / push
  6. message queue
  7. aggregation
  8. downsampling
  9. retention
  10. threshold
  11. dedupe
  12. bottleneck

20 床的體溫,護理長只想看一個數字

① 先想像

護理長不會盯著 20 條線。她問的是:「整層平均幾度?最高的是幾度?」

你猜猜看:三床體溫 36.5、37.0、39.5,平均 37.7。只看平均,你看得出有人發燒嗎?

③ 這叫做 aggregation

aggregation(彙總):把很多筆合成一個數字。常用的有 avg(平均)、max(最高)、sum(加總)、count(筆數)。

④ 跟這章的關係

原書要你決定:在哪一步算?監視器自己、送進護理站時,還是查詢的時候(下一頁)。

② 動手玩:先看 6 床,拉每床的體溫、換一種算法

37.0整層平均體溫沒有有人 ≥ 38 度嗎

另一個角度(收據盒):第 13 章簡報第 21 頁。

原書 Step 3Where aggregations can happen

在哪裡加總:agent、管線、還是查詢的時候?

這一步要解決的問題加總要在哪一步做?越早做越省,但丟掉的也越多。

🔭 示意 長條是相對比較,依原書的文字敘述畫,不是量測數字。

📖 原書 三個地方

  • Collection agent(client 端):只支援簡單的彙總邏輯,例如 counter 每分鐘加總一次再送給 collector
  • Ingestion pipeline(寫入儲存前):通常要用 Flink 這類串流處理引擎。只寫入算好的結果,寫入量大幅減少。但遲到的事件很難處理,而且不再存原始資料,失去精確度和一些彈性
  • Query side(寫入儲存後):查詢時才對一段時間的原始資料彙總。不會掉資料,但查詢較慢,因為結果是查詢時對整個資料集算出來的

文組翻譯:12 床的體溫。① 床邊監視器自己先算好每分鐘平均再送(簡單,但只能做簡單的算術);② 護理站收進來時就算好,只存平均(記錄簿輕鬆,但原始數字沒了,晚送到的那筆就麻煩);③ 每筆原始數字都存,醫師要看時才算(最完整,但每次都要算很久)。

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

  1. metric
  2. time series
  3. label
  4. TSDB
  5. pull / push
  6. message queue
  7. aggregation
  8. downsampling
  9. retention
  10. threshold
  11. dedupe
  12. bottleneck

到這裡你已經會了:數字怎麼送到護理站

下一階要解決的問題

資料要留一年。每秒百萬點、存一年,磁碟會不會爆?

原書 Step 3Query service · Cache · Figure 17

Query service 加 cache,然後原書自己說:可能不需要

這一步要解決的問題每次畫圖都去問 TSDB,TSDB 撐得住嗎?

📖 原書 Figure 17Cache layer:虛線框住 Query Service 和 Cache(依原書內容重繪)

📖 原書 Query service 是一群 query server,存取 TSDB、處理視覺化和警報系統送來的 request。有專門的 query server,就把 TSDB 和 client(視覺化、警報)解耦,以後要換 TSDB 或換視覺化、警報系統都比較有彈性。

📖 原書 · Cache layer 為了減輕 TSDB 負載、讓 query service 更快,加上 cache server 存查詢結果。白話:cache=先抄好放手邊的答案,正本在別處(第 1 章簡報第 18 頁)。

📖 原書 · The case against query service 可能沒有迫切需要自己做一層抽象:大部分工業級的視覺化與警報系統都有強大的外掛,能直接接市面上知名的 TSDB。TSDB 選得好,連自己的 cache 也不用加。

原書 Step 3Time-series database query language

同一件事:SQL 寫 20 行,Flux 寫 4 行

這一步要解決的問題為什麼不直接用 SQL 查?

📖 原書 SQL 的 exponential moving average

select id,
       temp,
       avg(temp) over (partition by group_nr
                       order by time_read) as rolling_avg
from (
  select id,
         temp,
         time_read,
         interval_group,
         id - row_number() over (partition by interval_group
                                 order by time_read) as group_nr
  from (
    select id,
           time_read,
           "epoch"::timestamp + "900 seconds"::interval
             * (extract(epoch from time_read)::int4 / 900) as interval_group,
           temp
    from readings
  ) t1
) t2
order by time_read;

📖 原書 Flux(InfluxDB 用的查詢語言)

from(db:"telegraf")
  |> range(start:-1h)
  |> filter(fn: (r) => r._measurement == "foo")
  |> exponentialMovingAverage(size:-10s)

SQL 的換行與縮排為了版面重排過,內容和原書相同。

📖 原書 Prometheus、InfluxDB 這些流行的監控系統大多不用 SQL,有自己的查詢語言。主要原因之一:用 SQL 查 time series 很難寫。上面的 SQL 例子出自 InfluxData 的文章〈Why We're Building Flux〉。

文組翻譯:要問「最近一小時的平均體溫」,Flux 就像直接跟護理站說這句話;SQL 像是先把每一筆紀錄依 15 分鐘分組、編號、再算平均,三層套娃。

原書 Step 3Storage layer · Figure 18

85% 的查詢只看最近 26 小時;時間戳只存「差多少」

這一步要解決的問題一年份、每秒百萬點,磁碟要怎麼省?

📖 原書 · 謹慎選 TSDB Facebook 的論文:對 operational data store 的查詢,至少 85% 是最近 26 小時內收集的資料。用一個善用這個特性的 TSDB,對整體效能影響很大。想了解儲存引擎可以看 InfluxDB storage engine 的設計文件。

📖 原書 · Data encoding and compression 編碼和壓縮能大幅減少資料大小,好的 TSDB 通常內建。1610087371 和 1610087381 只差 10 秒,只要 4 bits,不用 32 bits 存完整時間戳。所以存一個基準值加上差值:1610087371, 10, 10, 9, 11。白話:bit=電腦裡最小的一格 0 或 1;這就是第 13 頁「只記差值」那一招。

📖 原書 Figure 18Data encoding(依原書內容重繪;原圖標題寫 Double-delta Encoding)

動手玩:時間戳壓得多小?

160總 bits100%相對原始大小

📖 註 原書圖名是 double-delta,但例子裡的 10、10、9、11 是一階差值。真正的 delta-of-delta 是「差值的差值」:10 之後是 0、−1、2。間隔越規律,越接近一串 0。bits 是示意算法:delta 取「最少要幾個 bit」,delta-of-delta 再多 1 個正負號 bit;真實 TSDB 的編碼還有標頭。

延伸基礎第 8 階 · downsampling懂的人可以跳過

  1. metric
  2. time series
  3. label
  4. TSDB
  5. pull / push
  6. message queue
  7. aggregation
  8. downsampling
  9. retention
  10. threshold
  11. dedupe
  12. bottleneck

三個月前的體溫,還需要每分鐘一筆嗎?

① 先想像

昨天的體溫,醫師要一分鐘一分鐘看。三個月前的,只想知道「那幾天大概燒到幾度」。

你猜猜看:一週每分鐘一筆是 10,080 筆。改成每小時只存一筆平均,大約剩下幾%?

③ 這叫做 downsampling、resolution

downsampling(降採樣):把細的資料合成粗的,例如 60 筆平均成 1 筆。resolution(解析度):多久一筆。

④ 跟這章的關係

原書的規則:原始資料留 7 天,之後 1 分鐘一筆留 30 天,再之後 1 小時一筆留 1 年(第 34 頁)。

② 動手玩:把 12 床的 6 小時變粗

10,080一週要存的筆數39.0圖上看得到的最高

延伸基礎第 9 階 · retention懂的人可以跳過

  1. metric
  2. time series
  3. label
  4. TSDB
  5. pull / push
  6. message queue
  7. aggregation
  8. downsampling
  9. retention
  10. threshold
  11. dedupe
  12. bottleneck

記錄櫃只放 7 天:第 8 天早上要丟掉什麼?

① 先想像

記錄櫃有 14 格,一天放一格。規則是只留最近 7 天。第 8 天早上,新的一天要放進來。

你猜猜看:每天 1,440 筆、只留 7 天。第 8 天早上要丟掉多少筆?

③ 這叫做 retention

retention(保留期限):資料留多久,到期就刪。retention policy:每種解析度各留多久的規則。

④ 跟這章的關係

原書規定留 1 年。到期時怎麼丟最省力,Triton 有個很具體的做法(第 49 頁)。

② 動手玩:一天一天過

7櫃子裡的天數10,080櫃子裡的筆數

原書 Step 3Downsampling · Table 4–5 · Cold storage

舊資料不用那麼細:降採樣

這一步要解決的問題舊資料留一年,還要每 10 秒一筆嗎?

📖 原書 Downsampling:把高解析度資料轉成低解析度,減少整體磁碟用量。資料保留一年,舊資料可以降採樣。可以讓工程師和資料科學家為不同 metrics 定規則,例如:保留 7 天不採樣;30 天降到 1 分鐘;1 年降到 1 小時。

📖 原書 Table 4 → Table 5 10 秒彙整成 30 秒(cpu, host-a)

timestamp(Table 4)Metric_value30 秒 avg:原書 Table 5 / 依 Table 4 算

📖 原書 · Cold storage 很少用到的不活躍資料放冷儲存,成本低很多。白話:cold storage=便宜但拿得慢的倉庫(第 15 章簡報第 33 頁);rollup=把幾筆合成一筆,就是第 26 頁的 avg。

動手玩:解析度 vs 儲存量

🔭 示意 用原書的 1,000 萬條線、10 秒一點、每點 16 bytes(未壓縮的時間戳 + 數值)估算;壓縮後還會小很多。

延伸基礎第 10 階 · threshold懂的人可以跳過

  1. metric
  2. time series
  3. label
  4. TSDB
  5. pull / push
  6. message queue
  7. aggregation
  8. downsampling
  9. retention
  10. threshold
  11. dedupe
  12. bottleneck

體溫一超過 38 度,就叫醒值班醫師?

① 先想像

半夜 12 床量到 38.3 度,下一分鐘就退了。一小時後,他連續 20 分鐘都在 38.5 度以上。

你猜猜看:這兩次,哪一次該叫醒醫師?

③ 這叫做 threshold、for

threshold(門檻):超過就算異常的那條線。for(持續時間):要連續超過多久才算數。

④ 跟這章的關係

原書的警報規則 for: 5m 就是這個:連續 5 分鐘才發(第 37 頁)。

② 動手玩:12 床的半夜(00:00–02:00)

1醫師被叫醒幾次0其中虛驚叫到了真正的發燒

原書 Step 3Alerting system · Figure 19

警報的七個步驟

這一步要解決的問題數字超標之後,怎麼一步步變成值班手機上的一則通知?

📖 原書 Figure 19Alerting system,編號 1–7 是流程順序(依原書內容重繪)
  1. 載入設定檔到 cache server:規則寫成磁碟上的設定檔,常用 YAML
  2. Alert manager 從 cache 拿警報設定
  3. 依規則,alert manager 以預定間隔呼叫 query service;數值違反門檻就建立警報事件。它負責:過濾、合併、去重、存取控制、重試
  4. Alert store 是 key-value 資料庫(例如 Cassandra),保存所有警報的狀態:inactive、pending、firing、resolved,確保通知至少送出一次
  5. 符合條件的警報寫進 Kafka
  6. Alert consumer 從 Kafka 拉警報事件
  7. Alert consumer 處理事件,送到 email、簡訊、PagerDuty、HTTP endpoint 等通道
- name: instance_down
  rules:

  # Alert for any instance that is unreachable for >5 minutes.
  - alert: instance_down
    expr: up == 0
    for: 5m
    labels:
      severity: page

白話:YAML=一種寫設定的文字格式;key-value 資料庫=一個名字對一份內容(第 6 章簡報第 4 頁);at least once=寧可重複,也不能沒送到。

原書 Step 3 · 動手玩for: 5m

超過門檻不等於發警報:pending → firing → resolved

這一步要解決的問題一超過門檻就叫人,會發生什麼事?

現在的狀態

inactivependingfiringresolved

0送出的通知00:00模擬時間(1 秒 = 1 分鐘)

📖 原書 四個狀態 inactive、pending、firing、resolved 都存在 alert store(第 36 頁步驟 4)。for: 5m 的意思是:條件要連續成立 5 分鐘才從 pending 變 firing。

文組翻譯:病房監視器不會因為病人咳一聲就叫醫生,要持續異常才叫。

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

  1. metric
  2. time series
  3. label
  4. TSDB
  5. pull / push
  6. message queue
  7. aggregation
  8. downsampling
  9. retention
  10. threshold
  11. dedupe
  12. bottleneck

同一床 5 分鐘內響三次,醫師手機要響三次嗎?

① 先想像

12 床體溫高、心跳快、血氧低,5 分鐘內接連觸發三個警報。其實是同一件事:12 床不舒服。

你猜猜看:最好通知醫師幾次?

③ 這叫做 dedupe、group

dedupe(去重):同一件事只通知一次。group(合併):相關的警報包成一則。

④ 跟這章的關係

原書的 alert manager 負責「過濾、合併、去重」(第 39 頁)。

② 動手玩:值班醫師的手機

0手機響了幾次0觸發的警報事件

同樣的道理在聊天室:第 12 章簡報第 43 頁。

原書 Step 3Merge alerts · Figure 20 · Build vs buy

三個事件,一則警報

這一步要解決的問題同一件事觸發很多個警報,要通知幾次?

📖 原書 Figure 20Merge alerts:同一個 instance 短時間內的三個事件合併成一則警報(依原書內容重繪)
0值班手機響了幾次

📖 原書 Alert manager 還負責

  • 過濾、合併、去重:例如 Figure 20,instance 1 短時間內觸發三次
  • 存取控制:避免人為錯誤、維持安全,某些警報管理操作只限授權的人
  • 重試:檢查警報狀態,確保通知至少送出一次

📖 原書 Alerting system:build vs buy

市面上有很多工業級的現成警報系統,大多和流行的 TSDB 緊密整合,也能接 email、PagerDuty 這些現有通道。在現實世界,很難證明自己做一套警報系統是合理的。面試時(尤其高階職位),要準備好說明你的決定。

原書 Step 3Visualization system · Figure 21

Dashboard:好的視覺化系統很難做,原書建議用 Grafana

這一步要解決的問題數字要怎麼畫給人看?自己做,還是買?

📖 原書 Figure 21Grafana UI(原圖是產品畫面截圖,不重現介面,改畫成依 alt 描述的簡化示意)

📖 原書 視覺化建在資料層之上。metrics dashboard 可以用不同時間尺度顯示 metrics;alerts dashboard 顯示警報。Figure 21 的 dashboard 顯示目前 server request 數、記憶體 / CPU 使用率、頁面載入時間、流量、登入資訊。

📖 原書 高品質的視覺化系統很難做,用現成系統的理由非常充分。例如 Grafana 就很適合,能和很多可以直接買的流行 TSDB 整合。

白話:dashboard=把很多張圖放在同一個畫面的儀表板,就是護理站的大螢幕;百分位(upper_95)=100 次裡第 95 慢的那一次。

示意圖的五個面板照原圖:server requests(web_server_01–04)、Memory/CPU、client side full page load(upper_25 到 upper_95 的百分位)、Traffic In/Out、logins(這一小時 vs 上一小時),時間軸 20:30 到 21:20。

原書 Step 4Wrap up · Figure 22

最終設計

這一步要解決的問題把前面所有零件拼起來,長什麼樣子?

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

📖 原書 這章談了

高層次:資料收集、時間序列資料庫、警報、視覺化。深入:pull vs push(第 18–23 頁)、用 Kafka 擴展(24–25)、選對 TSDB(14、31)、降採樣(34)、警報與視覺化的 build vs buy(39–40)。

和 Figure 6 比,多了兩樣:寫入路上的 Kafka + Consumers(擋住 TSDB 停機時掉資料),讀取路上的 Cache(減輕 TSDB 負載)。原書說經過幾次迭代才精煉成這樣。

原書Chapter summary

章末心智圖

這一步要解決的問題整章的地圖:剛剛走過的路,一張圖看完。

📖 原書 Chapter Summary本章心智圖(依原書內容重繪)

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

  1. metric
  2. time series
  3. label
  4. TSDB
  5. pull / push
  6. message queue
  7. aggregation
  8. downsampling
  9. retention
  10. threshold
  11. dedupe
  12. bottleneck

到這裡你已經會了:存得下、叫得對人

下一階要解決的問題

原書自己說了三次「這些用買的」。那 Triton 問的是什麼?裝好之後,要看哪幾條線?

Triton 觀點Build vs buy

原書說了三次「用買的」;Triton:接上去就好

你猜猜看:30 台機器的公司,照原書從零自己蓋一整套(collector、Kafka、TSDB、alert manager)。最可能出什麼事?

📖 原書 設計了一整套,然後一再建議別自己做

  • 儲存:不建議自己做儲存系統,也不建議用 MySQL 這類通用儲存系統(第 14 頁)
  • Query service:可能沒有迫切需要自己做這層抽象,好的 TSDB 連 cache 都不用加(第 29 頁)
  • 「In a nutshell, we should probably use third-party visualization and alerting systems, instead of building our own.」
  • 警報:在現實世界很難證明自己做是合理的;視覺化:用現成系統的理由非常充分

而且原書的場景是「1 億 DAU、10 萬台機器的大公司內部」。

🗣️ Triton 本人說 用現成的,別自己發明

「如果你要知道系統效能,請用上grafana / newrelic或那個不能說的data什麼的來下metrics 一般來說你是想看db transaction要用上多少時間這種常見metrics,然後你用以上方案,很多framework(像java Spring / PHP laravel)的integration都早有人替你做好,你import package加上config就好 別自行亂用create_date / update_date來創作方案」056-database的create_date和update_date的事.md · 第 1 點

「在解決他們「資料庫很慢」問題前,首先就要先去解決他們的System Observability問題。」「明明不裝data2g / new relic / grafana都好好的,為何要裝?」「然後常常技術問題就變成政治問題……」173-查找和解決系統問題.md(038 是同一篇)

🔭 推論 兩邊同方向,重心不同:原書九成篇幅講「怎麼蓋」,最後才說買;Triton 一開始就假設你買了,問的是你接上了沒有、看的是哪幾條線。原書的設計適合拿來理解這些產品內部怎麼運作。

📅 2026 補充 056 底下一則回覆(💬 作者未標示)提到在 ORM 搭配 OpenTelemetry 自動產生遙測資料。OpenTelemetry 現在是 CNCF 的主流遙測標準,「import package 加上 config」這條路比原書出版時更平坦。

Triton 觀點Metrics 和 log 分開

Metrics 告訴你出事了,log 讓你重組案情

你猜猜看:把每一個 HTTP 5XX 錯誤都寫進 log,再從 log 裡數數量來發警報,會怎樣?

「監測系統是否正常(像是太多 HTTP 5XX )– 應該放在 Metrics,不應放在 log – Metrics和 log的數據量絕對有差, delay也有差」
「Metrics是用來告知系統是否出事 log是讓人們重組案情的」🗣️ Triton 本人說 051-concurrency.pdf.md · System Monitoring

「沒錢就單純 logrotate時存到 AWS S3 有錢就建 ELK DB的 status dump也是關鍵!」🗣️ Triton 本人說 051 · Logging

「用 RDBMS作為 logging server – log = 建立了便永不改動的數據,而且這些數據極少被單獨使用,一般都會經過 aggregation 用來產生報告 – txt檔案是 log 的理想存放位置」🗣️ Triton 本人說 012-Advanced_Database_Skills.pdf.md · 常犯錯誤

🔭 推論 原書把 log 排除在範圍外、交給 ELK(第 6 頁),和 Triton 的分法一致。Triton 多給了一條原書沒提的下限:沒預算時,log 放 S3 的文字檔就好,不要放進 RDBMS。

動手分:這該放 metrics 還是 log?

Triton 觀點知道要看哪幾條線

買了 Grafana 之後:該看哪幾條線?

你猜猜看:老闆說「系統很慢」,可是你手上沒有任何 metrics。這算誰的錯?

🗣️ 應用程式層:051 的清單

「你應該紀錄以下Metrics – 系統流量 – CPU, IO和各種糸統資源用量 – Exception / Error數量 – 各式各樣的 latency – DB Query的執行時間」
「當你的老闆跟你說「系統很慢」時…… – 你沒有數據=你的錯 – CPU / IO 已經用滿了=老闆不肯給錢的錯」051 · Metrics

051 的案例:某公司以為用越多 Redis 的 endpoint 越慢,「加了 Metrics 還有一堆實驗後發現:真正慢的不是 Redis,而是把資料丟進 Redis前的 json encoding / decoding library」。

第 12 階複習 · bottleneck:最慢、決定整體上限的那一站(第 2 章簡報第 30 頁)。cpu / io / lock bound=卡在 CPU、磁碟,還是在等鎖。

🗣️ 資料庫層:127 的五條線

  1. 「看看io wait time 如果db效能卡在io,你應該看到io wait time升起來的」
  2. 「看看io throughput(disk和network都要看) 如果你在production看到io throughput graph出現一個很高「平原」不再上去,那麼你的db有可能卡在io」
  3. 「看看CPU usage 如果cpu到達100%,這可能是:A) contention(今天這可能性很高,因為CPU效能過剩)B) 真的CPU效能不足」
  4. 「看看open connection數字 如果你的max_connection開太小,有機會明明db還有resources,但是外面進不來的」
  5. 「看看有沒有transaction打開很久,但就是沒有committed / rollback」

127-喵談 RPS.md

🗣️ 先分出是哪一種 bound

「data2g / newrelic / grafana上面的 CPU, io, waits, networks到底如何? 有沒有明顯的bottleneck? 現在系統到底是 cpu bound ? io bound ? lock bound ?」173 · 第 1 點

🔭 推論 對照原書:原書的需求寫「CPU、記憶體、request 數、MQ 訊息數」這類通用指標,然後花全章講管線。Triton 的清單短得多,但每一條都對應一個「出事時你要回答的問題」:卡在 IO、CPU、connection,還是 lock。

Triton 觀點 · 值班遊戲哪條線會先告訴你?

半夜三點被叫醒:哪一條線告訴你答案?

事件 1 / 5

判讀

看左邊五條線,點你認為「異常、而且解釋得了這件事」的那一條。

🗣️ Triton 本人說「很多時db效能問題,最終root cause都是application層亂來引起的。一般來說,在沒看清楚application的source code寫怎樣前。輕易改動db任何performance有關的設定是很危險的」127

🔭 示意 五條線的形狀是依 127 的文字描述畫的假資料;事件情境是為了遊戲編的,不是 Triton 的案例。

Triton 觀點出事那一分鐘發生了什麼

「智障(但有效)」:每分鐘 dump 一次 DB 狀態

你猜猜看:14:37 資料庫卡住,你 15:10 才連上去查。現在看 DB 狀態,還看得到當時發生什麼事嗎?

「當你遇上DB問題時……其中一個智障(但有效)好主意是:寫一個cron job,每一分鐘跑show engine innodb status 然後存成log file(不是mySQL的請自行對應相對的system view)然後系統出事時,就去找回對應的log來看去了解出事時發生什麼事。」
「connection leakage 特點是:出事時你看到所有connection都是idle沒工作的。」🗣️ Triton 本人說 115-喵盤查 DB 效能.md · 第 2、4 點

「我:昨天peak hours時段資料庫的CPU / diskIO用量已經觸及了我們預定的紅線了。從QPS流量來看,這是因為高用戶用量而不是系統問題,所以建議升級機器。」🗣️ Triton 本人說 172-查出資料庫的效能問題.md · capacity planning

「要真正查找和解決系統問題,是要一步一步去排除可能性,一點一點收窄問題去找到root cause的。」🗣️ Triton 本人說 173

動手找:14:37 出事了,翻那一分鐘的 dump


      

🔭 示意 快照內容是簡化過的假資料,不是 InnoDB 的完整輸出格式。

🔭 推論 這兩招補上原書沒講的兩塊:dump 是 log(事後重組案情),紅線是 metrics 上的警報門檻,而且 172 的紅線是用來做 capacity planning 的,不只是半夜叫人起床。

Triton 觀點保留期限與儲存

7 天後要丟掉的資料:一次 TRUNCATE 一整份 partition

動手玩:每天清掉最舊的一天

0這次要寫進 REDO log 的列數(示意)—清除花的時間(示意)

「一次要刪除大量資料的,很多時候都是基於資料的生命週期完結(像是貨運站的主資料庫只存放最近14天數據,每天便會有1/14的資料到期要清掉)在這種情況,一般建議做法是把table切成14份partition,根據record create_date來決定record存到那一份上,然後到期了,便把那一份partition作truncate來清空。」🗣️ Triton 本人說 160-我們談一下應該如何在production刪除40M個record.md

你猜猜看:保留 7 天。每天用 DELETE 刪掉最舊那天的 4,000 萬列,會怎樣?

🗣️ 為什麼 DELETE 會卡住

「如果要把40M個record delete,RDBMS便需要把這40M個records全都放到REDO log上」:有的 RDBMS 會 REDO log 爆掉強制 rollback,也可能 IO 不足拖慢其他 transaction。160

Triton 觀點保留期限與儲存(續)

依時間順序存,就依時間順序讀

🗣️ 依時間順序存,就依時間順序讀

「Random IO是Sequential IO的1 / 10效能也沒有。」「Range Scan on Primary Key能使用Sequential IO對tablespace作局部掃瞄,效能非常快的。」104

🔭 推論 原書的保留政策套 160:raw、1 分鐘、1 小時各自依日期切 partition,到期整份 truncate。規模只有幾十台、真要放 RDBMS 時,PK 用(series, timestamp),查「最近 26 小時」就是 range scan(104)。TSDB 內部也是依時間分塊、過期整塊刪除。

病房版:體溫記錄簿本來就是一天一本、照時間往下寫。查「昨天下午」就是翻到那一本、往下讀一段(第 13、33 頁)。

白話:sequential IO=照順序一路讀下去;random IO=東翻一頁、西翻一頁;PK(primary key)=每一列的唯一編號,資料照它排好放;IOT=資料本身就照 PK 順序存的表。

Triton 觀點Kafka 到底要不要

「還沒到每秒 1K message,Kafka 對你是 overkill」

用原書的數字算

間隔

🔭 推論 計算是套用 138 的門檻;原書沒給收集間隔,「打包」指 agent 一次把整台機器的 metrics 包成一則 message。

你猜猜看:30 台機器、每台每 10 秒送一次 metrics。每秒幾則 message?需要 Kafka 嗎?

「Kafka不是rabbitMQ的evolution結果」「像linkedin這種大型social platform,他們才要從零開始建一套滿足他們功能需求,但又能無限scalibility的Kafka 就先給結論:如果系統還沒到每秒1K Message的,kafka對你會是overkill。」🗣️ Triton 本人說 138-喵談 rabbitMQ 和 kafka.md

Triton 觀點Kafka 到底要不要(續)

同一個設計,換一個規模,答案相反

你猜猜看:原書讓 collector 忙不過來時回錯誤、agent 先暫存再重送。如果 agent 的暫存沒有上限,collector 一直落後,會怎樣?

「Auto-scaling是用來省錢的 一般用在 App. Server層,別用在 DB層 流量上升是慢慢的,不是爆發性的」
「每一層都需要 rate-limiting … 越早擋住過多的流量,就越能保護其後方系統」🗣️ Triton 本人說 051 · Auto-scaling、Rate-limiting

🔭 推論 在原書的 10 萬台規模,就算打包也是每秒上萬則,遠超過 1K,原書加 Kafka 是合理的。但大多數公司是幾十台機器:每秒個位數的 message,Kafka 是 overkill,原書自己也說 Gorilla 不用 queue。另外,原書讓 collector 依 CPU auto-scale、滿了就回錯誤讓 agent 暫存重送,這正是「collector 這一層的 rate-limiting」;依 051,agent 的暫存要有上限,等太久的資料就丟掉,反正原書也說 metrics 偶爾掉一點不是世界末日。

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

  1. metric
  2. time series
  3. label
  4. TSDB
  5. pull / push
  6. message queue
  7. aggregation
  8. downsampling
  9. retention
  10. threshold
  11. dedupe
  12. bottleneck

到這裡你已經會了:Triton 怎麼看

12 階全部走完了

下一頁用一句話收尾;再下一頁是名詞小卡,給大家課後複習。

一句話記住

監控系統用買的;
你的工作是知道要看哪幾條線,並在出事前畫好紅線。

原書教你的

  • Metrics 是 time series:名稱 + labels + (時間, 值),label 要低 cardinality
  • 寫入重、讀取尖峰 → 用 TSDB,不用 MySQL
  • Pull vs push 各有勝場,大公司兩種都要
  • Kafka 擋住 TSDB 停機、delta 編碼、降採樣省空間
  • 警報:for 5m、合併去重、至少送一次

Triton 補的

  • import package 加上 config,別自己發明(056)
  • Metrics 告訴你出事,log 讓你重組案情;log 別放 RDBMS(051、012)
  • DB 看五條線:io wait、io throughput、CPU、open connection、長 transaction(127)
  • 每分鐘 dump DB 狀態(115);retention 用 partition + truncate(160)

要先算的 N

  • 原書規模:每秒上萬則 message,Kafka 合理
  • 幾十台機器:每秒個位數,Kafka 是 overkill(138)
  • Root cause 多半在 application 層,dashboard 只告訴你是哪一層(127、172)

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

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

metric每隔一段時間量一次的一個數字
log描述「發生了什麼事」的文字紀錄,事後重組案情用
time series一串照時間排好的(時間, 數值)
data pointtime series 裡的一筆
label / tag貼在線上的小標籤,例如 host=i631
cardinality一個標籤有幾種可能的值;要低
line protocol一行寫一個點的文字格式(Prometheus、OpenTSDB)
DAU每天至少用一次的人數
write-heavy / spiky寫入一直很重/讀取一陣一陣
TSDB專門存 time series 的資料庫(InfluxDB、Prometheus)
columnar同一欄的資料放在一起存,方便壓縮
delta encoding只存「跟上一筆差多少」

給工程師的重點出處與頁碼對照

引述來源(materials/core)

Triton 本人的講義 / 文章

  • 051-concurrency.pdf.md — Metrics 清單、「你沒有數據=你的錯」、Logging(S3 / ELK / DB status dump)、System Monitoring(metrics 告知出事、log 重組案情)、json encoding 案例、Auto-scaling、每一層都要 rate-limiting
  • 056-database的create_date和update_date的事.md — 用 grafana / newrelic,import package 加 config;app 層 log 看 elasticSearch(文末 OpenTelemetry 那則是作者未標示的回覆)
  • 012-Advanced_Database_Skills.pdf.md — 別用 RDBMS 當 logging server,txt 檔是 log 的理想存放位置
  • 127-喵談 RPS.md — DB 的五條線、root cause 多在 application 層(後半回覆不引用)
  • 115-喵盤查 DB 效能.md — cron 每分鐘 show engine innodb status、connection leakage 全部 idle
  • 172-查出資料庫的效能問題.md — 紅線與 capacity planning、會害系統趴掉的多是 application bug(文末留言不引用)
  • 173-查找和解決系統問題.md(= 038) — cpu / io / lock bound、先解決 observability、「為何要裝」的政治問題
  • 160-…刪除40M個record.md — partition + truncate、DELETE 會塞爆 REDO log
  • 104-利用Range Scan on Primary Key的好處.md — random IO 不到 sequential 的 1/10、IOT range scan
  • 138-喵談 rabbitMQ 和 kafka.md — 每秒不到 1K message,Kafka 是 overkill

原書內部不一致(頁面上已註明)

「每天 1,000 萬筆」其實是 1,000 萬條線(6);Figure 18 叫 double-delta 但數字是 delta(31);Table 5 的 19、25 與 Table 4 平均不符(34);Figure 10 的 ② 箭頭方向;心智圖把 alerting、visualization 放在 Step 4。

原書對照

Alex Xu & Sahn Lam, System Design Interview Vol.2 Ch.5。Step 1 需求與 Figure 1(第 5 頁)、需求與假設(6)、Fundamentals 與 Figure 2(7)、Data model 與 Figure 3、Table 1–2(9–11)、Access pattern 與 Figure 4(12)、Data storage 與 Figure 5(14)、High-level design 與 Figure 6(15)、Pull model 與 Figure 7–11(18–20)、Push model 與 Figure 12–13(21)、Pull vs push 與 Table 3(22–23)、Kafka 與 Figure 14–16(24–25)、Aggregation(27)、Query service 與 Figure 17、查詢語言(29–30)、Storage layer 與 Figure 18、Table 4–5、cold storage(31–34)、Alerting 與 Figure 19–20(36–39)、Visualization 與 Figure 21(40)、Wrap up 與 Figure 22、心智圖(41–42)。Figure 1 的 logo 與 Figure 21 的 Grafana 截圖改畫成示意,其餘都依原書圖說與 alt 重繪,不是原圖。

循序漸進(文組版)的頁面

學習地圖(第 3 頁);延伸基礎 10 頁:metric、log(4)、time series(8)、label(10)、TSDB(13)、pull / push(17)、aggregation(26)、downsampling(32)、retention(33)、threshold(35)、dedupe(38);第 6 階 message queue、第 12 階 bottleneck 連到第 1、2 章簡報(24、46);小結(16、28、43、53);名詞小卡(55)。仁心醫院 5 樓是虛構的示範情境;體溫曲線、床數等示意數字不是實測值。

一個可以直接問自己的問題

你的系統上次變慢時,你是先看到 dashboard 上的線,還是先接到客戶的電話?

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