逾時、重試與熔斷
Timeouts, Retries and Circuit Breakers
下游一定會變慢或失敗。這篇從期限預算談起,一步步實作指數退避加 jitter 的重試、只重試該重試的錯誤、重試預算,再用 Go 寫出三態熔斷器與艙壁隔離,讓訂單服務在下游出事時不被拖垮。
這篇的步驟
上一篇〈服務發現與負載平衡〉我們讓訂單服務找得到庫存與付款服務的每一個實例,並把請求平均分過去;這篇接著處理「找到了,但它很慢、或回錯誤」的時候該怎麼辦。
這篇要解決什麼
在 example.com/shop 裡,下單的流程是:api-gateway 把請求轉給 order,order 先呼叫 inventory 保留庫存,再呼叫 payment 扣款,最後把訂單狀態從 pending 改成 paid。單體時代這些都是函式呼叫,失敗了就是一個 error;拆成服務之後,每一次呼叫都多了網路、序列化、對方的連線池與垃圾回收,任何一環都可能讓呼叫變慢、卡住或失敗。
最危險的不是「失敗」,而是「慢」。一個直接回 503 的下游,呼叫端很快就知道結果;一個卡住三十秒才回的下游,會讓呼叫端的 goroutine、連線池、記憶體一起被佔住,請求越堆越多,最後整條鏈一起倒下,這就是所謂的連鎖失敗(cascading failure)。這篇要用四個工具把這件事擋下來:
| 工具 | 解決的問題 | 一句話 |
|---|---|---|
| 逾時(期限) | 卡住不回 | 每個呼叫都要有上限,而且整條鏈共用一個截止時間 |
| 重試 | 暫時性失敗 | 只重試可能會成功的錯誤,並且退避、加隨機 |
| 熔斷 | 下游持續失敗 | 失敗太多就先不要打,給對方喘息,也讓自己快速失敗 |
| 艙壁 | 一個下游拖垮全部 | 不同下游各用各的資源池,互不搶用 |
這四個工具彼此相關:沒有逾時,重試永遠等不到「失敗」;沒有熔斷,重試會把已經生病的下游打得更慘;沒有艙壁,一個慢的付款服務會吃光呼叫庫存服務需要的資源。接下來一步一步把它們疊上去。
第 1 步:每個呼叫都要有期限
第一條規則很簡單:任何跨網路的呼叫都不能沒有上限。Go 的 http.Client 預設 Timeout 是零,代表永遠等;net.Dial 沒設定也可能等到作業系統層級的逾時,通常是好幾十秒甚至更久。實務上至少要在兩個地方設上限:
- 用戶端整體:
http.Client{Timeout: ...}或 gRPC 的呼叫期限,防止任何一個請求無限期地掛著。 - 每個請求:用
context.WithTimeout或context.WithDeadline包住,讓上游的取消可以一路傳下來。
〈context:取消、逾時與資料傳遞〉已經介紹過 context 的基本用法,這裡要強調的是微服務特有的問題:逾時應該是「期限預算」,而不是每一跳各自的數字。
假設 api-gateway 對外承諾兩秒內回應。如果 order 呼叫 inventory 時自己又給一個兩秒的逾時,inventory 再呼叫資料庫時又給兩秒,那麼最壞的情況下,使用者早就在閘道收到逾時錯誤、甚至已經按了重新整理,後面的服務還在認真地做一件沒有人在等的事。這些「孤兒工作」佔用資源、還可能產生副作用(例如庫存已經保留了,但訂單已經被當成失敗)。
正確的做法是在入口設定一個截止時間,然後把同一個截止時間往下傳。gRPC 會自動把 context 的期限放進 grpc-timeout 標頭傳給下游;HTTP 沒有標準標頭,常見的做法是自訂一個標頭(例如帶剩餘毫秒數),在對方的中介層裡還原成 context.WithTimeout。用剩餘時間而不是絕對時間,可以避開兩台機器時鐘不同步的問題。
圖:閘道設定兩秒的截止時間,訂單服務收到時只剩約 1.9 秒,保留庫存與扣款各自用掉一部分,最後剩下的才是確認訂單能用的時間(數字僅為示意)。
有了期限預算,每個服務都能做兩件聰明的事。第一,收到請求時先看剩多少時間,如果剩下的比自己最快的處理時間還少,直接回錯誤,不要開始做。第二,呼叫下游時可以再取更短的期限,例如「剩餘時間與 800ms 取小者」,這樣即使上游給了很寬的期限,單一下游也不會把預算全部吃掉,留一點給後面的步驟。
提示:期限只能變短不能變長。
context.WithTimeout(parent, d)產生的子 context,截止時間是「父的截止時間」與「現在加 d」兩者較早的那個,所以在下游呼叫時放心地取更短的期限,不會意外延長上游的承諾。
逾時的數字要怎麼定?一個常見的起點是參考下游的延遲分布:把逾時設在 p99 延遲的幾倍附近,而不是平均值的幾倍。設太短,下游只是偶爾慢一點就被當成失敗,失敗率上升,重試又把負載加大;設太長,就失去保護的意義。數字沒有標準答案,重點是要有依據,並且在〈可觀測性:日誌、指標、追蹤〉會談到的指標上持續觀察。
第 2 步:分辨哪些錯誤值得重試
有了期限,呼叫終於會「失敗」了,下一個問題是:失敗了要不要再試一次?很多人的第一個反應是全部重試三次,這通常是錯的。重試只有在兩個條件都成立時才有意義:
- 錯誤是暫時性的:再試一次有合理機會成功。
- 操作是冪等的:就算第一次其實成功了只是回應丟失,再做一次也不會造成重複的副作用。
第一個條件要靠錯誤分類。以 HTTP 與 gRPC 為例,大致可以這樣分:
| 類別 | HTTP | gRPC | 要不要重試 |
|---|---|---|---|
| 下游暫時不可用 | 503、連線被拒 | Unavailable | 要,退避後重試 |
| 被限流 | 429 | ResourceExhausted | 要,但遵守 Retry-After |
| 單次嘗試逾時 | 用戶端逾時 | DeadlineExceeded | 視冪等性與剩餘預算 |
| 參數錯誤 | 400、422 | InvalidArgument | 不要,結果永遠一樣 |
| 權限或認證 | 401、403 | PermissionDenied | 不要 |
| 業務結果 | 409、卡片被拒 | FailedPrecondition | 不要,這不是故障 |
第二個條件更容易被忽略。GET /orders/{id} 是天生冪等的,重試無害;但 POST /payments 如果第一次請求其實已經扣款成功,只是回應在網路上丟了,重試就會扣兩次錢。這種「不知道對方到底做了沒有」的情況在分散式系統裡是常態,不是例外。所以對有副作用的呼叫,要嘛不重試,要嘛先讓它變成冪等(帶冪等鍵),這正是下一篇〈冪等與分散式鎖〉的主題。
在 Go 裡,錯誤分類最好在用戶端轉接層(例如 internal/payment 的 client)就做好,用〈錯誤處理:包裝、哨兵、自訂型別〉介紹的哨兵錯誤或自訂型別表達,讓上層用 errors.Is 判斷,而不是到處比對狀態碼字串。
第 3 步:指數退避加上 jitter
決定要重試之後,下一個問題是「隔多久再試」。立刻重試幾乎沒有用:下游如果是因為過載而失敗,立刻重試只會讓它更過載。標準做法是指數退避(exponential backoff):第一次等 base,第二次等 2×base,第三次 4×base,並設一個上限,避免等待時間無限增長。
但只有指數退避還不夠。想像付款服務短暫故障一秒,在這一秒內有一千個請求失敗,它們全部在 100ms 後重試、300ms 後再重試……結果是每一波重試都在同一個瞬間湧進來,形成「驚群」,下游剛恢復又被打倒。解法是加上隨機抖動(jitter),讓每個用戶端的等待時間不一樣。
圖:上方是固定指數退避,所有用戶端在同一刻重試;下方加上 full jitter,重試被攤平在整段時間裡,下游看到的是平滑的負載。
常見的 jitter 策略有幾種。Full jitter 是在 [0, min(上限, base×2ⁿ)) 之間取均勻隨機值,分散效果最好,也最簡單;equal jitter 是取一半固定、一半隨機,保證至少等一段時間;decorrelated jitter 則讓下一次的等待依賴上一次的隨機結果。對大多數服務來說,full jitter 已經足夠好。
下面這個程式把前三步組在一起:每次嘗試有自己的逾時、整體有期限預算、只重試暫時性錯誤、等待時間用 full jitter,而且在預算不夠再試一次時就提早放棄。
package main
import (
"context"
"errors"
"fmt"
"math/rand/v2"
"time"
)
// 暫時性錯誤:重試可能會成功
var ErrUnavailable = errors.New("inventory: unavailable")
// 永久性錯誤:重試幾次結果都一樣
var ErrInvalid = errors.New("inventory: invalid sku")
type RetryPolicy struct {
MaxAttempts int // 含第一次,總共最多幾次
Base time.Duration // 第一次退避的上限
Max time.Duration // 退避上限的天花板
PerTry time.Duration // 每一次嘗試自己的逾時
}
func retryable(err error) bool {
// 單次嘗試逾時(不是整體期限到了)也視為可重試
return errors.Is(err, ErrUnavailable) || errors.Is(err, context.DeadlineExceeded)
}
// fullJitter 回傳 [0, min(Max, Base*2^attempt)) 之間的隨機等待時間
func fullJitter(p RetryPolicy, attempt int) time.Duration {
ceil := p.Base << attempt
if ceil <= 0 || ceil > p.Max {
ceil = p.Max
}
return rand.N(ceil)
}
func Do(ctx context.Context, p RetryPolicy, op func(context.Context) error) error {
var err error
for attempt := 0; attempt < p.MaxAttempts; attempt++ {
tryCtx, cancel := context.WithTimeout(ctx, p.PerTry)
err = op(tryCtx)
cancel()
if err == nil {
return nil
}
if ctx.Err() != nil {
return fmt.Errorf("整體期限已到,放棄: %w", err)
}
if !retryable(err) || attempt == p.MaxAttempts-1 {
return err
}
wait := fullJitter(p, attempt)
// 剩下的預算連「等待+再試一次」都不夠,就不要浪費
if dl, ok := ctx.Deadline(); ok && time.Until(dl) < wait+p.PerTry/2 {
return fmt.Errorf("預算不足以再試一次: %w", err)
}
fmt.Printf(" 第 %d 次失敗(%v),等 %v 後重試\n", attempt+1, err, wait.Round(time.Millisecond))
t := time.NewTimer(wait)
select {
case <-ctx.Done():
t.Stop()
return fmt.Errorf("等待重試時期限已到: %w", err)
case <-t.C:
}
}
return err
}
func main() {
p := RetryPolicy{MaxAttempts: 4, Base: 20 * time.Millisecond, Max: 200 * time.Millisecond, PerTry: 80 * time.Millisecond}
// 情境一:庫存服務前兩次暫時不可用,第三次成功
calls := 0
reserve := func(ctx context.Context) error {
calls++
if calls <= 2 {
return ErrUnavailable
}
return nil
}
ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
err := Do(ctx, p, reserve)
cancel()
fmt.Printf("情境一:呼叫 %d 次,結果 err=%v\n", calls, err)
// 情境二:參數錯誤,不應該重試
calls = 0
bad := func(ctx context.Context) error { calls++; return ErrInvalid }
ctx, cancel = context.WithTimeout(context.Background(), 500*time.Millisecond)
err = Do(ctx, p, bad)
cancel()
fmt.Printf("情境二:呼叫 %d 次,結果 err=%v\n", calls, err)
// 情境三:每次都卡住到單次逾時,整體預算很快用完
calls = 0
slow := func(ctx context.Context) error {
calls++
<-ctx.Done()
return ctx.Err()
}
ctx, cancel = context.WithTimeout(context.Background(), 200*time.Millisecond)
err = Do(ctx, p, slow)
cancel()
fmt.Printf("情境三:呼叫 %d 次,結果 err=%v\n", calls, err)
}執行後可以看到三種情境的差別(隨機等待時間每次不同):
第 1 次失敗(inventory: unavailable),等 1ms 後重試
第 2 次失敗(inventory: unavailable),等 21ms 後重試
情境一:呼叫 3 次,結果 err=<nil>
情境二:呼叫 1 次,結果 err=inventory: invalid sku
第 1 次失敗(context deadline exceeded),等 15ms 後重試
情境三:呼叫 2 次,結果 err=預算不足以再試一次: context deadline exceeded這段程式有幾個值得注意的細節。第一,ctx.Err() != nil 的檢查放在分類之前:如果是整體期限到了,不管錯誤長什麼樣子都不能再試。第二,context.DeadlineExceeded 被當成可重試,是因為它指的是「單次嘗試」的子 context 逾時,父 context 還有時間;這只適合冪等的操作。第三,等待用 select 同時監聽 ctx.Done(),上游取消時不會傻傻地睡完。第四,math/rand/v2 的 rand.N 可以直接對 time.Duration 取隨機值,而且全域來源是自動播種的,不需要自己處理種子。
第 4 步:重試預算,避免重試放大
即使每個呼叫都正確地退避,重試還有一個整體層面的問題:放大效應。假設呼叫鏈有三層,每層都重試三次,最下層在故障時會收到 3×3×3 = 27 倍的請求。下游明明已經不行了,重試卻讓它承受數十倍的負載,這是很多大型事故的共同模式。
處理放大效應有三個互補的原則:
- 只在一層重試。通常選最靠近使用者的那一層,或最了解冪等性的那一層。其他層遇到失敗就把錯誤往上傳,不要自己再加一輪。
- 限制重試次數。總嘗試次數兩到三次就夠了,再多通常只是在拖延失敗。
- 使用重試預算(retry budget)。不只限制單一請求的重試次數,而是限制「重試佔總請求的比例」。例如規定重試請求不得超過正常請求的一成:平常偶爾失敗,重試幾乎都被允許;下游大規模故障時,重試配額很快用完,多出來的失敗直接回給上游,不會再加重負擔。
重試預算的實作可以很簡單:用一個 token bucket,每個成功的正常請求放進 0.1 個 token,每次重試要花掉 1 個 token,桶子空了就不重試。gRPC 的 retry policy 也有類似的 retryThrottling 設定(以 token 數與比例描述),用 gRPC 時優先使用框架提供的機制,不要自己再包一層重試。
提示:被限流(429 或
ResourceExhausted)時,如果對方有回Retry-After,就照它說的時間等;這是下游明確告訴你它什麼時候有空,比任何退避公式都準。
第 5 步:熔斷器的三種狀態
重試處理的是「偶爾失敗」,但如果付款服務整個掛了五分鐘呢?這五分鐘內,每個下單請求都會乖乖地等逾時、重試、再等逾時,使用者等了好幾秒才收到失敗,訂單服務的 goroutine 與連線全部卡在等待上。更糟的是,下游恢復的那一刻,累積的請求一擁而上,可能又把它打倒。
熔斷器(circuit breaker)借用了電路保險絲的概念:偵測到下游持續失敗時,直接「跳開」,後續的呼叫不再送出,立刻回傳錯誤;過一段時間再放少量請求試探,確認恢復了才回到正常。它有三種狀態:
圖:Closed 時正常放行並計算失敗;失敗達門檻跳到 Open,直接拒絕;等待一段時間後進入 Half-open,只放少量試探請求,成功就回 Closed,失敗就回 Open。
- Closed(關閉):正常狀態,請求照常送出,同時統計失敗。失敗統計可以用「連續失敗次數」,也可以用「最近一段時間視窗內的失敗率」,後者對流量大的服務比較穩定,通常還會加上「視窗內至少要有 N 個請求才判斷」的條件,避免低流量時一兩次失敗就跳開。
- Open(跳開):失敗超過門檻後進入。這段期間所有呼叫立刻回傳
ErrOpen,不碰網路。呼叫端因此能快速失敗,可以改走降級邏輯,例如回覆「付款系統忙碌中,訂單已保留,請稍後再付款」。 - Half-open(半開):Open 維持一段時間後進入。只放行少量(常見是一個)試探請求;試探成功代表下游恢復,回到 Closed 並清除統計;試探失敗就回到 Open,重新計時。
熔斷器的關鍵設計問題是:什麼樣的錯誤算「失敗」?只有代表下游不健康的錯誤才該計入,例如逾時、連線失敗、5xx。卡片被拒、餘額不足、參數錯誤,都是下游正常運作下的業務結果,如果把它們算進去,一波刷卡被拒的請求就可能讓熔斷器跳開,把所有正常的付款也擋掉。
第 6 步:用 Go 實作一個熔斷器
社群有成熟的套件(例如 sony/gobreaker),實務上可以直接用。但自己寫一次能真正理解它的行為,而且核心只有幾十行。下面的實作採用連續失敗次數,Half-open 一次只放一個試探請求,並讓呼叫者決定哪些錯誤算失敗:
package main
import (
"context"
"errors"
"fmt"
"sync"
"time"
)
type State int
const (
Closed State = iota
Open
HalfOpen
)
func (s State) String() string {
return [...]string{"closed", "open", "half-open"}[s]
}
var ErrOpen = errors.New("circuit breaker is open")
type Breaker struct {
mu sync.Mutex
state State
failures int // closed 狀態下連續失敗次數
threshold int // 連續失敗幾次就跳開
openTimeout time.Duration // open 維持多久後放一個試探請求
openedAt time.Time
probing bool // half-open 時是否已有試探請求在跑
isFailure func(err error) bool // 哪些錯誤代表「下游不健康」
}
func NewBreaker(threshold int, openTimeout time.Duration, isFailure func(error) bool) *Breaker {
return &Breaker{threshold: threshold, openTimeout: openTimeout, isFailure: isFailure}
}
func (b *Breaker) State() State {
b.mu.Lock()
defer b.mu.Unlock()
return b.state
}
// allow 決定這次呼叫能不能放行
func (b *Breaker) allow() error {
b.mu.Lock()
defer b.mu.Unlock()
switch b.state {
case Open:
if time.Since(b.openedAt) < b.openTimeout {
return ErrOpen
}
b.state = HalfOpen
b.probing = false
fallthrough
case HalfOpen:
if b.probing {
return ErrOpen // 一次只放一個試探請求
}
b.probing = true
}
return nil
}
func (b *Breaker) record(err error) {
b.mu.Lock()
defer b.mu.Unlock()
failed := err != nil && b.isFailure(err)
switch b.state {
case HalfOpen:
b.probing = false
if failed {
b.trip()
} else {
b.state, b.failures = Closed, 0
}
case Closed:
if !failed {
b.failures = 0
return
}
b.failures++
if b.failures >= b.threshold {
b.trip()
}
case Open:
// 跳開前就已放行的慢請求,結果不影響狀態
}
}
func (b *Breaker) trip() {
b.state, b.openedAt, b.failures = Open, time.Now(), 0
}
func (b *Breaker) Call(ctx context.Context, fn func(context.Context) error) error {
if err := b.allow(); err != nil {
return err
}
err := fn(ctx)
b.record(err)
return err
}
var ErrPaymentDown = errors.New("payment: 503")
var ErrCardDeclined = errors.New("payment: card declined")
func main() {
br := NewBreaker(3, 100*time.Millisecond, func(err error) bool {
// 卡片被拒是業務結果,不代表付款服務壞掉
return !errors.Is(err, ErrCardDeclined)
})
healthy := false
charge := func(ctx context.Context) error {
if !healthy {
return ErrPaymentDown
}
return nil
}
ctx := context.Background()
for i := 1; i <= 5; i++ {
err := br.Call(ctx, charge)
fmt.Printf("呼叫 %d:err=%v,狀態=%v\n", i, err, br.State())
}
fmt.Println("…等待 openTimeout,付款服務恢復…")
time.Sleep(120 * time.Millisecond)
healthy = true
err := br.Call(ctx, charge)
fmt.Printf("試探呼叫:err=%v,狀態=%v\n", err, br.State())
err = br.Call(ctx, func(context.Context) error { return ErrCardDeclined })
fmt.Printf("卡片被拒:err=%v,狀態=%v(不計入失敗)\n", err, br.State())
}輸出如下,可以清楚看到狀態轉移:
呼叫 1:err=payment: 503,狀態=closed
呼叫 2:err=payment: 503,狀態=closed
呼叫 3:err=payment: 503,狀態=open
呼叫 4:err=circuit breaker is open,狀態=open
呼叫 5:err=circuit breaker is open,狀態=open
…等待 openTimeout,付款服務恢復…
試探呼叫:err=<nil>,狀態=closed
卡片被拒:err=payment: card declined,狀態=closed(不計入失敗)幾個實作細節值得說明。第一,allow 與 record 分成兩次加鎖,呼叫本身不持有鎖,否則一個慢呼叫會讓所有 goroutine 排隊等鎖。第二,allow 裡從 Open 轉到 Half-open 用了 fallthrough,讓「時間到了的那一個請求」直接成為試探者。第三,record 在 Open 狀態下什麼都不做:熔斷器跳開前已經放行的慢請求,它們的結果不應該再改變狀態。第四,試探請求如果因為 panic 沒有呼叫到 record,probing 會一直是 true,熔斷器就永遠卡在 Half-open;正式環境的實作要用 defer 確保一定會記錄結果,或替試探加上逾時。
熔斷器要放在哪裡?一個呼叫端對每個下游(甚至每個下游的每個關鍵操作)各有一個熔斷器,而不是全服務共用一個。付款服務壞了,不應該連帶擋掉對庫存服務的呼叫。至於重試與熔斷的順序,通常是重試在外、熔斷器在內:讓每一次嘗試都經過熔斷器,熔斷器跳開時,重試迴圈收到 ErrOpen 就應該直接放棄,ErrOpen 不屬於可重試錯誤。
第 7 步:艙壁隔離與降級
最後一個工具來自造船:船艙用隔板分成好幾格,一格進水不會讓整艘船沉沒。艙壁(bulkhead)的意思是讓不同的下游使用不同的資源池,一個下游變慢時,只會耗盡它自己那一格的資源。
在 Go 裡,最常被耗盡的資源是「同時進行中的呼叫數」。goroutine 很便宜,但每個卡住的呼叫都佔著一條連線、一份記憶體、一個請求的生命週期。如果訂單服務對付款服務的呼叫沒有上限,付款服務一變慢,訂單服務的所有處理器 goroutine 都可能卡在等付款,連查訂單這種完全不需要付款的請求也受影響。用一個帶緩衝的 channel 當號誌,就能替每個下游設定獨立的並發上限:
// 片段:每個下游各自一個艙壁,滿了就立刻拒絕,不排隊
type Bulkhead struct{ slots chan struct{} }
func NewBulkhead(n int) *Bulkhead { return &Bulkhead{slots: make(chan struct{}, n)} }
var ErrBulkheadFull = errors.New("bulkhead full")
func (b *Bulkhead) Do(ctx context.Context, fn func(context.Context) error) error {
select {
case b.slots <- struct{}{}:
defer func() { <-b.slots }()
return fn(ctx)
default:
return ErrBulkheadFull // 也可以改成 select ctx.Done() 等一小段時間
}
}
// 在 cmd/order/main.go 組裝時,付款與庫存各給一個
// payBH := NewBulkhead(50)
// invBH := NewBulkhead(100)golang.org/x/sync/semaphore 提供了加權版本的號誌,概念相同。HTTP 層面還有另一個常被忽略的艙壁:http.Transport 的 MaxConnsPerHost。對不同下游使用不同的 http.Client(各自的 Transport),連線池就自然分開了,這也呼應〈database/sql、交易與連線池〉裡談過的連線池設定觀念。
當熔斷器跳開或艙壁滿了,呼叫端就需要降級(fallback)策略:
| 情境 | 可能的降級 |
|---|---|
| 推薦服務失敗 | 回傳熱門商品的快取清單 |
| 庫存查詢失敗 | 商品頁顯示「庫存確認中」,下單時再嚴格檢查 |
| 付款服務失敗 | 訂單維持 pending,提示使用者稍後付款 |
| 通知服務失敗 | 放進訊息佇列稍後補發 |
降級的原則是:對核心交易保守,對周邊功能寬鬆。推薦清單舊一點沒關係,但付款失敗絕對不能假裝成功。付款的降級是「明確告訴使用者還沒付」,而不是「先當作付了」。
常見陷阱
- 只設了用戶端逾時,沒傳期限:每一跳各自用固定逾時,上游放棄後下游還在做,產生孤兒工作與不一致的副作用。
- 重試非冪等的操作:對扣款、建立訂單這類 POST 盲目重試,回應丟失時就會重複扣款。先有冪等鍵,再談重試。
- 每一層都重試:三層各重試三次就是 27 倍放大。選一層重試,其他層把錯誤往上傳。
- 退避沒有 jitter:所有用戶端在同一刻重試,下游一恢復就被同步的重試潮打倒。
- 把業務錯誤算進熔斷:卡片被拒、參數錯誤不代表下游壞了,算進去會讓熔斷器誤跳,擋掉正常請求。
- 全服務共用一個熔斷器:一個下游故障擋住所有下游。每個下游、必要時每個操作各自一個。
- Half-open 放太多試探:剛恢復的服務被試探流量打倒,熔斷器在 Open 與 Half-open 之間來回震盪。
- 逾時設得比下游的逾時還短:呼叫端已經放棄,下游卻還沒逾時,繼續佔用資源;外層的期限應該比內層長。
- 在重試迴圈裡用
time.Sleep:上游取消時無法中斷,要用select同時等計時器與ctx.Done()。 - 忽略
Retry-After:被限流時還照自己的公式重試,等於無視下游的明確要求。
重點整理
- 慢比失敗更危險;任何跨網路的呼叫都要有逾時,而且整條呼叫鏈共用一個期限預算,期限只會越傳越短。
- 只重試「暫時性」而且「冪等」的操作;錯誤分類在用戶端轉接層做好,用
errors.Is判斷。 - 重試用指數退避加 full jitter,等待時要能被 context 取消,預算不夠時提早放棄。
- 只在一層重試,並用重試預算限制重試比例,避免故障時的放大效應。
- 熔斷器有 Closed、Open、Half-open 三態;只有代表下游不健康的錯誤才算失敗;每個下游各自一個。
- 艙壁讓不同下游使用不同的資源池;搭配降級,對核心交易保守、對周邊功能寬鬆。
- 這些機制的參數都需要指標佐證,失敗率、重試次數、熔斷狀態變化都應該被監控。
下一篇
重試讓暫時性失敗得以恢復,卻也帶來新的風險:回應丟失時重試扣款,使用者就可能被扣兩次錢。下一篇〈冪等與分散式鎖〉會用冪等鍵、唯一約束與 fencing token,讓「做兩次」的效果等於「做一次」。