Skip to content

走向分布式:Gateway、服务调用与容错 ​

本篇要点:把单体应用的流量收进一个网关入口,并用限流、熔断、超时三组参数让它在下游抖动时不整体倒下。 前置文章:《测试体系:单元测试、切片测试与 Testcontainers》用 Testcontainers 给单体建了可信的测试基线;这一章是整个类目第一次把应用拆成多个进程,所有原来在进程内完成的调用,从此都要经过网络。

1 为什么需要它:流量只有六成,客户被拦在登录页外 ​

去年双十一预热第二天,我们的网关在流量只有平时六成的情况下,把三十多个企业客户拦在了登录页外面。错误码 429,来自限流器。运维第一时间去扩容,扩完还是 429。

原因跟容量一点关系都没有:所有请求的限流 key 都叫 null。

网关这一层有个共同特征——配错了不报错,只会在某个流量拐点突然显形。《测试体系:单元测试、切片测试与 Testcontainers》之前,所有调用都在同一个进程里,超时、重试、并发这些词只是方法签名上的注解;拆成多个服务之后,它们变成真实的网络行为:调用可能失败、可能很慢、可能成功但你不知道它成功了。网关就是承接这些不确定性的第一层。

它要回答四个问题:这个请求该去哪个服务、允不允许它过去、下游挂了怎么办、等多久算挂。四个问题对应路由、限流、熔断、超时,本篇按这个顺序讲。

2 核心概念 ​

2.1 职责边界:只处理与流量有关的事 ​

定义:网关(gateway)是所有外部流量进入系统的唯一入口,它在转发之前做与流量有关的判断——路由、认证、限流、熔断、灰度、日志。判断完就把请求交出去,不参与业务。

表 10-1 是我们实际划的边界。

表 10-1 网关该留下与该挪走的职责

职责留在网关挪到服务内理由
路由与路径重写✔只有网关知道服务拓扑
Token 校验✔拒绝无效流量越早越省
限流与熔断✔需要全局视角
参数校验✔网关不该懂业务字段
多服务结果聚合✔聚合逻辑会随需求变,改一次发一次网关风险高
业务重试(如下单补偿)✔网关重试会放大副作用

反例:在网关里写一个 /api/home 接口,聚合商品、订单、消息三个服务的数据。上线三个月后这个接口改了 14 次,每次都要发网关,而网关的发布窗口一周只有两次。

2.2 路由 = 断言 + 过滤器 ​

定义:一条路由(route)由三部分组成——id、目标 uri、以及一组断言(predicate,谓词)和一组过滤器(filter)。断言决定「这个请求归不归我管」,过滤器决定「转发前后要对它做什么」。order 决定多条路由都能匹配时谁先来。

类比:断言是机场的值机柜台分流牌,过滤器是过了分流牌之后的安检和传送带。分流牌写错,你会走错登机口;传送带装错,行李会丢。

反例:灰度路由和主路由都写 order: 0。Spring 按配置顺序匹配,先命中的吃掉全部流量,后一条等于不存在——不报错,日志里也看不出来。

2.3 限流:令牌桶的三个参数 ​

定义:Spring Cloud Gateway 的 RequestRateLimiter 用 Redis 实现令牌桶(token bucket)。桶里最多存 burstCapacity 个令牌,每秒补 replenishRate 个,一个请求消耗 requestedTokens 个;桶空则返回 429。

类比:桶是停车场的车位,burstCapacity 是车位数,replenishRate 是每小时放行的车数,requestedTokens 是一辆车占几个位——大车(导出接口)占得多。

反例:key-resolver 解析不出值时返回空。deny-empty-key 默认是 true,key 为空直接拒绝,于是登录页本身被 429,用户连认证的机会都没有。

2.4 熔断:先定义「什么算失败」 ​

定义:熔断器(circuit breaker,这里用 Resilience4j 实现)在滑动窗口内统计调用结果,失败率或慢调用比例超过阈值就从闭合(closed)切到打开(open),后续请求直接走降级;等待 waitDurationInOpenState 后进入半开(half-open),放少量请求试探。

关键参数是 slidingWindowSize(窗口内请求数)、minimumNumberOfCalls(最少样本数)、slowCallDurationThreshold(多慢算慢)、以及 statusCodes(哪些状态码计入失败)。

反例:不配 statusCodes。默认所有异常都算失败,前端一个字段名拼错连发十几个 400,失败率瞬间过 50%,熔断器打开,十秒内整片下单流量走降级。

2.5 超时分层:一个不等式 ​

定义:一条请求链上有三个超时——熔断器的慢调用阈值、网关的 response-timeout、上游服务自己的超时。三者必须满足 熔断慢调用阈值 < 网关 response-timeout < 上游服务超时,这个不等式的方向错了,后面所有统计都是假的。

