This resume is also available in English.

六、實戰部署第 3 / 5 篇 · 全部目錄

專欄 › 六、實戰部署 › 第 23 篇

從單體到微服務:十萬、百萬、千萬級的架構怎麼演進

From Monolith to Microservices: Evolving the Architecture at 100K, 1M and 10M Scale

同一套網路商店,從一個模組化單體開始,依規模一步步演進:十萬級水平擴充與快取、百萬級讀寫分離與拆出第一批服務、千萬級分片與多區域。每個階段講清楚瓶頸訊號、該做與不該過早做的事,以及怎麼安全拆出一個服務。

  • Architecture
  • Scalability
  • Microservices
這篇的步驟
  1. 這篇要解決什麼
  2. 第 1 步:先把「規模」定義清楚
  3. 第 2 步:起步(萬級)——一個模組化單體就夠了
  4. 第 3 步:十萬級——水平擴充、快取,仍然是單體
  5. 第 4 步:百萬級——讀寫分離、訊息佇列,拆出第一批服務
  6. 第 5 步:千萬級——分片、讀取模型、多區域
  7. 第 6 步:決策表——規模與架構選擇的對照
  8. 第 7 步:安全地拆出一個服務
  9. 常見陷阱
  10. 重點整理
  11. 下一篇

上一篇〈在 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、整合測試〉)。

使用者 shop 模組化單體 一個執行檔、一個映像檔、一次部署 訂單模組 internal/order 付款模組 internal/payment 庫存模組 internal/inventory 模組之間只透過介面呼叫,在 cmd/ 用依賴注入組起來 跨模組的一致性:一個資料庫交易就能保證 連線池 一個 PostgreSQL 每個模組只碰自己的資料表

圖:三個模組在同一個執行檔裡,只透過介面互相呼叫;部署一次、一個資料庫,每個模組只碰自己的資料表。

部署方式可以非常樸素:一台或兩台機器、一個映像檔、一條 CI 流水線。為了不在部署時中斷服務,至少跑兩個副本,並照〈設定與優雅關閉〉處理 SIGTERM。資料庫用託管服務,開啟自動備份,並實際演練一次還原——沒有演練過的備份,等於沒有備份。

此時的瓶頸與訊號

在這個階段,真正的瓶頸幾乎都不是技術,而是產品還在摸索:功能常常大改、資料模型常常變、領域邊界還不穩定。系統層面的訊號通常很溫和:

  • 單一副本的 CPU 與記憶體都還很低,加副本純粹是為了不停機部署。
  • 資料庫的慢查詢偶爾出現,但通常是少了某個索引。
  • 部署一次只要幾分鐘,全隊都能看懂整個程式。

該做什麼

把力氣花在讓單體「結構正確」上,這是之後每一步演進的地基:

  1. 模組邊界清楚:每個模組只公開介面,資料表只屬於一個模組,不同模組不直接 JOIN 彼此的資料表。這一條在現在看起來是多餘的紀律,等到第 4 步要拆服務時,它決定了拆分是幾週還是幾個月。
  2. 無狀態:工作階段放在簽章的 Cookie 或資料庫裡,上傳檔案放物件儲存,不要放在本機磁碟。現在多一點紀律,下一階段加副本時就只是改一個數字。
  3. 設定外部化:資料庫位址、密碼都從環境變數或檔案讀,同一個映像檔可以跑在任何環境。
  4. 基本的可觀測性:結構化日誌、請求延遲與錯誤率的指標、每個請求一個追蹤編號。這些在第 3 步會變得不可或缺,但從第一天就埋好成本最低。

不該過早做什麼

  • 不要一開始就拆微服務。 〈什麼時候該拆:邊界與拆分策略〉的那張表說得很清楚:微服務用網路呼叫、最終一致與多套部署,換取獨立發佈、獨立擴充與故障隔離。這三樣東西在幾個人的團隊、幾十 RPS 的流量下幾乎用不到,代價卻一樣不少。更糟的是,此時的邊界還不穩定,在單體裡畫錯邊界改個 import 就好,在服務之間畫錯,要改的是 API、資料庫與部署。
  • 不要先上 Kubernetes。 一個執行檔加一個託管資料庫,用最簡單的平台(甚至一台虛擬機)就能跑得很好。叢集本身就是一個需要學習與維運的系統。
  • 不要先上訊息佇列、快取、分片。 每加一個元件,就多一個會故障、要監控、要備份的東西。

拆分的判斷依據

這個階段的答案幾乎永遠是「不拆」。唯一的例外是某一塊有截然不同的非功能需求,例如需要特殊硬體的影像處理、或受法規要求必須隔離的資料;即使如此,也優先考慮「同一個程式庫、另一個執行檔」,而不是完整的獨立服務。

第 3 步:十萬級——水平擴充、快取,仍然是單體

系統長什麼樣

流量成長到每秒數百個請求,第一個要做的通常不是拆服務,而是讓同一個單體跑更多份、讓資料庫少做點事。

使用者 CDN 靜態檔案 負載平衡器 單體副本 1 單體副本 2 單體副本 N 無狀態:工作階段、上傳檔案都不放在本機,任何一個副本都能處理任何請求 Redis 快取 快取旁路、TTL PostgreSQL 主庫 索引、慢查詢、連線池 背景工作 寄信、報表離開請求路徑 可觀測性:日誌、指標、追蹤 p99 延遲、錯誤率、資料庫 CPU、連線池等待、快取命中率

