從單體到微服務:十萬、百萬、千萬級的架構怎麼演進
From Monolith to Microservices: Evolving the Architecture at 100K, 1M and 10M Scale
同一套網路商店,從一個模組化單體開始,依規模一步步演進:十萬級水平擴充與快取、百萬級讀寫分離與拆出第一批服務、千萬級分片與多區域。每個階段講清楚瓶頸訊號、該做與不該過早做的事,以及怎麼安全拆出一個服務。
這篇的步驟
上一篇〈在 Kubernetes 部署整套微服務〉把 api-gateway、order、payment、inventory 四個服務放上叢集,整套系統已經在跑了。這篇先停下來往後退一步,看看像這樣的系統,應該怎麼從一個小小的單體,隨著規模一階一階長成現在的樣子——這也正是這個系列的排列順序:先把單體寫好(第 5 到 8 篇),再學怎麼拆(第 9 篇起),最後才是整套微服務的部署。
這篇要解決什麼
「我們的系統要能撐百萬使用者,所以一開始就用微服務吧。」這句話聽起來很有遠見,實際上常常是一個系統最昂貴的錯誤之一。架構不是一次決定好的東西,而是隨著流量、資料量與團隊規模一起演進的;每一個階段都有那個階段最划算的做法,提早做下一階段的事,付出的是真實的成本,換來的卻是還用不到的能力。
這篇用同一套網路商店,把演進的路線一次走完:
- 先把「規模」定義清楚:用哪幾個數字判斷自己在哪個階段。
- 四個階段——萬級、十萬級、百萬級、千萬級——每個階段的系統長什麼樣、瓶頸與訊號是什麼、該做什麼、不該過早做什麼、拆分的判斷依據。
- 一張決策表,把規模與架構選擇對照起來。
- 一套「安全拆出一個服務」的步驟,從找邊界一路到刪掉舊程式。
先講結論:大多數系統一輩子都到不了千萬級,很多甚至不需要走到百萬級的微服務。這篇的目的不是鼓勵你一路往上爬,而是讓你知道自己在哪一階、下一階的訊號長什麼樣,在訊號出現之前,安心留在原地。
第 1 步:先把「規模」定義清楚
「十萬級」「百萬級」這種說法很常見,但如果不說清楚是在數什麼,討論很容易雞同鴨講。一個有一百萬註冊會員、每天只有幾千人登入的系統,和一個每天有一百萬人同時搶購的系統,需要的架構完全不同。所以先把座標軸定下來,這篇用四個數字描述規模:
| 指標 | 意義 | 為什麼重要 |
|---|---|---|
| 註冊使用者 | 資料庫裡有多少帳號 | 決定資料量、索引大小、備份時間 |
| 每日活躍使用者(DAU) | 一天內真正來用的人 | 決定平常的流量水位 |
| 尖峰每秒請求數(RPS) | 最忙的那一刻每秒有多少請求 | 決定要多少運算資源、資料庫撐不撐得住 |
| 每日訂單數(寫入量) | 一天產生多少需要寫入的交易 | 決定主資料庫的寫入壓力與資料成長速度 |
四個階段大致對應下面的數量級。請把這張表當成示意,而不是基準測試結果:同樣的數字,在一個查詢寫得好的系統裡可能毫無壓力,在一個每頁打幾十次資料庫的系統裡早就撐不住了。硬體、資料模型、讀寫比例、流量形狀(平穩或尖峰)都會讓門檻差上一個數量級。
| 階段 | 註冊使用者(約) | DAU(約) | 尖峰 RPS(約) | 每日訂單(約) |
|---|---|---|---|---|
| 萬級 | 數萬 | 數千 | 數十 | 數百到數千 |
| 十萬級 | 數十萬 | 數萬 | 數百 | 數千到數萬 |
| 百萬級 | 數百萬 | 數十萬 | 數千 | 數萬到數十萬 |
| 千萬級 | 數千萬以上 | 數百萬以上 | 數萬以上 | 數十萬以上 |
真正決定該不該往下一階走的,不是這些數字跨過了哪條線,而是訊號:p99 延遲開始上升、資料庫 CPU 長時間偏高、連線池經常要排隊、一次部署要協調好幾個團隊、某個功能的故障拖垮整個網站。這些訊號在每個階段都會具體列出來。數字告訴你大概在哪裡,訊號告訴你是不是該動了。
提示:規模還有一個常被忽略的維度——團隊人數。系統架構最後往往會反映組織的溝通結構(第 4 步談到的康威定律)。一個五人團隊維運二十個服務,痛苦的來源通常不是流量,而是人手。
第 2 步:起步(萬級)——一個模組化單體就夠了
系統長什麼樣
這個階段的系統,就是系列第 5 到 8 篇寫出來的那個程式:一個用 net/http 與中介層處理請求的 Go 執行檔(〈net/http 與中介層〉),內部依業務領域切成 internal/order、internal/payment、internal/inventory 三個模組,模組之間只透過介面呼叫,在 cmd/ 裡用依賴注入組起來(〈分層架構與依賴注入〉);背後是一個 PostgreSQL,透過 database/sql 的連線池存取,跨模組的一致性靠一個資料庫交易就能保證(〈database/sql、交易與連線池〉);表格驅動測試與整合測試讓你敢改(〈測試:表格驅動、httptest、整合測試〉)。
圖:三個模組在同一個執行檔裡,只透過介面互相呼叫;部署一次、一個資料庫,每個模組只碰自己的資料表。
部署方式可以非常樸素:一台或兩台機器、一個映像檔、一條 CI 流水線。為了不在部署時中斷服務,至少跑兩個副本,並照〈設定與優雅關閉〉處理 SIGTERM。資料庫用託管服務,開啟自動備份,並實際演練一次還原——沒有演練過的備份,等於沒有備份。
此時的瓶頸與訊號
在這個階段,真正的瓶頸幾乎都不是技術,而是產品還在摸索:功能常常大改、資料模型常常變、領域邊界還不穩定。系統層面的訊號通常很溫和:
- 單一副本的 CPU 與記憶體都還很低,加副本純粹是為了不停機部署。
- 資料庫的慢查詢偶爾出現,但通常是少了某個索引。
- 部署一次只要幾分鐘,全隊都能看懂整個程式。
該做什麼
把力氣花在讓單體「結構正確」上,這是之後每一步演進的地基:
- 模組邊界清楚:每個模組只公開介面,資料表只屬於一個模組,不同模組不直接 JOIN 彼此的資料表。這一條在現在看起來是多餘的紀律,等到第 4 步要拆服務時,它決定了拆分是幾週還是幾個月。
- 無狀態:工作階段放在簽章的 Cookie 或資料庫裡,上傳檔案放物件儲存,不要放在本機磁碟。現在多一點紀律,下一階段加副本時就只是改一個數字。
- 設定外部化:資料庫位址、密碼都從環境變數或檔案讀,同一個映像檔可以跑在任何環境。
- 基本的可觀測性:結構化日誌、請求延遲與錯誤率的指標、每個請求一個追蹤編號。這些在第 3 步會變得不可或缺,但從第一天就埋好成本最低。
不該過早做什麼
- 不要一開始就拆微服務。 〈什麼時候該拆:邊界與拆分策略〉的那張表說得很清楚:微服務用網路呼叫、最終一致與多套部署,換取獨立發佈、獨立擴充與故障隔離。這三樣東西在幾個人的團隊、幾十 RPS 的流量下幾乎用不到,代價卻一樣不少。更糟的是,此時的邊界還不穩定,在單體裡畫錯邊界改個 import 就好,在服務之間畫錯,要改的是 API、資料庫與部署。
- 不要先上 Kubernetes。 一個執行檔加一個託管資料庫,用最簡單的平台(甚至一台虛擬機)就能跑得很好。叢集本身就是一個需要學習與維運的系統。
- 不要先上訊息佇列、快取、分片。 每加一個元件,就多一個會故障、要監控、要備份的東西。
拆分的判斷依據
這個階段的答案幾乎永遠是「不拆」。唯一的例外是某一塊有截然不同的非功能需求,例如需要特殊硬體的影像處理、或受法規要求必須隔離的資料;即使如此,也優先考慮「同一個程式庫、另一個執行檔」,而不是完整的獨立服務。
第 3 步:十萬級——水平擴充、快取,仍然是單體
系統長什麼樣
流量成長到每秒數百個請求,第一個要做的通常不是拆服務,而是讓同一個單體跑更多份、讓資料庫少做點事。
圖:靜態檔案交給 CDN,動態請求經負載平衡器分給多個無狀態的單體副本;快取擋掉重複的讀取,背景工作把慢的事情移出請求路徑,可觀測性從第一天就有。
此時的瓶頸與訊號
- 應用程式的 CPU 在尖峰時偏高,單一副本的 p99 延遲上升。這是最容易解決的瓶頸:加副本。
- 資料庫的連線數逼近上限:副本一多,每個副本的連線池加起來可能超過資料庫允許的連線數。
- 慢查詢變多:資料量成長後,原本靠全表掃描也還算快的查詢開始變慢。
- 同樣的資料被反覆讀:商品頁、首頁推薦,大部分請求讀的是同一小群熱門資料。
- 請求裡做了不必要等待的事:下單後同步寄確認信、產生 PDF 收據,第三方服務一慢,整個請求跟著慢。
該做什麼
一、無狀態副本放在負載平衡器後面。 因為第 2 步已經做到無狀態,這裡只是把副本數從 2 調成 N。搭配健康檢查與優雅關閉,部署與擴充都不會掉請求。這是最便宜、效果最直接的擴充方式。
二、管好連線池。 副本數乘以每個副本的最大連線數,不能超過資料庫的上限,還要留空間給遷移與管理工具。〈database/sql、交易與連線池〉介紹過的 SetMaxOpenConns、SetMaxIdleConns、SetConnMaxLifetime 在這裡要依副本數重新計算。副本再多下去,可以在資料庫前面加一層連線池代理(例如 PgBouncer),讓大量應用程式連線共用少量資料庫連線。指標上要看「等待連線的時間」,它比「連線數」更早反映問題。
三、索引與慢查詢。 打開資料庫的慢查詢紀錄,用 EXPLAIN ANALYZE 看執行計畫,替真正常用的查詢條件建索引——例如「某個使用者依時間排序的訂單」需要 (user_id, created_at) 的複合索引。順手處理 N+1 查詢(迴圈裡逐筆查詢)與不必要的 SELECT *。這一步花費最少,常常帶來最大的改善;在加快取、加硬體之前,先確認查詢本身是對的。〈效能調校:pprof 與 benchmark〉的方法同樣適用:先量測,再優化。
四、Redis 快取,用快取旁路(cache-aside)。 讀取時先查快取,沒有才查資料庫並寫回快取;寫入時先寫資料庫、成功後刪除快取。有三個細節決定快取是幫手還是新的故障來源:
- TTL 一定要設,而且加上隨機抖動,避免大量鍵在同一秒一起過期。
- 刪除而不是更新快取:寫入後直接刪掉鍵,讓下一次讀取重新載入,比「同時更新資料庫與快取」少很多競爭問題。
- 防止驚群(stampede):熱門鍵過期的瞬間,成百上千個請求同時發現快取沒有,一起打進資料庫。解法是同一個鍵同時只放一個請求去查,其他人等結果。
下面這個只用標準函式庫的範例,把三個細節寫在一起。真實系統裡第一層會是 Redis,這裡用記憶體裡的 map 代替,重點在流程:
// 快取旁路(cache-aside):先查快取,沒有才查資料庫;
// 同一個鍵同時只放一個請求去資料庫,其他人等結果(避免驚群)。
package main
import (
"context"
"fmt"
"math/rand/v2"
"sync"
"sync/atomic"
"time"
)
type Item struct {
SKU string
Qty int
}
type Order struct {
ID int64
UserID int64
Items []Item
Total int64 // 以「分」為單位
Status string
}
type entry struct {
order Order
expires time.Time
}
// call 是一次進行中的資料庫查詢,晚到的請求等它完成。
type call struct {
done chan struct{}
order Order
err error
}
type OrderCache struct {
mu sync.Mutex
items map[int64]entry
inflight map[int64]*call
ttl time.Duration
load func(ctx context.Context, id int64) (Order, error)
}
func NewOrderCache(ttl time.Duration, load func(context.Context, int64) (Order, error)) *OrderCache {
return &OrderCache{
items: map[int64]entry{},
inflight: map[int64]*call{},
ttl: ttl,
load: load,
}
}
func (c *OrderCache) Get(ctx context.Context, id int64) (Order, error) {
c.mu.Lock()
if e, ok := c.items[id]; ok && time.Now().Before(e.expires) {
c.mu.Unlock()
return e.order, nil // 命中
}
if cl, ok := c.inflight[id]; ok {
c.mu.Unlock()
select { // 已經有人在查:等結果,但尊重自己的逾時
case <-cl.done:
return cl.order, cl.err
case <-ctx.Done():
return Order{}, ctx.Err()
}
}
cl := &call{done: make(chan struct{})}
c.inflight[id] = cl
c.mu.Unlock()
// 用獨立的 context 查詢:第一個請求被取消,不該連累正在等的其他人
loadCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), 2*time.Second)
cl.order, cl.err = c.load(loadCtx, id)
cancel()
c.mu.Lock()
delete(c.inflight, id)
if cl.err == nil {
// TTL 加上 ±10% 的隨機抖動,避免大量鍵在同一秒一起過期
jitter := time.Duration(rand.Int64N(int64(c.ttl)/5)) - c.ttl/10
c.items[id] = entry{order: cl.order, expires: time.Now().Add(c.ttl + jitter)}
}
c.mu.Unlock()
close(cl.done)
return cl.order, cl.err
}
// Invalidate 在寫入資料庫「之後」呼叫:寫入成功才刪快取,下次讀取重新載入。
func (c *OrderCache) Invalidate(id int64) {
c.mu.Lock()
delete(c.items, id)
c.mu.Unlock()
}
func main() {
var dbQueries atomic.Int64
load := func(ctx context.Context, id int64) (Order, error) {
dbQueries.Add(1)
select {
case <-time.After(50 * time.Millisecond): // 模擬一次較慢的查詢
case <-ctx.Done():
return Order{}, ctx.Err()
}
return Order{ID: id, UserID: 42, Items: []Item{{SKU: "tea", Qty: 2}}, Total: 39800, Status: "paid"}, nil
}
cache := NewOrderCache(30*time.Second, load)
var wg sync.WaitGroup
for range 100 {
wg.Add(1)
go func() {
defer wg.Done()
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
if _, err := cache.Get(ctx, 1001); err != nil {
fmt.Println("錯誤:", err)
}
}()
}
wg.Wait()
fmt.Println("100 個同時請求,資料庫查詢次數:", dbQueries.Load())
cache.Invalidate(1001)
o, _ := cache.Get(context.Background(), 1001)
fmt.Printf("失效後重新載入:訂單 %d %s %d 分,查詢次數:%d\n", o.ID, o.Status, o.Total, dbQueries.Load())
}執行後會看到 100 個同時請求只打了一次資料庫。context.WithoutCancel 讓實際查詢不受第一個請求取消的影響,等待的人則各自尊重自己的逾時。快取雪崩、熱點鍵與快取和資料庫不一致的更多變形,會在〈併發常見問題:從資料競爭到超賣〉的第 9 個問題詳細拆解。
提示:快取要能「整個消失」系統仍然正確,只是變慢。不要把只存在快取裡的資料(例如購物車)當成快取對待——那是資料庫,要用對待資料庫的方式設計持久化與備份。
五、靜態檔案走 CDN。 圖片、JavaScript、CSS 交給 CDN,檔名帶上內容雜湊,就能設很長的快取時間。這一步常常能直接拿掉一大半打到應用程式的請求。
六、背景工作移出請求路徑。 寄信、產生收據、通知第三方,都不需要讓使用者等。這個階段還不需要獨立的訊息佇列:在同一個資料庫裡建一張工作表,請求在交易裡寫入一筆待辦,背景的 worker 用 SELECT … FOR UPDATE SKIP LOCKED 取出處理。它和業務資料在同一個交易裡,天生不會「訂單寫了、通知沒排上」——這其實就是第 4 步 Outbox 的前身。
七、可觀測性成為日常。 〈可觀測性:日誌、指標、追蹤〉講的三樣東西,在十萬級要從「有在收」變成「有人在看」:每個端點的 p50/p99 延遲與錯誤率、資料庫 CPU 與連線池等待、快取命中率、背景工作的佇列長度,加上對使用者有感的告警。下一步該做什麼,全看這些指標說了什麼。
八、強制執行模組邊界。 程式碼量與人數都變多了,「模組只透過介面溝通」不能再靠默契。可以用 Go 的 internal 目錄限制匯入範圍、在 CI 裡用簡單的靜態檢查禁止 internal/order 匯入 internal/payment 的實作套件,或規定跨模組的資料表存取一律在程式碼審查中退回。邊界守住了,下一步拆服務才拆得動。
不該過早做什麼
- 還不需要讀寫分離。 只要索引與快取做好,一個規格足夠的主資料庫可以撐很遠。唯讀副本帶來的複寫延遲問題(第 4 步)在這裡是純粹的成本。
- 還不需要微服務。 應用程式的瓶頸用加副本就能解決,單體本身就能水平擴充——這是很多人跳過的關鍵事實。
- 不要什麼都快取。 每多快取一種資料,就多一個「資料不一致」的可能。先快取讀多寫少、可以接受短暫舊資料的東西,例如商品資訊;訂單狀態、庫存數量這類要求即時正確的資料,先不要放進快取。
拆分的判斷依據
仍然是不拆。這個階段的「拆」是模組層級的:把模組邊界從約定變成強制,讓每個模組的資料表、介面、測試都能獨立看待。如果發現某兩個模組總是一起改、資料表互相 JOIN,現在把它們合併或重畫邊界,成本遠低於拆成服務之後再改。
第 4 步:百萬級——讀寫分離、訊息佇列,拆出第一批服務
系統長什麼樣
到了每秒數千請求、一天數萬到數十萬筆訂單,單一資料庫與單一部署單位開始成為真正的限制。這是第一次有充分理由拆出服務的階段——但只拆痛的地方。
圖:api-gateway 統一處理認證與限流;payment 與 inventory 先拆出去並擁有自己的資料庫,其餘功能仍在原本的單體(order)裡;服務之間用訊息佇列傳事件,order 的資料庫加上唯讀副本分擔讀取。
此時的瓶頸與訊號
- 主資料庫的讀取吃滿:即使有快取,報表、後台查詢、列表頁的讀取仍讓主庫 CPU 長時間偏高。
- 寫入與讀取互相干擾:一個大型報表查詢拖慢了下單的寫入。
- 部署變成協調問題:好幾個團隊改同一個程式庫,一次發佈要等所有人的功能都準備好;某個團隊的錯誤讓整個網站回滾。
- 故障擴散:第三方金流變慢時,卡住的請求佔滿了連線與 goroutine,連瀏覽商品都受影響。
- 某一塊的負載形狀明顯不同:庫存在搶購時被大量扣減,訂單查詢卻平穩;整包一起擴充很浪費。
該做什麼
一、唯讀副本與讀寫分離。 主庫只處理寫入與少數需要強一致的讀取,其他讀取分給一個或多個唯讀副本。最大的陷阱是複寫延遲:副本是非同步複寫的,使用者剛下完單、馬上跳到「我的訂單」,如果這次讀取打到還沒追上的副本,就會看到「剛剛的訂單不見了」。常見的對策:
- 讀自己的寫入(read-your-writes):剛寫過資料的使用者,在一小段時間內讀主庫。
- 強一致的讀取一律走主庫:付款前檢查訂單狀態、扣庫存前檢查數量,這些決策不能基於舊資料。
- 監控複寫延遲:延遲超過門檻時,暫時把讀取導回主庫,或讓副本退出讀取名單。
下面的路由把這幾條規則寫在一起。它是泛型的,正式程式裡 T 就是 *sql.DB:
// 讀寫分離的路由:寫入一律走主庫;讀取預設走唯讀副本,
// 但剛寫過資料的使用者在一小段時間內改讀主庫,避開複寫延遲。
package main
import (
"fmt"
"sync"
"sync/atomic"
"time"
)
// Router 用泛型,正式程式裡 T 就是 *sql.DB。
type Router[T any] struct {
primary T
replicas []T
next atomic.Uint64
stick time.Duration // 寫入後黏在主庫多久,要大於平常的複寫延遲
mu sync.Mutex
lastWrite map[int64]time.Time // userID → 最後一次寫入時間
}
func NewRouter[T any](primary T, replicas []T, stick time.Duration) *Router[T] {
return &Router[T]{primary: primary, replicas: replicas, stick: stick, lastWrite: map[int64]time.Time{}}
}
// Writer 回傳主庫,並記下這個使用者剛寫過。
func (r *Router[T]) Writer(userID int64) T {
r.mu.Lock()
r.lastWrite[userID] = time.Now()
r.mu.Unlock()
return r.primary
}
// Reader 回傳可以讀的資料庫。strong 表示這次讀取不能接受舊資料(例如付款前檢查狀態)。
func (r *Router[T]) Reader(userID int64, strong bool) T {
if strong || len(r.replicas) == 0 {
return r.primary
}
r.mu.Lock()
t, ok := r.lastWrite[userID]
if ok && time.Since(t) >= r.stick {
delete(r.lastWrite, userID) // 過了黏著期就清掉,避免 map 無限長大
ok = false
}
r.mu.Unlock()
if ok {
return r.primary // 讀自己剛寫的資料
}
i := r.next.Add(1) % uint64(len(r.replicas))
return r.replicas[i]
}
func main() {
r := NewRouter("primary", []string{"replica-a", "replica-b"}, 2*time.Second)
fmt.Println("使用者 1 瀏覽訂單:", r.Reader(1, false))
fmt.Println("使用者 1 瀏覽訂單:", r.Reader(1, false))
fmt.Println("使用者 1 下單寫入:", r.Writer(1))
fmt.Println("使用者 1 查看剛下的單:", r.Reader(1, false))
fmt.Println("使用者 2 瀏覽訂單:", r.Reader(2, false))
fmt.Println("使用者 2 付款前確認:", r.Reader(2, true))
}這個範例把「誰剛寫過」記在單一行程的記憶體裡,只適合示意:多個副本時,下一個請求可能落在另一個副本上。實務上可以把最後寫入的時間(或資料庫的複寫位置,例如 PostgreSQL 的 LSN)放進使用者的工作階段或 Cookie,讓任何一個副本都能判斷。
二、訊息佇列處理非同步工作。 資料庫裡的工作表撐到這裡開始吃力,而且多個服務要訂閱同一個事件(訂單成立後,庫存要扣、通知要寄、點數要加)。這時換成真正的訊息佇列,用〈訊息佇列與事件驅動〉的方式,讓服務之間用事件溝通,消費者必須冪等、要有重試與死信佇列。
三、沿著限界上下文拆出第一批服務——只拆痛的地方。 依照〈什麼時候該拆:邊界與拆分策略〉的方法,用絞殺者模式一次搬一塊。電商系統裡,常見的第一批候選是:
| 候選 | 為什麼優先 |
|---|---|
| payment | 依賴第三方、延遲難以預測、需要故障隔離;合規與稽核要求不同 |
| inventory | 搶購時寫入壓力集中、需要獨立擴充;邊界清楚(只管數量與預留) |
| order | 通常是核心,留在原本的程式裡,其他功能從它周圍搬走 |
順序依「痛點」而定,不是依「容易拆」而定:如果你的系統最痛的是搜尋或通知,先拆那一塊。判斷的標準是第 1 步的那幾個訊號——拆出去之後,能不能獨立發佈、獨立擴充,或把故障隔離開來。
四、API Gateway 收斂入口。 服務一多,認證、限流、路由不該在每個服務裡各寫一次。照〈API Gateway:路由、認證、限流〉把它們集中到 api-gateway,它同時也是絞殺者模式的那層路由:哪些路徑還在單體、哪些已經搬到新服務,都在這裡決定。服務之間的呼叫則要加上〈逾時、重試與熔斷〉,讓金流變慢時只影響付款,不會拖垮整個網站。
五、每個服務擁有自己的資料庫。 這是拆分是否成功的分水嶺。如果 payment 拆成獨立服務,卻還直接讀寫單體資料庫裡的 payments 表,你得到的是「分散式單體」:部署分開了,耦合一點都沒少,還多了網路呼叫。每份資料只有一個主人,其他服務透過 API 或事件取得;跨服務的一致性用〈分散式交易:Saga 與 Outbox〉的 Saga 協調,事件用 Outbox 在同一個交易裡可靠地發出,所有會被重試的操作照〈冪等與分散式鎖〉設計成冪等。
六、Kubernetes 與自動化。 三四個服務、每個服務多個副本、各自的發佈節奏,手動管理開始吃不消。這時把部署交給叢集,就是〈在 Kubernetes 部署整套微服務〉做的事:每個服務一組 Deployment、HPA 依負載自動擴縮。CPU 不是好指標的服務(例如主要在等資料庫的 inventory),可以改用每秒請求數之類的自訂指標,並讓擴充快、縮減慢:
# deploy/k8s/base/inventory/hpa.yaml
# 以每個 Pod 的每秒請求數為主、CPU 為輔;需要先安裝自訂指標轉接器
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
name: inventory
spec:
scaleTargetRef:
apiVersion: apps/v1
kind: Deployment
name: inventory
minReplicas: 3
maxReplicas: 30
metrics:
- type: Pods
pods:
metric:
name: http_requests_per_second
target:
type: AverageValue
averageValue: '200' # 示意值:用壓測量出單一 Pod 的舒適負載再填
- type: Resource
resource:
name: cpu
target:
type: Utilization
averageUtilization: 70
behavior:
scaleUp:
stabilizationWindowSeconds: 0
policies:
- type: Percent
value: 100
periodSeconds: 30
scaleDown:
stabilizationWindowSeconds: 300
policies:
- type: Pods
value: 2
periodSeconds: 60多個指標時,HPA 會分別算出需要的副本數,取最大的那個。averageValue 不要憑感覺填:用壓力測試找出單一 Pod 在 p99 延遲還可接受時能處理多少請求,再打個折扣。還要記得,應用程式擴充了,資料庫不會跟著擴充——副本上限乘以連線池大小,仍然不能超過資料庫的連線上限。
七、團隊結構對齊服務邊界。 康威定律說:系統的結構會反映設計它的組織的溝通結構。反過來運用它:讓一個團隊完整擁有一個或幾個服務(程式、資料庫、部署、告警、值班),服務邊界就是團隊邊界。如果一個服務需要三個團隊一起改,或一個團隊每次改功能都要動五個服務,那是邊界畫錯了的訊號。
不該過早做什麼
- 不要一口氣拆成十幾個服務。 先拆一兩個最痛的,把拆分的流程、監控、部署跑順,再決定下一個。每個服務都需要有人負責值班。
- 不要先分片。 讀寫分離、快取、把大表依時間分割(PostgreSQL 的分割表)通常能再撐很久。分片是第 5 步的事,而且是不可逆程度最高的決定之一。
- 不要自己打造平台。 服務網格、自建的部署系統、自寫的服務發現,在幾個服務的規模下都不划算;用託管服務與現成工具。
拆分的判斷依據
拆一個服務之前,至少要能回答以下問題,而且答案是「是」:
- 這一塊有明確的限界上下文,資料能有單一主人嗎?
- 拆出去之後,能帶來獨立發佈、獨立擴充或故障隔離其中至少一項真正需要的好處嗎?
- 它和其他模組之間不需要強一致的交易,或可以用 Saga 接受最終一致嗎?
- 有一個團隊願意、也有能力完整擁有它嗎?
- 自動化部署、集中日誌、指標與分散式追蹤都已經就緒了嗎?
任何一題答「否」,先在模組化單體裡把它整理好,比拆出去划算。
第 5 步:千萬級——分片、讀取模型、多區域
系統長什麼樣
到這個量級,單一主資料庫的寫入能力、單一區域的可用性、單一團隊的維運能力都成了限制。系統的主軸從「拆服務」轉向「拆資料」與「拆地理位置」。
圖:全域流量管理把使用者導到不同區域;區域內先限流與降載,訂單資料依 user_id 分片,事件串流把變更餵給讀取模型與搜尋索引;區域之間非同步複寫。
此時的瓶頸與訊號
- 主庫的寫入成為天花板:已經升到最大規格,寫入吞吐仍然不夠,或單一資料表大到索引維護、備份還原、結構變更都需要數小時。
- 查詢需求互相衝突:同一份訂單資料,下單要依訂單編號查、「我的訂單」要依使用者查、客服要全文搜尋、營運要做聚合統計,一套索引滿足不了所有人。
- 單一區域的故障不可接受:一個雲端區域的事故等於整個生意停擺。
- 流量尖峰遠超平均:大型促銷時瞬間流量可能是平時的數倍到數十倍,擴充速度追不上。
- 成本成為一級問題:基礎設施費用大到值得專人管理。
該做什麼
一、分片:把一張大表拆到多個資料庫。 第一步通常是同一個資料庫裡的分割表(partitioning):資料還在一個 PostgreSQL 裡,但實體上分成多個子表,查詢只要帶上分割鍵,就只會掃描相關的子表,維護(例如刪除舊資料)也可以一次處理一個分割區:
-- order 資料庫:訂單表依 user_id 雜湊分成 8 個分割區(數量為示意)
CREATE TABLE orders (
id BIGINT NOT NULL,
user_id BIGINT NOT NULL,
total BIGINT NOT NULL, -- 單位:分
status TEXT NOT NULL DEFAULT 'pending'
CHECK (status IN ('pending', 'paid', 'cancelled')),
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
PRIMARY KEY (user_id, id) -- 主鍵與唯一索引必須包含分割鍵
) PARTITION BY HASH (user_id);
CREATE TABLE orders_p0 PARTITION OF orders FOR VALUES WITH (MODULUS 8, REMAINDER 0);
CREATE TABLE orders_p1 PARTITION OF orders FOR VALUES WITH (MODULUS 8, REMAINDER 1);
CREATE TABLE orders_p2 PARTITION OF orders FOR VALUES WITH (MODULUS 8, REMAINDER 2);
CREATE TABLE orders_p3 PARTITION OF orders FOR VALUES WITH (MODULUS 8, REMAINDER 3);
CREATE TABLE orders_p4 PARTITION OF orders FOR VALUES WITH (MODULUS 8, REMAINDER 4);
CREATE TABLE orders_p5 PARTITION OF orders FOR VALUES WITH (MODULUS 8, REMAINDER 5);
CREATE TABLE orders_p6 PARTITION OF orders FOR VALUES WITH (MODULUS 8, REMAINDER 6);
CREATE TABLE orders_p7 PARTITION OF orders FOR VALUES WITH (MODULUS 8, REMAINDER 7);
-- 在父表建立索引,會自動建到每個分割區
CREATE INDEX orders_user_created_idx ON orders (user_id, created_at DESC);
-- 帶上分割鍵的查詢只會掃描一個分割區
EXPLAIN SELECT id, total, status
FROM orders
WHERE user_id = 42
ORDER BY created_at DESC
LIMIT 20;分割表解決的是單表太大的問題,寫入仍然在同一台主機上。當單台主機的寫入真的不夠時,才進一步分片(sharding):不同的使用者落在不同的資料庫叢集上。分片鍵的選擇決定了一切:
- 以
user_id分片:同一個使用者的訂單都在同一個分片上,「我的訂單」只查一個分片,下單的交易也不跨分片。這是電商最常見的選擇。 - 以
order_id分片:寫入分布最平均,但「某個使用者的所有訂單」要查所有分片。 - 熱點分片:分片鍵的分布不均時,某個分片會特別忙。一個賣家的大型促銷、一個企業帳號的大量下單,都可能讓某個分片成為熱點。以賣家為鍵的資料尤其容易出現這種情況。
實務上常見的設計,是先雜湊到固定數量的邏輯分片(例如 1024 個),再用一張對照表把邏輯分片對應到實體資料庫。需要擴充時,只要把一部分邏輯分片搬到新的資料庫並更新對照表,不必重新計算每一筆資料的歸屬;把邏輯分片編進訂單編號,則讓只拿到訂單編號的請求也能直接找到分片:
// 分片鍵:user_id 先雜湊到固定數量的邏輯分片,再由對照表對應到實體資料庫。
// 搬遷時只改對照表,不必重新計算每一筆資料的雜湊。
package main
import (
"encoding/binary"
"fmt"
"hash/fnv"
)
const logicalShards = 1024 // 一開始就定好,之後不改
// LogicalShard 決定某個使用者的資料屬於哪一個邏輯分片。
func LogicalShard(userID int64) int {
var b [8]byte
binary.BigEndian.PutUint64(b[:], uint64(userID))
h := fnv.New32a()
h.Write(b[:])
return int(h.Sum32() % logicalShards)
}
// ShardMap 是邏輯分片 → 實體資料庫的對照表,實務上放在設定或協調服務裡。
type ShardMap []shardRange
type shardRange struct {
from, to int // 含 from、不含 to
db string
}
func (m ShardMap) DB(userID int64) string {
s := LogicalShard(userID)
for _, r := range m {
if s >= r.from && s < r.to {
return r.db
}
}
panic(fmt.Sprintf("邏輯分片 %d 沒有對應的資料庫", s))
}
// OrderID 把邏輯分片編進訂單編號的低 10 位:只拿到訂單編號也能找到分片。
func OrderID(userID, seq int64) int64 {
return seq<<10 | int64(LogicalShard(userID))
}
// ShardOfOrder 從訂單編號取回邏輯分片。
func ShardOfOrder(orderID int64) int {
return int(orderID & (logicalShards - 1))
}
func main() {
m := ShardMap{
{0, 256, "orders-db-1"},
{256, 512, "orders-db-2"},
{512, 768, "orders-db-3"},
{768, 1024, "orders-db-4"},
}
count := map[string]int{}
for id := int64(1); id <= 100000; id++ {
count[m.DB(id)]++
}
for _, r := range m {
fmt.Printf("%s:%d 位使用者\n", r.db, count[r.db])
}
id := OrderID(42, 7)
fmt.Printf("使用者 42 的訂單 %d 在邏輯分片 %d(= %d)\n", id, ShardOfOrder(id), LogicalShard(42))
}提示:分片之後,跨分片的 JOIN、跨分片的交易、全域唯一約束(例如「優惠碼只能用一次」)都變得困難或昂貴。這就是為什麼分片要放在最後:它把很多原本資料庫幫你做的事,變成應用程式要自己處理的事。決定分片之前,先確認讀寫分離、分割表、垂直拆分(把不同的表放到不同資料庫,也就是第 4 步的每個服務一個資料庫)、升級硬體都已經用盡。
二、CQRS 與讀取模型。 命令查詢責任分離(CQRS)把「寫入用的模型」和「查詢用的模型」分開:寫入端維持正規化、以分片鍵組織的資料,每次變更透過 Outbox 或 CDC(變更資料擷取,直接讀資料庫的交易日誌)發出事件;讀取端訂閱事件,建立為特定查詢最佳化的資料,例如依使用者預先整理好的訂單列表、給客服用的全文搜尋索引(Elasticsearch 或 OpenSearch 這類搜尋引擎)、給營運用的分析資料庫。代價是讀取模型永遠落後寫入一點點,介面上要容許「剛下的單幾秒後才出現在搜尋結果裡」。
三、事件串流。 訊息佇列在百萬級是「把工作交出去」;到了千萬級,事件常常變成整個系統的資料骨幹:同一串訂單事件,同時餵給讀取模型、搜尋索引、推薦、風控、資料倉儲。這時會傾向使用保留歷史、能重播的事件串流平台(〈訊息佇列與事件驅動〉比較過的 Kafka 類型)。新的下游系統可以從頭重播事件建立自己的資料,而不用去要上游的資料庫存取權。事件的結構與版本演進,在這個階段變成和 API 一樣重要的契約。
四、先多可用區,再多區域。 高可用的第一步是多可用區(multi-AZ):同一個區域內的多個資料中心,延遲很低,資料庫可以同步複寫,一個可用區故障時自動切換。大多數系統到這裡就足夠了。多區域(multi-region)則是另一個量級的複雜度:
| 模式 | 做法 | 好處 | 代價 |
|---|---|---|---|
| 主備(主動-被動) | 一個區域服務流量,另一個區域複寫資料待命 | 模型簡單,寫入只有一個主 | 切換時可能遺失尚未複寫的資料,切換需要演練 |
| 雙活(主動-主動) | 多個區域同時服務讀寫 | 就近服務、單區故障無感 | 寫入衝突、跨區一致性、資料分配都要重新設計 |
雙活通常要和分片一起設計:每個使用者有一個「歸屬區域」,他的寫入只在那個區域發生,其他區域只讀或轉送,以避免同一筆資料在兩邊同時被修改。另外還有資料駐留(data residency)的法規要求:某些國家或產業規定使用者資料必須留在特定地區,這會直接決定分片與區域的對應方式,最好在設計之初就問清楚,而不是事後補救。
五、限流與降載。 規模到了這裡,一定會遇到「流量超過能力」的時刻,系統要能有計畫地拒絕,而不是全面崩潰。〈API Gateway:路由、認證、限流〉的限流是第一道防線;第二道是降載(load shedding):服務偵測到自己過載時(例如佇列等待時間超過門檻),直接拒絕一部分請求並回應 503,保住正在處理的請求能完成。還可以替功能分優先級:下單與付款最重要,推薦、瀏覽紀錄、評論可以在尖峰時暫時關閉。熔斷、逾時、重試的退避與上限,在這個規模下也從「好習慣」變成「必要條件」——不受控的重試會把小故障放大成全面崩潰。
六、容量規劃與壓力測試。 不再是「出事再加機器」,而是事先估算:大型促銷預計多少流量、每個服務在 p99 延遲可接受時能撐多少、資料庫的寫入餘裕還有多少,並用接近正式環境的資料與流量形狀做壓力測試。壓測要找的不只是「撐到多少」,還有「超過之後怎麼壞」——是優雅地拒絕一部分請求,還是連鎖崩潰。
七、平台團隊與成本。 服務數量多、團隊多的時候,每個團隊各自處理部署、監控、資料庫、機密管理會造成大量重複。這時值得成立平台團隊,把叢集、部署流程、可觀測性、資料庫範本做成內部產品,讓業務團隊用標準方式自助完成。成本也要成為工程指標之一:每筆訂單的基礎設施成本、閒置資源、過度配置的副本數、跨區傳輸費用,都應該被量測與檢討。
不該過早做什麼
這個階段的每一項都很昂貴,所以「不該過早做」的清單其實就是整個階段:沒有寫入瓶頸不要分片、沒有法規或可用性需求不要多區域、沒有多種查詢需求衝突不要上 CQRS、服務不多不要建平台團隊。 很多系統在十萬級或百萬級就能穩定地服務它們的使用者很多年,這不是失敗,而是架構剛好符合需求。
拆分的判斷依據
到了千萬級,拆分的對象從「服務」變成「資料」與「區域」,判斷依據也跟著改變:
- 拆資料:主庫寫入已達上限、單表維護時間不可接受,且已找到能讓絕大多數交易不跨分片的分片鍵。
- 拆讀取模型:有多種互相衝突的查詢需求,且業務能接受讀取模型的短暫延遲。
- 拆區域:單一區域故障的損失大於多區域的建置與維運成本,或法規要求資料駐留。
第 6 步:決策表——規模與架構選擇的對照
把前面四個階段濃縮成一張表。「—」表示這個階段通常還不需要;同樣地,這只是常見的起點,要以自己系統的訊號為準:
| 架構選擇 | 萬級 | 十萬級 | 百萬級 | 千萬級 |
|---|---|---|---|---|
| 部署單位 | 模組化單體 | 單體、多副本 | 單體+拆出的少數服務 | 多個服務,由多個團隊擁有 |
| 應用程式擴充 | 2 個副本保持可用 | 負載平衡器後水平擴充 | 叢集與 HPA 自動擴縮 | 多可用區、多區域 |
| 資料庫 | 一個 PostgreSQL | 索引、慢查詢、連線池 | 讀寫分離、每個服務一個資料庫 | 分割表、分片 |
| 快取 | — | Redis 快取旁路 | 多層快取、熱點保護 | 依區域部署、容量規劃 |
| 非同步工作 | 同步處理即可 | 資料庫工作表 | 訊息佇列、Outbox | 事件串流、CDC |
| 查詢與搜尋 | 資料庫查詢 | 資料庫查詢+索引 | 唯讀副本 | CQRS 讀取模型、搜尋引擎 |
| 入口 | 單體自己處理 | 負載平衡器、CDN | API Gateway | 全域流量管理、限流與降載 |
| 可觀測性 | 結構化日誌、基本指標 | 延遲、錯誤率、告警 | 分散式追蹤、每個服務的儀表板 | 服務等級目標、容量與成本指標 |
| 組織 | 一個團隊 | 一個團隊、模組各有負責人 | 依服務分團隊 | 業務團隊+平台團隊 |
讀這張表的方式是「由左往右,訊號出現才移動一格」,而不是「目標是千萬級,所以直接填最右邊那一欄」。每一列可以獨立移動:很多系統的資料庫還在十萬級那一格,入口卻已經需要 API Gateway;也有系統的流量很小,但因為法規需要多區域。
第 7 步:安全地拆出一個服務
不論在哪個階段決定拆,拆的過程都應該是一連串可以退回的小步驟,而不是一次切換。下面以把 inventory 從單體拆出來為例:
圖:從找邊界到刪掉舊程式共七步;直到最後一步之前,舊的路徑都還在,任何一步出問題都能退回上一步。
1. 找出邊界。 在單體裡先把庫存變成一個獨立的模組:其他模組只能透過 inventory.Service 介面呼叫它,不能直接碰它的資料表。這一步完全在單體裡完成,可以用編譯器與測試確認沒有遺漏的呼叫點。如果發現某些功能怎麼切都切不乾淨,例如訂單與庫存的資料總是需要在同一個交易裡更新,那就是邊界畫錯的訊號,先重畫邊界,或接受用預留與 Saga 改成最終一致。
2. 確立資料歸屬。 盤點所有讀寫庫存資料表的程式碼,把它們全部改成透過庫存模組的介面。報表、後台、批次作業這些容易遺漏的地方要特別檢查——可以替庫存資料表建立專用的資料庫帳號,其他模組的帳號撤銷存取權,讓遺漏的存取直接失敗。到這一步為止,資料仍在單體的資料庫裡,但只有一個主人了。
3. 建立新服務並同步資料。 新的 inventory 服務有自己的資料庫。單體仍然是資料的主人,所有寫入照舊發生在單體,再把變更同步到新資料庫。同步有兩種主要做法:
- Outbox:單體在同一個交易裡寫入業務資料與一筆事件,由轉送程式發到訊息佇列,新服務消費事件更新自己的資料(〈分散式交易:Saga 與 Outbox〉)。
- CDC:直接讀取資料庫的交易日誌,把資料表的變更轉成事件。不需要改單體的程式,但事件是「資料列變了」而不是「業務上發生了什麼」。
要避免的是應用程式層的雙寫:在單體裡先寫自己的資料庫、再呼叫新服務寫一次。兩次寫入之間的任何失敗,都會讓兩邊永遠不一致,而且很難察覺。同步開始前,先做一次歷史資料的完整搬移,再用同步機制追上之後的變更;最後寫一支對帳程式,定期比對兩邊的資料。
4. 影子流量。 讓 api-gateway(或單體裡的轉接層)把庫存的讀取請求同時送一份給新服務,但只比對結果、不採用:使用者拿到的仍然是單體的回應,比對不一致時記錄下來。這一步能在完全沒有風險的情況下發現資料同步的漏洞、邊界情況的行為差異與新服務的效能問題。影子流量只適用於讀取;寫入請求不能直接複製,否則會重複扣庫存。
5. 切換讀取。 比對結果穩定之後,依比例把讀取請求改由新服務回答:先 1%、再 10%、再全部。寫入仍然在單體,新服務的資料仍然由同步機制更新。這時要注意同步延遲:剛扣完庫存的讀取,可能拿到同步前的數字,需要強一致的讀取仍然走單體。任何時候發現問題,把比例調回 0 即可。
6. 切換寫入。 這是唯一真正有風險的一步:資料的主人從單體換成新服務。常見做法是選一個低流量的時段,短暫凍結庫存的寫入(或依商品分批切換),確認同步已完全追上,再把寫入的路由指向新服務。切換後反向同步一段時間:新服務的變更同步回單體的舊資料表,讓還沒搬走的報表繼續可用,也讓退回仍然可能。寫入路徑的所有操作都要冪等,因為切換前後的重試可能同時到達兩邊。
7. 移除舊程式。 觀察一段足夠長的時間(至少經過一次完整的業務週期,例如月結)之後,刪掉單體裡的庫存程式碼、舊資料表與反向同步。這一步常常被無限期延後,結果系統裡永遠有兩份程式碼與兩份資料,維護成本比拆分前還高。把它排進計畫,拆分才算完成。
提示:每一步都要有明確的「完成條件」與「退回方式」寫在計畫裡,例如「影子比對連續一週不一致率低於門檻才進入第 5 步」「切換寫入後一小時內錯誤率上升就切回」。拆服務最常見的失敗不是技術做不到,而是在不確定的狀態下停留太久——兩套系統、兩份資料,誰都不敢刪。
常見陷阱
- 過早微服務。 在萬級或十萬級就拆成十幾個服務,團隊把大部分時間花在部署、網路錯誤、跨服務除錯與資料一致性上,產品開發反而變慢。這是最常見、代價也最高的錯誤;單體本身就能水平擴充。
- 把規模數字當成門檻。 「到一百萬使用者就要拆」不是一個有意義的規則。看訊號,不看數字:延遲、資料庫負載、連線池等待、部署協調的成本、故障擴散的範圍。
- 還沒做無狀態就加副本。 工作階段存在本機記憶體、上傳檔案放本機磁碟,加了負載平衡器之後使用者會隨機登出、檔案隨機消失。
- 跳過索引與查詢優化,直接加快取或加機器。 一個缺索引的查詢,再大的機器也只是延後問題爆發的時間,快取則把問題藏起來直到快取失效那一刻。
- 快取沒有 TTL、沒有防驚群。 快取不一致的資料永遠不會修正;熱門鍵過期的瞬間,資料庫被打垮。
- 讀寫分離後忘了複寫延遲。 使用者剛下的單「不見了」、付款前讀到舊的訂單狀態。需要強一致的讀取必須走主庫。
- 拆了服務、沒拆資料庫。 多個服務共用同一個資料庫與資料表,結果是分散式單體:部署分開了,耦合沒少,還多了網路呼叫與部分失敗。
- 應用程式層雙寫。 先寫自己的資料庫再呼叫另一個服務,兩步之間的失敗會造成永久不一致。用 Outbox 或 CDC。
- 太早分片或選錯分片鍵。 分片幾乎不可逆,選錯分片鍵會讓大部分查詢跨分片、熱點集中在少數分片。先用盡讀寫分離、分割表、垂直拆分。
- 一步跳到雙活多區域。 寫入衝突、跨區一致性、資料駐留,每一項都是大工程。先做好多可用區,主備的切換演練過了,再談雙活。
- 只會擴充、不會拒絕。 沒有限流與降載的系統,在流量超過能力時不是變慢,而是全面崩潰;不受控的重試再把它推得更深。
- 拆到一半停住。 舊程式與舊資料表沒有刪除,兩套系統永遠並存。拆分計畫要包含最後一步。
- 忽略團隊結構。 服務邊界和團隊邊界不一致,每次改功能都要好幾個團隊協調——微服務的好處完全沒拿到,成本全部付了。
重點整理
- 規模用多個數字描述:註冊使用者、DAU、尖峰 RPS、每日訂單;各階段的數量級只是示意,真正決定是否前進的是訊號。
- 萬級:模組化單體+一個 PostgreSQL+一次部署。把邊界、無狀態、設定外部化與基本可觀測性做好,不要拆服務。
- 十萬級:無狀態副本放在負載平衡器後、連線池依副本數計算、索引與慢查詢、Redis 快取旁路(TTL 加抖動、寫後刪除、防驚群)、CDN、背景工作移出請求路徑、可觀測性成為日常,並強制執行模組邊界。仍然是單體。
- 百萬級:讀寫分離並處理複寫延遲、訊息佇列、沿限界上下文只拆最痛的服務(常見是 payment 與 inventory)、API Gateway、每個服務擁有自己的資料庫、Saga/Outbox/冪等、Kubernetes 與 HPA、團隊對齊服務邊界。
- 千萬級:分割表再到分片(固定數量的邏輯分片+對照表、注意熱點)、CQRS 讀取模型與搜尋引擎、事件串流、先多可用區再多區域、限流與降載、容量規劃與壓測、平台團隊與成本管理。大多數系統不需要走到這裡。
- 安全拆出一個服務:找出邊界 → 確立資料歸屬 → 新服務建資料庫並用 Outbox 或 CDC 同步 → 影子流量比對 → 依比例切換讀取 → 切換寫入並反向同步 → 移除舊程式。每一步都要能退回。
- 過早的微服務是常見且昂貴的錯誤;留在符合需求的階段,不是落後,而是正確的工程判斷。
下一篇
架構長大之後,最先撐不住的通常是資料庫:查詢越來越慢,第一個想到的解法是加索引。但在幾千萬列、正在接單的表上加索引,做錯一步就可能鎖住整張表、讓服務停擺。下一篇〈正確加索引:大型資料表上線不出事〉接著這篇往資料層走:怎麼從證據找出該加的索引、怎麼設計,以及怎麼在大型資料表上安全地加上去。