This resume is also available in English.

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

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

冷熱資料與分庫分表:資料長大之後怎麼拆

Hot and Cold Data, Sharding and Splitting Databases: What to Do When the Data Grows

資料長大之後,先量測、再依序用便宜的方法,最後才拆。這篇從冷熱分離、依時間分割與歸檔,講到垂直拆分、分片鍵與路由、內嵌分片的訂單編號、跨分片查詢,以及不停機搬遷與維運。

  • 資料庫
  • Sharding
  • Go
  • PostgreSQL
這篇的步驟
  1. 這篇要解決什麼
  2. 第 1 步:先診斷,再決定要不要拆
  3. 第 2 步:冷熱資料——先把不常用的資料移開
  4. 第 3 步:垂直拆分——依業務領域,或依欄位
  5. 第 4 步:水平分片——分片鍵、路由與全域唯一編號
  6. 第 5 步:分片之後會壞掉的東西
  7. 第 6 步:路由放在中介層,還是應用程式裡
  8. 第 7 步:不停機地搬遷
  9. 第 8 步:維運——監控、備份、結構變更與容量規劃
  10. 常見陷阱
  11. 重點整理
  12. 下一篇

上一篇〈正確加索引:大型資料表上線不出事〉處理了「表很大、查詢很慢」最常見也最便宜的解法:找出缺的索引,並在不鎖表的情況下把它加上去。再往前一篇〈從單體到微服務:十萬、百萬、千萬級的架構怎麼演進〉則從架構的角度,一路走到千萬級的分片、讀取模型與多區域。那篇在千萬級只用一個小節帶過「把一張大表拆到多個資料庫」;這篇把這一步完整展開:資料真的長大之後,怎麼判斷該不該拆、先拆什麼、怎麼拆,以及拆完之後要付出哪些代價。

這篇要解決什麼

網路商店上線幾年之後,orders 表通常會變成整個系統裡最大的一張表。它的成長和使用者數量無關,只和時間有關:就算每天的訂單數不變,表也會每天變大。結果是一連串慢慢浮現的問題:備份從幾分鐘變成幾小時、加一個欄位要排維護時段、索引大到放不進記憶體、偶爾一個沒帶好條件的查詢就讓主庫的 CPU 滿載。

面對這些問題,「分庫分表」常常是第一個被提出來的答案,但它也是最昂貴、最難回頭的答案。這篇依照實際該做的順序,一步一步處理:

  • 先診斷:量哪些數字、便宜的修法有哪些、哪些訊號才代表真的需要拆。
  • 冷熱分離:大部分的舊資料幾乎沒人讀,先把它們移開——依時間分割表、歸檔資料庫、物件儲存,以及配套的快取與 API 行為。
  • 垂直拆分:依業務領域把不同的表放到不同的資料庫,或把一張寬表裡不常用的欄位拆出去。
  • 水平分片:選分片鍵、選路由方式、用邏輯分片讓之後的擴充變便宜、產生內嵌分片資訊的全域唯一訂單編號,並用 Go 寫出路由套件。
  • 分片之後會壞掉的東西:跨分片查詢、分頁與排序、聚合、唯一約束、跨分片交易、JOIN 與報表,以及各自的處理方式。
  • 路由放在中介層還是應用程式裡。
  • 不停機搬遷:全量複製、CDC 追上、驗證、切換讀取、切換寫入、退回計畫,以及之後的再分片。
  • 維運:每個分片的監控、備份、結構變更與容量規劃。

範例延續整個系列的網路商店 example.com/shop:api-gateway、order、payment、inventory 四個服務,資料庫是 PostgreSQL,SQL 也以 PostgreSQL 的語法撰寫;MySQL 只在差異大的地方補充說明。

第 1 步:先診斷,再決定要不要拆

「資料庫很慢」不是一個可以直接處理的問題。慢的可能是某一個查詢、某一張表、某一種負載(讀或寫)、某一個時段,處理方式完全不同。所以第一步永遠是量測,而且要量到能回答「到底是什麼大、什麼慢、什麼忙」。

要量哪些數字

指標怎麼量(PostgreSQL)回答什麼問題
慢查詢與最耗時的查詢log_min_duration_statement、pg_stat_statements時間花在哪幾個查詢上;是少數查詢還是整體都慢
表與索引的大小pg_total_relation_size、pg_indexes_size哪幾張表在長大、索引是否比資料還大
列數與成長速度pg_stat_user_tables.n_live_tup,每天記一次照目前速度,多久之後會到下一個門檻
每秒查詢數與讀寫比例pg_stat_statements 的 calls 差值、應用程式指標瓶頸在讀還是寫;讀寫分離有沒有用
p99 延遲應用程式的延遲直方圖(〈可觀測性:日誌、指標、追蹤〉)使用者實際感受到的慢;平均值會把問題藏起來
快取命中率(buffer pool)pg_statio_user_tables 的 heap_blks_hit 與 heap_blks_read常用的資料是否還放得進記憶體
連線數與等待pg_stat_activity、連線池的等待指標是資料庫慢,還是應用程式在排隊等連線
複寫延遲pg_stat_replication唯讀副本還能不能承擔更多讀取
資料的「年齡分布」依月份統計列數,以及被讀取的資料有多舊(下一步)冷熱分離能減掉多少

幾個實用的查詢:

-- 最大的 10 張表:列數、總大小(含索引與 TOAST)、索引大小、掃描方式
SELECT relname,
       n_live_tup,
       pg_size_pretty(pg_total_relation_size(relid)) AS total_size,
       pg_size_pretty(pg_indexes_size(relid))        AS index_size,
       seq_scan, idx_scan
FROM pg_stat_user_tables
ORDER BY pg_total_relation_size(relid) DESC
LIMIT 10;

-- 資料表的 buffer 命中率:長期明顯下降,代表常用資料已經放不進記憶體
SELECT sum(heap_blks_hit)::numeric
       / nullif(sum(heap_blks_hit) + sum(heap_blks_read), 0) AS heap_hit_ratio
FROM pg_statio_user_tables;

-- 總耗時最多的查詢(需要啟用 pg_stat_statements 擴充;欄位名稱是 PostgreSQL 13 以後的版本)
SELECT calls,
       round(total_exec_time) AS total_ms,
       round(mean_exec_time::numeric, 2) AS mean_ms,
       rows,
       left(query, 80) AS query
FROM pg_stat_statements
ORDER BY total_exec_time DESC
LIMIT 10;

-- 訂單的年齡分布:每個月有多少筆
SELECT date_trunc('month', created_at) AS month, count(*) AS orders
FROM orders
GROUP BY 1
ORDER BY 1;

提示:這些數字要長期記錄,而不是出事時才查一次。成長速度比目前的大小更重要:一張 200 GB、每月成長 2% 的表,和一張 50 GB、每月翻倍的表,處理的急迫性完全不同。

便宜的修法,依序先做

量完之後,大部分的「資料庫撐不住」都能用下面這些方法解決,而且每一項都比拆資料庫便宜得多。順序大致就是成本由低到高:

  1. 修查詢與補索引。 慢查詢清單的前幾名,通常就佔了大部分的負載。缺的索引、沒帶條件的全表掃描、N+1 查詢、SELECT * 拉回不需要的大欄位,都是改幾行就有數倍效果的地方。大型資料表上的索引要怎麼安全地加,請看上一篇〈正確加索引:大型資料表上線不出事〉。
  2. 調連線池。 很多「資料庫很慢」其實是應用程式在排隊等連線,或是連線太多讓資料庫忙著切換。連線池的大小要依副本數一起算(〈database/sql、交易與連線池〉)。
  3. 加快取。 同一小群熱門資料被反覆讀取時,快取旁路(cache-aside)能直接拿掉大部分的讀取(〈從單體到微服務〉的十萬級)。
  4. 讀寫分離。 讀多寫少時,把可以容忍些許延遲的讀取導到唯讀副本,並處理好複寫延遲。
  5. 垂直擴充。 換更大的機器、更快的磁碟、更多記憶體。聽起來不夠「架構」,但它不用改任何程式,而且現在單台資料庫主機能提供的資源已經非常可觀。在拆資料庫要花好幾個月的前提下,先升級硬體換取時間,常常是最理性的選擇。
  6. 冷熱分離。 把很少被讀的舊資料移出主表(第 2 步)。這一步會改到資料的存放方式,但仍然在同一個資料庫或同一個服務之內,複雜度遠低於分片。

哪些訊號才值得拆

上面都做過之後,還出現下面這些訊號,才值得認真考慮拆分。重點是:不同的訊號對應不同的拆法,不要把它們混成一個「分庫分表」:

訊號問題的本質對應的做法
單表很大,但大部分是很少被讀的舊資料;備份、結構變更、清理越來越久資料量,不是負載冷熱分離(第 2 步)
不同業務的表互相搶資源;一個服務的批次作業拖慢另一個服務;團隊互相等不同領域的資料綁在一起垂直拆分(第 3 步)
熱資料本身就放不進一台主機的記憶體;寫入吞吐已經到單一主庫的上限單一主庫的寫入與容量天花板水平分片(第 4 步起)

最後一列的門檻最高。讀取的壓力幾乎都能用快取與唯讀副本解決,真正逼你分片的,通常是寫入:每一筆寫入都要落在主庫上,副本加得再多也分攤不了。

第 2 步:冷熱資料——先把不常用的資料移開

用存取模式定義冷熱

「熱資料」不是「新資料」的同義詞,而是經常被讀寫、需要低延遲的資料;「冷資料」則是很少被存取、可以慢一點、但仍然要保存的資料。對訂單來說,存取模式通常非常集中:

  • 下單後的幾天:付款、出貨、查詢狀態,讀寫都很頻繁。
  • 幾週到幾個月:偶爾查看、申請退貨、客服查詢。
  • 幾個月以後:幾乎只剩使用者翻歷史訂單、年度報表、稽核與法規保存。

不要用猜的,要量。最直接的做法是在讀取訂單的地方,記錄「被讀到的訂單有多舊」,做成直方圖:

// 片段:internal/order/service.go
// 每讀一筆訂單,就記下它的年齡(天);儀表板上看分布,就知道冷熱的分界該畫在哪裡。
age := time.Since(o.CreatedAt).Hours() / 24
s.metrics.OrderReadAgeDays.Observe(age)

跑一兩週,你可能會看到類似「98% 的讀取集中在 90 天內的訂單」這樣的結果。這就是冷熱的分界:90 天內是熱資料,其餘可以移到更便宜、更慢的地方。保留在線上的期間,通常還要再加上退貨期、對帳週期等業務規則,取兩者中較長的那個。

