《Kubernetes 分布式系统原理深入解析》3.3 缓存滞后、relist 退避与一致性边界

informer 缓存是异步维护的,必然滞后于 etcd;watch 连接断开时 informer 会重新 list 全量,并用指数退避防止打爆 apiserver。本节精确刻画『缓存有多滞后、滞后怎么产生、怎么消除』以及 relist 退避的边界条件。lab 用 informer/reflector.go 验证缓存滞后到追赶的过程与退避序列。

3.3 缓存滞后、relist 退避与一致性边界

list-watch 给了控制器一个近乎免费的本地缓存,但代价是:缓存永远比 etcd 旧一点。本节不回避这个事实,而是精确刻画「旧多少、为什么旧、旧了会怎样」,以及连接断开时 informer 如何用退避安全恢复。

缓存滞后:系统设计的一部分

控制器读到的「当前状态」其实是一个时点快照,它的年龄 ≈ watch 传播延迟:

写者写 etcd ──(a)──> etcd 提交 ──(b)──> apiserver watch 到 ──(c)──> 控制器 informer watch 到 ──(d)──> Indexer 更新

滞后 = (a)+(b)+(c)+(d)。其中:

  • (a) 写提交本身(Raft 往返,毫秒级)。
  • (b)+(c) 事件传播(网络 + apiserver 扇出,毫秒~百毫秒)。
  • (d) FIFO 排队到 worker 处理(取决于队列积压,可到秒级)。

所以控制器看到的「当前」可能落后几毫秒到几秒。这不是 bug,是有界滞后的一致性档位:控制器的观察是「最终一致 + 有界延迟」,而不是线性一致。

滞后在什么时候会咬人

大多数场景滞后无害(控制器重试幂等),但有三类场景要小心:

  1. 读后写(Read-Modify-Write):控制器读缓存算出差异写回 apiserver。若缓存旧,算出的差异基于旧状态——但写回带 RV 乐观锁,冲突会 409 并重试。所以滞后被乐观锁「兜住」,不会覆盖新数据。
  2. 状态判定:observedGeneration == generation 判断「控制器是否已处理」。若 status 更新还没进缓存,判定可能短暂为 false——但控制器会持续调谐直到追平,最终一致。
  3. 跨 informer 时序:两个 informer(Deployment 与 ReplicaSet)滞后不同步时,可能暂时看到「有 RS 没 Pod」的中间态。控制器的幂等与重试保证了最终收敛。

核心认识:滞后是「有界的」,且被「乐观锁 + 幂等 + 重试」兜底。这是声明式系统允许缓存存在的根基。

断连与 relist:从不漏事件

watch 是长连接,会断(网络抖动、apiserver 重启、超时)。断连时 informer 的处理不是「重连 watch」,而是重新 List 全量:

watch 断开
  └─> 指数退避等待
      └─> 重新 List(拿全量 + 新 RV)
          └─> 用 Sync 增量重建缓存
              └─> 重新 Watch(从新 RV 续接)

为什么不只重连 watch?因为断连期间的事件可能丢了(watch 流断的那一刻,从旧 RV 续接可能拿到「已压缩」的旧版本,或错过断连瞬间的写)。relist 用全量覆盖缓存,从根上消除断连期间的不一致。代价是 list 全量比增量贵——所以要有退避。

退避:避免打爆 apiserver

如果 watch 频繁断连,informer 反复 list 会给 apiserver 造成压力。client-go 用指数退避:

第 1 次重试:等待 50ms~1s(含抖动)
第 2 次:100ms~2s
第 3 次:200ms~4s
...
封顶:8s(不再增长)

退避的分布式意义:失败越频繁,越要放慢,防止「失败风暴」把自己打到 apiserver 上。这呼应卷二第 12 章 APF 限流的思想——系统内的重试行为必须自我节流。

一致性边界:什么时候可以信任缓存

给控制器工程师一个实操判据:

我要回答的问题读哪里可信度
对象存在吗、现状如何informer 缓存有界滞后,最终一致
我的写成功了吗写响应的 RV线性一致(已提交)
控制器处理到哪一代了observedGeneration vs generation最终一致,持续追平
我需要绝对最新的状态直读 apiserver(GET 不带缓存)看 apiserver 实现

实践中:控制器默认读缓存,必要时(如关键状态判定)直读 apiserver。二者共存正是「有界滞后 + 按需线性」的工程形态。

滞后窗口的量化:控制器看到的状态到底多旧

把滞后量化,有助于判断「控制器读到的是不是可接受的旧」:

写提交 t0 ──(10ms)──> apiserver 扇出 t1
         ──(5ms)──> informer watch 到达 t2
         ──(排队)──> worker Pop t3
         ──(处理)──> Indexer 更新 t4
  • t0→t1:etcd 到 apiserver 的事件传播(毫秒)。
  • t1→t2:apiserver 到 informer 的网络与协议(毫秒~百毫秒)。
  • t2→t3:DeltaFIFO 排队(正常空闲时接近 0;高峰期可到秒级)。
  • t3→t4:worker 消费写入 Indexer(毫秒)。

