Go语言微服务限流降级实战：Token Bucket + Sentinel双层防护体系搭建

微服务限流的架构选型：为什么需要双层防护

微服务架构下，单个服务的过载会通过调用链路级联扩散，导致整个系统雪崩。限流是防止雪崩的第一道防线。工程实践中，单层限流存在盲区：网关层限流粒度粗，无法感知下游服务负载；服务层限流粒度细，但无法拦截流量洪峰。双层防护的思路是网关层用Token Bucket做粗粒度总量控制，服务层用Sentinel做细粒度热点控制和降级。

Token Bucket限流器实现

Token Bucket算法的核心参数是桶容量（burst）和填充速率（rate）。Go语言标准库golang.org/x/time/rate提供了生产可用的实现：

package middleware

import (
    "net/http"
    "sync"
    "golang.org/x/time/rate"
)

type IPRateLimiter struct {
    ips     map[string]*rate.Limiter
    mu      sync.RWMutex
    rate    rate.Limit
    burst   int
}

func NewIPRateLimiter(r rate.Limit, burst int) *IPRateLimiter {
    return &IPRateLimiter{
        ips:   make(map[string]*rate.Limiter),
        rate:  r,
        burst: burst,
    }
}

func (l *IPRateLimiter) GetLimiter(ip string) *rate.Limiter {
    l.mu.Lock()
    defer l.mu.Unlock()

    limiter, exists := l.ips[ip]
    if !exists {
        limiter = rate.NewLimiter(l.rate, l.burst)
        l.ips[ip] = limiter
    }
    return limiter
}

// HTTP中间件
func (l *IPRateLimiter) Middleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        ip := r.RemoteAddr
        if !l.GetLimiter(ip).Allow() {
            http.Error(w, "too many requests", http.StatusTooManyRequests)
            return
        }
        next.ServeHTTP(w, r)
    })
}

该实现按IP维度创建独立限流器，每个IP有自己的Token Bucket。rate.Limit类型实际上是float64，支持细粒度的QPS控制，例如rate.Limit(100.5)表示每秒100.5个请求。

Sentinel Go集成与规则配置

阿里开源的Sentinel提供了比Token Bucket更丰富的流控策略，包括热点参数限流、熔断降级、系统自适应保护等。Go版本集成方式：

import (
    sentinel "github.com/alibaba/sentinel-golang/api"
    "github.com/alibaba/sentinel-golang/core/flow"
    "github.com/alibaba/sentinel-golang/core/circuitbreaker"
    "github.com/alibaba/sentinel-golang/core/config"
)

func initSentinel() error {
    // 初始化Sentinel
    conf := config.NewDefaultConfig()
    conf.Sentinel.App.Name = "order-service"
    conf.Sentinel.Log.Dir = "/var/log/sentinel"
    if err := sentinel.InitWithConfig(conf); err != nil {
        return err
    }

    // 流控规则：每秒最大1000 QPS
    _, _ = flow.LoadRules([]*flow.Rule{
        {
            Resource:               "/api/orders",
            TokenCalculateStrategy: flow.Direct,
            ControlBehavior:        flow.Reject,
            Threshold:              1000,
            StatIntervalInMs:       1000,
        },
        {
            Resource:               "/api/orders",
            TokenCalculateStrategy: flow.Direct,
            ControlBehavior:        flow.WarmUp,
            Threshold:              2000,
            WarmUpPeriodSec:       30,
            StatIntervalInMs:       1000,
        },
    })

    // 熔断规则：慢调用比例熔断
    _, _ = circuitbreaker.LoadRules([]*circuitbreaker.Rule{
        {
            Resource:         "/api/orders",
            Strategy:         circuitbreaker.SlowRequestRatio,
            RetryTimeoutMs:   5000,
            MinRequestAmount: 10,
            StatIntervalMs:   10000,
            MaxSlowRatio:     0.6,
            SlowTimeThresholdMs: 500,
        },
    })

    return nil
}

