《Kubernetes 分布式系统原理深入解析》12.3 令牌桶限流与配额预算

配额的落地机制是令牌桶:优先级每秒获得一定令牌,每个请求消费一个令牌;令牌随时间匀速补充、有上限。令牌桶既能限『平均速率』(每秒预算),又能容忍『突发』(桶内积攒的令牌一次用掉)。本节解剖令牌桶算法、突发容忍的意义与配额预算的配置。lab 用 admission/apf.go 验证预算内放行、超预算排队。

12.3 令牌桶限流与配额预算

12.1/12.2 节讲了「分优先级、排队、公平」。本节落到配额的具体实现:令牌桶(token bucket)。它是 APF 限流的引擎——既限平均速率,又容忍突发。本节解剖算法与预算的意义。

令牌桶:把「每秒配额」变成「可累积的预算」

优先级每秒有 BudgetPerSec 个配额。令牌桶把它实现为:

桶里有令牌:每个请求消费 1 个令牌
令牌随时间补充:每秒补 BudgetPerSec 个
桶有上限:最多积攒 BudgetPerSec 个(不能无限攒)

lab 的 fill 与 Dequeue:

func (p *PriorityLevel) fill(now time.Time) {
    if !p.init {
        p.tokens = p.BudgetPerSec // 首轮起填
        p.lastFill = now
        p.init = true
        return
    }
    elapsed := now.Sub(p.lastFill).Seconds()
    p.tokens += elapsed * p.BudgetPerSec
    if p.tokens > p.BudgetPerSec {
        p.tokens = p.BudgetPerSec // 封顶:不能无限攒
    }
    p.lastFill = now
}

func (p *PriorityLevel) Dequeue(now time.Time) string {
    p.fill(now)
    ...
    if p.tokens >= 1 {
        p.tokens--
        ... // 放行队首
    }
    return ""
}

令牌桶的两面:

  1. 限平均速率:长期看,放行速率 ≈ 每秒配额——不会持续超发。
  2. 容忍突发:空闲时桶里攒满令牌,突发请求一来可以「一次用光」——短时超发可以。

突发容忍:为什么重要

令牌桶比「每秒硬限 N 个」更适合真实流量,因为请求天然有突发:

限流方式突发 20 个请求(预算 10/s)
每秒硬限10 个被拒(哪怕之前空闲了很久)
令牌桶(桶=10)空闲攒满 10 个令牌 → 10 个放行、10 个排队

硬限对「偶发突发」太苛刻:一个服务平时每秒 1 个请求,某瞬间因为某个任务并发了 20 个——硬限会拒掉多余的,令牌桶则能用「平时攒下的预算」消化一部分。

令牌桶在「平均速率」与「峰值容忍」之间折中:平均不快于预算,但允许「把此前没用完的预算一次性花掉」。这是对「真实工作负载有突发性」的尊重——限流不该惩罚「偶尔忙一下」的正常流量。

预算封顶:防「攒太久一次清空」

令牌桶有一个重要细节:桶上限 = 每秒配额(lab 里 tokens > BudgetPerSec 就封顶)。

为什么封顶:如果不封顶,一个优先级空闲 1 小时攒 3600 个令牌,突发一来全放行——等于「把限流变成不限流」。封顶保证「可容忍的突发有界」:

桶状态可突发量
空闲满桶≤ 每秒配额(一次突发至多用掉一个周期的预算)
持续繁忙几乎无积攒,突发只能排队

封顶让「突发容忍」是有限的:能容忍「短时高峰」,不能容忍「长期积攒的一次性清空」。这是限流语义的关键——限制突发的同时保留一定的灵活性。

预算的工程含义:怎么设 BudgetPerSec

配额预算的设置是运维决策:

考虑含义
apiserver 总处理能力各级预算之和 ≈ 总能力,超了就排队/降级
流量优先级系统级高一些,批量任务低一些
增长余量留突发空间(令牌桶天然支持)

预算本质是「给哪类流量多少处理能力」的分配。设得太高,该级流量会挤占其他级;设得太低,该级频繁排队。APF 预算的调整是「限流策略的运维化」——不写代码,只调数字。

令牌桶与 6.1 节退避的对比:两种限速哲学

控制面里有两套「限速」,机制不同、目的互补:

机制在哪作用对象哲学
指数退避(6.1 节)客户端重试节奏失败越频繁越放慢
令牌桶(本节)服务端请求速率平均不超预算、容忍突发

退避是「失败后的自我惩罚」,令牌桶是「配额内的公平分配」。一个控制「重试的节奏」,一个控制「请求的速率」——客户端控制不了 apiserver 的配额,apiserver 也控制不了客户端的退避,两者组合才是完整的限流体系(12.1 节的分层)。

令牌桶的惰性结算:只在需要时算账