order 服務 依訂單時間決定查哪一層 近 3 個月 更舊的訂單 熱資料:線上主庫 最近 3 個月的訂單 依月分割的 orders 快取擋住重複讀取 讀寫頻繁、延遲要低 溫資料:歸檔資料庫 3 到 24 個月的已結束訂單 orders_archive,只讀 較便宜的機器與磁碟 「歷史訂單」才查這裡 冷資料:物件儲存 超過 24 個月 依月份的 Parquet 檔 用查詢引擎掃描 報表、稽核、法規保存 歸檔工作(每天) 分批搬、確認後才刪除 匯出工作(每月) 整月匯出、核對、再刪除 越往右越便宜、越慢、越少被讀;線上的熱路徑只碰左邊那一層

圖:order 服務依訂單時間決定查哪一層。歸檔工作每天把已結束的舊訂單分批搬到歸檔資料庫;更舊的資料每月整批匯出到物件儲存。線上的熱路徑只碰最左邊那一層。

做法一:依時間分割表

〈從單體到微服務〉示範過依 user_id 雜湊分割的 orders,那是為了把一張表平均分成幾份。要做冷熱分離,則是依時間做範圍分割:每個月一個分割區,新資料永遠寫進最新的幾個分割區,舊的分割區不再變動,處理起來就像一個一個獨立的檔案。

-- order 資料庫:訂單表依 created_at 每月一個分割區
CREATE TABLE orders (
    id         BIGINT      NOT NULL,             -- 由應用程式產生(第 4 步),不用序列
    user_id    BIGINT      NOT NULL,
    total      BIGINT      NOT NULL,             -- 單位:分
    status     TEXT        NOT NULL DEFAULT 'pending'
               CHECK (status IN ('pending', 'paid', 'cancelled')),
    paid_at    TIMESTAMPTZ,
    created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
    PRIMARY KEY (id, created_at)                 -- 主鍵必須包含分割鍵
) PARTITION BY RANGE (created_at);

CREATE TABLE orders_2026_10 PARTITION OF orders
    FOR VALUES FROM ('2026-10-01 00:00:00+00') TO ('2026-11-01 00:00:00+00');
CREATE TABLE orders_2026_11 PARTITION OF orders
    FOR VALUES FROM ('2026-11-01 00:00:00+00') TO ('2026-12-01 00:00:00+00');
CREATE TABLE orders_2026_12 PARTITION OF orders
    FOR VALUES FROM ('2026-12-01 00:00:00+00') TO ('2027-01-01 00:00:00+00');

-- 在父表建立的索引,會自動建到每個分割區
CREATE INDEX orders_user_created_idx ON orders (user_id, created_at DESC);
CREATE INDEX orders_created_id_idx   ON orders (created_at, id);

-- 帶上時間條件的查詢只會掃描相關的分割區(partition pruning)
EXPLAIN SELECT id, total, status
FROM orders
WHERE user_id = 42
  AND created_at >= '2026-11-01 00:00:00+00'
ORDER BY created_at DESC
LIMIT 20;

EXPLAIN 的結果裡只會出現 orders_2026_11 與之後的分割區,十月的分割區根本不會被打開。這就是分割區修剪(partition pruning):查詢條件裡有分割鍵,規劃器就能直接排除不可能有資料的分割區。反過來說,不帶時間條件的查詢會掃描所有分割區,所以「我的訂單」這類查詢要預設帶上時間範圍(例如最近 90 天),再另外提供查更舊訂單的入口。

分割表有幾個一定要知道的規則與陷阱:

  • 主鍵與唯一索引必須包含分割鍵。 所以主鍵是 (id, created_at),資料庫無法替你保證 id 單獨唯一;id 的唯一性要由產生方式保證(第 4 步的編號產生器)。同理,order_items 不能再用外鍵參照 orders(id),常見做法是在 order_items 也存一份 created_at 並同樣依時間分割,或拿掉外鍵、由應用程式保證。
  • 找不到分割區的資料會寫入失敗。 如果十二月的分割區還沒建,十二月一日的第一筆訂單會得到 no partition of relation "orders" found for row 的錯誤。要有排程工作提前建好未來幾個月的分割區(PostgreSQL 生態裡常用 pg_partman 這類擴充來自動化),並對「未來分割區剩不到 N 個」設告警。
  • 預設分割區(DEFAULT)是雙面刃。 它能接住沒有對應分割區的資料,避免寫入失敗,但之後新建對應的分割區時,PostgreSQL 要掃描預設分割區確認沒有衝突的資料,而且下面的 DETACH ... CONCURRENTLY 在有預設分割區時不能使用。比較穩的做法是不建預設分割區,改用告警確保分割區永遠提前建好。

舊資料的清理,從「DELETE 幾千萬筆」變成「卸離一個分割區」:

-- 不阻擋線上讀寫地卸離舊分割區(PostgreSQL 14 起;不能在交易區塊裡執行,
-- 也不能在有預設分割區的表上使用)
ALTER TABLE orders DETACH PARTITION orders_2026_10 CONCURRENTLY;

-- 卸離之後它就是一張普通的表:匯出到歸檔庫或物件儲存、核對筆數之後再刪除
DROP TABLE orders_2026_10;

DELETE 大量資料會產生大量的 WAL、讓索引與表膨脹、拖慢複寫;卸離與刪除分割區則幾乎是瞬間完成的檔案操作。光是這一點,就讓依時間分割成為處理「只會一直長大的表」最划算的工具。

提示:MySQL 也支援 PARTITION BY RANGE,舊資料用 ALTER TABLE ... DROP PARTITION 清理,觀念相同。差異在於:MySQL 的分割表同樣要求每個唯一鍵都包含分割欄位,而且 InnoDB 的分割表不支援外鍵。

做法二:歸檔資料庫與歸檔工作

分割表把冷資料留在同一個資料庫裡,只是放在不同的分割區;資料仍然佔用主庫的磁碟、備份與還原時間。更進一步的做法,是把已結束的舊訂單搬到另一個歸檔資料庫:機器規格可以小很多、磁碟便宜很多、不需要唯讀副本,而線上主庫只留下熱資料。

歸檔資料庫的表結構和線上的一樣,再加一個搬移時間:

-- 歸檔資料庫(另一台 PostgreSQL)
CREATE TABLE orders_archive (
    id          BIGINT      PRIMARY KEY,
    user_id     BIGINT      NOT NULL,
    total       BIGINT      NOT NULL,
    status      TEXT        NOT NULL,
    paid_at     TIMESTAMPTZ,
    created_at  TIMESTAMPTZ NOT NULL,
    archived_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
CREATE INDEX orders_archive_user_created_idx ON orders_archive (user_id, created_at DESC);

搬資料的工作看起來只是「複製過去、刪掉原本的」,但它跑在正式環境的主庫上,要同時滿足好幾個條件:

  • 分批:一次只搬幾百到幾千筆,每批之間休息一下,避免長交易、鎖競爭與複寫延遲暴增。
  • 用 keyset 分頁,不用 OFFSET:OFFSET 100000 要先讀過並丟掉前十萬筆,越後面越慢;keyset 分頁記住上一批最後一筆的 (created_at, id),下一批從它之後開始,每一批的成本都一樣。
  • 冪等:工作隨時可能在任何一步中斷(部署、當機、逾時)。寫進歸檔庫用 ON CONFLICT DO NOTHING,重跑同一批不會重複,也不會出錯。
  • 先確認、再刪除:寫進歸檔庫之後,先確認每一筆都在,才從線上刪除;確認失敗就停下來,寧可不搬,不可遺失。
  • 只搬已結束的訂單:pending 的訂單即使很舊(例如付款流程卡住),也還可能被更新,不能搬。刪除時同樣要再檢查一次狀態。
  • 可以取消:收到 context 取消(例如服務要關閉)時,做完手上這一批就停。

歸檔工作會執行的 SQL:

-- Live.Batch:keyset 分頁,依 (created_at, id) 由舊到新
SELECT id, user_id, total, status, created_at
FROM orders
WHERE created_at < $1
  AND status IN ('paid', 'cancelled')
  AND (created_at, id) > ($2, $3)
ORDER BY created_at, id
LIMIT $4;

-- Archive.Upsert(歸檔資料庫):已經存在就略過,重跑安全
INSERT INTO orders_archive (id, user_id, total, status, paid_at, created_at)
VALUES ($1, $2, $3, $4, $5, $6)
ON CONFLICT (id) DO NOTHING;

-- Archive.Count(歸檔資料庫):確認這一批都寫進去了
SELECT count(*) FROM orders_archive WHERE id = ANY($1);

-- Live.Delete:再檢查一次狀態,只刪已結束的
DELETE FROM orders WHERE id = ANY($1) AND status IN ('paid', 'cancelled');

(created_at, id) > ($2, $3) 是 PostgreSQL 的列比較(row comparison),等同於「created_at 比較大,或 created_at 相同但 id 比較大」,搭配 (created_at, id) 的索引就能直接定位到上一批的結尾。只用 created_at 當游標會出錯:同一毫秒建立的兩筆訂單,可能一筆在上一批的結尾、一筆被跳過。= ANY($1) 接收一個陣列參數;使用 pgx 這類驅動時,可以直接傳入 Go 的 []int64。

Go 的部分把「怎麼存取資料庫」抽成兩個小介面,歸檔的流程本身不依賴任何驅動,測試也就不需要真的資料庫。internal/archive/archive.go:

// Package archive 把已經結束、超過保留期限的訂單,從線上資料庫分批搬到歸檔資料庫。
package archive

import (
	"context"
	"errors"
	"fmt"
	"time"
)

// Order 是要搬的一筆訂單(實務上連同 order_items 一起搬)。
type Order struct {
	ID        int64
	UserID    int64
	Total     int64 // 單位:分
	Status    string
	CreatedAt time.Time
}

// Cursor 是 keyset 分頁的位置:上一批最後一筆的 (created_at, id)。
type Cursor struct {
	CreatedAt time.Time
	ID        int64
}

// Live 是線上的訂單資料庫。
type Live interface {
	// Batch 依 (created_at, id) 由舊到新,回傳排在 after 之後、
	// created_at 早於 before 的已結束訂單,最多 limit 筆。
	Batch(ctx context.Context, before time.Time, after Cursor, limit int) ([]Order, error)
	// Delete 刪除這些編號中仍然是已結束狀態的訂單,回傳實際刪除的筆數。
	Delete(ctx context.Context, ids []int64) (int64, error)
}

// Archive 是歸檔資料庫。
type Archive interface {
	// Upsert 寫入訂單;編號已經存在就略過,所以同一批重跑也安全。
	Upsert(ctx context.Context, orders []Order) error
	// Count 回傳這些編號裡,歸檔資料庫已經有幾筆。
	Count(ctx context.Context, ids []int64) (int, error)
}

// ErrVerify 表示寫進歸檔庫的筆數對不上,這一批不會刪除。
var ErrVerify = errors.New("archive: verification failed")

// Archiver 每一批都是:讀 → 寫進歸檔庫 → 確認 → 才從線上刪除。
type Archiver struct {
	Live      Live
	Archive   Archive
	BatchSize int
	Pause     time.Duration // 每批之間休息,讓複寫與磁碟 I/O 喘口氣
}

// Stats 是一次執行的結果。
type Stats struct {
	Batches int
	Moved   int64
}

// Run 搬移 created_at 早於 before 的已結束訂單,直到搬完、出錯或 ctx 被取消。
// 中途停下來沒關係:已經搬到一半的那一批,下次執行會再寫一次(略過)並刪除。
func (a *Archiver) Run(ctx context.Context, before time.Time) (Stats, error) {
	var st Stats
	var cur Cursor
	for {
		batch, err := a.Live.Batch(ctx, before, cur, a.BatchSize)
		if err != nil {
			return st, fmt.Errorf("archive: read batch: %w", err)
		}
		if len(batch) == 0 {
			return st, nil
		}

		ids := make([]int64, len(batch))
		for i, o := range batch {
			ids[i] = o.ID
		}
		if err := a.Archive.Upsert(ctx, batch); err != nil {
			return st, fmt.Errorf("archive: write batch: %w", err)
		}
		n, err := a.Archive.Count(ctx, ids)
		if err != nil {
			return st, fmt.Errorf("archive: verify batch: %w", err)
		}
		if n != len(ids) {
			return st, fmt.Errorf("%w: %d of %d orders found in archive", ErrVerify, n, len(ids))
		}
		deleted, err := a.Live.Delete(ctx, ids)
		if err != nil {
			return st, fmt.Errorf("archive: delete batch: %w", err)
		}

		st.Batches++
		st.Moved += deleted
		last := batch[len(batch)-1]
		cur = Cursor{CreatedAt: last.CreatedAt, ID: last.ID}
		if len(batch) < a.BatchSize {
			return st, nil
		}

		select {
		case <-ctx.Done():
			return st, ctx.Err()
		case <-time.After(a.Pause):
		}
	}
}

這段程式的幾個重點:

  • 每一批的順序是「讀 → 寫入歸檔 → 確認 → 刪除」。任何一步失敗都直接回傳錯誤,不會跳到下一步。最壞的情況是寫進歸檔庫之後、刪除之前中斷:下次執行時同一批會再被讀到,Upsert 略過已經存在的、Count 確認通過、Delete 把它們刪掉——結果和沒中斷一樣。
  • 確認只比對筆數。 這是最低限度的檢查;資料特別重要時,可以再比對每一批的校驗和(第 7 步有範例)。
  • 每批之間的 Pause 讓唯讀副本追上、讓線上請求有喘息的空間。批次大小與休息時間要依複寫延遲調整:觀察到延遲上升就調小。
  • order_items 要一起搬。 範例只搬 orders,實務上歸檔庫的 Upsert 要在同一個交易裡寫入訂單與它的品項,線上的 Delete 也要在同一個交易裡先刪品項、再刪訂單。

如果歸檔表和線上表在同一個資料庫裡(例如只是想把舊資料移到另一個表空間),PostgreSQL 可以用一個陳述式完成搬移,刪除與寫入在同一個交易裡,不需要額外確認:

WITH moved AS (
    DELETE FROM orders
    WHERE id IN (
        SELECT id FROM orders
        WHERE created_at < '2026-11-01 00:00:00+00'
          AND status IN ('paid', 'cancelled')
        ORDER BY created_at, id
        LIMIT 1000
    )
    RETURNING id, user_id, total, status, paid_at, created_at
)
INSERT INTO orders_archive (id, user_id, total, status, paid_at, created_at)
SELECT id, user_id, total, status, paid_at, created_at FROM moved
ON CONFLICT (id) DO NOTHING;

測試用一個放在記憶體裡的假資料庫,同時實作 Live 與 Archive,並能模擬「搬到一半當機」「歸檔庫漏寫」等情況。internal/archive/archive_test.go:

package archive

import (
	"context"
	"errors"
	"slices"
	"sync"
	"testing"
	"time"
)

// store 同時扮演線上資料庫與歸檔資料庫,全部放在記憶體裡。
type store struct {
	mu       sync.Mutex
	live     map[int64]Order
	archived map[int64]Order

	failDeletes int    // 接下來幾次 Delete 要失敗(模擬搬到一半當機)
	dropOne     bool   // Upsert 時故意漏掉一筆(模擬歸檔庫寫入有問題)
	onDelete    func() // 每次 Delete 成功後呼叫
}

func newStore(orders ...Order) *store {
	s := &store{live: map[int64]Order{}, archived: map[int64]Order{}}
	for _, o := range orders {
		s.live[o.ID] = o
	}
	return s
}

func finished(o Order) bool { return o.Status == "paid" || o.Status == "cancelled" }

func (s *store) Batch(ctx context.Context, before time.Time, after Cursor, limit int) ([]Order, error) {
	if err := ctx.Err(); err != nil {
		return nil, err
	}
	s.mu.Lock()
	defer s.mu.Unlock()
	var out []Order
	for _, o := range s.live {
		afterCursor := o.CreatedAt.After(after.CreatedAt) ||
			(o.CreatedAt.Equal(after.CreatedAt) && o.ID > after.ID)
		if finished(o) && o.CreatedAt.Before(before) && afterCursor {
			out = append(out, o)
		}
	}
	slices.SortFunc(out, func(a, b Order) int {
		if c := a.CreatedAt.Compare(b.CreatedAt); c != 0 {
			return c
		}
		return int(a.ID - b.ID)
	})
	return out[:min(limit, len(out))], nil
}

func (s *store) Delete(ctx context.Context, ids []int64) (int64, error) {
	s.mu.Lock()
	if s.failDeletes > 0 {
		s.failDeletes--
		s.mu.Unlock()
		return 0, errors.New("connection reset")
	}
	var n int64
	for _, id := range ids {
		if o, ok := s.live[id]; ok && finished(o) {
			delete(s.live, id)
			n++
		}
	}
	hook := s.onDelete
	s.mu.Unlock()
	if hook != nil {
		hook()
	}
	return n, nil
}

func (s *store) Upsert(ctx context.Context, orders []Order) error {
	s.mu.Lock()
	defer s.mu.Unlock()
	for i, o := range orders {
		if s.dropOne && i == 0 {
			continue
		}
		if _, ok := s.archived[o.ID]; !ok {
			s.archived[o.ID] = o
		}
	}
	return nil
}

func (s *store) Count(ctx context.Context, ids []int64) (int, error) {
	s.mu.Lock()
	defer s.mu.Unlock()
	n := 0
	for _, id := range ids {
		if _, ok := s.archived[id]; ok {
			n++
		}
	}
	return n, nil
}

var (
	cutoff = time.Date(2026, 5, 1, 0, 0, 0, 0, time.UTC)
	old    = cutoff.AddDate(0, -6, 0)
)

// fixture:25 筆舊的已結束訂單、2 筆舊的 pending、3 筆新訂單。
// 每兩筆共用同一個 created_at,用來確認 keyset 游標不會漏掉同一時間的訂單。
func fixture() *store {
	var orders []Order
	for i := range 25 {
		status := "paid"
		if i%5 == 0 {
			status = "cancelled"
		}
		orders = append(orders, Order{ID: int64(100 + i), UserID: 42, Total: 1999, Status: status,
			CreatedAt: old.Add(time.Duration(i/2) * time.Hour)})
	}
	orders = append(orders,
		Order{ID: 200, Status: "pending", CreatedAt: old},
		Order{ID: 201, Status: "pending", CreatedAt: old.Add(time.Hour)},
		Order{ID: 300, Status: "paid", CreatedAt: cutoff},
		Order{ID: 301, Status: "paid", CreatedAt: cutoff.Add(time.Hour)},
		Order{ID: 302, Status: "pending", CreatedAt: cutoff.Add(2 * time.Hour)},
	)
	return newStore(orders...)
}

func TestRunMovesOnlyOldFinishedOrders(t *testing.T) {
	s := fixture()
	a := &Archiver{Live: s, Archive: s, BatchSize: 10}

	st, err := a.Run(t.Context(), cutoff)
	if err != nil {
		t.Fatal(err)
	}
	if st.Moved != 25 || st.Batches != 3 {
		t.Fatalf("stats = %+v, want 25 moved in 3 batches", st)
	}
	if len(s.archived) != 25 || len(s.live) != 5 {
		t.Fatalf("archive %d, live %d", len(s.archived), len(s.live))
	}
	for _, id := range []int64{200, 201, 300, 301, 302} {
		if _, ok := s.live[id]; !ok {
			t.Errorf("order %d must stay live", id)
		}
	}
}

func TestRerunAfterCrashIsSafe(t *testing.T) {
	s := fixture()
	s.failDeletes = 1 // 第一批寫進歸檔庫之後、刪除之前「當機」
	a := &Archiver{Live: s, Archive: s, BatchSize: 10}

	if _, err := a.Run(t.Context(), cutoff); err == nil {
		t.Fatal("expected the first run to fail")
	}
	if len(s.archived) != 10 || len(s.live) != 30 {
		t.Fatalf("after crash: archive %d, live %d", len(s.archived), len(s.live))
	}

	st, err := a.Run(t.Context(), cutoff)
	if err != nil {
		t.Fatal(err)
	}
	if st.Moved != 25 || len(s.archived) != 25 || len(s.live) != 5 {
		t.Fatalf("after rerun: %+v, archive %d, live %d", st, len(s.archived), len(s.live))
	}
}

func TestVerifyFailureDeletesNothing(t *testing.T) {
	s := fixture()
	s.dropOne = true
	a := &Archiver{Live: s, Archive: s, BatchSize: 10}

	_, err := a.Run(t.Context(), cutoff)
	if !errors.Is(err, ErrVerify) {
		t.Fatalf("got %v, want ErrVerify", err)
	}
	if len(s.live) != 30 {
		t.Fatalf("live has %d orders, want all 30", len(s.live))
	}
}

func TestRunStopsWhenCancelled(t *testing.T) {
	s := fixture()
	ctx, cancel := context.WithCancel(t.Context())
	s.onDelete = cancel // 第一批刪完就取消
	a := &Archiver{Live: s, Archive: s, BatchSize: 10, Pause: time.Hour}

	done := make(chan struct{})
	var st Stats
	var err error
	go func() {
		st, err = a.Run(ctx, cutoff)
		close(done)
	}()
	select {
	case <-done:
	case <-time.After(5 * time.Second):
		t.Fatal("Run did not stop after cancel")
	}
	if !errors.Is(err, context.Canceled) || st.Moved != 10 {
		t.Fatalf("got %+v, %v", st, err)
	}
}

fixture 刻意讓每兩筆訂單共用同一個 created_at:如果游標只記時間,第二筆就會被跳過,TestRunMovesOnlyOldFinishedOrders 會抓到。TestRerunAfterCrashIsSafe 驗證最重要的性質——中斷後重跑,結果和一次跑完一樣,沒有遺失也沒有重複。

做法三:冷儲存——物件儲存與查詢引擎

歸檔資料庫裡的資料再放幾年,又會變成一個很大、幾乎沒人讀的資料庫。更舊的資料可以再往下一層:每個月匯出成 Parquet 這類欄式檔案格式,放到物件儲存(S3 相容的儲存服務),依 year=2024/month=03/ 這樣的路徑分區。欄式格式壓縮率高,而且只讀需要的欄位。

查詢冷資料不再走線上的 API,而是交給能直接讀 Parquet 的查詢引擎(例如 DuckDB、Trino,或雲端供應商提供的同類服務),供報表、稽核或偶爾的客服查詢使用。匯出的流程和歸檔工作的精神相同:匯出整個月 → 核對筆數與金額總和 → 確認無誤才刪除來源,並把每次匯出的檔案位置、筆數與校驗和記錄下來。

提示:資料「要保存多久」與「能保存多久」都是法規與業務問題,不是技術問題。會計憑證通常有法定保存年限;個人資料則可能有刪除請求,冷儲存裡的檔案也要能找到並處理。訂單的保存政策最好在設計冷熱分層時就和法務確認,並寫進文件。

熱資料再加上快取

冷熱分離之後,線上主庫只剩熱資料,快取的效果也更好:快取的目標本來就是熱資料。訂單的快取延續〈從單體到微服務〉的快取旁路模式,幾個重點:

  • 只快取熱資料。 歷史訂單、歸檔資料不要放進快取,否則冷資料會把熱資料擠出去。
  • TTL 加上隨機抖動,避免大量的鍵在同一秒過期。
  • 防驚群:熱門的鍵過期瞬間,成百個請求同時回源打資料庫。用 singleflight 讓同一個鍵只回源一次,細節在下一篇〈併發常見問題:從資料競爭到超賣〉的「快取雪崩與驚群效應」。
  • 寫入後刪除快取,而不是更新快取,避免並行寫入讓快取停在舊值。

API 的行為也要跟著改

冷熱分離不只是資料庫的事,API 也要讓使用者與前端知道資料分成了兩種,有三個地方要跟著調整。

列表預設只查熱資料。 GET /orders 回傳最近 90 天的訂單;更舊的訂單走另一個明確的入口,例如 GET /orders/archived,回應可以慢一點,前端也能顯示「查詢歷史訂單中」。 單筆查詢依編號決定去哪裡查。 第 4 步的訂單編號內嵌了建立時間,shard.TimeOf(orderID) 不用查任何表就知道訂單有多舊:

// 片段:internal/order/service.go
// 舊訂單先查歸檔庫;剛過期限、歸檔工作還沒搬到的訂單,再回線上庫找。
func (s *Service) Get(ctx context.Context, userID, orderID int64) (Order, error) {
	if shard.TimeOf(orderID).Before(s.archiveCutoff()) {
		o, err := s.archive.Get(ctx, userID, orderID)
		if !errors.Is(err, ErrNotFound) {
			return o, err
		}
	}
	return s.live.Get(ctx, userID, orderID)
}

歸檔工作可能剛好在兩次查詢之間搬走這筆訂單,使得兩邊都沒找到;在 live.Get 也回傳找不到時,再查一次歸檔庫就能補上這個空隙。

分頁用 keyset,不用 OFFSET。 和歸檔工作同樣的理由:使用者往後翻得越深,OFFSET 越慢。API 回傳一個不透明的游標(把最後一筆的 created_at 與 id 編碼起來),下一頁帶著游標查:

-- 「我的訂單」的下一頁:比游標更舊的 20 筆
SELECT id, total, status, created_at
FROM orders
WHERE user_id = $1
  AND (created_at, id) < ($2, $3)
ORDER BY created_at DESC, id DESC
LIMIT 20;

搭配 (user_id, created_at DESC, id DESC) 的索引,每一頁的成本都一樣。keyset 分頁的代價是不能「直接跳到第 37 頁」,但對訂單列表、動態牆這類往下捲的介面,本來就不需要。

第 3 步:垂直拆分——依業務領域,或依欄位

依業務領域拆資料庫

垂直拆分是「把不同的表放到不同的資料庫」。在微服務的脈絡裡,它其實就是每個服務擁有自己的資料庫:orders、order_items 歸 order 服務;payments、refunds 歸 payment 服務;stock、reservations 歸 inventory 服務。這一步在〈從單體到微服務〉的百萬級已經做過,這裡從資料的角度再看一次它的效果與代價。

垂直拆分:依業務領域 一個 PostgreSQL 所有服務的表放在一起 order orders payment payments inventory stock 每個服務擁有自己的資料庫 表的種類變少,資料量不變 跨庫不能 JOIN、不能共用交易 → 改用 API、事件、Saga/Outbox 水平分片:依分片鍵 order 資料庫 orders 一張表太大 分片 1 orders 分片 2 orders 分片 N orders 表結構相同,放不同的使用者 每個分片的資料量與寫入變少 不帶分片鍵的查詢要問所有分片 → 先選對分片鍵,再補索引表

圖:垂直拆分讓每個資料庫裡的表變少,但每張表的資料量不變;水平分片讓同一張表分散到多個結構相同的分片,每個分片只放一部分使用者。

垂直拆分的好處:

  • 資源隔離。 payment 的對帳批次不會再拖慢 order 的下單;每個資料庫可以依自己的負載選規格。
  • 擁有者明確。 一個資料庫只有一個服務能寫,結構變更只需要一個團隊決定。
  • 比分片簡單得多。 每個資料庫內部仍然是完整的關聯式資料庫:交易、JOIN、唯一約束全都照常可用。

代價是跨資料庫的 JOIN 與交易消失了。「下單同時扣庫存」不能再是一個資料庫交易,要改成預留庫存加上 Saga,事件透過 Outbox 可靠地發出(〈分散式交易:Saga 與 Outbox〉);「訂單列表顯示付款狀態」不能再 JOIN payments,要嘛呼叫 payment 服務,要嘛在 order 這邊保存一份由事件更新的付款狀態(〈訊息佇列與事件驅動〉)。

垂直拆分的限制也很清楚:它減少的是「一個資料庫裡有幾種表」,不是「一張表有多大」。拆完之後 order 資料庫裡的 orders 和原本一樣大,如果問題是這張表本身,就要靠冷熱分離或水平分片。

依欄位拆表

另一種垂直拆分發生在一張表之內:把很寬、不常用或很大的欄位移到另一張表,主表只留下常被查詢與更新的窄欄位。訂單常見的例子是收件地址、備註、發票資訊:列表頁從來不需要,只有訂單明細頁才用。

-- 主表 orders 保持窄;明細頁才需要的欄位放到 order_details,一對一
CREATE TABLE order_details (
    order_id         BIGINT PRIMARY KEY,   -- 對應 orders.id
    shipping_address JSONB  NOT NULL,
    note             TEXT,
    invoice_key      TEXT                  -- 發票 PDF 在物件儲存裡的位置,不把檔案存進資料庫
);

效果是主表每一列變小、同樣的記憶體能放更多列、掃描與索引都更快,經常更新的 status 也不必連帶處理一大串不相關的欄位。PostgreSQL 會把很大的欄位值自動移到 TOAST 另外存放,所以單純「欄位很大」的影響比想像中小;拆分的主要理由是存取模式不同:一組欄位幾乎每個請求都用,另一組幾乎沒人用。檔案(圖片、PDF)則不論如何都不該存進資料庫,放物件儲存、資料庫只存位置。

第 4 步:水平分片——分片鍵、路由與全域唯一編號

做到這裡還不夠的系統,問題通常已經是「熱資料本身就太大、寫入太多」。水平分片把同一張表的資料依分片鍵分散到多個資料庫(分片),每個分片的結構相同、各自放一部分資料。

選分片鍵

分片鍵是分片設計裡最重要、也最難改的決定。選法是:把最重要、最頻繁的查詢與交易列出來,看哪一個鍵能讓它們幾乎都只落在一個分片。

分片鍵落在單一分片的操作要跨分片的操作熱點風險
user_id下單(一個交易)、我的訂單、單筆訂單(編號內嵌分片時)依賣家、依商品、依時間的全站查詢低;少數重度買家影響有限
order_id單筆訂單我的訂單(要問所有分片)最低,寫入最平均
merchant_id賣家後台的所有查詢我的訂單(一個使用者跨很多賣家)高;大賣家的促銷集中在一個分片

對網路商店的訂單,user_id 通常是最好的選擇:下單的交易只涉及一個使用者,「我的訂單」只查一個分片,而賣家後台的查詢量遠小於買家,可以用第 5 步的索引表處理。分片鍵選定之後,同一個使用者的相關資料都要用同一個鍵分片:order_items、order_details 跟著訂單走,才不會一筆訂單的資料散落在不同分片。

選鍵時還要問:這個鍵的值會不會變?(使用者 ID 不會變,賣家的歸屬可能會。)分布夠不夠平均?有沒有某一個值大到一個分片放不下?(一個企業帳號每天下十萬筆訂單,就算放在自己的分片也可能太大。)

選路由方式

決定了分片鍵,還要決定「某個鍵的值去哪一個分片」:

路由方式做法優點缺點
雜湊取餘數hash(key) % N,N 是資料庫數量最簡單、分布平均N 一改變,幾乎所有資料都要搬
一致性雜湊鍵與節點都放上雜湊環,鍵歸順時針遇到的第一個節點加減節點只搬一部分資料需要虛擬節點才平均;搬遷範圍不好控制
範圍依鍵的範圍分,例如 ID 0–999 萬在分片 1範圍查詢方便遞增的鍵讓寫入全部集中在最後一個分片
目錄(對照表)用一張表記錄每個鍵在哪個分片最有彈性,任何鍵都能單獨搬每次路由都要查表;對照表本身要高可用
固定邏輯分片+對照hash(key) % 1024 得到邏輯分片,再查小對照表搬遷以邏輯分片為單位,成本可控邏輯分片數一開始就要定好

最後一種是前幾種的折衷,也是〈從單體到微服務〉用的做法:雜湊的對象不是實體資料庫,而是固定數量的邏輯分片(例如 1024 個),再用一張只有 1024 列的小對照表,把邏輯分片對應到實體資料庫。

user_id 分片鍵 FNV 雜湊 % 1024 邏輯分片 0 到 1023 對照表 有版本號 連線池 實體資料庫 對照表(版本 2):邏輯分片 → 實體資料庫 0 – 255 256 – 511 512 – 767 768 – 1023 orders-db-1 orders-db-2 orders-db-3 orders-db-4 擴充時把一部分邏輯分片搬到新資料庫,換上新版本的對照表;資料的雜湊值不用重算 訂單編號(正的 int64,共 63 位) 毫秒時間(41 位) 產生器(6) 序號(6) 邏輯分片(10) id & 1023 就是邏輯分片:只拿到訂單編號,也能不查表直接找到資料庫

圖:user_id 雜湊到 1024 個邏輯分片之一,對照表再把邏輯分片對到實體資料庫;擴充時只改對照表。訂單編號的最低 10 位就是邏輯分片,所以只拿到訂單編號也能直接路由。

邏輯分片數要怎麼定?幾個原則:

  • 遠大於你可能需要的實體資料庫數量。 1024 個邏輯分片可以從 2 台一路擴充到幾百台,而且每次搬遷只動其中一小部分。
  • 取 2 的次方,方便把它編進編號的位元裡(id & 1023)。
  • 邏輯分片最好是一個可以整個搬走的單位。 常見做法是每個邏輯分片在實體資料庫裡有自己的 schema(例如 shard_0042.orders),或至少所有表都有可以篩選邏輯分片的欄位;搬遷時就能以邏輯分片為單位複製與驗證。一開始 1024 個 schema 分布在 2 台資料庫上,看起來很多,但每個 schema 很小,換來的是之後的每次擴充都只是「搬幾個 schema、改對照表」。

全域唯一的訂單編號

分片之後,資料庫的自動遞增序列不能再用:每個分片各自從 1 開始,編號就會重複。全域唯一編號有幾種常見做法:

做法特性要注意的地方
各分片序列錯開起點與間隔分片 1 產生 1、5、9…,分片 2 產生 2、6、10…分片數改變時很難調整
UUID v4完全隨機,不需協調128 位元、無序,B-tree 索引的插入位置分散
UUID v7、ULID時間在前、隨機在後,大致依時間排序128 位元;不帶分片資訊
Snowflake 類型(64 位元)時間+機器編號+序號,大致遞增、可以放進 BIGINT依賴時鐘;機器編號要確保不重複

這裡用 Snowflake 的思路,但把邏輯分片編進最低的 10 位:訂單編號由毫秒時間(41 位)、產生器編號(6 位)、同一毫秒內的序號(6 位)與邏輯分片(10 位)組成。這樣的編號有三個好處:大致依時間遞增,插入 B-tree 索引時集中在尾端;id & 1023 就是邏輯分片,只拿到訂單編號(例如付款回呼、客服查詢)也能不查表直接路由;高位是時間,TimeOf 能判斷訂單有多舊,用在前面的冷熱路由。

時鐘是這類編號最大的風險。伺服器的時鐘可能被 NTP 往回調整,如果產生器不處理,就可能在「同一毫秒」發出重複的編號。下面的實作在時鐘小幅倒退時等它追上,倒退太多就回傳錯誤,絕不發出可能重複的編號。產生器編號則必須在所有同時執行的副本之間唯一,例如在 Kubernetes 用 StatefulSet 的序號,或在啟動時向協調服務租用一個編號。

提示:64 位元的編號超過 JavaScript 能精確表示的整數範圍(2^53),在 JSON 裡直接用數字輸出,瀏覽器端讀到的編號會被捨入成另一個數字。API 裡的訂單編號一律用字串輸出。另外,依時間遞增的編號會透露「你們一天有多少訂單」,如果這是敏感資訊,對外可以另外提供一個不透露順序的編號。

用 Go 寫出路由套件

路由套件放在 internal/shard:邏輯分片的計算、對照表、依對照表找出連線池的 Router,以及產生編號的 IDGen。internal/shard/shard.go:

// Package shard 把訂單路由到資料庫:
// user_id → 邏輯分片(固定 1024 個)→ 對照表 → 實體資料庫的連線池。
package shard

import (
	"database/sql"
	"encoding/binary"
	"errors"
	"fmt"
	"hash/fnv"
	"sync/atomic"
)

// LogicalShards 一開始就定好,之後不改:擴充時只搬邏輯分片、改對照表。
const LogicalShards = 1024

// shardBits 是訂單編號裡存放邏輯分片的低位數:2^10 = 1024。
const shardBits = 10

// ErrUnknownShard 表示分片編號超出範圍。
var ErrUnknownShard = errors.New("shard: unknown shard")

// Of 回傳某個使用者的資料所屬的邏輯分片。
func Of(userID int64) int {
	var b [8]byte
	binary.BigEndian.PutUint64(b[:], uint64(userID))
	h := fnv.New32a()
	h.Write(b[:])
	return int(h.Sum32() % LogicalShards)
}

// OfOrder 從訂單編號的低 10 位取回邏輯分片,不必查表。
func OfOrder(orderID int64) int {
	return int(orderID & (LogicalShards - 1))
}

// Range 表示邏輯分片 [From, To) 放在名為 DB 的實體資料庫。
type Range struct {
	From, To int
	DB       string
}

// Map 是某一個版本的對照表:每個邏輯分片對到一個實體資料庫。
type Map struct {
	Version int
	owner   [LogicalShards]string
}

// NewMap 檢查 ranges 剛好涵蓋全部邏輯分片:不重疊、不留空。
func NewMap(version int, ranges []Range) (*Map, error) {
	m := &Map{Version: version}
	for _, r := range ranges {
		if r.From < 0 || r.To > LogicalShards || r.From >= r.To || r.DB == "" {
			return nil, fmt.Errorf("shard: invalid range %+v", r)
		}
		for s := r.From; s < r.To; s++ {
			if m.owner[s] != "" {
				return nil, fmt.Errorf("shard: logical shard %d assigned twice", s)
			}
			m.owner[s] = r.DB
		}
	}
	for s, db := range m.owner {
		if db == "" {
			return nil, fmt.Errorf("shard: logical shard %d has no database", s)
		}
	}
	return m, nil
}

// Owner 回傳邏輯分片所在的實體資料庫名稱。
func (m *Map) Owner(shardID int) string { return m.owner[shardID] }

// Router 依目前的對照表找出連線池;搬遷分片時可以在執行中整份換掉對照表。
type Router struct {
	current atomic.Pointer[Map]
	pools   map[string]*sql.DB // 實體資料庫名稱 → 連線池,啟動時建好、之後唯讀
}

// NewRouter 用第一版對照表與所有實體資料庫的連線池建立 Router。
func NewRouter(m *Map, pools map[string]*sql.DB) (*Router, error) {
	r := &Router{pools: pools}
	if err := r.Swap(m); err != nil {
		return nil, err
	}
	return r, nil
}

// Swap 換上新版本的對照表。新表用到的資料庫都要有連線池,版本只能往前。
func (r *Router) Swap(m *Map) error {
	for s := range LogicalShards {
		if _, ok := r.pools[m.owner[s]]; !ok {
			return fmt.Errorf("shard: no pool for database %q", m.owner[s])
		}
	}
	for {
		old := r.current.Load()
		if old != nil && m.Version <= old.Version {
			return fmt.Errorf("shard: map version %d is not newer than %d", m.Version, old.Version)
		}
		if r.current.CompareAndSwap(old, m) {
			return nil
		}
	}
}

// Version 回傳目前使用中的對照表版本,方便記進日誌與指標。
func (r *Router) Version() int { return r.current.Load().Version }

// DB 回傳邏輯分片所在資料庫的連線池。
func (r *Router) DB(shardID int) (*sql.DB, error) {
	if shardID < 0 || shardID >= LogicalShards {
		return nil, fmt.Errorf("%w: %d", ErrUnknownShard, shardID)
	}
	return r.pools[r.current.Load().owner[shardID]], nil
}

// ForUser 回傳某個使用者的資料所在的連線池。
func (r *Router) ForUser(userID int64) (*sql.DB, error) { return r.DB(Of(userID)) }

// ForOrder 只憑訂單編號就找到連線池。
func (r *Router) ForOrder(orderID int64) (*sql.DB, error) { return r.DB(OfOrder(orderID)) }

internal/shard/id.go:

package shard

import (
	"errors"
	"fmt"
	"sync"
	"time"
)

// 訂單編號是正的 int64,63 個位元由高到低:
//
//	[41 位:自 epoch 起的毫秒][6 位:產生器編號][6 位:同一毫秒內的序號][10 位:邏輯分片]
//
// 時間在最高位,所以編號大致依時間遞增;分片在最低位,所以 OfOrder 只要取低 10 位。
const (
	seqBits     = 6
	workerBits  = 6
	seqShift    = shardBits
	workerShift = shardBits + seqBits
	timeShift   = shardBits + seqBits + workerBits

	maxSeq    = 1<<seqBits - 1
	MaxWorker = 1<<workerBits - 1
	maxMillis = 1<<41 - 1

	// maxBackward 是可以原地等待的時鐘倒退量;超過就回傳錯誤,不發出可能重複的編號。
	maxBackward = 10 * time.Millisecond
)

// epoch 是編號的起算時間;41 位毫秒大約可以用 69 年。上線後不能再改。
var epoch = time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC)

