This resume is also available in English.

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

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

服務發現與負載平衡

Service Discovery and Load Balancing for Go Microservices

服務有多個實例、IP 隨時會變,呼叫端要怎麼找到健康的那幾台?這篇比較用戶端與伺服器端負載平衡,用 Go 寫出帶心跳的註冊中心與輪詢、最少連線、一致性雜湊三種演算法,並說明 Kubernetes 的 DNS 做法。

  • Go
  • Microservices
  • Load Balancing
  • Kubernetes
這篇的步驟
  1. 這篇要解決什麼
  2. 第 1 步:用戶端還是伺服器端負載平衡
  3. 第 2 步:註冊中心與心跳
  4. 第 3 步:主動健康檢查與被動健康檢查
  5. 第 4 步:三種負載平衡演算法
  6. 第 5 步:一致性雜湊為什麼能減少搬動
  7. 第 6 步:Kubernetes 的服務發現:Service 與 DNS
  8. 第 7 步:gRPC 的長連線問題與用戶端負載平衡
  9. 常見陷阱
  10. 重點整理
  11. 下一篇

上一篇〈API Gateway:路由、認證、限流〉把所有外部流量集中到 api-gateway,但它的路由表把 order、payment、inventory 的位址寫死在程式裡。這篇接著解決這個問題:當每個服務都跑了好幾個實例、實例會擴充、縮減、重新部署,呼叫端要怎麼隨時知道「現在有哪些健康的實例」,又要怎麼把請求平均地分給它們?

這篇要解決什麼

在單體時代,呼叫另一個模組只是一次函式呼叫,不存在「找不到對方」的問題。拆成服務之後,order 要呼叫 inventory,必須先回答兩個問題:

  1. 服務發現(service discovery):inventory 現在有哪些實例?位址是什麼?哪些是健康的?
  2. 負載平衡(load balancing):這次請求要送給其中哪一個?

這兩件事緊密相關,但值得分開思考。服務發現提供一份「候選名單」,負載平衡從名單裡挑一個。名單的來源可能是註冊中心、DNS 或平台的 API;挑選的方式可能是輪詢、最少連線或一致性雜湊;挑選的位置可能在呼叫端,也可能在中間的一台負載平衡器。

這篇會依序:

  • 比較用戶端負載平衡與伺服器端負載平衡。
  • 用 Go 寫一個帶心跳與 TTL 的最小註冊中心,理解健康檢查的本質。
  • 實作三種常用的負載平衡演算法,並觀察一致性雜湊在擴充時的效果。
  • 看 Kubernetes 怎麼用 Service 與 DNS 把這些事情內建好,以及 gRPC 在其中要注意什麼。

第 1 步:用戶端還是伺服器端負載平衡

負載平衡的決策放在哪裡,有兩種基本架構:

用戶端負載平衡 伺服器端負載平衡 訂單服務 內建挑選邏輯 註冊中心 庫存 A 庫存 B 庫存 C 直接連到實例,少一跳 訂單服務 負載平衡器 L4/L7 庫存 A 庫存 B 庫存 C 用戶端很簡單,但多一跳

圖:左邊由呼叫端向註冊中心取得實例清單、自己挑一台直接連線;右邊呼叫端只認得一個位址,由中間的負載平衡器挑選後端。

面向用戶端負載平衡伺服器端負載平衡
誰挑實例呼叫端的函式庫中間的負載平衡器(L4 或 L7)
網路路徑直接連到實例,少一跳多經過一台負載平衡器
呼叫端複雜度高:要整合服務發現、健康狀態、演算法低:只需要一個固定位址
多語言支援每種語言都要有對應的函式庫與語言無關
單點故障沒有中心節點(註冊中心除外)負載平衡器本身要做高可用
對長連線的效果好:可以對每個實例各開連線L4 只能平衡「連線」,無法平衡連線裡的請求
典型例子gRPC 內建的負載平衡、服務網格的 sidecar雲端負載平衡器、NGINX、Kubernetes Service

兩者之間還有一種常見的折衷:服務網格(service mesh)。它在每個服務旁邊放一個 sidecar 代理,對應用程式來說像是伺服器端負載平衡(只要連到本機的代理),實際上卻是在每個節點上做用戶端負載平衡。

選擇的原則可以很簡單:沒有特殊需求時,用平台提供的伺服器端負載平衡(例如 Kubernetes Service),最省事;當你使用 gRPC 這類長連線協定、或需要依請求內容做路由(例如一致性雜湊)時,才考慮用戶端負載平衡。

第 2 步:註冊中心與心跳

不管哪一種架構,總要有人維護「目前有哪些健康實例」這份名單。最直接的做法是一個註冊中心(registry),常見的產品有 Consul、etcd、ZooKeeper、Nacos 等。它們的核心機制其實很單純:

  1. 實例啟動後,向註冊中心登記自己的服務名稱與位址。
  2. 實例定期送出心跳,代表「我還活著」。
  3. 註冊中心如果在 TTL(存活時間)內沒收到某個實例的心跳,就把它視為不健康,不再出現在查詢結果裡。
  4. 實例優雅關閉時主動註銷,不必等 TTL 過期。
  5. 呼叫端查詢某個服務的健康實例清單,通常會在本地快取一段時間,或訂閱變更通知。
註冊中心 TTL 內有心跳才算健康 庫存 A 庫存 B 庫存 C 心跳中斷 → 下線 ① 註冊/心跳 訂單服務 ② 查詢清單 ③ 直接呼叫健康實例

圖:實例向註冊中心註冊並持續送心跳;心跳中斷的實例會被下線。呼叫端查詢健康清單後,直接呼叫實例。

下面用標準函式庫寫一個最小的註冊中心。為了簡單,註冊與心跳是同一個動作: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 := &registry{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 也算出一個位置,然後順時針找到的第一個實例,就是它的主人。

庫存 A 庫存 B 庫存 C 庫存 D(新) SKU-1 SKU-7 SKU-9 SKU-1 → 庫存 B SKU-7 → 庫存 C SKU-9 → 庫存 D (加 D 前屬於 A) 加入 D 只搬走 C 到 D 之間的 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。

下一篇

現在呼叫端能找到健康的實例,也能把請求分散出去了,但只要是網路呼叫,就一定會遇到慢、失敗與暫時無法使用。下一篇〈逾時、重試與熔斷〉會說明怎麼設定合理的逾時、什麼時候該重試、以及怎麼用熔斷避免一個故障的服務拖垮整個系統。