正常负载下滞后是几十到几百毫秒,积压时可达秒级。 这不是失败,是「有界滞后」档位的正常表现。控制器的设计必须能容忍它——依赖乐观锁、幂等、重试兜底(3.1 节的承诺,2.2 节的保障)。

relist 的代价与「可压缩窗口」

relist 全量虽然安全,但贵:几万个对象重新 List + 重新进 FIFO + 重新处理。所以 informer 不会随便 relist——只在三种情况触发:

触发条件说明
watch 连接断开网络/超时,最常用
收到 410 Gone起点 RV 已被 etcd 压缩
显式 relist 请求代码调用(如重新注册)

注意「410 Gone 起点已压缩」的含义:etcd 只保留最近一段 revision(后端压缩窗口)。如果 informer 因故长时间未同步(如进程暂停 10 分钟),恢复后它的 RV 起点已不可用——只能 relist。这解释了为什么 informer 的恢复永远是「全量重建」,而不是「从上次断点续增量」。

工程结论:缓存可以接受滞后,但不能接受「断点不可续」。list-watch 的原语保证永远是「全量 + 增量」两段式,任何一端失效就重来全量——这是可靠性优先于性能的选择。relist 的退避序列(50ms~8s)正是为「全量重建的成本」配的节流阀:重建越频繁,等待越久,避免失败风暴。

三个常见误解

  • 「缓存滞后 = 控制器会漏状态」——错误。list-watch 保证不漏事件;滞后是「看到得晚」,不是「看不到」。
  • 「watch 断连只重连就行」——错误。必须 relist 全量重建,否则断连期间可能丢事件。
  • 「退避是为了惩罚失败者」——不是。退避是分布式系统的自我节流:防止重试风暴压垮共享的 apiserver。

缓存的最终一致不是「最终平等」:滞后对状态判定的具体影响

「最终一致」在 K8s 里具体到一次状态判定,是这样工作的:

以「Deployment 是否滚动完成」为例:

t0  用户改 image,Generation 2→3
t1  Deployment 控制器 watch 到(滞后 δ)
t2  控制器开始滚动:建新 RS
t3  新 RS 控制器 watch 到 RS,建新 Pod
t4  新 Pod 就绪
t5  RS 控制器写 RS status
t6  Deployment 控制器 watch 到 RS status,写 Deployment status
t7  用户 `kubectl get deploy` 看到 updatedReplicas=3

t0→t7 之间每一步都有缓存滞后叠加,但每一层的 status 更新都被下一层「最终看到」。最终一致 = 每个观察者最终会看到最新状态,但到达的时间各不相同。用户看到的「完成」不是瞬时值,而是经过多层滞后传导后的结果。

两个实操要点:

  1. 别在脚本里「apply 完立刻断言状态」:滞后叠加意味着断言可能短暂失败。要等 kubectl rollout status(它自己轮询等待)而非一次 GET。
  2. 观察 observedGeneration 而非直接看 readyReplicas:generation 追平才是「控制器已处理」,readyReplicas 达标可能还是旧一代的残留(2.1 节)。

滞后不是「系统错了」,而是「有界一致性的正常表现」。接受它、观测 generation、用等待而非断言,是控制器工程师的正确姿势。

滞后与 resync:两种「补」的层次不同

滞后与 resync 都涉及「缓存和现实有差距」,但层次完全不同:

  • 滞后是「现实变了,缓存还没跟上」——由 watch 传播延迟造成,被动。
  • resync是「缓存可能已同步,但控制器可能漏处理」——把缓存里的对象重新交给控制器检查,主动。

两者互补:滞后由 informer 的 relist 兜底(全量重建),漏处理由控制器的 resync 兜底(重新入队)。理解这层区别,就不会把「加 resync 间隔」当成「修滞后」的手段——滞后靠 relist,漏处理靠 resync,两个旋钮管两个问题。

滞后与 409 的接力:读旧写新不丢数据

控制器读旧缓存、算出差异、写回 apiserver 时,如果现实已变,写会 409。这正是滞后被「兜住」的完整链条:读的是旧值 → 写的是基于旧值的计算 → apiserver 发现版本不符 → 409 → 控制器重读重算。缓存滞后永远不会导致「覆盖新数据」,因为乐观锁在写路径上拦截了基于旧状态的写入。滞后只影响「暂时看到旧值」,不影响「最终正确」。

本节 lab

本节验证两个核心行为:缓存滞后到追赶、relist 退避序列:

cd private/labs/k8s-ctrl-lab
go test ./informer -run 'TestCacheLag|TestRelistBackoff' -v
  • TestCacheLag:对象在 apiserver 更新后,Indexer 缓存保持旧值;处理 watch 增量后缓存才追赶——「缓存滞后是异步更新」的直观演示。
  • TestRelistBackoff:退避序列单调递增且封顶 8s——断连重试的自我节流。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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