lab 的 fill 是「用的时候补」,不是「定时补」——这是令牌桶的经典实现技巧(惰性结算):

func (p *PriorityLevel) Dequeue(now time.Time) string {
    p.fill(now) // 现在这一刻才按 elapsed 补令牌
    ...
}

为什么惰性:如果用定时器每秒补一次,空闲时也在空转、还要处理并发;惰性结算把「补令牌」推迟到「真正要放行请求的那一刻」——now.Sub(p.lastFill) * BudgetPerSec 一次算清,省一个定时器、无并发竞争。

惰性结算的等价性:不论何时调用,算出的令牌数 = 用定时器逐秒补的结果。分布式系统的实现里这类「把定时驱动改成事件驱动」的技巧很常见(第 6 章 workqueue 的延迟也是事件驱动)——关键不是「怎么计时」,而是「结算结果正确」。

不同请求的不同代价:配额不只是「个数」

真实 APF 的配额不是「每秒 N 个请求」这么简单——不同请求的代价不同:

请求类型相对代价
读缓存内的对象低
写、list、watch高(要落盘/要遍历/要常驻连接)

APF 用「代价因子」把不同请求折算成「配额单位的消耗」:一个 list 消耗多个配额单位、一个普通读消耗一个。这比「每个请求消耗 1」公平得多——限流限的是「消耗的处理能力」,不是「请求个数」。一个疯狂 list 的客户端比一个疯狂读小对象的客户端耗资源得多,理应更快被限。

lab 的 BudgetPerSec(个请求/秒)是简化:真实 APF 的预算单位是「代价单位」。理解这个维度,才理解「为什么我发了 100 个请求没事、发 10 个 list 就被限了」——限流衡量的从来不是请求数,而是资源消耗。

配额预算的容量规划:粗估算

预算设置的前置问题是「apiserver 能扛多少」。粗估算方法:

步骤做法
1. 测基线压测/观察 apiserver 单副本每秒能处理多少请求
2. 分配把总能力按优先级拆成各级预算
3. 留余量各级预算之和略小于总能力(留突发与不可控流量)

预算之和 ≠ 总能力:预算之和超过总能力,等于「给了配额但兑现不了」——流量一起涌来还是排队;预算之和留余量,才有「超额时的缓冲」。预算不是「目标」,是「承诺的分配」——分配之和不能超过可兑现的总额。

预算不是一次定死:观察队列长度(12.2 节)和限流拒绝率,反过来调预算。APF 是「数字驱动的限流」:指标 → 调整 → 再观察,这是运维的闭环——与 8.3 节诊断方法论一脉相承。

令牌桶 vs 漏桶:两种限流的哲学

限流还有一种经典实现「漏桶」(leaky bucket),常与令牌桶混淆:

令牌桶漏桶
模型攒令牌、用令牌水注桶、匀速漏出
突发容忍(可用积攒的令牌)不允许(出口匀速)
平均速率受限受限

关键差异在「突发」:漏桶的出口是严格匀速的——突发一律排队,不给你「攒的量」;令牌桶则允许用积攒的预算「爆一下」。APF 选令牌桶,因为 K8s 的请求天然有突发——漏桶会把正常突发全排队、增加队列压力。

理解两种模型,才能看懂限流参数:调令牌桶是「给多少预算 + 桶多大」;调漏桶是「出口速率定死」。K8s 用令牌桶不是巧合,是「容忍突发」的设计选择。

三个常见误解

  • 「令牌桶是每秒硬限」——错误。令牌桶允许用积攒的预算容忍突发;硬限是另一套(更苛刻)的限流。
  • 「空闲越久突发能力越大」——错误。桶有上限,空闲攒满就封顶;可突发量是「一个周期的预算」,不是无限累积。
  • 「配额越高越好」——错误。配额是分配,总预算超过 apiserver 能力等于不限流;要按优先级合理分配。

本节 lab

本节验证令牌桶的预算放行与超预算排队:

cd private/labs/k8s-ctrl-lab
go test ./admission -run 'TestAPFTokenBucket' -v
  • TestAPFTokenBucket:预算 2/s 时 3 个请求——第 1 秒放行 2 个(预算),c 排队;1 秒后令牌补充,c 放行——「预算内放行、超预算排队、令牌随时间补充」的完整节奏。

继续阅读

探索更多技术文章

浏览归档,发现更多关于系统设计、工具链和工程实践的内容。

全部文章 返回首页

「books」更多文章

  1. 《大规模分布式计算深入解析》15.3 落地:从 Neo4j 到自研图引擎
  2. 《大规模分布式计算深入解析·图计算与图数据库内核》 · 目录与学习路径(45 篇)
  3. 《大规模分布式计算深入解析》15.2 十一卷主线:从切分到图