熔断、降级与限流

CircuitBreakerConfig config = CircuitBreakerConfig.custom()
    .failureRateThreshold(50)
    .waitDurationInOpenState(Duration.ofSeconds(30))
    .permittedNumberOfCallsInHalfOpenState(3)
    .slidingWindowSize(100)
    .build();

CircuitBreaker cb = CircuitBreaker.of("orderService", config);

// 装饰调用
Supplier<String> decorated = CircuitBreaker
    .decorateSupplier(cb, () -> orderClient.getOrder(id));
String result = Try.ofSupplier(decorated)
    .recover(throwable -> "fallback_order")
    .get();

// 基于慢调用比例的降级
DegradeRule rule = new DegradeRule("getOrder")
    .setGrade(CircuitBreakerStrategy.SLOW_REQUEST_RATIO)
    .setCount(0.5)           // 慢调用比例阈值
    .setTimeWindow(30)       // 熔断时长（秒）
    .setSlowRatioThreshold(500); // 慢调用阈值（ms）

RateLimiter limiter = RateLimiter.create(100); // QPS = 100

// 阻塞获取
limiter.acquire();

// 非阻塞尝试
if (limiter.tryAcquire(10, TimeUnit.MILLISECONDS)) {
    process(request);
} else {
    return "Too Many Requests";
}

-- 滑动窗口限流
local key = KEYS[1]
local now = tonumber(ARGV[1])
local window = tonumber(ARGV[2])
local limit = tonumber(ARGV[3])

redis.call('ZREMRANGEBYSCORE', key, 0, now - window)
local count = redis.call('ZCARD', key)

if count < limit then
    redis.call('ZADD', key, now, now)
    redis.call('EXPIRE', key, window)
    return 1  -- 允许
else
    return 0  -- 拒绝
end

ThreadPoolBulkheadConfig config = ThreadPoolBulkheadConfig.custom()
    .maxThreadPoolSize(10)
    .coreThreadPoolSize(5)
    .queueCapacity(20)
    .build();

ThreadPoolBulkhead bulkhead = ThreadPoolBulkhead.of("backendA", config);
CompletionStage<String> result = bulkhead.executeSupplier(() -> backendService.call());

spring:
  cloud:
    sentinel:
      transport:
        dashboard: sentinel-dashboard:8080
      datasource:
        flow:
          nacos:
            server-addr: nacos:8848
            dataId: ${spring.application.name}-flow-rules
            rule-type: flow

@RestController
public class OrderController {
    @GetMapping("/orders/{id}")
    @SentinelResource(
        value = "getOrderById",
        blockHandler = "handleBlock",
        fallback = "handleFallback"
    )
    public Order getOrder(@PathVariable Long id) {
        return orderService.getById(id);
    }
    
    public Order handleBlock(Long id, BlockException ex) {
        throw new TooManyRequestsException();
    }
    
    public Order handleFallback(Long id, Throwable ex) {
        return Order.empty(); // 降级
    }
}

// 简化版 BBR 核心逻辑
type BBR struct {
    maxInFlight   int64     // 最大并发
    minRT         float64   // 历史最小响应时间
    lastDropTime  time.Time // 上次丢弃时间
    windowSize    int       // 滑动窗口大小
}

func (b *BBR) Allow() bool {
    // 1. 测量当前系统的 inflight 和 RT
    inflight := atomic.LoadInt64(&b.inflight)
    rt := b.currentRT()

    // 2. 计算当前处理能力上限
    // maxFlight = minRT / RT * 历史最大并发
    maxFlight := int64(b.minRT / rt * float64(b.maxInFlight))

    if inflight >= maxFlight {
        // 3. 超过上限则丢弃并记录
        atomic.AddInt64(&b.dropped, 1)
        b.lastDropTime = time.Now()
        return false
    }
    atomic.AddInt64(&b.inflight, 1)
    return true
}

