什麼時候該拆:邊界與拆分策略
When to Split: Service Boundaries and Decomposition Strategies
微服務不是預設答案。這篇從模組化單體出發,教你用限界上下文與資料擁有權找出邊界,再用絞殺者模式一次搬一小塊,也說清楚哪些情況根本不該拆。
這篇的步驟
上一篇〈測試:表格驅動、httptest、整合測試〉我們替訂單服務補齊了單元測試與整合測試,到這裡它已經是一個結構清楚、能放心修改的 Go 程式。這篇接著回答一個每個成長中的系統遲早會遇到的問題:要不要把它拆成好幾個服務?如果要,邊界該畫在哪裡、又該怎麼一步一步拆?
這篇要解決什麼
「微服務」這個詞常常被當成架構升級的同義詞,好像系統夠大就應該拆。實際上,拆服務是一筆交換:你用網路呼叫取代函式呼叫,用最終一致取代單一資料庫交易,用多套部署流程取代一套,換來的是團隊可以獨立發佈、服務可以獨立擴充、故障可以被隔離在一部分。如果換來的東西你用不到,付出的成本就全是浪費。
這篇不急著寫 gRPC 或 Gateway,而是先把「判斷」講清楚:
- 為什麼建議先做模組化單體,而不是一開始就拆。
- 怎麼用限界上下文(bounded context)與資料擁有權找出真正的邊界。
- 怎麼用絞殺者模式(strangler fig)把單體裡的一塊安全地搬出去,而且隨時能退回。
- 哪些情況下,拆了只會更糟。
我們繼續使用前面幾篇的線上商店:一開始只有一個 order 程式,裡面處理下單、付款與庫存。這篇的目標是把它整理成可以拆成 order、payment、inventory 三個服務的形狀,並把第一個服務真正搬出去。
第 1 步:先承認單體不是問題
很多團隊想拆服務,起因是「程式越來越亂、改一個地方壞三個地方」。但這通常是模組邊界不清楚的問題,不是部署單位太大的問題。把一團亂的程式切成三個服務,你得到的是三團亂、再加上三倍的網路錯誤。
單體有幾個常被低估的優點:
| 面向 | 單體 | 微服務 |
|---|---|---|
| 呼叫成本 | 函式呼叫,奈秒等級、不會失敗 | 網路呼叫,毫秒等級、會逾時、會部分失敗 |
| 資料一致性 | 一個資料庫交易就能保證 | 需要 Saga、Outbox、冪等等額外設計 |
| 重構 | IDE 一鍵改名,編譯器幫你檢查 | 改介面要考慮新舊版本並存 |
| 部署 | 一條流水線、一個映像檔 | 多條流水線、版本相容性矩陣 |
| 除錯 | 一份日誌、一個堆疊追蹤 | 需要分散式追蹤才看得到全貌 |
| 獨立擴充 | 只能整包一起擴充 | 可以只擴充吃重的那個服務 |
| 團隊自主 | 大家改同一個程式庫、同一個發佈節奏 | 各團隊有自己的發佈節奏 |
表格右邊最後兩列,才是拆服務真正買到的東西。所以第一個要問的問題不是「系統夠不夠大」,而是:有沒有某一塊需要獨立發佈、獨立擴充,或需要把故障隔離開來? 如果答案是否定的,先把單體整理好,比拆服務划算得多。
提示:業界常說的「Monolith First」並不是叫你永遠不要拆,而是先在單體裡把邊界練習清楚。邊界在單體裡畫錯了,改一下 import 就好;在微服務之間畫錯了,要改的是 API、資料庫與部署。
第 2 步:在單體裡畫出模組邊界
拆服務的第一步,是在不改變部署方式的前提下,讓程式「看起來像」已經拆好了。這就是模組化單體(modular monolith):同一個行程、同一個執行檔,但每個業務領域有自己的套件,而且彼此只透過明確的介面溝通。
沿用前面文章的專案結構,我們把 internal/ 依領域切開:
example.com/shop
├── cmd/
│ └── order/main.go # 目前唯一的執行檔,把所有模組組起來
├── internal/
│ ├── order/ # 訂單:handler.go、service.go、repository.go
│ ├── payment/ # 付款:只公開 Service 介面
│ └── inventory/ # 庫存:只公開 Service 介面
├── api/proto/ # 之後放 gRPC 契約(下一篇)
└── deploy/ # compose 與 k8s 設定這個結構有三條規則,要比目錄本身更重要:
- 模組之間只能呼叫對方公開的介面,不能直接 import 對方的 repository,更不能直接查對方的資料表。
- 每個模組擁有自己的資料表。
orders表只有order模組可以寫,stock表只有inventory模組可以寫。即使它們還在同一個資料庫裡,也要假裝不在。 - 組裝只發生在
cmd/裡。這延續了〈分層架構與依賴注入〉的做法:依賴注入讓order模組拿到的是一個介面,它不知道背後是同一個行程裡的結構,還是遠端的服務。
下面這段程式把規則具體化。OrderService 依賴 InventoryService 介面,而不是庫存的資料表;庫存不夠時回傳哨兵錯誤 ErrOutOfStock,呼叫端用 errors.Is 判斷,這是〈錯誤處理:包裝、哨兵、自訂型別〉講過的模式:
// 模組化單體:order 模組只透過 inventory.Service 介面跟庫存模組說話。
// 實際專案裡兩者分別在 internal/order 與 internal/inventory,這裡為了能單獨執行放在同一個檔案。
package main
import (
"context"
"errors"
"fmt"
"sync"
)
// ---- internal/inventory:對外只公開這個介面與錯誤 ----
type InventoryService interface {
Reserve(ctx context.Context, orderID string, items []Item) error
}
var ErrOutOfStock = errors.New("inventory: out of stock")
// inventoryModule 擁有自己的資料,其他模組不能直接碰 stock。
type inventoryModule struct {
mu sync.Mutex
stock map[string]int
}
func (m *inventoryModule) Reserve(ctx context.Context, orderID string, items []Item) error {
if err := ctx.Err(); err != nil {
return err
}
m.mu.Lock()
defer m.mu.Unlock()
for _, it := range items { // 先全部檢查,再一起扣,避免扣到一半
if m.stock[it.SKU] < it.Qty {
return fmt.Errorf("reserve %s for %s: %w", it.SKU, orderID, ErrOutOfStock)
}
}
for _, it := range items {
m.stock[it.SKU] -= it.Qty
}
return nil
}
// ---- internal/order ----
type Item struct {
SKU string
Qty int
Price int64 // 單價,以「分」為單位
}
type Order struct {
ID string
UserID string
Items []Item
Total int64 // 以「分」為單位,避免浮點誤差
Status string
}
const (
StatusPending = "pending"
StatusPaid = "paid"
StatusCancelled = "cancelled"
)
type OrderService struct {
inv InventoryService // 依賴介面,不依賴 inventory 的資料表
}
func (s *OrderService) PlaceOrder(ctx context.Context, id, userID string, items []Item) (*Order, error) {
if err := s.inv.Reserve(ctx, id, items); err != nil {
return nil, fmt.Errorf("place order %s: %w", id, err)
}
o := &Order{ID: id, UserID: userID, Items: items, Status: StatusPending}
for _, it := range items {
o.Total += it.Price * int64(it.Qty)
}
// 之後才寫入 orders 表(屬於 order 模組自己的資料)
return o, nil
}
func main() {
inv := &inventoryModule{stock: map[string]int{"SKU-1": 3}}
orders := &OrderService{inv: inv}
ctx := context.Background()
o, err := orders.PlaceOrder(ctx, "o-1", "u-1", []Item{{SKU: "SKU-1", Qty: 2, Price: 19900}})
fmt.Println(o.Status, o.Total, err) // pending 39800 <nil>
_, err = orders.PlaceOrder(ctx, "o-2", "u-2", []Item{{SKU: "SKU-1", Qty: 2, Price: 19900}})
fmt.Println(err, errors.Is(err, ErrOutOfStock))
}為了能單獨執行,這段程式把兩個模組放在同一個檔案裡,但請注意它們之間唯一的接觸點就是 InventoryService 介面與 ErrOutOfStock。當某一天 inventory 變成獨立服務,你只需要寫一個新的型別去實作同一個介面(裡面改成發 gRPC 請求),OrderService 一行都不用改。這就是「先在單體裡練習邊界」的實際收穫:拆服務變成換一個介面實作,而不是重寫業務邏輯。
圖:左邊三個模組共用一個資料庫但各自擁有資料表;右邊拆成三個服務後,每個服務擁有自己的資料庫,彼此只透過 API 或事件溝通。
一個實用的檢查方法:在 CI 裡加一條規則,禁止 internal/order import internal/inventory 底下除了介面以外的套件。Go 的 internal 目錄只能限制「樹外」的匯入,限制不了兄弟模組之間的匯入,所以這類規則通常要靠 lint 工具或一小段掃描 go list -deps 輸出的腳本來守住。
第 3 步:用限界上下文找出真正的邊界
目錄怎麼切看起來很主觀,有沒有比較客觀的方法?領域驅動設計(DDD)裡的「限界上下文」是目前最常用的工具。它的核心觀察是:同一個詞在不同的業務情境裡,往往代表不同的東西。
以商店裡的「商品」為例:
- 在訂單的世界裡,商品是一筆訂單明細:哪個 SKU、買了幾個、成交當下的單價是多少。重點是「下單那一刻的快照」,之後商品改價,舊訂單的金額不能跟著變。
- 在付款的世界裡,根本不在乎商品是什麼顏色、什麼尺寸,只在乎要收多少錢、用什麼幣別、付款狀態是
pending還是paid。 - 在庫存的世界裡,商品是倉庫裡的一個品項:放在哪個倉位、目前可用量是多少、有多少被預留。它不在乎售價。
如果硬要設計一個「萬用商品模型」讓三邊共用,這個模型會越長越大,每個欄位只有一部分人在乎,每次修改都要三個團隊一起開會。反過來,承認這是三個不同的模型、各自活在自己的上下文裡,邊界就自然出現了。
圖:同一個「商品」在訂單、付款、庫存三個上下文裡是三個不同的模型,各自只保留自己需要的欄位。
找邊界時可以問這幾個問題:
| 問題 | 傾向放在同一個服務 | 傾向拆開 |
|---|---|---|
| 這兩塊資料需要在同一個交易裡一起改嗎? | 是,而且經常 | 很少,或可以接受稍後一致 |
| 修改其中一塊時,另一塊常常要一起改嗎? | 常常一起改 | 各改各的 |
| 兩者的負載特性差很多嗎? | 差不多 | 一個讀多寫少、一個尖峰明顯 |
| 由同一群人負責嗎? | 同一個團隊 | 不同團隊、不同發佈節奏 |
| 對故障的容忍度一樣嗎? | 一樣 | 一個掛了另一個必須照常運作 |
訂單與付款之間,答案通常偏向拆開:付款要接外部金流、規則複雜、需要獨立稽核,而且付款服務暫時故障時,使用者至少應該還能瀏覽訂單。訂單與「訂單明細」則幾乎一定放在一起:它們必須在同一個交易裡建立,拆開只會製造麻煩。
提示:邊界畫得好不好,看的是「跨邊界的呼叫有多頻繁、多囉唆」。如果完成一個操作要在兩個服務之間來回呼叫五六次,邊界大概畫錯了,應該把其中一部分合回去。
第 4 步:資料擁有權才是真正的切割線
服務拆開最難的部分從來不是程式,而是資料。一條很硬的規則:每一份資料只有一個主人,只有主人可以寫它,其他人想要就問主人。
最常見的反模式是「拆了程式、沒拆資料庫」:三個服務各自部署,但都連到同一個資料庫,order 服務為了方便直接 JOIN 庫存表。這樣做的結果是你得到了微服務所有的成本(網路、部署、版本),卻沒有得到任何好處:庫存團隊改一個欄位名稱,訂單服務就壞了;兩個服務仍然得同時發佈。這通常被稱為「分散式單體」,是最糟的組合。
資料擁有權確定之後,其他服務要用這份資料有三種方式:
- 同步查詢:需要最新值時,呼叫主人的 API。例如下單前問
inventory夠不夠。簡單直接,但主人掛掉時你也受影響。 - 保存副本:訂閱主人發出的事件,在自己這邊存一份唯讀副本。例如
order保存商品名稱與價格的快照,用來顯示訂單。讀取不依賴對方,代價是資料會稍微落後。 - 在請求裡帶過來:呼叫端直接把需要的資料放進請求,接收端不再回頭查。
哪一種都不是永遠正確,但有一個訊號值得注意:如果某個服務的大部分功能都要同步查另一個服務才能完成,它們的邊界很可能該合併。
拆資料庫也意味著你失去了跨服務的資料庫交易。下單時「建立訂單+預留庫存+扣款」不再能包在一個 BEGIN ... COMMIT 裡,這正是後面〈分散式交易:Saga 與 Outbox〉要處理的問題。在決定拆之前就要想清楚:這條業務流程能不能接受「先建立訂單、稍後才確認付款」這種最終一致?如果業務上完全不能接受,那兩者大概不該拆。
第 5 步:用絞殺者模式一次搬一小塊
邊界與資料都想清楚了,接著是怎麼搬。最危險的做法是「大爆炸重寫」:停止單體開發半年,另起爐灶寫一整套微服務,然後某天一次切換。這種專案常常因為新系統永遠追不上舊系統的功能而失敗。
絞殺者模式(strangler fig pattern)的名字來自一種會沿著宿主樹生長、最後取而代之的植物。做法是:
- 在單體前面放一層路由(反向代理)。一開始所有流量都原封不動轉給單體。
- 挑一塊邊界清楚、風險可控的功能,例如付款,在新服務裡實作。
- 修改路由,讓這一小組路徑轉到新服務,其餘仍然給單體。
- 觀察一段時間,確認正確後刪掉單體裡對應的程式碼;有問題就把路由改回去。
- 重複,直到單體只剩下核心,或完全消失。
路由層用標準函式庫的 httputil.ReverseProxy 就能寫,配合 Go 1.22 起 http.ServeMux 支援的「方法+路徑」樣式,搬走的端點一目了然:
// 絞殺者模式的路由層:已搬走的路徑轉到新服務,其餘照舊交給單體。
package main
import (
"log"
"net/http"
"net/http/httputil"
"net/url"
"os"
)
func mustProxy(raw string) *httputil.ReverseProxy {
u, err := url.Parse(raw)
if err != nil {
log.Fatalf("bad upstream %q: %v", raw, err)
}
return httputil.NewSingleHostReverseProxy(u)
}
func env(key, def string) string {
if v := os.Getenv(key); v != "" {
return v
}
return def
}
func main() {
monolith := mustProxy(env("MONOLITH_URL", "http://127.0.0.1:9000"))
payment := mustProxy(env("PAYMENT_URL", "http://127.0.0.1:9100"))
mux := http.NewServeMux()
// 已經搬到 payment 服務的端點(Go 1.22 的方法+路徑樣式)
mux.Handle("POST /api/payments", payment)
mux.Handle("GET /api/payments/{id}", payment)
// 開關:出問題時設 PAYMENT_ROLLBACK=1 就整段退回單體
if os.Getenv("PAYMENT_ROLLBACK") == "1" {
mux = http.NewServeMux()
}
// 其他一律交給單體
mux.Handle("/", monolith)
addr := env("ADDR", ":8080")
log.Printf("strangler router listening on %s", addr)
log.Fatal(http.ListenAndServe(addr, mux))
}這段程式刻意保留一個「退回開關」:設定 PAYMENT_ROLLBACK=1 重新啟動,付款路徑就全部回到單體。搬遷期間,能快速退回比什麼都重要。實務上這個開關常常做成可以即時調整的設定,或依使用者比例逐步放量(先 1%、再 10%……)。
圖:路由層把已經搬走的付款路徑轉到新服務,其他路徑照舊交給單體;出問題時只要改路由就能退回。
這個路由層後來會長成正式的 API Gateway,加上認證、限流與請求 ID,那是〈API Gateway:路由、認證、限流〉的主題。
搬遷時還有兩件事要一併規劃:
- 資料怎麼搬:新服務有自己的資料庫後,舊資料要遷移過去。常見做法是先讓單體在寫入時同時寫一份到新資料庫(或透過事件同步),新服務上線後先只讀、比對結果,確認一致後才把寫入權交出去。
- 第一塊挑什麼:優先挑邊界清楚、和其他模組耦合少、而且有明確獨立需求的部分。付款常常是好選擇,因為它本來就要對接外部金流,介面相對穩定;反過來,訂單這種處在所有流程中心的模組,通常最後才搬。
第 6 步:知道什麼時候不該拆
最後也最重要的一步,是學會說不。下面這些情況,拆服務通常弊大於利:
| 情況 | 為什麼拆了更糟 | 比較好的做法 |
|---|---|---|
| 團隊只有少數幾個人 | 維運多套服務的負擔會吃掉開發時間 | 模組化單體,部署多個副本 |
| 業務還在快速摸索 | 邊界還會大幅變動,跨服務重構很昂貴 | 等邊界穩定再拆 |
| 只是想「擴充效能」 | 單體本身也能水平擴充 | 先找瓶頸(見〈效能調校:pprof 與 benchmark〉) |
| 兩塊資料必須強一致 | 跨服務只能做到最終一致 | 留在同一個服務、同一個交易 |
| 沒有自動化部署與可觀測性 | 出問題時找不到原因 | 先建好 CI/CD、日誌、指標、追蹤 |
| 動機是「技術履歷好看」 | 成本真實存在,好處不存在 | 誠實面對需求 |
拆服務之前,基礎設施至少要有:每個服務都能自動建置成映像檔並部署、能集中查詢日誌、有基本的指標與告警、能追蹤一個請求跨過哪些服務。這些是系列後半〈可觀測性:日誌、指標、追蹤〉與部署相關文章的內容。沒有它們,微服務出問題時你會像在黑暗中找鑰匙。
也要記得,「拆」不是單向的。如果兩個服務事後證明呼叫太頻繁、總是一起改、資料需要強一致,把它們合回去是完全正當的決定,不是失敗。
常見陷阱
- 按技術分層拆服務:拆成「API 服務」「業務邏輯服務」「資料存取服務」。每個功能都要穿過三個服務,任何改動都要三邊一起發佈。服務要按業務能力拆,不要按技術層拆。
- 共用資料庫:拆了程式、沒拆資料。結果是分散式單體,耦合一點都沒少。
- 拆得太細:一個實體一個服務(使用者服務、地址服務、電話服務……)。呼叫鏈變長,延遲與失敗機率都跟著放大。
- 共用的「common」函式庫越長越大:把領域模型放進大家共用的套件,等於用另一種方式把服務綁在一起。共用的只應該是真正通用的工具(例如日誌格式),不是業務模型。
- 同步呼叫鏈太長:A 呼叫 B、B 呼叫 C、C 呼叫 D。只要其中一個慢,整條鏈都慢;每個服務的可用度相乘,整體可用度會明顯下降。能改成非同步事件的就改。
- 大爆炸切換:一次把所有功能切到新系統,沒有退路。用絞殺者模式,一次一小塊。
- 忘了資料遷移與雙寫的一致性:程式搬過去了,舊資料還在單體的表裡。遷移計畫要跟程式搬遷一起設計。
重點整理
- 微服務是一筆交換:用網路呼叫、最終一致與更複雜的維運,換取獨立發佈、獨立擴充與故障隔離。用不到這些好處就不要拆。
- 先做模組化單體:依業務領域分套件、只透過介面溝通、每個模組擁有自己的資料表、組裝只在
cmd/進行。 - 用限界上下文找邊界:同一個詞在不同上下文裡是不同的模型,不要追求萬用模型。
- 資料擁有權是真正的切割線:每份資料只有一個主人,其他服務用同步查詢、事件副本或請求攜帶取得。
- 用絞殺者模式漸進搬遷:前面放一層路由,一次搬一小組路徑,永遠保留退回的能力。
- 沒有自動化部署與可觀測性之前,不要拆;拆錯了,合回去也是正當的選擇。
下一篇
邊界畫好了,order 要怎麼跟獨立出去的 inventory 說話?用 JSON over HTTP 可以,但型別容易對不上、也沒有串流與 deadline 的標準做法。下一篇〈gRPC 與 Protocol Buffers〉會用一份 .proto 契約把服務之間的介面定下來,並產生型別安全的 Go 程式碼。