《Kubernetes 分布式系统原理深入解析》15.3 一致性 vs 性能的权衡全景

收束卷一:从一致性模型到 Raft 共识再到 etcd 工程,每个选择都是一致性档位与代价的交换。本节给出五档全景、成本明细与决策框架,lab 用全量 46 用例逐档验证各档行为。

15.3 一致性 vs 性能的权衡全景

15.2 节把性能瓶颈拆成磁盘与网络两块预算,本质是「给一致性档位算账」。本节收束卷一:从第 2 章的一致性模型,到第 4–10 章的 Raft 共识,再到第 11–15 章的 etcd 工程,一路下来每一个「为什么这么设计」的选择,本质上都是在一致性档位与代价之间做交换。把这笔账的骨架画出来,就是本节的权衡全景。

卷一主线:每个选择都是档位与代价的交换

卷一的主线是一条「理论 → 算法 → 工程」的链条,每一环都在回答同一类问题:

章节一致性决定付的代价
第 2 章线性一致 vs 最终一致的选择分区下可用性的取舍(CAP)
第 4–10 章用 Raft 多数派保证写与读的线性一致fsync、网络往返、日志复制
第 11 章写入路径把共识变成产品WAL 落盘 + 多数派确认
第 12 章mvcc + 乐观锁支撑并发写revision 存储、冲突重试
第 13 章watch 事件流让客户端追新扇出成本、慢消费者限流
第 14–15 章容错与运维把代价量化2f+1、RTT/fsync 预算

没有哪一章是「为了更一致而更一致」——每一档一致性都明码标价,工程就是在这些价格里挑能付得起的组合。

把「账」说得更直白:第 2 章定档位,第 4–10 章定算法,第 11–13 章把算法变成存储产品,第 14–15 章给整套系统定容错与运维的价格。读者跟着这条线走下来,应该得到的不是「记住 etcd 有哪些配置」,而是一种带着价签看设计的习惯:任何一个「为什么强一致」「为什么这里可以弱一致」的问题,答案都是同一句话——这个档位,付得起这个代价。

一致性档位全景:五档并用

etcd 与 K8s 控制面并不是单一「强一致」系统,而是多档并用。按从新到旧排开:

档位机制谁在用能否读到旧
写线性一致多数派提交 + WAL fsync所有 etcd 写不可能(写必须多数确认)
线性一致读ReadIndex / Lease Readapiserver 直连读不可能
串行化读本机 mvcc 直接读可容忍旧的查询可能
watch 事件流revision 边界的事件重放informer、控制器按事件序号追平
apiserver 缓存watch cache / informer 本地 store大多数控制器读一定旧(设计如此)

关键认知:这些档位在同一个系统里同时运行。etcd 本身写与读可以不同档(写永远线性一致,读可降档);apiserver 在 etcd 之上又叠加了自己的缓存档。一致性不是系统的一个属性开关,而是每个请求可以选择的档位。

五个档位之间靠什么衔接?靠 revision 与 resourceVersion。写档推进主 revision;线性一致读与串行化读都在 mvcc 上按 revision 读;watch 档从某个 revision 重放事件流(第 13.1 节);缓存档用事件流把本地 store 推进到最新。所以「档位」不是彼此孤立的五种读法,而是同一把 revision 尺子上的五个读点——这正是第 12.3 节「resourceVersion 背后的 mvcc」在本节的回响。

运行时的一张请求路线图可以看到五档怎么共存:写请求永远进 Raft 多数派(写档);apiserver 的单对象 Get 直连 etcd 走 ReadIndex(线性一致读档);不带 resourceVersion 的 List 由 watch cache 的快照服务(缓存档);控制器消费 informer 的事件流(watch 档)维护本地 store;个别监控类查询用 WithSerializable() 降成串行化读。同一个 apiserver 进程,同一个 etcd 集群,五种档位同时在服务——这就是「一致性是多档并用」的现场。

值得单独说明的是写档:etcd 的写没有「串行化写」这种降档选项。理由很硬——写一旦不同步多数派,就成了每个副本各自的局部状态,副本之间的数据会分叉,watch、读、恢复全部失去共同基准。所以在 etcd 里「写 = 线性一致」是唯一选项,可调的只是读档与缓存档。这也是本卷反复强调的一句话的出处:一致性档位能降的是读,不是写。