Sentinel的WarmUp（预热）模式适合启动阶段或流量突增场景——冷启动时QPS从较低值逐步攀升到阈值，避免瞬间打满下游服务。SlowRequestRatio熔断策略在慢调用比例超过60%时触发熔断，5秒后尝试半开放恢复。

热点参数限流：按业务维度精细控制

电商场景下，热门商品ID是典型的热点参数。Sentinel支持按方法参数值做独立限流：

import (
    "github.com/alibaba/sentinel-golang/core/hotspot"
)

func initHotspotRules() {
    // 对商品ID做热点参数限流
    _, _ = hotspot.LoadRules([]*hotspot.Rule{
        {
            Resource:        "getProductDetail",
            MetricType:      hotspot.QPS,
            ParamIndex:      0,
            Threshold:       50,
            DurationInSec:   1,
            ParamsMaxCount:  1000,
            SpecificItems: map[interface{}]int64{
                // 特定热门商品单独限流
                "hot-item-12345": 200,
            },
        },
    })
}

func getProductDetailHandler(w http.ResponseWriter, r *http.Request) {
    productID := r.URL.Query().Get("id")
    
    entry, err := sentinel.Entry("getProductDetail",
        sentinel.WithArgs(productID))
    if err != nil {
        http.Error(w, "rate limited", http.StatusTooManyRequests)
        return
    }
    defer entry.Exit()
    
    // 正常业务逻辑
    // ...
}

SpecificItems允许对特定参数值设置更高的阈值，避免热门商品页面因统一限流而不可用，同时防止冷门商品消耗过多限流配额。

降级策略：Fallback与服务降级

限流触发后的降级策略决定了用户体验。通用降级方案包括返回缓存数据、返回默认值、返回排队提示：

type DegradationStrategy struct {
    cache    *lru.Cache
    fallback func() (interface{}, error)
}

func (s *DegradationStrategy) Execute(
    key string,
    primary func() (interface{}, error),
) (interface{}, error) {
    // 尝试主逻辑
    result, err := primary()
    if err == nil {
        s.cache.Add(key, result)
        return result, nil
    }

    // 主逻辑失败，尝试缓存
    if cached, ok := s.cache.Get(key); ok {
        return cached, nil
    }

    // 缓存也没有，执行兜底逻辑
    if s.fallback != nil {
        return s.fallback()
    }

    return nil, fmt.Errorf("service unavailable: %w", err)
}

降级策略的选择取决于业务场景：商品详情页可以返回缓存数据（最终一致性可接受），支付接口必须返回明确错误（资金安全优先），推荐列表可以返回默认列表（有损服务优于完全不可用）。

限流指标监控与动态规则调整

生产环境限流规则需要动态调整。Sentinel支持通过数据源（DataSource）从Nacos、ZooKeeper等配置中心拉取规则：

import (
    "github.com/alibaba/sentinel-golang/ext/datasource/nacos"
)

func initDynamicRules() {
    nacosDs, err := nacos.NewNacosDataSource(
        nacos.Config{
            ServerConfigs: []constant.ServerConfig{{
                IpAddr: "nacos.default.svc",
                Port:   8848,
            }},
            NamespaceId: "production",
        },
        "sentinel-flow-rules",
        "ORDER_SERVICE_GROUP",
        func(rule []byte) error {
            var rules []*flow.Rule
            if err := json.Unmarshal(rule, &rules); err != nil {
                return err
            }
            _, _ = flow.LoadRules(rules)
            return nil
        },
    )
    if err != nil {
        log.Fatalf("init nacos datasource failed: %v", err)
    }
    _ = nacosDs.Initialize()
}

监控方面，Sentinel的指标数据通过metric/stat包暴露，集成Prometheus后可在Grafana中可视化限流效果、熔断状态、通过QPS和拒绝QPS。告警规则建议：拒绝率>10%持续1分钟触发warning，拒绝率>30%持续30秒触发critical——后者意味着下游服务可能已接近过载阈值。