冷熱資料與分庫分表:資料長大之後怎麼拆
Hot and Cold Data, Sharding and Splitting Databases: What to Do When the Data Grows
資料長大之後,先量測、再依序用便宜的方法,最後才拆。這篇從冷熱分離、依時間分割與歸檔,講到垂直拆分、分片鍵與路由、內嵌分片的訂單編號、跨分片查詢,以及不停機搬遷與維運。
這篇的步驟
上一篇〈正確加索引:大型資料表上線不出事〉處理了「表很大、查詢很慢」最常見也最便宜的解法:找出缺的索引,並在不鎖表的情況下把它加上去。再往前一篇〈從單體到微服務:十萬、百萬、千萬級的架構怎麼演進〉則從架構的角度,一路走到千萬級的分片、讀取模型與多區域。那篇在千萬級只用一個小節帶過「把一張大表拆到多個資料庫」;這篇把這一步完整展開:資料真的長大之後,怎麼判斷該不該拆、先拆什麼、怎麼拆,以及拆完之後要付出哪些代價。
這篇要解決什麼
網路商店上線幾年之後,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、每月翻倍的表,處理的急迫性完全不同。
便宜的修法,依序先做
量完之後,大部分的「資料庫撐不住」都能用下面這些方法解決,而且每一項都比拆資料庫便宜得多。順序大致就是成本由低到高:
- 修查詢與補索引。 慢查詢清單的前幾名,通常就佔了大部分的負載。缺的索引、沒帶條件的全表掃描、N+1 查詢、
SELECT *拉回不需要的大欄位,都是改幾行就有數倍效果的地方。大型資料表上的索引要怎麼安全地加,請看上一篇〈正確加索引:大型資料表上線不出事〉。 - 調連線池。 很多「資料庫很慢」其實是應用程式在排隊等連線,或是連線太多讓資料庫忙著切換。連線池的大小要依副本數一起算(〈database/sql、交易與連線池〉)。
- 加快取。 同一小群熱門資料被反覆讀取時,快取旁路(cache-aside)能直接拿掉大部分的讀取(〈從單體到微服務〉的十萬級)。
- 讀寫分離。 讀多寫少時,把可以容忍些許延遲的讀取導到唯讀副本,並處理好複寫延遲。
- 垂直擴充。 換更大的機器、更快的磁碟、更多記憶體。聽起來不夠「架構」,但它不用改任何程式,而且現在單台資料庫主機能提供的資源已經非常可觀。在拆資料庫要花好幾個月的前提下,先升級硬體換取時間,常常是最理性的選擇。
- 冷熱分離。 把很少被讀的舊資料移出主表(第 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 服務依訂單時間決定查哪一層。歸檔工作每天把已結束的舊訂單分批搬到歸檔資料庫;更舊的資料每月整批匯出到物件儲存。線上的熱路徑只碰最左邊那一層。
做法一:依時間分割表
〈從單體到微服務〉示範過依 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 服務。這一步在〈從單體到微服務〉的百萬級已經做過,這裡從資料的角度再看一次它的效果與代價。
圖:垂直拆分讓每個資料庫裡的表變少,但每張表的資料量不變;水平分片讓同一張表分散到多個結構相同的分片,每個分片只放一部分使用者。
垂直拆分的好處:
- 資源隔離。
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 雜湊到 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 分片)。查詢時先查索引拿到訂單編號,需要完整資料時再依編號回到分片——因為編號內嵌了分片,這一步不用查任何對照表。全文搜尋與報表也是同樣的模式,只是目的地換成搜尋引擎與資料倉儲。
圖:帶 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 步:不停機地搬遷
不論是從單一資料庫拆成分片,還是之後把一部分邏輯分片搬到新資料庫,都要在系統持續服務的情況下完成。流程和〈從單體到微服務〉安全拆出服務的步驟同一個精神:一連串可以退回的小步驟。
圖:從全量複製到清理舊資料共七步。第 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%、10%、100%,有問題就把比例調回 0。寫入仍然在舊庫,新庫由 CDC 更新。
- 切換寫入:這是唯一有風險的一步。對要搬的那幾個邏輯分片短暫凍結寫入(幾秒):寫入請求暫時回傳可重試的錯誤,等 CDC 把最後的變更套用完,再發布新版本的對照表,讓寫入改到新庫。因為以邏輯分片為單位切換,每次影響的只是一小部分使用者,其他使用者完全無感。
- 反向同步:切換後一段時間,把新庫的變更同步回舊庫。萬一新庫出問題,可以把對照表換回上一個版本,資料也沒有遺失。
- 清理:觀察至少一個完整的業務週期後,停止反向同步、刪掉舊庫裡已搬走的資料。
每一步都要事先寫好完成條件與退回方式,例如「驗證連續 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 程式裡的資料競爭一路到資料庫的超賣與熱點列,一個一個重現這些問題,並把它們修好。