This resume is also available in English.

三、拆成微服務第 1 / 4 篇 · 全部目錄

專欄 › 三、拆成微服務 › 第 9 篇

什麼時候該拆:邊界與拆分策略

When to Split: Service Boundaries and Decomposition Strategies

微服務不是預設答案。這篇從模組化單體出發,教你用限界上下文與資料擁有權找出邊界,再用絞殺者模式一次搬一小塊,也說清楚哪些情況根本不該拆。

  • Go
  • Microservices
  • Architecture
這篇的步驟
  1. 這篇要解決什麼
  2. 第 1 步:先承認單體不是問題
  3. 第 2 步:在單體裡畫出模組邊界
  4. 第 3 步:用限界上下文找出真正的邊界
  5. 第 4 步:資料擁有權才是真正的切割線
  6. 第 5 步:用絞殺者模式一次搬一小塊
  7. 第 6 步:知道什麼時候不該拆
  8. 常見陷阱
  9. 重點整理
  10. 下一篇

上一篇〈測試:表格驅動、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 設定

這個結構有三條規則,要比目錄本身更重要:

  1. 模組之間只能呼叫對方公開的介面,不能直接 import 對方的 repository,更不能直接查對方的資料表。
  2. 每個模組擁有自己的資料表。orders 表只有 order 模組可以寫,stock 表只有 inventory 模組可以寫。即使它們還在同一個資料庫裡,也要假裝不在。
  3. 組裝只發生在 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 一行都不用改。這就是「先在單體裡練習邊界」的實際收穫:拆服務變成換一個介面實作,而不是重寫業務邏輯。

模組化單體(一個部署單位) 訂單模組 付款模組 庫存模組 共用資料庫 拆分 微服務(各自部署、各自擁有資料) 訂單服務 訂單 DB 付款服務 付款 DB 庫存服務 庫存 DB 服務之間只透過 API 或事件溝通 不能直接讀別人的資料表

圖:左邊三個模組共用一個資料庫但各自擁有資料表;右邊拆成三個服務後,每個服務擁有自己的資料庫,彼此只透過 API 或事件溝通。

一個實用的檢查方法:在 CI 裡加一條規則,禁止 internal/order import internal/inventory 底下除了介面以外的套件。Go 的 internal 目錄只能限制「樹外」的匯入,限制不了兄弟模組之間的匯入,所以這類規則通常要靠 lint 工具或一小段掃描 go list -deps 輸出的腳本來守住。

第 3 步:用限界上下文找出真正的邊界

目錄怎麼切看起來很主觀,有沒有比較客觀的方法?領域驅動設計(DDD)裡的「限界上下文」是目前最常用的工具。它的核心觀察是:同一個詞在不同的業務情境裡,往往代表不同的東西。

以商店裡的「商品」為例:

  • 在訂單的世界裡,商品是一筆訂單明細:哪個 SKU、買了幾個、成交當下的單價是多少。重點是「下單那一刻的快照」,之後商品改價,舊訂單的金額不能跟著變。
  • 在付款的世界裡,根本不在乎商品是什麼顏色、什麼尺寸,只在乎要收多少錢、用什麼幣別、付款狀態是 pending 還是 paid。
  • 在庫存的世界裡,商品是倉庫裡的一個品項:放在哪個倉位、目前可用量是多少、有多少被預留。它不在乎售價。

如果硬要設計一個「萬用商品模型」讓三邊共用,這個模型會越長越大,每個欄位只有一部分人在乎,每次修改都要三個團隊一起開會。反過來,承認這是三個不同的模型、各自活在自己的上下文裡,邊界就自然出現了。

同一個字,在不同上下文裡是不同的模型 訂單上下文 訂單明細 sku、數量、成交單價 下單當下的快照 自己的資料庫 付款上下文 付款項目 金額、幣別、付款狀態 不在乎商品規格 自己的資料庫 庫存上下文 庫存品項 sku、倉位、可用量 不在乎售價 自己的資料庫

圖:同一個「商品」在訂單、付款、庫存三個上下文裡是三個不同的模型,各自只保留自己需要的欄位。

找邊界時可以問這幾個問題:

