详解Go微服务容错设计(熔断+降级+限流全解析)

// 创建带超时的 context
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()
// 在请求中传递 context
req, _ := http.NewRequestWithContext(ctx, "GET", "http://service-a/api", nil)
resp, err := http.DefaultClient.Do(req)
if err != nil {
    // 超时或连接错误处理
    log.Printf("request failed: %v", err)
    return
}
defer resp.Body.Close()

// 简化的状态判断逻辑
if failureCount > threshold {
    state = Open
    startTimeoutTimer()
} else if state == HalfOpen && success {
    state = Closed
    resetCounter()
}

package main
import (
    "fmt"
    "time"
    "github.com/afex/hystrix-go/hystrix"
)
func init() {
    hystrix.ConfigureCommand("remote-call", hystrix.CommandConfig{
        Timeout:                1000, // 超时时间（毫秒）
        MaxConcurrentRequests:  10,   // 最大并发数
        RequestVolumeThreshold: 5,    // 触发熔断的最小请求数
        SleepWindow:            5000, // 熔断后等待时间
        ErrorPercentThreshold:  50,   // 错误率阈值
    })
}
func remoteCall() error {
    return hystrix.Do("remote-call", func() error {
        // 模拟远程调用
        time.Sleep(800 * time.Millisecond)
        return nil
    }, func(err error) error {
        // 降级逻辑
        fmt.Println("触发降级处理")
        return nil
    })
}

import "github.com/sony/gobreaker"
var cb = &gobreaker.CircuitBreaker{
    StateMachine: gobreaker.Settings{
        Name:        "UserService",
        MaxFailures: 3,
        Interval:    10 * time.Second,
        Timeout:     5 * time.Second,
    },
}
result, err := cb.Execute(func() (interface{}, error) {
    return callUserService()
})

HystrixCommandProperties.Setter()
    .withCircuitBreakerEnabled(true)
    .withCircuitBreakerRequestVolumeThreshold(20)
    .withCircuitBreakerErrorThresholdPercentage(50)
    .withCircuitBreakerSleepWindowInMilliseconds(5000);

circuitBreaker.WithLabelValues("payment-service").Set(1) // 状态为1表示OPEN

// 伪代码：降级判断逻辑
func shouldDegraded(latency time.Duration, errRate float64) bool {
    if latency > 500*time.Millisecond && errRate > 0.05 {
        return true // 触发综合降级
    }
    return false
}

var cacheOnce sync.Once
var cacheInstance *RedisClient
var defaultData = map[string]string{"status": "degraded"}
func GetCache() map[string]string {
    cacheOnce.Do(func() {
        conn, err := dialRedis()
        if err != nil {
            log.Println("Redis unavailable, using default response")
            return
        }
        cacheInstance = conn
    })
    if cacheInstance == nil {
        return defaultData // 降级返回默认值
    }
    return cacheInstance.Get("data")
}

ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
defer cancel()
result, err := dependency.Call(ctx)
if err != nil {
    return fallbackResponse // 触发降级
}

// 每分钟最多允许100次请求
if currentTime.WindowStart == currentWindow.Start {
    if currentWindow.Count < 100 {
        currentWindow.Count++
        allow = true
    }
}

type LeakyBucket struct {
    capacity  int       // 桶容量
    water     int       // 当前水量
    rate      time.Duration // 出水速率
    lastLeak  time.Time // 上次漏水时间
}
func (lb *LeakyBucket) Allow() bool {
    now := time.Now()
    leakedWater := int(now.Sub(lb.lastLeak) / lb.rate)
    if leakedWater > 0 {
        lb.water = max(0, lb.water-leakedWater)
        lb.lastLeak = now
    }
    if lb.water < lb.capacity {
        lb.water++
        return true
    }
    return false
}

type TokenBucket struct {
    capacity  int
    tokens    int
    rate      time.Duration
    lastToken time.Time
}
func (tb *TokenBucket) Allow() bool {
    now := time.Now()
    newTokens := int(now.Sub(tb.lastToken) / tb.rate)
    tb.tokens = min(tb.capacity, tb.tokens+newTokens)
    tb.lastToken = now
    if tb.tokens > 0 {
        tb.tokens--
        return true
    }
    return false
}

local key = KEYS[1]
local rate = tonumber(ARGV[1])        -- 令牌生成速率（个/秒）
local capacity = tonumber(ARGV[2])    -- 桶容量
local now = tonumber(ARGV[3])         -- 当前时间戳（毫秒）
local fill_time = capacity / rate
local ttl = math.ceil(fill_time * 2)
local last_tokens = tonumber(redis.call('get', key) or capacity)
local last_time = tonumber(redis.call('get', key .. ':time') or now)
local delta = math.min(capacity, (now - last_time) / 1000 * rate)
local tokens = math.max(0, last_tokens + delta)
local allowed = tokens >= 1
if allowed then
    tokens = tokens - 1
    redis.call('set', key, tokens, 'PX', ttl * 1000)
    redis.call('set', key .. ':time', now, 'PX', ttl * 1000)
end
return { allowed, tokens }

// 使用滑动窗口统计最近N秒请求
type SlidingWindow struct {
    windowSize int           // 窗口大小（秒）
    slots      []int         // 每秒请求数数组
    currentIndex int
}
func (sw *SlidingWindow) Increment() {
    now := time.Now().Second() % sw.windowSize
    if now != sw.currentIndex {
        sw.shiftSlots(now)
    }
    sw.slots[now]++
}

// 示例：Go 单元测试片段
func TestOrderService_CreateOrder(t *testing.T) {
    svc := NewOrderService(repoMock)
    order := &Order{Amount: 100.0, UserID: "user-123"}
    err := svc.Create(context.Background(), order)
    if err != nil {
        t.Errorf("expected no error, got %v", err)
    }
}