反例:网关 10s、熔断阈值 2s、上游 5s。这个组合下熔断器统计到的永远是「上游 5 秒返回的错误」,不是真实耗时;而网关要等 10 秒才认输,中间那 5 秒里它什么都看不到。

3 动手实践 ​

任务:为订单服务配一条带灰度、限流、熔断的路由,再用请求计数、超时和路由 id 三处结果验证它按预期工作。

3.1 路由骨架(注意 5.0 的配置前缀) ​

yaml
spring:
  data:
    redis:
      timeout: 500ms            # 限流依赖 Redis,客户端超时别用默认值
  cloud:
    gateway:
      httpclient:               # 全局超时仍在 gateway.httpclient 下,5.0 没有跟着路由前缀迁移
        connect-timeout: 1000
        response-timeout: 3s
      server:
        webflux:
          routes:
            - id: order-api-gray
              uri: lb://order-service-canary
              order: -1             # 必须小于 Weight 路由,否则 header 永远没机会匹配
              predicates:
                - Path=/api/orders/**
                - Header=X-Gray,1
              filters:
                - StripPrefix=1

            - id: order-api-canary
              uri: lb://order-service-canary
              predicates:
                - Path=/api/orders/**
                - Weight=order-gray,10
              filters:
                - StripPrefix=1
                - name: RequestRateLimiter
                  args:
                    key-resolver: "#{@userKeyResolver}"
                    redis-rate-limiter.replenishRate: 50
                    redis-rate-limiter.burstCapacity: 50
                    redis-rate-limiter.requestedTokens: 1

            - id: order-api
              uri: lb://order-service
              predicates:
                - Path=/api/orders/**
                - Weight=order-gray,90
              filters:
                - StripPrefix=1
                - name: RequestRateLimiter
                  args:
                    key-resolver: "#{@userKeyResolver}"
                    redis-rate-limiter.replenishRate: 50
                    redis-rate-limiter.burstCapacity: 50
                    redis-rate-limiter.requestedTokens: 1
                - name: CircuitBreaker
                  args:
                    name: orderCircuitBreaker
                    fallbackUri: forward:/fallback/order
                    statusCodes: [500, 502, 504]

预期输出(发布后第一件事就是检查路由有没有真的加载):

bash
curl -s localhost:8080/actuator/gateway/routes | jq -r '.[].route_id'
# order-api-gray
# order-api-canary
# order-api

Gateway 升到 5.0.4 之后,路由配置从 spring.cloud.gateway.routes 挪到了 spring.cloud.gateway.server.webflux.routes。旧前缀不会被 PropertiesRouteDefinitionLocator 读到,而它也不报错——服务正常启动,健康检查绿的,日志一行警告都没有,路由一条都没加载。所以上面那条 curl 是发布流程的固定步骤,看不到 id 就不用往下查了。

3.2 限流 key:加前缀、留兜底 ​

java
@Bean
KeyResolver userKeyResolver() {
    return exchange -> exchange.getPrincipal()
            .map(Principal::getName)
            .map(uid -> "order:" + uid)                    // 加业务前缀,避免不同路由共用一个桶
            .switchIfEmpty(Mono.fromSupplier(() -> {
                var remote = exchange.getRequest().getRemoteAddress();
                String ip = remote == null ? "0.0.0.0" : remote.getAddress().getHostAddress();
                String ua = String.valueOf(exchange.getRequest().getHeaders().getFirst(HttpHeaders.USER_AGENT));
                return "anon:" + ip + ":" + ua.hashCode(); // UA 参与哈希,拆开同 NAT 下的不同客户端
            }));
}

运行结果(同一账号在 1 秒内打 60 次,requestedTokens=1、replenishRate=50):

text
前 50 次:HTTP/1.1 200
第 51 次起:HTTP/1.1 429,X-RateLimit-Remaining: 0

那个业务前缀很容易被忽略。我们后来加了促销路由,两条路由的 key 都是 u1001,用户在主站和促销站共享计数,促销一来全站被限。另外,客户整个办公区走一个 NAT 出口时,几千人共享一个桶——补 UA 哈希是为了把同 IP 的不同客户端拆开。

3.3 熔断与降级返回体 ​

java
@GetMapping("/fallback/order")
public ResponseEntity<Map<String, Object>> orderFallback(ServerWebExchange exchange) {
    Throwable err = exchange.getAttribute(
            ServerWebExchangeUtils.CIRCUITBREAKER_EXECUTION_EXCEPTION_ATTR);
    return ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE)
            .body(Map.of("code", "ORDER_DEGRADED",
                         "reason", err == null ? "unknown" : err.getClass().getSimpleName(),
                         "traceId", MDC.get("traceId")));
}

预期输出(下游连续超时 3 次之后):

json
{"code":"ORDER_DEGRADED","reason":"TimeoutException","traceId":"9f2c1a"}

这里用 503 而不是 429 或 502:503 加一个 Retry-After 头能让客户端重试逻辑自己动起来,而 502 会让前端以为网关坏了,直接弹通用错误页。fallbackUri 只认 forward: 前缀,写成 http://fallback.internal/... 不会报错,只是永远不会跳转。

3.4 参数怎么标定 ​

表 10-2 是我们最终留下的一组值,每个值后面写清依据。

表 10-2 限流与熔断参数的标定依据

参数最终值依据
replenishRate50下游单实例容量 70 QPS 的 70%
burstCapacity50与 replenishRate 相等,限流最平滑
requestedTokens1(导出接口 8)按成本限流,重接口单独算账
slowCallDurationThreshold800ms上游 P99 的 1.5 倍
response-timeout3s必须大于熔断阈值
minimumNumberOfCalls30原来 10 太容易误开
waitDurationInOpenState10s与上游扩容时间匹配

burstCapacity 等于 replenishRate 是试出来的。早期设成 3 倍(允许瞬时三倍尖峰),结果每次上游抖动都被尖峰打穿一次,平滑之后反而更稳。代价是突发流量会被更早拒掉,产品那边接受了。

标定之前先算一遍量级:单实例 70 QPS、两实例 140 QPS,取 70% 是 98,分摊到两条灰度路由各 50,合计 100,与容量基本对齐。这一步不用精确,但必须算——否则 50 这个数字只是抄来的。

3.5 三处容易漏的组合 ​

第一处是重试与熔断叠加。我们同时开了 Retry 和 CircuitBreaker,一次失败被重试放大成三次失败,熔断器按调用次数统计,等于把失败率乘了三倍,提前打开。要么把重试挪到客户端,要么把 minimumNumberOfCalls 按重试倍数放大,我们选了后者,代价是低流量时反应变钝。

第二处是限流与熔断的顺序。限流拒绝的请求不该计入熔断统计,否则大促一限流,熔断器跟着开,两个降级手段互相放大。图 10-1 画的就是这个顺序。

图 10-1 网关内部的处理顺序:限流在熔断之前

如图 10-1 所示,RequestRateLimiter 排在 CircuitBreaker 之前不是风格问题。顺序反了,被限流的请求会先喂给熔断器,大促时两个机制会一起收紧。

第三处是路由缓存。在配置中心把灰度权重从 10 改成 50,观察四十分钟,流量还是 10%。配置绑定成功了,Environment 也刷新了,但 CachingRouteLocator 还拿着旧缓存,没有人通知它失效。必须显式发 RefreshRoutesEvent 或调一次 /actuator/gateway/refresh。

4 常见误解 ​

以为 Weight 组内权重必须凑够 100。 框架按组内总和归一化,10/90 和 1/9 等价。权重设 0 表示保留定义但不接流量,比删路由好回滚。

以为 fallbackUri 可以指向外部服务。 只支持 forward: 前缀,其余写法静默失效——能启动,永远不跳转。

以为限流和熔断是两道独立的保险。 它们会互相放大:重试放大失败率、限流放大熔断统计。三个机制(限流、熔断、重试)的叠加顺序要画出来确认,不能各自配好就上线。

以为配置改了就生效。 路由有缓存,灰度有权重缓存,Redis 断连时 RequestRateLimiter 会直接抛异常。这三件事都不会在启动时暴露。

5 小结 ​

  1. 《测试体系:单元测试、切片测试与 Testcontainers》之前,超时和重试只是注解;拆成多进程之后,它们变成真实的网络行为,网关是第一层承接者。
  2. 网关只做与流量有关的事:路由、认证、限流、熔断、灰度。业务聚合、参数校验、补偿重试都留在服务内。
  3. 路由 = 断言 + 过滤器 + order。灰度 Header 路由的 order 必须小于 Weight 路由,否则 header 永远匹配不到。
  4. 限流的 key 要带业务前缀并留兜底;deny-empty-key 默认拒绝,key 为空会把登录页也挡掉。
  5. 熔断要先定义什么算失败:statusCodes 不配,400 会把熔断器提前打开。
  6. 三级超时必须满足 熔断阈值 < 网关超时 < 上游超时,否则熔断器看到的是网关的等待时间,不是下游的真实耗时。

6 相关文章 ​

网关让在线请求有了入口,但系统里还有另一类负载:对账、报表、数据迁移——它们不需要低延迟,需要的是「跑完、可重跑、断了能接上」。《进阶:Spring Batch 6 批处理与 ETL》讲 Spring Batch 6 的批处理模型,从 JobInstance 讲到分片,以及断点续跑为什么会多算一遍。