每档的成本:多数派往返、fsync、WAL 与扇出限流

每一档的成本都能对应到本卷讲过的具体机制:

  • 写线性一致:Leader WAL fsync(第 15.2 节磁盘预算)+ 一轮多数派往返(网络预算)。这是最贵的一档,K8s 的每次对象写入都买它。
  • 线性一致读:ReadIndex 一轮多数派确认(第 10.1/10.2 节),延迟 ≈ 写路径去掉 fsync。单对象 Get 走这档。
  • 串行化读:零一致性往返,只读本机 mvcc;代价是可能旧(第 10.3 节)。
  • watch 事件流:每个 watcher 一份扇出(第 13.2 节),backlog 占内存,慢消费者被限流取消(TestWatchSlowConsumerCanceled)。代价是 store 的保护性丢弃。
  • apiserver 缓存:一次 watch 建立后本地增量维护,读到旧值是设计而非事故;代价是「旧」本身。

把档位与成本合成一张账本:

档位每笔往返每笔落盘主要成本项
写线性一致1 轮多数派1 次 WAL fsync磁盘 + 网络
线性一致读1 轮多数派0网络
串行化读00几乎为零
watch 事件流0(推送)0扇出与 backlog
缓存读00新鲜度(旧)

档位越低,成本越低,代价从「钱」变成了「旧」。

给每档配上典型延迟量级(同机房、正常负载):

档位典型延迟相对写档
写线性一致约 1–3 ms基准
线性一致读约 0.5–2 ms少一次 fsync
串行化读亚毫秒少一轮往返
watch 事件事件推送延迟(毫秒级)无请求式往返
缓存读本机内存读几乎为零

这些数字不是精确基准,而是「档位越高、每一笔要多付什么」的示意。工程上要的是量级感:从缓存读到线性一致读,每一档的跳升都对应可感知的延迟与吞吐变化。

这些成本还有一个共同特征:几乎都按请求计费,而不是按系统静态计费。一次写付一次 fsync + 一次往返;一次线性一致读付一次往返;一个 watch 从建立起持续占一份扇出与 backlog,直到被取消——因此成本与流量成正比,流量上涨时每一档的成本都会线性放大。理解「按请求计费」,就能解释为什么高 QPS 集群对档位选择更敏感:同样一个 List,QPS 1 时缓存与直连的差距无所谓,QPS 1 万时差距就是吞吐量级。

把「按请求计费」再落一层:由于成本按请求放大,读路径的缓存档在 K8s 里不是「可选的优化」,而是默认架构。informer 的一次 List+Watch 建立缓存后,后续读全部命中本地 store,只在事件流断开时才回落 etcd——缓存档把大部分读成本从「每请求一次网络往返」降成「每事件一次本地更新」,这正是控制器能高频调谐而不把 etcd 打垮的原因。

工程决策框架:必须新与可旧的分流

第 10.3 节给读路径画过一个四问框架,把它放大到整个系统就成立:

  1. 这个操作会触发写吗? 会(条件写、先读后写)→ 线性一致档;不会 → 看下一条。
  2. 旧值会伤害正确性吗? 会(判空、删了重建、选主)→ 线性一致档;只影响展示 → 缓存/串行化档。
  3. 写后需要立刻读回吗? 需要(read-your-writes)→ 线性一致;允许异步 → watch + 本地缓存。
  4. 延迟与成本预算? 每笔多数派往返是否付得起;付不起就接受旧。

K8s 的日常形态就是这套框架的产物:控制器用 informer 本地缓存做周期调谐(可旧),在具体决策点(删 namespace 前确认清空、Update 前的 RV 校验)回落线性一致读。系统没有一刀切选「最强一致」,而是把请求按「对旧」的容忍度分流。

拿一个具体的控制器动作走一遍框架:一个 StatefulSet 控制器要创建第 4 个副本。

  1. 它先 List 当前副本与 Pod 状态——走 informer 缓存(可旧,几秒内的滞后可接受);
  2. 然后要为新建 Pod 生成名字并保证唯一——生成唯一名涉及判空/存在性检查,必须读最新,回落线性一致读;
  3. 接着 Update StatefulSet 的 observedGeneration 等字段——更新前要带 resourceVersion 做乐观锁,这个写走写档,冲突时收到 409、重读重试。