import "github.com/zeromicro/go-zero/core/limit"

// 自适应限流器：CPU > 80% 或请求延迟上升时自动限流
limiter := limit.NewTokenLimiter(
    1000,           // 每秒令牌数（上限）
    100,            // 桶大小
    redis.NewRedis(...),
    "api_limit_key",
)

if ok, _ := limiter.Allow(); !ok {
    return errors.New("服务过载，请稍后重试")
}

// Sentinel 多维限流规则
FlowRule rule1 = new FlowRule("api_order_create")
    .setGrade(RuleConstant.FLOW_GRADE_QPS)
    .setCount(100)           // 接口级：100 QPS
    .setStrategy(RuleConstant.STRATEGY_DIRECT);

FlowRule rule2 = new FlowRule("api_order_create")
    .setGrade(RuleConstant.FLOW_GRADE_QPS)
    .setCount(10)            // 用户级：每用户 10 QPS
    .setStrategy(RuleConstant.STRATEGY_CHAIN)
    .setRefResource("user_id");

FlowRule rule3 = new FlowRule("api_order_create")
    .setGrade(RuleConstant.FLOW_GRADE_QPS)
    .setCount(5)             // 商户级：每商户 5 QPS
    .setStrategy(RuleConstant.STRATEGY_CHAIN)
    .setRefResource("merchant_id");

// Sentinel 热点参数限流
ParamFlowRule hotRule = new ParamFlowRule("product_detail")
    .setParamIdx(0)          // 第 0 个参数（productId）
    .setCount(100)           // 默认每个 productId 100 QPS
    .setDurationInSec(1);

// 特殊商品（如秒杀品）独立阈值
hotRule.setParamFlowItemList(Arrays.asList(
    new ParamFlowItem("SKU_999", 5, 1),   // 秒杀品：5 QPS
    new ParamFlowItem("SKU_001", 500, 1)  // 热门品：500 QPS
));

# 熔断器指标
- name: circuit_breaker_state
  help: "Current state of circuit breaker (0=closed, 1=open, 2=half-open)"
  labels: [service, method]

- name: circuit_breaker_failures_total
  help: "Total number of failures"
  labels: [service, method, exception_type]

# 限流指标
- name: rate_limit_rejected_total
  help: "Total number of rejected requests"
  labels: [api, dimension, limit_type]

- name: rate_limit_allowed_total
  help: "Total number of allowed requests"

# 降级指标
- name: degrade_fallback_total
  help: "Total number of fallback invocations"
  labels: [service, fallback_type]

# 资源隔离指标
- name: bulkhead_active_executions
  help: "Current active executions in bulkhead"
  labels: [bulkhead_name]

- name: bulkhead_queue_wait_time_seconds
  help: "Time spent waiting in bulkhead queue"

# 熔断器长时间处于 OPEN 状态
groups:
  - name: stability
    rules:
      - alert: CircuitBreakerOpenTooLong
        expr: circuit_breaker_state == 1
        for: 5m
        annotations:
          summary: "熔断器已连续开启超过 5 分钟"

      - alert: HighRateLimitRejection
        expr: rate(rate_limit_rejected_total[1m]) > 100
        for: 2m
        annotations:
          summary: "限流拒绝率过高，可能需要扩容"

      - alert: SlowCallRatioHigh
        expr: |
          (
            rate(circuit_breaker_slow_calls_total[5m])
            /
            rate(circuit_breaker_calls_total[5m])
          ) > 0.8
        annotations:
          summary: "慢调用比例超过 80%，触发降级"

# Chaos Mesh 实验：模拟网络延迟
apiVersion: chaos-mesh.org/v1alpha1
kind: NetworkChaos
metadata:
  name: payment-service-delay
spec:
  action: delay
  mode: all
  selector:
    namespaces:
      - production
    labelSelectors:
      app: payment-service
  delay:
    latency: "500ms"
    jitter: "100ms"
  duration: "10m"