// ErrClockBackwards 表示系統時鐘倒退太多(例如被手動調整)。
var ErrClockBackwards = errors.New("shard: clock moved backwards")

// IDGen 產生內嵌邏輯分片的訂單編號。同一時間每個執行中的副本要用不同的 worker。
type IDGen struct {
	mu     sync.Mutex
	worker int64
	lastMS int64
	seq    int64

	now   func() time.Time    // 測試時換成假時鐘
	sleep func(time.Duration) // 同上
}

// NewIDGen 建立產生器;worker 必須在 0..MaxWorker 之間,且不能和其他副本重複。
func NewIDGen(worker int) (*IDGen, error) {
	if worker < 0 || worker > MaxWorker {
		return nil, fmt.Errorf("shard: worker %d out of range 0..%d", worker, MaxWorker)
	}
	return &IDGen{worker: int64(worker), lastMS: -1, now: time.Now, sleep: time.Sleep}, nil
}

// Next 為邏輯分片 shardID 產生一個新的訂單編號。
func (g *IDGen) Next(shardID int) (int64, error) {
	if shardID < 0 || shardID >= LogicalShards {
		return 0, fmt.Errorf("%w: %d", ErrUnknownShard, shardID)
	}
	g.mu.Lock()
	defer g.mu.Unlock()
	for {
		ms := g.now().Sub(epoch).Milliseconds()
		switch {
		case ms < 0 || ms > maxMillis:
			return 0, fmt.Errorf("shard: time %d ms since epoch out of range", ms)
		case ms > g.lastMS:
			g.lastMS, g.seq = ms, 0
		case ms == g.lastMS && g.seq < maxSeq:
			g.seq++
		case ms == g.lastMS:
			// 這一毫秒的序號用完了,等到下一毫秒。
			g.sleep(time.Millisecond)
			continue
		default:
			// 時鐘倒退(例如 NTP 校時):小幅度就等它追上,太大就拒絕。
			back := time.Duration(g.lastMS-ms) * time.Millisecond
			if back > maxBackward {
				return 0, fmt.Errorf("%w by %v", ErrClockBackwards, back)
			}
			g.sleep(back)
			continue
		}
		return g.lastMS<<timeShift | g.worker<<workerShift | g.seq<<seqShift | int64(shardID), nil
	}
}