同一个控制器动作,三处用了三种档位。这就是框架的实际产出:不是「整个控制器强一致」,而是每个子操作按其对「新」的需求挑档位。

这个框架也不只适用于 etcd/K8s——它是所有「要强一致又要性能」的系统的通用问答。数据库的隔离级别选择、缓存失效策略、选主协议的超时设计,都能套进这四问。本卷用 etcd 把框架讲透,是因为 etcd 是它最纯粹的实现样例;框架本身的价值,在于把「一致性与性能的权衡」从直觉变成可复用的问题清单。

事务、乐观锁与 watch 限流的成本

并发写的一致性档位,成本在冲突处理上:

  • 事务(Txn):第 12.2 节的 Txn(If/Then) 仍走多数派写——它买的是「If 条件与 Then 动作原子生效」,成本就是写档全价;条件不满足时整体跳过,客户端拿到的是一次「确认后的否决」。
  • 乐观锁(CAS / CASModRev):基于 mod_revision / resourceVersion 的冲突检测,冲突时返回失败(K8s 表现为 409),客户端重读重试。成本不在成功路径,而在冲突率——高冲突率下重试风暴会放大写路径负载。
  • watch 限流:慢消费者积压超过上限被取消(TestWatchSlowConsumerCanceled),store 用「丢客户端」保护自己不被无限拖住。代价是客户端断线后要重建 watch(先 List 再 Watch),多一次全量同步。

三者的共同点:一致性档位不变,成本随工作负载形态变化。同一套乐观锁,低冲突时几乎无感,高冲突时变成主要开销——所以工程上要监控冲突率与 watch 积压,而不是假设「成本恒定」。

冲突成本随负载形态变化的例子:两个客户端同时基于同一 revision 更新同一个 key。低冲突(每分钟 1 次)时,第二次 CASModRev 偶尔失败、客户端重读重试一次就成功,成本忽略不计;高冲突(每秒 100 次,比如多个控制器同时写同一对象的状态字段)时,重试本身变成新的写负载,可能形成「冲突 → 重试 → 新冲突」的放大。所以高冲突场景的解法不是加大重试,而是减小写面——K8s 的做法是把写尽量收敛到同一控制器、或拆分对象避免热点 key。监控里的 409 比例是这项成本最直接的指标。

把三类成本放回「档位与代价」的主线:事务买原子性,乐观锁买并发下的正确性,watch 限流买事件流的可持续性——每一类都是在用「可度量的运行开销」换「可承诺的一致性语义」。部署调优时盯住的不是抽象概念,而是这几个可观测指标:写延迟(fsync + RTT)、ReadIndex 确认频率、409 冲突率、watch 积压与取消数。

越一致越好的误区:CAP 的工程结论

第 2 章 CAP 的结论在本节兑现成一条工程铁律:分区下「可用」与「线性一致」不可兼得,所以系统必须把「必须新」与「可旧」分开。追求「全系统强一致」不是更高尚,而是把不可兼得的成本硬塞给所有请求:

  • 每个请求都付多数派往返,吞吐被最贵档位卡死;
  • 分区时所有读都不可用,哪怕只是展示类查询;
  • 缓存、watch 这些把「旧」当设计输入的机制全被废弃,控制器的调谐模型重建。

可用的系统反着来:用最贵档位保护正确性,用最便宜档位吸收吞吐。etcd 写线性一致 + 读可降档、apiserver 缓存读 + 决策点回落,就是这个原则的两层落地。一致性不是美德,是规格——规格要与代价匹配,才谈得上可用。

把系统一刀切成两半是最简化的心智模型:一半是事实,一半是视图。事实部分(写、判空、选主、条件变更)必须线性一致,用最贵的档位;视图部分(列表、状态展示、监控、调谐循环)只需要最终一致,用最便宜的档位加 watch 追新。etcd 提供写档与读档的分级,apiserver 提供直连与缓存的叠加,本质都是把这「两半」的边界落在代码里——而不是让每个请求都按最贵档位来。

