服務發現與負載平衡
Service Discovery and Load Balancing for Go Microservices
服務有多個實例、IP 隨時會變,呼叫端要怎麼找到健康的那幾台?這篇比較用戶端與伺服器端負載平衡,用 Go 寫出帶心跳的註冊中心與輪詢、最少連線、一致性雜湊三種演算法,並說明 Kubernetes 的 DNS 做法。
這篇的步驟
上一篇〈API Gateway:路由、認證、限流〉把所有外部流量集中到 api-gateway,但它的路由表把 order、payment、inventory 的位址寫死在程式裡。這篇接著解決這個問題:當每個服務都跑了好幾個實例、實例會擴充、縮減、重新部署,呼叫端要怎麼隨時知道「現在有哪些健康的實例」,又要怎麼把請求平均地分給它們?
這篇要解決什麼
在單體時代,呼叫另一個模組只是一次函式呼叫,不存在「找不到對方」的問題。拆成服務之後,order 要呼叫 inventory,必須先回答兩個問題:
- 服務發現(service discovery):
inventory現在有哪些實例?位址是什麼?哪些是健康的? - 負載平衡(load balancing):這次請求要送給其中哪一個?
這兩件事緊密相關,但值得分開思考。服務發現提供一份「候選名單」,負載平衡從名單裡挑一個。名單的來源可能是註冊中心、DNS 或平台的 API;挑選的方式可能是輪詢、最少連線或一致性雜湊;挑選的位置可能在呼叫端,也可能在中間的一台負載平衡器。
這篇會依序:
- 比較用戶端負載平衡與伺服器端負載平衡。
- 用 Go 寫一個帶心跳與 TTL 的最小註冊中心,理解健康檢查的本質。
- 實作三種常用的負載平衡演算法,並觀察一致性雜湊在擴充時的效果。
- 看 Kubernetes 怎麼用 Service 與 DNS 把這些事情內建好,以及 gRPC 在其中要注意什麼。
第 1 步:用戶端還是伺服器端負載平衡
負載平衡的決策放在哪裡,有兩種基本架構:
圖:左邊由呼叫端向註冊中心取得實例清單、自己挑一台直接連線;右邊呼叫端只認得一個位址,由中間的負載平衡器挑選後端。
| 面向 | 用戶端負載平衡 | 伺服器端負載平衡 |
|---|---|---|
| 誰挑實例 | 呼叫端的函式庫 | 中間的負載平衡器(L4 或 L7) |
| 網路路徑 | 直接連到實例,少一跳 | 多經過一台負載平衡器 |
| 呼叫端複雜度 | 高:要整合服務發現、健康狀態、演算法 | 低:只需要一個固定位址 |
| 多語言支援 | 每種語言都要有對應的函式庫 | 與語言無關 |
| 單點故障 | 沒有中心節點(註冊中心除外) | 負載平衡器本身要做高可用 |
| 對長連線的效果 | 好:可以對每個實例各開連線 | L4 只能平衡「連線」,無法平衡連線裡的請求 |
| 典型例子 | gRPC 內建的負載平衡、服務網格的 sidecar | 雲端負載平衡器、NGINX、Kubernetes Service |
兩者之間還有一種常見的折衷:服務網格(service mesh)。它在每個服務旁邊放一個 sidecar 代理,對應用程式來說像是伺服器端負載平衡(只要連到本機的代理),實際上卻是在每個節點上做用戶端負載平衡。
選擇的原則可以很簡單:沒有特殊需求時,用平台提供的伺服器端負載平衡(例如 Kubernetes Service),最省事;當你使用 gRPC 這類長連線協定、或需要依請求內容做路由(例如一致性雜湊)時,才考慮用戶端負載平衡。
第 2 步:註冊中心與心跳
不管哪一種架構,總要有人維護「目前有哪些健康實例」這份名單。最直接的做法是一個註冊中心(registry),常見的產品有 Consul、etcd、ZooKeeper、Nacos 等。它們的核心機制其實很單純:
- 實例啟動後,向註冊中心登記自己的服務名稱與位址。
- 實例定期送出心跳,代表「我還活著」。
- 註冊中心如果在 TTL(存活時間)內沒收到某個實例的心跳,就把它視為不健康,不再出現在查詢結果裡。
- 實例優雅關閉時主動註銷,不必等 TTL 過期。
- 呼叫端查詢某個服務的健康實例清單,通常會在本地快取一段時間,或訂閱變更通知。
圖:實例向註冊中心註冊並持續送心跳;心跳中斷的實例會被下線。呼叫端查詢健康清單後,直接呼叫實例。
下面用標準函式庫寫一個最小的註冊中心。為了簡單,註冊與心跳是同一個動作:PUT /instances 一次就續約一次;GET /services/{service} 只回傳 TTL 內有心跳的實例;DELETE 讓實例在優雅關閉時主動下線。路由使用 Go 1.22 起 http.ServeMux 支援的方法與路徑參數:
// 最小的服務註冊中心:實例註冊、定期心跳續約,逾時沒心跳就自動下線。
package main
import (
"encoding/json"
"log"
"net/http"
"sort"
"sync"
"time"
)
const ttl = 10 * time.Second // 示意:心跳超過 10 秒沒來就視為不健康
type instance struct {
Service string `json:"service"`
Addr string `json:"addr"`
LastBeat time.Time `json:"last_beat"`
}
type registry struct {
mu sync.RWMutex
byID map[string]*instance // key = service + "|" + addr
}
func (r *registry) beat(service, addr string, now time.Time) {
r.mu.Lock()
defer r.mu.Unlock()
id := service + "|" + addr
if in, ok := r.byID[id]; ok {
in.LastBeat = now
return
}
r.byID[id] = &instance{Service: service, Addr: addr, LastBeat: now}
}
func (r *registry) deregister(service, addr string) {
r.mu.Lock()
defer r.mu.Unlock()
delete(r.byID, service+"|"+addr)
}
// healthy 只回傳 TTL 內有心跳的實例。
func (r *registry) healthy(service string, now time.Time) []string {
r.mu.RLock()
defer r.mu.RUnlock()
var addrs []string
for _, in := range r.byID {
if in.Service == service && now.Sub(in.LastBeat) < ttl {
addrs = append(addrs, in.Addr)
}
}
sort.Strings(addrs)
return addrs
}
// reap 定期清掉過期很久的紀錄,避免 map 只增不減。
func (r *registry) reap(now time.Time) {
r.mu.Lock()
defer r.mu.Unlock()
for id, in := range r.byID {
if now.Sub(in.LastBeat) > 3*ttl {
delete(r.byID, id)
}
}
}
type beatReq struct {
Service string `json:"service"`
Addr string `json:"addr"`
}
func main() {
reg := ®istry{byID: map[string]*instance{}}
go func() {
for now := range time.Tick(ttl) {
reg.reap(now)
}
}()
mux := http.NewServeMux()
// 註冊與心跳是同一個動作:PUT 一次就續約一次
mux.HandleFunc("PUT /instances", func(w http.ResponseWriter, r *http.Request) {
var req beatReq
if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 1<<10)).Decode(&req); err != nil ||
req.Service == "" || req.Addr == "" {
http.Error(w, "service and addr are required", http.StatusBadRequest)
return
}
reg.beat(req.Service, req.Addr, time.Now())
w.WriteHeader(http.StatusNoContent)
})
// 優雅關閉時主動下線,不必等 TTL 過期
mux.HandleFunc("DELETE /instances/{service}/{addr}", func(w http.ResponseWriter, r *http.Request) {
reg.deregister(r.PathValue("service"), r.PathValue("addr"))
w.WriteHeader(http.StatusNoContent)
})
mux.HandleFunc("GET /services/{service}", func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(reg.healthy(r.PathValue("service"), time.Now()))
})
log.Println("registry listening on :8500")
log.Fatal(http.ListenAndServe(":8500", mux))
}幾個設計重點:
- 健康是「推斷」出來的:註冊中心並不知道實例真的能不能處理請求,只知道它有沒有按時送心跳。所以心跳應該由實例裡真正代表健康的邏輯送出,例如確認資料庫連線池可用時才送,而不是開一個獨立的 goroutine 無條件地送。
- TTL 的取捨:TTL 太短,網路稍微抖動就會誤判下線;太長,實例掛了很久呼叫端才知道。常見的設定是心跳間隔為 TTL 的三分之一左右,允許偶爾漏掉一兩次。
- 讀寫分開上鎖:查詢遠比心跳頻繁,所以用
sync.RWMutex,這是〈Goroutine、Channel 與並發模式〉提過的技巧。 - 清理過期紀錄:
reap定期刪除很久沒心跳的紀錄,避免 map 只增不減。
實例這一端要做的事,是在啟動完成後開始定期 PUT,並在〈設定與優雅關閉〉的關閉流程中,先 DELETE 自己、等一小段時間讓呼叫端更新名單,再停止接受新請求。順序反過來的話,呼叫端會在名單更新前把請求送到一個已經關閉的實例。
提示:這個註冊中心本身是單點,而且資料只在記憶體裡。正式的註冊中心會用 Raft 等共識演算法在多個節點間複製資料。理解原理之後,正式環境請使用成熟的產品,或直接使用平台內建的機制(第 6 步)。
第 3 步:主動健康檢查與被動健康檢查
心跳是一種「實例自己回報」的健康訊號。另一種方式是由外部主動檢查,兩者常常一起使用:
| 方式 | 誰執行 | 怎麼做 | 優點 | 缺點 |
|---|---|---|---|---|
| 心跳/TTL | 實例自己 | 定期向註冊中心續約 | 註冊中心負擔小 | 實例「活著」不代表「能服務」 |
| 主動檢查 | 註冊中心或負載平衡器 | 定期打 /healthz 或 gRPC Health 服務 | 從外部看到的真實狀態 | 檢查流量隨實例數增加 |
| 被動檢查 | 呼叫端 | 觀察真實請求的錯誤率,連續失敗就暫時剔除 | 反應最快、不需額外流量 | 需要先有失敗的請求 |
在 Kubernetes 裡,主動檢查由 kubelet 透過探針完成,而且分成兩種意義不同的探針:
- 存活探針(liveness):失敗代表行程卡死了,需要重新啟動。檢查內容要非常輕量,不要依賴外部資源,否則資料庫一抖動,所有實例都被重啟。
- 就緒探針(readiness):失敗代表暫時不要送流量給我,例如還在暖機、或依賴的資料庫暫時連不上。實例會從 Service 的端點清單移除,但不會被重啟。
被動檢查則和〈逾時、重試與熔斷〉的熔斷器是同一個概念:連續失敗的實例暫時從名單中剔除,過一段時間再放少量請求試探。
第 4 步:三種負載平衡演算法
有了健康實例的名單,接下來要挑一台。下面這個程式實作三種最常用的演算法,可以直接執行觀察結果:
// 三種負載平衡演算法:輪詢、最少連線、一致性雜湊(含虛擬節點)。
package main
import (
"fmt"
"hash/crc32"
"slices"
"strconv"
"sync"
"sync/atomic"
)
// ---------- 輪詢 ----------
type RoundRobin struct {
addrs []string
next atomic.Uint64
}
func (rr *RoundRobin) Pick() string {
n := rr.next.Add(1) - 1
return rr.addrs[n%uint64(len(rr.addrs))]
}
// ---------- 最少連線 ----------
type LeastConn struct {
mu sync.Mutex
active map[string]int
}
// Acquire 挑目前進行中請求最少的實例;用完務必呼叫回傳的 release。
func (lc *LeastConn) Acquire() (addr string, release func()) {
lc.mu.Lock()
defer lc.mu.Unlock()
best := -1
for a, n := range lc.active {
// 平手時依名稱決定,讓結果可預期
if best == -1 || n < best || (n == best && a < addr) {
addr, best = a, n
}
}
lc.active[addr]++
return addr, func() {
lc.mu.Lock()
lc.active[addr]--
lc.mu.Unlock()
}
}
// ---------- 一致性雜湊 ----------
type Ring struct {
replicas int // 每個實例放幾個虛擬節點
hashes []uint32 // 排序過的環上位置
owner map[uint32]string // 位置 → 實例
}
func NewRing(replicas int, addrs ...string) *Ring {
r := &Ring{replicas: replicas, owner: map[uint32]string{}}
for _, a := range addrs {
r.Add(a)
}
return r
}
func (r *Ring) Add(addr string) {
for i := range r.replicas {
h := crc32.ChecksumIEEE([]byte(addr + "#" + strconv.Itoa(i)))
r.hashes = append(r.hashes, h)
r.owner[h] = addr
}
slices.Sort(r.hashes)
}
// Get 從 key 的位置順時針找第一個虛擬節點。
func (r *Ring) Get(key string) string {
h := crc32.ChecksumIEEE([]byte(key))
i, _ := slices.BinarySearch(r.hashes, h)
if i == len(r.hashes) {
i = 0 // 繞回環的起點
}
return r.owner[r.hashes[i]]
}
func main() {
addrs := []string{"inventory-a:9003", "inventory-b:9003", "inventory-c:9003"}
rr := &RoundRobin{addrs: addrs}
for range 4 {
fmt.Print(rr.Pick(), " ")
}
fmt.Println()
lc := &LeastConn{active: map[string]int{}}
for _, a := range addrs {
lc.active[a] = 0
}
a1, done1 := lc.Acquire()
a2, _ := lc.Acquire()
done1() // 第一個請求結束了
a3, _ := lc.Acquire()
fmt.Println("least-conn:", a1, a2, a3)
// 一致性雜湊:加入第四個實例後,只有一部分 key 換主人
ring := NewRing(100, addrs...)
before := map[string]string{}
for i := range 10000 {
k := "SKU-" + strconv.Itoa(i)
before[k] = ring.Get(k)
}
ring.Add("inventory-d:9003")
moved := 0
for k, old := range before {
if ring.Get(k) != old {
moved++
}
}
fmt.Printf("consistent hash: %.1f%% of keys moved\n", float64(moved)/100)
}執行後會看到類似這樣的輸出(一致性雜湊的百分比會隨雜湊函式與虛擬節點數略有不同,數字僅供示意):
inventory-a:9003 inventory-b:9003 inventory-c:9003 inventory-a:9003
least-conn: inventory-a:9003 inventory-b:9003 inventory-a:9003
consistent hash: 22.0% of keys moved輪詢(round-robin):依序輪流,用 atomic.Uint64 遞增計數器,不需要鎖。當每個請求的成本差不多、每台實例的規格也相同時,輪詢簡單又有效。它的變形「加權輪詢」讓規格較大的實例分到較多請求。
最少連線(least connections):挑目前進行中請求最少的實例。當請求的處理時間差異很大時(例如有的查詢 5 毫秒、有的 2 秒),輪詢會讓某台實例剛好累積一堆慢請求,最少連線則會自動避開忙碌的實例。實作上要注意:每次挑選都要搭配一個 release,請求結束時一定要呼叫(通常用 defer),否則計數只增不減。當實例很多時,掃過整份名單的成本也會上升,常見的折衷是「隨機挑兩台,選比較閒的那台」(power of two choices),效果接近最少連線,成本卻低得多。
一致性雜湊(consistent hashing):同一個 key 總是落在同一台實例上,適合需要「親和性」的情境,例如每台實例在本地快取某些 SKU 的庫存資料,希望同一個 SKU 的請求都送到同一台,以提高快取命中率。
| 演算法 | 適合的情境 | 需要注意 |
|---|---|---|
| 輪詢 | 請求成本相近、實例同規格 | 慢請求可能集中在某台 |
| 加權輪詢 | 實例規格不同 | 權重要隨規格調整 |
| 最少連線 | 請求處理時間差異大 | 需要追蹤進行中的請求數 |
| 隨機選二 | 實例多、想要低成本近似最少連線 | 需要負載資訊 |
| 一致性雜湊 | 本地快取、有狀態的分片 | 熱門 key 會讓單台過載 |
第 5 步:一致性雜湊為什麼能減少搬動
如果用最直覺的 hash(key) % N 來分配,實例數從 3 變成 4 時,幾乎所有 key 的落點都會改變,等於所有快取一起失效,後端資料庫瞬間承受全部流量。一致性雜湊就是為了解決這個問題。
做法是把雜湊值的範圍想像成一個環:每個實例依自己名稱的雜湊值放在環上某個位置;每個 key 也算出一個位置,然後順時針找到的第一個實例,就是它的主人。
圖:key 從自己在環上的位置順時針找第一個節點;加入新節點 D 時,只有落在 C 與 D 之間的 key 會改由 D 負責,其他 key 不動。
加入一個新實例時,它只會「接手」環上相鄰的一段,其他 key 完全不受影響。理想情況下,從 N 台增加到 N+1 台,只有大約 1/(N+1) 的 key 需要搬動;範例從 3 台加到 4 台,理論值是 25%,實際執行結果也在這附近。
範例裡的 replicas 是虛擬節點數。如果每個實例只在環上放一個點,點的分布很可能不均勻,某台實例會負責特別大的一段。讓每個實例在環上放幾十到上百個虛擬節點,分布就會平均得多;實例下線時,它負責的範圍也會分散給多台實例,而不是全部壓到下一個鄰居身上。
一致性雜湊要注意熱門 key:如果某個 SKU 正在大促銷,它的所有請求都會落在同一台實例上。常見的處理方式是對熱門 key 額外分散,或改用「有界負載的一致性雜湊」,讓超過平均負載一定比例的實例把請求讓給下一個節點。
第 6 步:Kubernetes 的服務發現:Service 與 DNS
如果服務跑在 Kubernetes 上,前面的大部分工作平台都已經做好了:
- Pod 會被調度、重啟、換 IP,你不應該直接記住 Pod 的 IP。
- Service 依標籤選取一組 Pod,提供一個穩定的虛擬 IP(ClusterIP)與 DNS 名稱。只有就緒探針通過的 Pod 才會出現在 Service 的端點(EndpointSlice)裡,這就是內建的註冊中心加健康檢查。
- 叢集 DNS(通常是 CoreDNS)讓你用名稱找到 Service。同一個命名空間裡,直接用
inventory就能解析;完整名稱是inventory.shop.svc.cluster.local。 - kube-proxy(或替代的網路外掛)在每個節點上把送往 ClusterIP 的連線分配到後面的 Pod,這是一種 L4 的伺服器端負載平衡。
# 一般的 Service:一個穩定的虛擬 IP,由 kube-proxy 在連線層分配
apiVersion: v1
kind: Service
metadata:
name: inventory
namespace: shop
spec:
selector:
app: inventory
ports:
- name: grpc
port: 9003
targetPort: 9003
---
# Headless Service:不配虛擬 IP,DNS 直接回傳每個就緒 Pod 的 IP
apiVersion: v1
kind: Service
metadata:
name: inventory-headless
namespace: shop
spec:
clusterIP: None
selector:
app: inventory
ports:
- name: grpc
port: 9003
targetPort: 9003對一般的 HTTP/1.1 服務,普通的 Service 就夠了。這也是為什麼在 Kubernetes 上,上一篇 Gateway 的路由表可以直接寫成 http://order:8080:名稱由 DNS 解析,負載平衡由 Service 處理。完整的部署設定會在〈Docker 與 Kubernetes 部署(單一服務)〉與〈在 Kubernetes 部署整套微服務〉中示範。
第 7 步:gRPC 的長連線問題與用戶端負載平衡
普通的 Service 有一個常被忽略的陷阱:它平衡的是「連線」,不是「請求」。gRPC 建立在 HTTP/2 上,一條連線可以同時跑大量請求,而且會長時間保持。結果是:order 的每個實例只和 inventory 的其中一個 Pod 建立連線,之後所有請求都送給它;inventory 擴充到 10 個 Pod,新增的 9 個可能幾乎沒有流量。
解法是讓 gRPC 用戶端自己做負載平衡:透過 headless Service 拿到所有 Pod 的 IP,對每個 IP 各建一條連線,再以輪詢分配請求。grpc-go 內建這個能力,只需要在建立連線時指定 DNS 解析與 round_robin 策略:
// 片段:gRPC 用戶端負載平衡(DNS 解析出多個 IP,輪詢分配,並做健康檢查)
package main
import (
"log"
"google.golang.org/grpc"
"google.golang.org/grpc/credentials/insecure"
_ "google.golang.org/grpc/health" // 啟用用戶端健康檢查
inventoryv1 "example.com/shop/api/proto/inventory/v1"
)
const serviceConfig = `{
"loadBalancingConfig": [{"round_robin": {}}],
"healthCheckConfig": {"serviceName": ""}
}`
func main() {
// headless Service 讓 DNS 回傳每個 Pod 的 IP,round_robin 會對每個 IP 各建一條連線
conn, err := grpc.NewClient(
"dns:///inventory-headless.shop.svc.cluster.local:9003",
grpc.WithTransportCredentials(insecure.NewCredentials()),
grpc.WithDefaultServiceConfig(serviceConfig),
)
if err != nil {
log.Fatal(err)
}
defer conn.Close()
inventory := inventoryv1.NewInventoryServiceClient(conn)
_ = inventory // 交給 order 的 service 使用
}說明:
dns:///目標:grpc-go 會用 DNS 解析名稱,並在連線出問題時重新解析。headless Service 讓 DNS 回傳每一個就緒 Pod 的 IP。round_robin:grpc-go 預設的策略是pick_first,只連第一個位址;改成round_robin才會對每個位址建立子連線並輪流使用。- 健康檢查:設定
healthCheckConfig並匯入google.golang.org/grpc/health後,用戶端會透過標準的 gRPC Health 服務檢查每個後端,不健康的會暫時不分配請求(伺服器端也要註冊 Health 服務)。 - DNS 的更新速度:DNS 不會主動推送變更,新 Pod 加入時,用戶端要等到重新解析才會知道。伺服器端可以設定連線的最長存活時間(
keepalive.ServerParameters的MaxConnectionAge),讓用戶端定期重連並重新解析,新實例才能逐步分到流量。
如果不想在每個服務裡處理這些細節,服務網格(例如 Istio、Linkerd)會在 sidecar 或節點代理裡做 L7 的請求級負載平衡,應用程式只需要連到一般的 Service 名稱。這是用基礎設施的複雜度換取應用程式的簡單,適合服務數量已經不少的團隊。
常見陷阱
- 把實例位址寫死在設定裡:實例一擴充或重新部署就失效。用服務名稱,交給服務發現解析。
- 存活探針檢查外部依賴:資料庫一抖動,所有實例都因存活探針失敗被重啟,讓事情變得更糟。外部依賴只放在就緒探針。
- 關閉順序錯誤:先停止服務、再註銷,呼叫端會在名單更新前把請求送到已關閉的實例。要先註銷(或讓就緒探針失敗)、等待、再關閉。
- gRPC 走一般的 Service 卻以為有負載平衡:HTTP/2 長連線讓請求集中在少數 Pod。改用 headless Service 加
round_robin,或使用服務網格。 - 用
hash % N分配有狀態的請求:實例數一變動,幾乎所有 key 都會重新分配,快取全部失效。用一致性雜湊。 - 一致性雜湊沒有虛擬節點:分布不均,少數實例承擔大部分 key。
- 最少連線忘了釋放計數:請求出錯或 panic 時沒有遞減,那台實例就永遠看起來很忙。用
defer釋放。 - 註冊中心沒有高可用:它掛掉時,新的呼叫端就找不到任何服務。用成熟產品的叢集模式,呼叫端也要保留最後一份已知的名單作為備援。
- TTL 設得太短或太長:太短會因網路抖動誤判,太長會讓故障實例繼續收到流量。依心跳間隔與可接受的偵測時間來設定。
重點整理
- 服務發現回答「有哪些健康實例」,負載平衡回答「這次送給哪一個」。
- 伺服器端負載平衡讓呼叫端最簡單;用戶端負載平衡少一跳,並能處理長連線與依內容路由。服務網格介於兩者之間。
- 註冊中心的核心是註冊、心跳、TTL 與註銷;健康是推斷出來的,心跳應反映真實的服務能力。
- 健康檢查分為心跳、主動與被動三種;Kubernetes 的存活探針與就緒探針用途不同,不要混用。
- 輪詢適合成本相近的請求,最少連線適合處理時間差異大的請求,一致性雜湊適合需要親和性的情境,搭配虛擬節點才能分布均勻。
- 在 Kubernetes 上,Service 與叢集 DNS 已經內建服務發現與 L4 負載平衡;gRPC 要用 headless Service 加
round_robin才能平衡到每個 Pod。
下一篇
現在呼叫端能找到健康的實例,也能把請求分散出去了,但只要是網路呼叫,就一定會遇到慢、失敗與暫時無法使用。下一篇〈逾時、重試與熔斷〉會說明怎麼設定合理的逾時、什麼時候該重試、以及怎麼用熔斷避免一個故障的服務拖垮整個系統。