// TimeOf 從訂單編號取回建立時間(精確到毫秒),可以用來判斷訂單是否已經歸檔。
func TimeOf(orderID int64) time.Time {
	return epoch.Add(time.Duration(orderID>>timeShift) * time.Millisecond)
}

和〈從單體到微服務〉裡的示意版相比,這個版本補上了正式使用時需要的幾件事:

  • 對照表在建立時就驗證完整性:每個邏輯分片都要有、而且只有一個實體資料庫。錯誤的設定在啟動時就失敗,而不是在某個使用者下單時才出錯。
  • 對照表有版本號,可以在執行中原子地整份替換。 atomic.Pointer 讓讀取不需要鎖,CompareAndSwap 確保兩個同時發生的替換不會讓版本倒退。搬遷分片時,協調程式發布新版本,所有副本換上之後,新的請求就會走到新的資料庫。
  • 連線池在啟動時就全部建好。 路由時只查 map,不在請求路徑上建立連線;新對照表用到的資料庫如果沒有連線池,替換會被拒絕。
  • IDGen 用互斥鎖保護序號,每毫秒每個產生器最多 64 個編號,用完就等下一毫秒;now 與 sleep 可以在測試裡換成假時鐘。

測試全部是純邏輯,不需要資料庫。internal/shard/shard_test.go:

package shard

import (
	"database/sql"
	"errors"
	"sync"
	"testing"
	"time"
)

func fourDBs(t *testing.T) *Map {
	t.Helper()
	m, err := NewMap(1, []Range{
		{0, 256, "orders-db-1"},
		{256, 512, "orders-db-2"},
		{512, 768, "orders-db-3"},
		{768, 1024, "orders-db-4"},
	})
	if err != nil {
		t.Fatal(err)
	}
	return m
}

// 測試不需要真的連線:只比對拿到的是不是同一個 *sql.DB。
func pools(names ...string) map[string]*sql.DB {
	p := map[string]*sql.DB{}
	for _, n := range names {
		p[n] = new(sql.DB)
	}
	return p
}

func TestUsersSpreadEvenly(t *testing.T) {
	m := fourDBs(t)
	perDB := map[string]int{}
	perShard := make([]int, LogicalShards)
	for id := int64(1); id <= 100_000; id++ {
		s := Of(id)
		perShard[s]++
		perDB[m.Owner(s)]++
	}
	for s, n := range perShard {
		if n == 0 {
			t.Errorf("logical shard %d got no users", s)
		}
	}
	for db, n := range perDB {
		if n < 23_750 || n > 26_250 { // 期望 25,000,容許 ±5%
			t.Errorf("%s got %d users", db, n)
		}
	}
}

func TestNewMapRejectsBadRanges(t *testing.T) {
	tests := map[string][]Range{
		"gap":          {{0, 512, "a"}, {513, 1024, "b"}},
		"overlap":      {{0, 600, "a"}, {512, 1024, "b"}},
		"out of range": {{0, 1025, "a"}},
		"empty name":   {{0, 1024, ""}},
	}
	for name, ranges := range tests {
		if _, err := NewMap(1, ranges); err == nil {
			t.Errorf("%s: expected an error", name)
		}
	}
}

func TestRouterFollowsSwappedMap(t *testing.T) {
	p := pools("orders-db-1", "orders-db-2", "orders-db-3", "orders-db-4", "orders-db-5")
	r, err := NewRouter(fourDBs(t), p)
	if err != nil {
		t.Fatal(err)
	}

	var user int64 = 42
	s := Of(user)
	before, _ := r.ForUser(user)
	if before != p[fourDBs(t).Owner(s)] {
		t.Fatal("ForUser returned the wrong pool")
	}

	// 把使用者 42 所在的那一個邏輯分片搬到 orders-db-5。
	var ranges []Range
	if s > 0 {
		ranges = append(ranges, Range{0, s, "orders-db-1"})
	}
	ranges = append(ranges, Range{s, s + 1, "orders-db-5"})
	if s+1 < LogicalShards {
		ranges = append(ranges, Range{s + 1, LogicalShards, "orders-db-2"})
	}
	v2, err := NewMap(2, ranges)
	if err != nil {
		t.Fatal(err)
	}
	if err := r.Swap(v2); err != nil {
		t.Fatal(err)
	}
	after, _ := r.ForUser(user)
	if after != p["orders-db-5"] || r.Version() != 2 {
		t.Fatalf("after swap: got version %d", r.Version())
	}

	if err := r.Swap(fourDBs(t)); err == nil {
		t.Error("an older map version must be rejected")
	}
	missing, _ := NewMap(3, []Range{{0, 1024, "orders-db-9"}})
	if err := r.Swap(missing); err == nil {
		t.Error("a map naming a database without a pool must be rejected")
	}
	if _, err := r.DB(LogicalShards); !errors.Is(err, ErrUnknownShard) {
		t.Errorf("DB(1024): got %v", err)
	}
}

func TestIDCarriesShardAndTime(t *testing.T) {
	g, err := NewIDGen(3)
	if err != nil {
		t.Fatal(err)
	}
	r, _ := NewRouter(fourDBs(t), pools("orders-db-1", "orders-db-2", "orders-db-3", "orders-db-4"))

	var user int64 = 42
	start := time.Now().Truncate(time.Millisecond)
	id, err := g.Next(Of(user))
	if err != nil {
		t.Fatal(err)
	}
	if id <= 0 {
		t.Fatalf("id %d must be positive", id)
	}
	if OfOrder(id) != Of(user) {
		t.Fatalf("OfOrder(%d) = %d, want %d", id, OfOrder(id), Of(user))
	}
	byOrder, _ := r.ForOrder(id)
	byUser, _ := r.ForUser(user)
	if byOrder != byUser {
		t.Fatal("an order must live on its user's database")
	}
	if got := TimeOf(id); got.Before(start) || got.After(time.Now()) {
		t.Fatalf("TimeOf = %v, want about %v", got, start)
	}
}

func TestIDsAreUniqueAcrossGoroutines(t *testing.T) {
	g, _ := NewIDGen(1)
	const workers, each = 8, 2000
	ids := make(chan int64, workers*each)
	var wg sync.WaitGroup
	for w := range workers {
		wg.Go(func() {
			for i := range each {
				id, err := g.Next((w*each + i) % LogicalShards)
				if err != nil {
					t.Error(err)
					return
				}
				ids <- id
			}
		})
	}
	wg.Wait()
	close(ids)

	seen := map[int64]bool{}
	for id := range ids {
		if seen[id] {
			t.Fatalf("duplicate id %d", id)
		}
		seen[id] = true
	}
	if len(seen) != workers*each {
		t.Fatalf("got %d ids", len(seen))
	}
}

// fakeClock 只在單一 goroutine 的測試裡使用:sleep 直接把時間往前撥。
type fakeClock struct{ t time.Time }

func (c *fakeClock) now() time.Time        { return c.t }
func (c *fakeClock) sleep(d time.Duration) { c.t = c.t.Add(d) }
func (c *fakeClock) install(g *IDGen)      { g.now, g.sleep = c.now, c.sleep }
func (c *fakeClock) back(d time.Duration)  { c.t = c.t.Add(-d) }

func TestSequenceOverflowWaitsForNextMillisecond(t *testing.T) {
	c := &fakeClock{t: epoch.Add(time.Hour)}
	g, _ := NewIDGen(0)
	c.install(g)

	var last int64
	for i := range maxSeq + 2 { // 多要一個,第 65 個要等到下一毫秒
		id, err := g.Next(7)
		if err != nil {
			t.Fatal(err)
		}
		if id <= last {
			t.Fatalf("id %d not increasing (call %d)", id, i)
		}
		last = id
	}
	if got := TimeOf(last); !got.Equal(epoch.Add(time.Hour + time.Millisecond)) {
		t.Fatalf("last id time = %v", got)
	}
}

func TestClockBackwards(t *testing.T) {
	c := &fakeClock{t: epoch.Add(time.Hour)}
	g, _ := NewIDGen(0)
	c.install(g)

	first, _ := g.Next(1)
	c.back(5 * time.Millisecond) // 小幅倒退:等待後繼續
	second, err := g.Next(1)
	if err != nil || second <= first {
		t.Fatalf("small step back: id %d after %d, err %v", second, first, err)
	}

	c.back(time.Second) // 大幅倒退:拒絕
	if _, err := g.Next(1); !errors.Is(err, ErrClockBackwards) {
		t.Fatalf("big step back: got %v", err)
	}
}