卷一收尾:etcd 是控制面的共识地基,卷二继续数据面

卷一的主线到此闭环:K8s 控制面为什么需要 etcd 这样的共识存储——因为控制面是把「对象期望状态」当作事实存储的系统,这个事实必须是线性一致、多数派持久、能备份能恢复的。etcd 把 Raft 从算法变成产品:WAL 与快照两件套保证持久,mvcc 与事务支撑并发,watch 把变化推给消费者,租约与压缩把生命周期管住,quorum 与运维把容错和恢复落到实处。

卷二将把镜头从存储抬到数据面:API Server 的 list-watch 与 informer(事件流如何变成本地缓存)、乐观并发在 Update 路径上的完整循环、基于租约的控制器选主、以及控制器负反馈如何把「期望状态」调成「实际状态」。你在卷一学会的每一档一致性代价,都会在卷二的数据面里继续作为预算出现——只是记账的组件从 etcd 换成了 apiserver 与控制器。

最后把卷一与整本书的关系说清:分布式系统的三个地基——共识(Raft)、存储(etcd 的 mvcc/事务/watch/租约/压缩)、容错(quorum/备份/恢复)——在卷一是同一套地基的三个面。卷二会在这些地基上盖 API Server 的数据面:list-watch 把共识存储变成事件流,informer 把事件流变成本地缓存,控制器把本地缓存变成负反馈回路。到那时回头再看卷一,「一致性档位与代价」仍然是每一次设计选择的底层语言——只是语法从「etcd 的 RangeRequest.serializable」换成了「informer 的 resync 周期与 cache 新鲜度」。

也正因如此,卷一和卷二之间没有断裂:卷一里 etcd 对一致性档位的每一笔定价,卷二都会在 apiserver 与控制器里以「缓存新鲜度」「冲突重试」「watch 重建」的形式再次出现。读完卷一再进卷二,你对「为什么 apiserver 有 watch cache」「为什么 informer 不保证实时」会带着预算意识去理解,而不是当作孤立的实现细节。

给卷一画一张收尾路线图:第 1–3 章搭理论底座(目标、一致性谱系、时钟);第 4–8 章讲共识算法(选举、复制、安全、成员变更);第 9–10 章解决规模问题(压缩快照、读的一致性);第 11–13 章落到 etcd 产品(写入路径、mvcc/事务、watch);第 14–15 章回答运维与权衡(容错、fsync/RTT、一致性代价)。每条主线都在为下一章埋伏笔,走到 15.3,所有伏笔都收回了。

本节 lab

本节做全量验证,用 lab 里每一类用例对应本节的每一档一致性:

cd private/labs/k8s-etcd-lab
go test ./... -count=1

当前全量 46 个用例通过(raft 21 + store 8 + watcher 7 + lease 4 + clock 3 + consistency 3),逐档对应如下:

  • 线性一致读(多数派确认成本):raft 的 TestLinearizableReadIndex —— ReadIndex 用 CommitIndex 回答读边界,未提交日志不参与读;
  • 串行化读/本机读的旧窗口:consistency 的 TestEventualStaleReadWindow —— 传播延迟内必须能读到旧值,传播完成后收敛;
  • CAP 分区取舍:consistency 的 TestCAPPartitionTradeoff —— 分区下线性一致拒绝写、最终一致两侧分叉;
  • 写档的多数派成本:raft 的 TestQuorumSurvivesTwoFailures 与 TestSlowFollowerFsyncDragsCommit —— 2 个故障仍提交、慢 fsync 不破坏多数派;
  • 乐观锁冲突检测:store 的 TestTxnAtomicIfThen 与 TestCASAndCASModRev —— 过期 revision 的条件写失败且不产生写;
  • watch 限流的取舍:watcher 的 TestWatchSlowConsumerCanceled —— 积压超上限被取消,健康消费者不受影响;
  • 租约保活(周期往返):lease 的 TestKeepAlivePreventsExpiry —— 持续续约不过期、停止后按 TTL 到期。

每一档都有对应用例,「一致性档位 vs 代价」不是抽象口号,而是这份 lab 里逐条可运行、可断言的规格。卷一以它收束,卷二将在这块地基上继续。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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