問題傾向放在同一個服務傾向拆開
這兩塊資料需要在同一個交易裡一起改嗎?是,而且經常很少,或可以接受稍後一致
修改其中一塊時,另一塊常常要一起改嗎?常常一起改各改各的
兩者的負載特性差很多嗎?差不多一個讀多寫少、一個尖峰明顯
由同一群人負責嗎?同一個團隊不同團隊、不同發佈節奏
對故障的容忍度一樣嗎?一樣一個掛了另一個必須照常運作

訂單與付款之間,答案通常偏向拆開:付款要接外部金流、規則複雜、需要獨立稽核,而且付款服務暫時故障時,使用者至少應該還能瀏覽訂單。訂單與「訂單明細」則幾乎一定放在一起:它們必須在同一個交易裡建立,拆開只會製造麻煩。

提示:邊界畫得好不好,看的是「跨邊界的呼叫有多頻繁、多囉唆」。如果完成一個操作要在兩個服務之間來回呼叫五六次,邊界大概畫錯了,應該把其中一部分合回去。

第 4 步:資料擁有權才是真正的切割線

服務拆開最難的部分從來不是程式,而是資料。一條很硬的規則:每一份資料只有一個主人,只有主人可以寫它,其他人想要就問主人。

最常見的反模式是「拆了程式、沒拆資料庫」:三個服務各自部署,但都連到同一個資料庫,order 服務為了方便直接 JOIN 庫存表。這樣做的結果是你得到了微服務所有的成本(網路、部署、版本),卻沒有得到任何好處:庫存團隊改一個欄位名稱,訂單服務就壞了;兩個服務仍然得同時發佈。這通常被稱為「分散式單體」,是最糟的組合。

資料擁有權確定之後,其他服務要用這份資料有三種方式:

  1. 同步查詢:需要最新值時,呼叫主人的 API。例如下單前問 inventory 夠不夠。簡單直接,但主人掛掉時你也受影響。
  2. 保存副本:訂閱主人發出的事件,在自己這邊存一份唯讀副本。例如 order 保存商品名稱與價格的快照,用來顯示訂單。讀取不依賴對方,代價是資料會稍微落後。
  3. 在請求裡帶過來:呼叫端直接把需要的資料放進請求,接收端不再回頭查。

哪一種都不是永遠正確,但有一個訊號值得注意:如果某個服務的大部分功能都要同步查另一個服務才能完成,它們的邊界很可能該合併。

拆資料庫也意味著你失去了跨服務的資料庫交易。下單時「建立訂單+預留庫存+扣款」不再能包在一個 BEGIN ... COMMIT 裡,這正是後面〈分散式交易:Saga 與 Outbox〉要處理的問題。在決定拆之前就要想清楚:這條業務流程能不能接受「先建立訂單、稍後才確認付款」這種最終一致?如果業務上完全不能接受,那兩者大概不該拆。

第 5 步:用絞殺者模式一次搬一小塊

邊界與資料都想清楚了,接著是怎麼搬。最危險的做法是「大爆炸重寫」:停止單體開發半年,另起爐灶寫一整套微服務,然後某天一次切換。這種專案常常因為新系統永遠追不上舊系統的功能而失敗。

絞殺者模式(strangler fig pattern)的名字來自一種會沿著宿主樹生長、最後取而代之的植物。做法是:

  1. 在單體前面放一層路由(反向代理)。一開始所有流量都原封不動轉給單體。
  2. 挑一塊邊界清楚、風險可控的功能,例如付款,在新服務裡實作。
  3. 修改路由,讓這一小組路徑轉到新服務,其餘仍然給單體。
  4. 觀察一段時間,確認正確後刪掉單體裡對應的程式碼;有問題就把路由改回去。
  5. 重複,直到單體只剩下核心,或完全消失。

路由層用標準函式庫的 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/payments/* 訂單單體(舊) 其他所有路徑 一次搬一小塊 流量逐步移過去 單體越來越小 出問題時改路由 就能退回單體

圖:路由層把已經搬走的付款路徑轉到新服務,其他路徑照舊交給單體;出問題時只要改路由就能退回。

這個路由層後來會長成正式的 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 程式碼。