用 go test -race ./... 執行:TestIDsAreUniqueAcrossGoroutines 讓 8 個 goroutine 同時要編號,同時檢查唯一性與資料競爭;兩個假時鐘的測試則重現「序號用完」與「時鐘倒退」這兩個在正式環境很少見、但一旦發生就會產生重複編號的情況。

第 5 步:分片之後會壞掉的東西

分片把一個資料庫變成多個,原本資料庫替你做的很多事,現在要由應用程式自己處理。下面是最常遇到的幾項,以及各自的處理方式:

原本理所當然的事分片之後處理方式
不帶分片鍵的查詢要問所有分片(scatter-gather)索引表或搜尋引擎,由 CDC 或事件維護
跨全部資料的分頁與排序每個分片各自排序,要再合併限制深度、用 keyset、或交給讀取模型
COUNT、SUM 等聚合每個分片算一份再加總,慢且不一致資料倉儲,或事件維護的計數表
全域唯一約束只能保證分片內唯一以該欄位為鍵的唯一性表、或由擁有該資料的服務負責
跨分片交易沒有單一資料庫交易用分片鍵避免;避不掉就用 Saga
JOIN不同分片的資料不能 JOIN反正規化、小表複製到每個分片
報表直接查線上分片會拖垮它們CDC 到資料倉儲

不帶分片鍵的查詢

依 user_id 分片之後,「某個賣家的所有訂單」不帶分片鍵,最直接的做法是對所有分片同時查詢再合併(scatter-gather)。分片少、查詢不頻繁時這是可以接受的,但它的成本隨分片數成長,而且任何一個分片變慢,整個查詢就跟著慢。

比較好的做法,是為這個查詢維護一份以賣家為鍵的索引:CDC 讀取每個分片的交易日誌,把訂單的變更發成事件,消費者更新 merchant_orders (merchant_id, created_at, order_id) 這樣的表(它本身也可以依 merchant_id 分片)。查詢時先查索引拿到訂單編號,需要完整資料時再依編號回到分片——因為編號內嵌了分片,這一步不用查任何對照表。全文搜尋與報表也是同樣的模式,只是目的地換成搜尋引擎與資料倉儲。

order 服務 帶 user_id:只查一個分片 依賣家查:先查索引,再拿 order_id 回分片 orders-db-1 orders-db-2 orders-db-N CDC+事件串流 讀交易日誌(WAL) 賣家訂單索引 merchant_id → order_id 搜尋引擎 客服用的全文搜尋 資料倉儲 報表、跨分片聚合 右邊三份資料都落後分片幾秒;需要最新狀態時,拿 order_id 回分片讀

圖:帶 user_id 的查詢直接到一個分片;其他查詢由 CDC 維護的資料回答,需要最新狀態時再拿 order_id 回分片讀。

這些衍生資料都會落後分片幾秒。介面要能接受「剛下的單過幾秒才出現在賣家後台」;需要最新狀態的操作(例如出貨前確認訂單沒被取消),一律回到分片讀。

跨分片的分頁、排序與聚合

「全站最新的 20 筆訂單」在分片之後,要從每個分片各取最新的 20 筆,在應用程式裡合併排序再取前 20。第一頁還好,第 100 頁就要從每個分片各取 2000 筆——深分頁的成本隨分片數成倍增加。處理方式是限制能翻的深度、改用 keyset 游標(每個分片各記一個位置),或者乾脆把這類查詢交給讀取模型。

COUNT、SUM 這類聚合也一樣:每個分片算一份再加總雖然可行,但慢,而且各分片計算的時間點不同,結果不是同一瞬間的快照。營運報表交給資料倉儲;介面上需要即時顯示的計數(例如「待出貨訂單數」),用事件維護一張計數表。

唯一約束

UNIQUE (email) 在分片之後只能保證「同一個分片內唯一」。如果 users 依 user_id 分片,兩個不同分片的使用者仍然可以註冊同一個 email。處理方式是以這個欄位為鍵,另外建一張唯一性表:user_emails (email PRIMARY KEY, user_id) 依 email 分片,註冊時先在這張表插入,成功才建立使用者。兩次寫入在不同的分片上,所以要設計成可以重試、可以補償的流程(先佔位、再建立、失敗就釋放)。優惠碼「只能用一次」這類規則同理:讓優惠碼的使用紀錄以優惠碼為鍵,由擁有它的服務負責。

跨分片交易

最好的處理方式是用分片鍵避開:以 user_id 分片,一筆訂單、它的品項、它的 Outbox 事件都在同一個分片上,下單仍然是一個本地交易。真正需要跨分片的操作(例如兩個使用者之間的轉移),把它當成跨服務的交易處理:Saga 加上補償,事件透過 Outbox 發出(〈分散式交易:Saga 與 Outbox〉)。兩階段提交在理論上可行,但它會讓所有參與的分片一起等待最慢的那一個,大多數線上系統會避免。

JOIN 與報表

分片之後不能跨分片 JOIN。常見的處理是反正規化:訂單上直接存下單當下的商品名稱與單價(這本來就是正確的做法,商品之後可能改名或調價);小而少變的參考資料(幣別、地區、運費級距)複製一份到每個分片。報表則一律走 CDC 到資料倉儲,不要在線上分片上跑大型查詢。

第 6 步:路由放在中介層,還是應用程式裡

分片的路由可以放在兩個地方:

做法例子優點代價
應用程式內的路由(函式庫)這篇的 internal/shard沒有額外的網路跳轉與元件;路由規則完全看得懂、能測每個存取資料的服務都要用同一套程式;跨語言要重寫
資料庫中介層(代理或分散式層)Vitess(MySQL)、Citus(PostgreSQL 擴充)、Apache ShardingSphere應用程式像在連一個資料庫;重新分片等工作有工具支援多一個要維運、要高可用的元件;行為與限制要花時間熟悉;除錯多一層

幾點中性的觀察:

  • Vitess 是為 MySQL 設計的分片系統,應用程式透過它的閘道連線,它負責路由與重新分片的流程。
  • Citus 是 PostgreSQL 的擴充,把表宣告成分散式表後,由協調節點把查詢分派到各個工作節點。
  • Apache ShardingSphere 提供以函式庫嵌入(Java 生態)或以代理方式執行的模式。
  • ProxySQL 這類 MySQL 代理主要處理連線池、讀寫分離與依規則路由,本身不是完整的分片方案。

每個產品支援的 SQL 範圍、跨分片查詢與交易的行為、重新分片的方式都不同,而且會隨版本改變;要用之前,以官方文件為準,並用自己的查詢實際測過。

怎麼選?如果只有一兩個服務需要分片、分片邏輯簡單(一個鍵、一張對照表),應用程式內的路由通常最容易理解與除錯——它就是一個幾百行、有測試的套件。如果有很多服務、很多語言要存取同一批分片資料,或希望重新分片有成熟的工具支援,中介層的價值就會超過它的維運成本。不論選哪一種,分片鍵的選擇、跨分片查詢的處理,都還是你的設計工作,工具不會替你決定。

第 7 步:不停機地搬遷

不論是從單一資料庫拆成分片,還是之後把一部分邏輯分片搬到新資料庫,都要在系統持續服務的情況下完成。流程和〈從單體到微服務〉安全拆出服務的步驟同一個精神:一連串可以退回的小步驟。

步驟 讀寫在哪裡 1. 建好新分片,全量複製歷史資料 讀寫:舊庫 2. CDC 從複製開始的位置追上變更 讀寫:舊庫,新庫跟著變 3. 逐段驗證:筆數與校驗和 讀寫:舊庫 4. 影子讀取:兩邊都查、只比對 回應用舊庫,新庫只比對 5. 依比例切換讀取 讀:新庫;寫:舊庫 6. 凍結寫入幾秒、追平後切換寫入 讀寫:新庫 7. 反向同步一段時間,再刪舊資料 讀寫:新庫,舊庫跟著變 第 6 步以前,出問題只要停下來或把讀取切回;第 6 步以後,靠反向同步退回

圖:從全量複製到清理舊資料共七步。第 6 步切換寫入之前,任何一步出問題只要停下來或把讀取切回;之後靠反向同步退回。

雙寫,還是 CDC

讓新分片跟上舊資料庫的變更,有兩種做法:

  • 應用程式雙寫:每次寫入舊庫,也寫一份到新庫。看起來簡單,但兩次寫入不在同一個交易裡,任何一次失敗、任何一次並行寫入的順序不同,兩邊就會不一致,而且不會有人知道。〈從單體到微服務〉已經把它列為要避免的做法。
  • 全量複製+CDC:先在某個一致的時間點做一份快照,複製到新分片;同時記下這個時間點在交易日誌裡的位置,從那裡開始用 CDC 把之後的變更依序套用到新分片。PostgreSQL 的邏輯複製(logical replication)就是這個模式:建立複寫槽時可以同時取得一致的快照與起始位置。變更依日誌的順序套用,不會有雙寫的順序問題。

驗證

CDC 追上之後,在切換任何流量之前,先證明兩邊的資料一樣。以範圍為單位比對筆數與校驗和,範圍可以是一個邏輯分片的一個月:

-- 在舊庫與新庫各跑一次,比對兩邊的結果
SELECT count(*) AS row_count,
       md5(string_agg(id::text || ':' || user_id || ':' || total || ':' || status,
                      ',' ORDER BY id)) AS checksum
FROM orders
WHERE (id & 1023) = $1          -- 邏輯分片(編號的低 10 位)
  AND created_at >= $2
  AND created_at <  $3;

範圍要切得夠小,比對不一致時才能快速定位、只重新複製那一段。驗證要在 CDC 持續運作時重複進行,近期的範圍會因為變更還在途中而短暫不一致,只要隨後收斂即可;較舊的範圍則必須完全一致。

切換讀取、切換寫入

  1. 影子讀取:讀取請求同時查兩邊,回應用舊庫的結果,記錄不一致。
  2. 依比例切換讀取:1%、10%、100%,有問題就把比例調回 0。寫入仍然在舊庫,新庫由 CDC 更新。
  3. 切換寫入:這是唯一有風險的一步。對要搬的那幾個邏輯分片短暫凍結寫入(幾秒):寫入請求暫時回傳可重試的錯誤,等 CDC 把最後的變更套用完,再發布新版本的對照表,讓寫入改到新庫。因為以邏輯分片為單位切換,每次影響的只是一小部分使用者,其他使用者完全無感。
  4. 反向同步:切換後一段時間,把新庫的變更同步回舊庫。萬一新庫出問題,可以把對照表換回上一個版本,資料也沒有遺失。
  5. 清理:觀察至少一個完整的業務週期後,停止反向同步、刪掉舊庫裡已搬走的資料。

