13.2 大集群 watch 扇出与限流
13.1 把 watch 协议的单条语义讲清楚了:一个 watcher 从某个 revision 起,订阅一个 key 区间的事件流。但 K8s 控制面从来不只有一个 watcher——每个控制器、每个 kubelet、每个 informer 都在 watch,同一份事件要被很多人同时看到。本节看 watch 在大集群下的放大效应:一次写如何扇出给成千上万个 watcher,慢消费者如何变成风险,服务端如何用限流保护自己,以及 apiserver 的 watch cache 为什么是这个架构里的关键一层。它与 13.1 的关系是「单条 → 多条」:13.1 的 watcher 是一个,本节把它放大成几千个同时存在,并回答由此带来的新问题——放大效应如何产生、服务端如何不被拖垮。
一次写、多份消费:扇出的定义
扇出(fanout)指的是:一次写操作在 mvcc 里只产生一个事件,但这个事件要被所有「覆盖到该 key」的 watcher 各消费一份。等价的描述是——写是单点的,读增量是多点的。
| 角色 | 数量 | 动作 |
|---|---|---|
| 写者(apiserver) | 每写一次 | mvcc 追加一个事件,revision +1 |
| watcher A(控制器 X) | 订阅某前缀 | 收到该事件 |
| watcher B(kubelet) | 订阅某前缀 | 收到同一事件 |
| watcher C(informer) | 订阅某前缀 | 收到同一事件 |
一次 Put 推进一个 revision,但事件被复制到 N 份消费路径上。每个 watcher 拿到的内容完全相同——同一个 revision、同一个 key、同一个值——只是各自独立消费,互不干扰:一个 watcher 没读走,不影响其他 watcher 读到。看一个最小实例:客户端 A 与客户端 B 都从 rev 0 开始 watch 同一个前缀,服务端 Put("k","fanout") 产生 rev 1 一个事件。服务端的动作是把这一个事件投进 A、B 两个通道,A 与 B 各自读出同一份 PUT k=fanout @1。扇出不是事件在 mvcc 里的复制(mvcc 里仍只有一条),而是投递复制:日志一份、投递 N 份。
写放大与读放大要分开算:
| 指标 | 写端 | 分发端 |
|---|---|---|
| 放大性质 | 无(始终 1 个事件) | N 份投递 |
| 代价主体 | mvcc 追加日志 | 通道复制与同步 |
| 优化手段 | —— | 减少 watcher 数量(聚合) |
扇出的成本不在写端而在分发端——服务端要把同一事件复制给 N 个通道。所以优化 watch 的着眼点不是「减少事件」,而是「减少 watcher 数量」,这正是 apiserver watch cache 聚合要做的事。理解「复制给 N 个通道」发生在哪一层,是后面看懂 watch cache 的关键。
每个 watcher 还有自己独立的消费游标:A 读到事件 1、2、3,B 可能只读了 1——它们各自维护自己的 lastRev,互不共享。这正是 13.3 节重连协议的基础:服务端把事件发给所有 watcher,但每个 watcher 读到哪、断在哪儿,完全由自己记账。扇出保证「大家看到同一份内容」,不保证「大家同步消费」。
扇出还有一个一致性含义:所有 watcher 收到的是同一 revision 的事件,因此「不同 watcher 看到的演进顺序」一致——只要它们都追平到同一 revision,本地缓存内容就一致(第 2 章的一致性谱系里,这属于同一时间线上的顺序一致)。扇出不引入分歧,只放大数量。
最后澄清一个常见误解:扇出不是「广播给所有 watcher」,而是「覆盖该 key 区间的所有 watcher」。一个 watcher 只在订阅范围包含该 key 时才收到事件——前缀较窄的 watcher 收到的事件天然更少。扇出的实际规模等于「事件所在区间」与「各 watcher 订阅区间」的交叠之和;窄订阅是客户端自己控制扇出成本的手段,也是 13.1 节选对 key 范围的工程意义所在。
扇出的数学表述可以写成:一次写 w 的分发成本等于覆盖 w 的 watcher 数。同一前缀上的 watcher 越多、该前缀写入越频繁,这个和就越大;优化的两个方向分别是缩小订阅范围(窄前缀)与减少 watcher 数量(聚合)。
大集群下的 watch 数量:成千上万 watcher 的场景
扇出的放大倍数由「活跃 watcher 数」决定。算一笔 5000 节点集群的账:
| 来源 | 数量量级 | 覆盖前缀 |
|---|---|---|
| kubelet(每节点 1 个 informer) | 5000 | 大多限节点前缀,部分全集群 |
| 各类内置控制器 | 数十 | 全集群 /registry/... |
| CRD 控制器 / 自定义 operator | 数十到数百 | 各自资源前缀 |
| 调度器、扩展组件 | 数十 | 全集群 |
把「限节点前缀」与「全集群前缀」分开看:限节点前缀(如 /registry/nodes/<node>/)每次写只命中少量 watcher;全集群前缀(如 /registry/pods/、/registry/events/)才是扇出热区——一次写会命中这条前缀上的所有 watcher。于是单个 etcd 成员同时服务几千到上万条 watch 流是常态,其中全集群前缀上的写事件要被这条前缀的全部订阅者各自收走。
watch 流本身还有成本:每条流都要维护位置、缓冲、心跳。etcd 对每条 watch 定期做进度通知(13.3 节)、对落后的 unsynced watcher 做批量回放,这些同步循环的复杂度随 watcher 数增长。所以「watch 数翻倍」不是「成本翻倍」那么简单——同步循环、锁竞争、心跳都在放大。这也是为什么 watch 性能要按「事件数 × 覆盖 watcher 数」估算,而不是只按事件数。
再看下游的联动成本:一个 informer 的 watch 每收到一个事件,都要做本地 store 更新、触发回调;控制器每触发一次调谐,还要读一遍缓存。这些成本不在 etcd 端直接计量,但都源于 etcd 扇出的那一个事件——扇出是整条链的起点,下游所有增量处理都是它的后续。
还有一类 watcher 会周期性重建:informer 收到 410 或流超时后强制 relist + 重 watch(13.3 节)。于是 watcher 数量本身是波动的——稳态几千条,故障恢复时可能短时间内叠加到上万条。服务端的限流与缓冲必须按峰值设计,不能按稳态设计。
慢消费者与积压:backlog 如何累积
扇出的前提是每个 watcher 都能及时消费。但客户端不是始终在线的:GC 暂停、网络抖动、客户端进程处理不过来,都会让一个 watcher 的消费速度暂时归零。服务端此时有两个选择:丢掉没来得及发的事件,或者把事件先积压起来。
etcd 的选择是「先积压」:每个 watcher 有一条有界的事件通道(以 v3.5 源码为例,缓冲长度是 1024)。通道没满,事件正常投递;通道满了,服务端不能无限等——它把这批事件放进一个受害者队列(victims),稍后重试投递。积压的代价由服务端的内存和重试循环承担。一个 watcher 的通道一直满,就意味着服务端一直替它存着未投递的事件,直到它消费,或通道里的内容因压缩而过期。
victims 的重试不是无限频率:服务端会限速重试,避免受害者队列占用过多 CPU。重试之间事件继续积压,但不会丢——只要压缩还没越过起点,事件就还在。这套设计的本意是「尽可能不丢」,但它有一个软肋:重试本身占用同步循环,受害者越多,正常 watcher 的同步越慢,形成连锁放大。
用时间线看积压是怎么涨起来的(假设通道容量 3):
t0 写 e1 → 通道 [e1] 客户端还没来读
t1 写 e2 → 通道 [e1,e2]
t2 写 e3 → 通道 [e1,e2,e3] 满
t3 写 e4 → 通道满,服务端转 victims 重试
... 客户端继续不来,victims 越积越多
客户端只要有一小段停顿(GC、网络拥塞、CPU 忙),积压就会随时间线性上涨;服务端要替它承担这段停顿的全部代价。这里的「积压」与 13.1 的「backlog 追平」是同一个词、两种用法:backlog 追平是创建时一次性补历史(服务端主动、有界);实时积压是客户端不及时消费的堆积(客户端被动、无界)。前者是协议特性,后者是需要限流的风险。
积压还有一个与压缩的交叉点:积压里的未投递事件,若其 revision 已被压缩回收,就再也不可能投递了。此时 watcher 即使想消费,也拿不到完整历史——服务端只能把它取消。所以「慢消费者」与「压缩」是两个独立的风险源,但它们会合谋:慢消费者拖得越久,越容易被压缩淘汰(13.1 的 410 路径)。限流的意义之一,就是让慢消费者在压缩之前就被清理,避免走到更昂贵的 relist 分支。
通道容量是服务端的单个旋钮:容量越大,容忍停顿越久,但内存越高、积压拖累越大;容量越小,服务端越安全,但正常的短暂抖动更容易触发取消。etcd 的 1024 是经验取值——对 K8s 的典型事件速率(毫秒到秒级一条),它能容纳几秒到几十秒的客户端停顿,又不至于让单个 watcher 占太多内存。真正危险的不是通道本身,而是「客户端持续不来 + 事件持续产生」的组合:这种组合下无界积压会把内存吃穿。
另一个角度看积压:它本质上是「把排队从客户端挪到服务端」。客户端自己也可以排队(把事件放入本地缓冲慢慢处理),区别是客户端排队自己承担内存,服务端排队则所有用户一起承担。协议上「谁更该承担排队」没有标准答案,但服务端必须给自己留退路——这正是下一节积压上限的由来。
积压上限与取消:限流保护服务端
让积压无限增长是不可接受的——服务端必须设一条线,过了线就止损。限流的语义可以设计成两种:
| 策略 | 做法 | 代价 |
|---|---|---|
| 无限重试 | 一直替客户端存事件,直到它消费 | 服务端被拖住,积压无上界 |
| 设上限取消 | 积压超上限,取消该 watcher,通知客户端重连 | 客户端多一次重连/重建,但服务端有界 |
etcd 的真实机制是两者的混合:有界通道 + victims 重试(尽量不丢事件),而真正把落后者拦下来的是压缩——watcher 还在 victims 里没追平,压缩点已经越过它的起点,它就被 ErrCompacted 取消(13.1 的断流路径)。本节的 lab 用一个更直白的模型演示同样的语义:积压上限设为 2,写满第 3 个事件且客户端没消费,watcher 立即被取消,返回 ErrCanceled。两种实现细节不同,但工程结论一致:服务端对单个 watcher 的容忍必须有界,越界就取消,把恢复的责任交还给客户端。
需要区分两种「watch 失败」的成因:ErrCompacted 是起点被历史回收(13.1 的断流,与客户端快慢无关);ErrCanceled 是客户端消费太慢(本节限流)。前者的修复是换一个更新的起点,后者的修复是让自己快起来——但对重连协议而言两者殊途同归:都重新 List + 重建 watch。因此 13.3 节的重连协议对两种失败一视同仁。
还有一点容易被忽略:取消是「最终生效」,不保证即时。服务端可能在取消的同时还在投递已排队的事件——客户端以收到错误为准,错误之前的事件仍可正常消费并计入 lastRev。这让重连边界永远清晰:错误即终结,终结之前的事件都算数。
取消不是丢数据:被取消的 watcher 客户端握有自己的已消费 revision,走 13.1 的重建协议即可追回。服务端为此付出的代价只是让客户端重连一次,而不是无限期替它缓存。上限本身是个旋钮:设太大,积压会吃内存;设太小,正常的 GC 停顿都会误杀 watcher、引发重连风暴。取值要在「服务端内存预算」与「客户端重连频率」之间权衡。
客户端怎么知道自己被取消了?取消不是悄悄发生的——服务端会在这条 watch 流上返回错误(ErrCanceled 或 ErrCompacted),客户端收到错误就知道流已终结,进入重连协议。若连接本身也断了、错误送不到,客户端靠 13.3 节的 progress notify 超时同样能察觉——两边都保证「不会被无声抛弃」。
本节的 lab 把上限设为 2 是一个教学极值,真实系统绝不会用这么小的值。它演示的是机制而非取值:publish 在投递时检查积压长度,超过 maxBuffer 就把 watcher 标记为 canceled,之后该 watcher 的任何 Events 调用都返回 ErrCanceled。
还有一层边界藏在 13.1 的 backlog 追平里:创建 watch 时的回放同样受积压上限约束。若客户端从很远的历史起点创建 watch,回放事件量本身就超过上限,watcher 在创建那一刻就被取消(本 lab 的 Watch 实现里,回放后检查 len(buffered) > maxBuffer 即置 canceled)。所以追平起点不是「越旧越好」——它决定回放量,回放量又受积压上限约束。这也是 K8s 要求 informer 常驻 watch、避免长时间离线后一次性补巨量历史的原因之一。取消是一次到位的——不是超过一点点就反复试探,而是越界即断,让客户端尽快进入重连而不是继续拖着服务端。让客户端尽快重连还有一层好处:重连走 13.1 的重建协议,从 lastRev + 1 或 relist 后的 rv1 + 1 续读,服务端只需回放一次 backlog,不必长期维持一条半死的流——取消的本质是把「长期慢速占用」转成「一次快速重新对齐」。
apiserver watch cache:把 N 个 watch 聚合成 1 个
如果每个 informer 都直连 etcd,上面的扇出会直接把 etcd 打穿。apiserver 的 watch cache(Cacher)是这层放大器的开关:
- 聚合:同一前缀下,无论 100 个还是 1000 个客户端 watch,apiserver 只在 etcd 上维护 1 条底层 watch;
- 扇出:etcd 事件到达后,Cacher 把事件转发给所有本地订阅该前缀的客户端 watch;
- 快照:Cacher 同时维护一份对象缓存,List 默认由快照服务(第 10.3 节讲过这条弱一致路径)。
于是真正的扇出放大发生在 apiserver 内部,而不是 etcd 上:etcd 看到的 watcher 数量被压到「每 apiserver 每资源前缀 1 条」。再乘上 apiserver 副本数:K8s 通常跑 2–3 个 apiserver,每个都对同一资源前缀维护一条 etcd watch——etcd 端的总量是「资源前缀数 × apiserver 数」,一个几百前缀 × 3 副本的集群也就几百条,远小于客户端总数。聚合的效果是跨 apiserver 的:etcd 不知道也不关心 apiserver 背后挂了多少 informer。这是 K8s 能在 5000 节点集群上不把 etcd watch 打爆的关键设计——聚合层的本质是用 etcd 的一次写放大,替换掉 apiserver 内部的 N 次读放大。
代价也是真实的:Cacher 的本地缓存是弱一致的(第 10.3 节),List 默认从快照读,可能比 etcd 当前状态旧几个事件;watch 事件到达 Cacher 后再转发,多一跳延迟。用「多一跳延迟」换「etcd watcher 数量降两个数量级」,在大集群里几乎总是划算的。
举个例子量化聚合效果:某集群有 2000 个 informer 都在 watch /registry/pods/(500 个节点、多控制器)。没有聚合时,etcd 要面对 2000 条流;有聚合后,若跑 3 个 apiserver,etcd 端只有 3 条底层 watch。2000 → 3,降了两个数量级。这 3 条流内部,Cacher 再把事件复制给 2000 个客户端——放大发生在内存分发,而不是网络与 etcd 锁竞争。聚合做到资源粒度,每类资源独立一条底层 watch,既保留「不同资源互不影响」的隔离性,又把同一资源内的扇出留在内存里。
聚合也不是没有上限:etcd 端每条底层 watch 的事件速率与体积,要能跟得上 apiserver 的转发。若某资源前缀的事件速率极高(比如 Event 对象在故障期的爆发,第 9.3 节提过),聚合后的单条底层 watch 会成为瓶颈——此时要在 apiserver 侧限订阅粒度或降采样。聚合解决「watcher 数量」问题,不解决「事件速率」问题,两者要分开评估。
顺带一提,K8s 的 watch cache 不只服务 informer:kubectl get -w、Metrics Server 等临时客户端也走同一聚合路径。聚合对「短命 watch」同样有效——一个只存在几秒的 watch 不需要在 etcd 上单独开流,直接在本地扇出即可。这让临时订阅不会冲击 etcd 的 watcher 上限,也解释了为什么 kubectl 的 --watch 在大型集群里不会造成明显负载。
apiserver 的聚合还有一个微妙的边界:Cacher 只对「缓存启用的资源」聚合。某些高频但低价值的资源若关闭了 watch cache(K8s 允许按资源关闭),其客户端 watch 会直连 etcd,扇出直接打在 etcd 上。判断是否关闭的标准与本节一致:看该前缀的 watcher 数与事件速率的乘积,是否值得为它维护一条底层 watch 与一份缓存。
限流的工程取舍:宁可取消、不可拖垮
把限流的取舍原则说透:单个 watcher 的健康不值得牺牲整个成员的可用性。一条慢 watcher 的积压消耗的内存、重试循环、锁竞争,会推迟所有其他 watcher 和写请求的处理;对一个同时服务 apiserver 写路径的成员,这就是控制面整体延迟上升。所以宁可让慢客户端重连——一次 relist 的成本是下载几千个对象,远低于让成员卡死。
落到配置与运维上,有几个可操作的判断:
- 压缩 retention 是硬边界:auto-compaction 越激进,落后者越容易被
ErrCompacted淘汰,重连频率越高;第 9.3 节的 8h 经验值就是在「容忍慢 watcher」与「控制库体积」之间的平衡; - apiserver 的 watch 超时与 relist:客户端 watch 断开后自动 relist,是有界的自愈;但 relist 本身也放大读负载,批量 relist(比如网络恢复后同时发起)会叠加成峰值;
- 用客户端限流替代服务端兜底:informer 的 relist 频率、缓存大小,客户端侧可以主动控制,别把全部兜底责任压给服务端。
还有一个经常被忽略的取舍点:限流阈值要与告警联动。生产里「watch 被取消的次数」是可观测的(etcd 的 watcher 取消计数、apiserver 的 relist 计数)。如果取消频率异常上升,往往是客户端批量失联或事件速率突变的前兆——此时调阈值只是止血,先定位「谁在批量落后」才是解药。
把本节的三层防护排个序:watch cache 聚合是最前的闸(从源头减少 watcher 数),积压上限与取消是中闸(对单条慢流止损),压缩是后闸(兜底淘汰落后者)。三道闸各自独立,缺一道都会让压力转移到下一道、甚至击穿整个链条。
最后补一个认知:限流不是「惩罚客户端」,而是「划分责任」。服务端负责有界(积压上限、压缩、watch cache 聚合),客户端负责可恢复(记录 lastRev、自动重连、relist)。把两边各做对,watch 这条链在 5000 节点集群上才是稳定的;任何一边缺位,故障都会以「etcd 打爆」或「缓存永久陈旧」的形式反弹回来。一句话总结本节:watch 是读放大的通道,扇出把一次写变成 N 份消费;大集群靠 apiserver watch cache 聚合把 N 降到几十,靠压缩和有界积压把单个 watcher 的坏影响隔离开。
本节 lab
本节两个用例在 private/labs/k8s-etcd-lab/watcher/:
TestWatchFanoutBroadcast:验证扇出——两个 watcher 都从 rev 0 开始,一次Put后各自收到同一事件(同一个 key、同一个值、同一个 revision);TestWatchSlowConsumerCanceled:验证慢消费者限流——积压上限设为 2,连续写 3 个事件且不消费,第三个事件触发积压 3 > 2,watcher 被取消(ErrCanceled);随后新建的健康 watcher 不受影响。
运行命令:
cd private/labs/k8s-etcd-lab
go test ./watcher -run 'TestWatchFanoutBroadcast|TestWatchSlowConsumerCanceled' -v
预期断言:
- 扇出用例:两个 watcher 都必须收到恰好 1 个事件,事件 key 都是
k、内容都是fanout,且均未被取消; - 慢消费者用例:前 2 个事件不消费时 watcher 仍正常;第 3 个事件写入后,
Events必须返回ErrCanceled;从当前 rev+1=4 新建的 watcher 必须正常且无积压事件。
两条全过即表示一次写扇出多份、以及积压超限取消慢消费者(健康 watcher 不受连坐)的语义符合本节描述。
继续阅读
探索更多技术文章
浏览归档,发现更多关于系统设计、工具链和工程实践的内容。