圖:靜態檔案交給 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 步:百萬級——讀寫分離、訊息佇列,拆出第一批服務

系統長什麼樣

到了每秒數千請求、一天數萬到數十萬筆訂單,單一資料庫與單一部署單位開始成為真正的限制。這是第一次有充分理由拆出服務的階段——但只拆痛的地方。

使用者 Kubernetes 叢集,命名空間 shop api-gateway 認證、限流、路由 order(原單體) 其餘功能仍在這裡 payment 第一個拆出的服務 inventory 擁有庫存資料 訊息佇列 各服務用 Outbox 發出事件,消費者冪等 order 主庫 寫入只到這裡 payment 資料庫 只有 payment 能讀寫 inventory 資料庫 只有 inventory 能讀寫 唯讀副本 × 2 非同步複寫,有延遲:讀自己剛寫的資料要回主庫

圖: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 步的事,而且是不可逆程度最高的決定之一。
  • 不要自己打造平台。 服務網格、自建的部署系統、自寫的服務發現,在幾個服務的規模下都不划算;用託管服務與現成工具。

拆分的判斷依據

拆一個服務之前,至少要能回答以下問題,而且答案是「是」:

  1. 這一塊有明確的限界上下文,資料能有單一主人嗎?
  2. 拆出去之後,能帶來獨立發佈、獨立擴充或故障隔離其中至少一項真正需要的好處嗎?
  3. 它和其他模組之間不需要強一致的交易,或可以用 Saga 接受最終一致嗎?
  4. 有一個團隊願意、也有能力完整擁有它嗎?
  5. 自動化部署、集中日誌、指標與分散式追蹤都已經就緒了嗎?

任何一題答「否」,先在模組化單體裡把它整理好,比拆出去划算。

第 5 步:千萬級——分片、讀取模型、多區域

系統長什麼樣

到這個量級,單一主資料庫的寫入能力、單一區域的可用性、單一團隊的維運能力都成了限制。系統的主軸從「拆服務」轉向「拆資料」與「拆地理位置」。

全域流量管理(DNS/Anycast) 區域 A(多個可用區) 邊緣:限流、降載、api-gateway order payment inventory 還有搜尋、推薦、通知……由不同團隊負責 訂單資料庫:依 user_id 分片 分片 1 分片 2 分片 3 …… 事件串流(CDC、Outbox) 讀取模型 「我的訂單」列表 搜尋索引 商品與訂單搜尋 區域 B 同一套服務 主備:平時待命 雙活:平時就接流量 資料駐留:某些使用者 的資料只能留在本區 跨區複寫 非同步,有延遲

圖:全域流量管理把使用者導到不同區域;區域內先限流與降載,訂單資料依 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 讀取模型、搜尋引擎
入口單體自己處理負載平衡器、CDNAPI Gateway全域流量管理、限流與降載
可觀測性結構化日誌、基本指標延遲、錯誤率、告警分散式追蹤、每個服務的儀表板服務等級目標、容量與成本指標
組織一個團隊一個團隊、模組各有負責人依服務分團隊業務團隊+平台團隊

讀這張表的方式是「由左往右,訊號出現才移動一格」,而不是「目標是千萬級,所以直接填最右邊那一欄」。每一列可以獨立移動:很多系統的資料庫還在十萬級那一格,入口卻已經需要 API Gateway;也有系統的流量很小,但因為法規需要多區域。

第 7 步:安全地拆出一個服務

不論在哪個階段決定拆,拆的過程都應該是一連串可以退回的小步驟,而不是一次切換。下面以把 inventory 從單體拆出來為例:

1 找出邊界 在單體裡先變成獨立模組,只透過介面呼叫 2 資料歸屬 資料表只給這個模組讀寫,其他模組改走介面 3 同步資料 新服務建好資料庫,用 Outbox 或 CDC 持續複製 4 影子流量 同一個請求也送新服務,只比對結果、不採用 5 切換讀取 依比例把讀取改由新服務回答,寫入仍在單體 6 切換寫入 新服務成為資料的主人,反向同步給單體一段時間 7 移除舊程式 刪掉單體裡的程式碼、資料表與同步機制 每一步都能單獨退回上一步;直到第 7 步,舊路徑都還在

圖:從找邊界到刪掉舊程式共七步;直到最後一步之前,舊的路徑都還在,任何一步出問題都能退回上一步。

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 同步 → 影子流量比對 → 依比例切換讀取 → 切換寫入並反向同步 → 移除舊程式。每一步都要能退回。
  • 過早的微服務是常見且昂貴的錯誤;留在符合需求的階段,不是落後,而是正確的工程判斷。

下一篇

架構長大之後,最先撐不住的通常是資料庫:查詢越來越慢,第一個想到的解法是加索引。但在幾千萬列、正在接單的表上加索引,做錯一步就可能鎖住整張表、讓服務停擺。下一篇〈正確加索引:大型資料表上線不出事〉接著這篇往資料層走:怎麼從證據找出該加的索引、怎麼設計,以及怎麼在大型資料表上安全地加上去。