每一步都要事先寫好完成條件與退回方式,例如「驗證連續 24 小時沒有不一致才切換讀取」「切換寫入後 15 分鐘內錯誤率上升就換回舊的對照表」。凍結寫入期間的重試,靠的是寫入路徑的冪等(〈冪等與分散式鎖〉),同一個請求在切換前後各到達一次也不會重複下單。

之後的再分片

邏輯分片的價值在這裡最明顯:資料量再成長、需要從 4 台擴充到 8 台時,不必重新計算任何一筆資料的雜湊,只要把每台資料庫上一半的邏輯分片搬到新資料庫,每個邏輯分片照上面的流程走一次,最後更新對照表。如果一開始用的是 hash(user_id) % 4,改成 % 8 會讓大約一半的資料換位置,而且無法分批切換——這就是為什麼邏輯分片數要一開始就定好、而且要遠大於實體資料庫數。

第 8 步:維運——監控、備份、結構變更與容量規劃

每個分片都要監控

分片之後,「資料庫的 CPU」不再是一個數字,而是 N 個。監控要能回答:有沒有某個分片特別忙?

  • 每個實體資料庫的 QPS、p99 延遲、CPU、連線數、磁碟用量、複寫延遲,放在同一張圖上比較。指標依實體資料庫加標籤;邏輯分片的編號記在日誌與追蹤裡就好,不要做成指標的標籤,否則 1024 個值會讓指標的數量暴增。
  • 找出流量最高的邏輯分片:在路由層統計每個邏輯分片的請求數,定期輸出前幾名。
  • 熱點分片的處理:如果是某幾個邏輯分片特別忙,把它們搬到自己的資料庫;如果是單一個鍵(例如一個超大的企業帳號)特別忙,邏輯分片也救不了,要針對它特別設計,例如替這個帳號的資料再細分,或在入口限流。

備份與還原

每個分片各自備份、各自做時間點還原(PITR),這一點和單一資料庫相同。不同的是:多個分片之間沒有共同的一致時間點。各分片的備份是各自的瞬間,還原到「同一秒」也不保證跨分片的資料彼此一致(例如一個跨分片的 Saga 剛好走到一半)。所以要定期演練還原單一分片,並準備好還原之後的對帳程序:用事件或日誌把跨分片的流程補齊。對照表本身也要備份,它是所有資料能被找到的前提。

結構變更

同一個結構變更要套用到所有分片,而且不可能在同一瞬間完成。原則是:

  • 程式要能同時面對新舊兩種結構。 用「擴充、遷移、收縮」的順序:先加新欄位(可為空)、部署能讀寫兩種結構的程式、回填資料、最後才移除舊欄位。任何時刻都可能有些分片已經變更、有些還沒。
  • 用同一套遷移工具依序套用到每個分片,記錄每個分片目前的版本,失敗時停下來,不要繼續套用到下一個分片。
  • 大表的變更用線上方式。 PostgreSQL 的許多結構變更(例如加一個可為空、沒有預設值的欄位)只修改系統目錄,很快就完成;建索引用 CREATE INDEX CONCURRENTLY(〈正確加索引〉)。MySQL 生態則常用 gh-ost、pt-online-schema-change 這類線上結構變更工具,以複製一張新表再切換的方式進行。

容量規劃:一個算給你看的例子

下面用一組假設的數字算一次,示範思考的方式;實際的數字一定要用自己系統的量測與壓力測試取代。

假設:每天 100 萬筆訂單;一筆訂單連同品項、Outbox 事件與索引,約佔 2 KB;尖峰每秒的訂單數是全天平均的 10 倍;每筆訂單在主庫上約產生 10 個寫入陳述式(訂單、品項、Outbox、狀態更新等)。

  • 平均每秒訂單:1,000,000 ÷ 86,400 ≈ 12 筆;尖峰約 120 筆,也就是約 1,200 個寫入陳述式每秒。
  • 每天新增資料:1,000,000 × 2 KB ≈ 2 GB;一年約 730 GB。
  • 只保留 90 天的熱資料:約 180 GB。

結論:這個規模不需要分片。每秒一千多個簡單寫入,對一台規格合理的 PostgreSQL 主庫並不吃力;真正的問題是一年 730 GB、而且每年持續累積的資料量,而冷熱分離正好讓主庫穩定在 180 GB 左右。

換一組假設:每天 2,000 萬筆訂單,其他條件不變。

  • 尖峰約 2,300 筆訂單、約 23,000 個寫入陳述式每秒。
  • 每天新增約 40 GB;90 天的熱資料約 3.6 TB。
  • 假設壓力測試量到:一台主庫在 p99 延遲可接受的前提下,能穩定承受約 5,000 個寫入陳述式每秒。那麼至少需要 23,000 ÷ 5,000 ≈ 5 台;保留約 50% 的餘裕給促銷與故障切換,取 8 台。
  • 1024 個邏輯分片 ÷ 8 台 = 每台 128 個邏輯分片;每台的熱資料約 3.6 TB ÷ 8 = 450 GB。

這時分片才有明確的理由,而且數字也告訴你:從 8 台再擴充時,每台搬出一半的邏輯分片即可。容量規劃的價值不在於算得精準,而在於把假設寫下來,之後用實際量測去修正,並在數字逼近門檻之前(例如使用率超過 60%)就開始準備下一步。

常見陷阱

  • 還沒量測就決定分片。 慢的可能只是幾個缺索引的查詢,或是連線池設定錯誤。先看 pg_stat_statements 與表的大小,再談拆分。
  • 把冷熱分離和分片混為一談。 表很大但大部分是舊資料,問題是資料量不是負載;依時間分割與歸檔就能解決,不需要分片。
  • 用 DELETE 清理大量舊資料。 一次刪幾千萬筆會產生大量 WAL、拖慢複寫、讓表膨脹。依時間分割、直接卸離舊分割區。
  • 忘了提前建立分割區。 新的月份一到,所有寫入都失敗。排程建立未來的分割區,並對剩餘數量設告警。
  • 歸檔工作不冪等、先刪再寫。 中斷一次就遺失資料。先寫入歸檔、確認、再刪除,並讓重跑安全。
  • 用 OFFSET 分頁大表。 越後面越慢,歸檔工作與 API 都一樣。用 (created_at, id) 的 keyset 分頁。
  • 只用時間當游標。 同一時間的多筆資料會被跳過。游標要包含唯一的欄位。
  • 分片鍵選在少數查詢上。 讓最頻繁的查詢與交易都要跨分片,等於失去分片的意義。列出查詢,依資料選鍵。
  • 用 hash % 實體資料庫數 路由。 加一台資料庫就要搬幾乎所有資料。用固定數量的邏輯分片加對照表。
  • 分片之後還用資料庫的自動遞增序列。 各分片的編號會重複。用全域唯一的編號,並處理時鐘倒退。
  • 在 JSON 裡用數字輸出 64 位元的編號。 瀏覽器端會捨入成另一個數字。用字串。
  • 應用程式雙寫來搬遷。 兩邊遲早不一致而且沒人知道。用全量複製加 CDC,並逐段驗證。
  • 沒有退回計畫就切換寫入。 每一步都要有完成條件與退回方式,切換後保留反向同步。
  • 只看整體指標。 平均值會把單一熱點分片藏起來。每個分片分開看,並找出流量最高的邏輯分片。

重點整理

  • 先量測:慢查詢、表與索引大小、成長速度、讀寫比例、p99、buffer 命中率、資料的年齡分布。依序先用便宜的修法:修查詢與索引、連線池、快取、讀寫分離、垂直擴充、冷熱分離。
  • 不同的訊號對應不同的拆法:資料量大但多是舊資料→冷熱分離;不同領域互相干擾→垂直拆分;熱資料與寫入超過單一主庫→水平分片。
  • 冷熱依存取模式定義並實際量測。依時間範圍分割讓查詢只掃相關分割區、舊資料以卸離分割區清理;歸檔工作分批、keyset 分頁、冪等寫入、先確認再刪除、可取消;更舊的資料匯出到物件儲存。
  • 熱資料加快取(TTL 加抖動、防驚群、寫後刪除);API 預設只查熱資料,歷史訂單走明確的入口,分頁用 keyset。
  • 垂直拆分讓每個服務擁有自己的資料庫,代價是跨庫 JOIN 與交易改成 API、事件、Saga 與 Outbox;欄位拆分依存取模式把不常用的欄位移出主表。
  • 分片鍵依最頻繁的查詢與交易選擇,網路商店的訂單通常用 user_id;路由用固定數量的邏輯分片加有版本的對照表;訂單編號內嵌邏輯分片與時間,並處理時鐘倒退與產生器編號重複。
  • 分片之後,不帶分片鍵的查詢、分頁、聚合、唯一約束、交易、JOIN 與報表都要重新設計:CDC 維護的索引與資料倉儲、唯一性表、用分片鍵避開跨分片交易、Saga、反正規化。
  • 路由放在應用程式裡簡單透明,中介層適合多服務、多語言與需要成熟工具的情況;產品的行為以官方文件為準。
  • 不停機搬遷:全量複製加 CDC、逐段比對筆數與校驗和、影子讀取、依比例切換讀取、短暫凍結後切換寫入、反向同步、確認後清理。邏輯分片讓之後的再分片只是搬遷,不是重算。
  • 維運:每個分片分開監控並找出熱點、各自備份並演練還原、結構變更用擴充與收縮的順序逐一套用、把容量規劃的假設寫下來並用量測修正。

下一篇

資料拆開之後,系統裡同時運作的東西變多了:更多分片、更多副本、更多背景工作,還有切換時為了不出錯而加上的重試。每多一個同時讀寫同一份資料的執行者,就多一個互相插隊的機會——兩個請求同時扣同一件商品的庫存、歸檔工作和使用者同時改到同一筆訂單、快取過期瞬間湧進資料庫的請求、搬遷時被套用了兩次的事件。下一篇〈併發常見問題:從資料競爭到超賣〉進入「實戰踩坑」,從 Go 程式裡的資料競爭一路到資料庫的超賣與熱點列,一個一個重現這些問題,並把它們修好。