《Kubernetes 分布式系统原理深入解析》2.3 一致性模型的工程代价

上一节讲一致性模型的承诺,本节给它们贴上价签:线性一致的代价是延迟、可用性与写放大,弱一致的代价是读旧值、合并语义与客户端复杂度。先给出 3 节点 etcd 一次线性一致写、可串行化读与缓存读的可复算量级,再用表格说明 K8s 每一层为什么选这个档位,最后从工程师视角给出选档与接受最终一致窗口的方法。lab 读 consistency/models.go,用 SetPropagation 演示传播延迟越大读旧窗口越大。

2.3 一致性模型的工程代价

2.2 节讲了每一档一致性承诺什么,本节给它们贴价签。分布式系统没有免费的强度:线性一致贵在协议,弱一致贵在客户端。强一致要付延迟、可用性与吞吐,弱一致把成本转移到读旧窗口、合并语义和调用方复杂度上。理解了这本账,你就能回答一个贯穿全书的问题:为什么同一个 K8s 里,etcd 的写必须线性一致,而 informer 的读可以最终一致。

读之前先建立一个心理模型:一致性强度不是「对错」问题,而是「预算」问题。每档承诺都有价签——强一致把预算花在协议与硬件上(quorum、fsync、复制),弱一致把预算花在代码与心智上(合并、读旧容忍、路由)。K8s 的工程判断不是「选最强的那档」,而是在每一条数据路径上选预算恰好够用的那档。下面三小节分别是强一致的账单、弱一致的账单,以及 K8s 的账单。

强一致的账本:延迟、可用性、吞吐

先看强一致。它的三笔账可以用一句话概括:让所有副本「同时」看到同一份状态,就必须让写慢下来、让分区失去一部分可用性、让每次写翻倍复制。下面逐笔拆。

强一致(这里以线性一致为代表)的工程代价有三个维度。

延迟。线性一致写必须保证「多数节点都持久化了这笔写之后才能返回」。在 Raft 里,一次写要经历:客户端 → leader 的 RTT、leader 广播日志到 followers、多数节点 fsync、leader 在多数确认后回复客户端。quorum 往返加 fsync 是延迟的大头。fsync 是把数据真正刷到磁盘的动作,单次在普通 SSD 上要 0.5–2ms,在 SATA HDD 上要 5–10ms——这个数字比任何网络优化都更顽固。3 节点集群一次写往往落在 2–6ms 量级(下一节精确估算)。

quorum 的大小决定了你每笔写要等几个人。3 节点集群需要 2/3 确认(leader 自身 + 1 个 follower),5 节点集群需要 3/5 确认(leader 自身 + 2 个 follower):每多等一个节点,就多付一次「它 fsync 完才发确认」的往返。这也是为什么 etcd 生产常见 3 节点而不是 5 节点——5 节点把故障容忍从 1 台提到 2 台,却把每次写的等待从 2 个 fsync 提到 3 个,延迟与吞吐都更贵。选节点数,本质是在「容错数」与「每写成本」之间定价。

延迟还不是稳定的:多数确认取决于「最慢的那个多数节点」,所以 p99 延迟由慢盘与调度噪声决定,而不是平均值。生产里 etcd 写延迟抖动,多半来自某个 follower 的磁盘突然慢了一次——这就是为什么磁盘选型与节点间网络质量,直接决定强一致写的体验。

可用性。线性一致承诺「读必见最新」,这要求读也过 quorum。一旦发生网络分区,落在少数派的节点既不能写也不能线性一致读——用「分区时不可用」换「一致不撒谎」。2.1 节 CAP 已经论证过:P 分区下 C 与 A 不可兼得,线性一致就是那个「选 C」的档位。

把 3 节点、网络一分为二(1 台 vs 2 台)时的行为列出来,强一致与弱一致的分野一目了然:

场景线性一致(强)最终一致(弱)
分区:2 台一侧写允许(2/3 = 多数)允许
分区:1 台一侧写拒绝(写返回错误)允许(本地成功,重聚时合并/冲突)
分区:1 台一侧读拒绝(不可用)允许(读到本地旧值)
重聚之后无冲突,历史唯一需要合并规则(LWW 等)

同一笔「少数派写」,强一致直接拒绝(牺牲可用性),弱一致接受下来(重聚后要解决冲突)。选哪边没有对错,但你必须知道自己选的是哪边——最危险的系统是「自以为是强一致,实际是弱一致」。

吞吐。每笔写要被复制到多数节点、各自 fsync,日志还要进 WAL、再应用到 mvcc 状态机,这是天然的写放大。更关键的是写路径被串行化:Raft 的日志追加必须在 leader 上按序进行,同一时刻只有一条日志在提交通道里走。单写点加复制系数,决定了强一致系统的写吞吐上限远低于单机。

写放大的账可以拆细一点:一笔写至少产生(1)leader 的 WAL fsync 一次;(2)每个 follower 的 WAL fsync 一次(多数即至少一个);(3)日志条目在每台节点各存一份;(4)提交后应用到 mvcc 状态机,再产生一次索引写入。粗略算,3 节点集群一笔写 ≈ 2 次 WAL fsync + 3 份日志 + 3 份状态机写入,而单机一次写只要 1 次 fsync + 1 份数据。这个复制系数,就是强一致「每笔写」相对单机多付的固定成本。

弱一致的账本:读旧、合并、客户端复杂度

再看弱一致。它的三笔税也可以用一句话概括:副本「不同时」看到同一份状态,代价就转移给了读方与合并方。下面逐笔拆。

弱一致(以最终一致为代表)把成本从协议挪到了别处。它有三个隐性税:

读旧值。副本异步传播期间,任何读都可能命中旧值。这个「读旧窗口」的宽度由传播延迟决定——K8s 里 informer 缓存可能比 etcd 旧几百毫秒甚至数秒。读旧不是可选项,是弱一致的内建行为:要么接受它,要么在每个读点处理它。读旧的代价还要乘上读的频率:读多写少的数据,读旧窗口被高频读反复撞见,问题放大;写多读少的数据,窗口很快过去,影响有限。informer 属于前者——它把 etcd 的状态拉进每个节点内存、靠高频读把命中率拉满,同时坦然接受「缓存旧于 etcd」,代价全由声明式调谐吸收。

需要合并语义。分区重聚时,两侧各自接受了互不兼容的写(还记得 2.1 的 TestCAPPartitionTradeoff 吗:分区的两侧一个写了 x=a、一个写了 x=b),重聚后必须有规则决定谁赢。最简单的是最后写赢(LWW,last-writer-wins),但 LWW 会丢并发更新;复杂的是版本向量 + 应用层合并(如无冲突复制数据类型 CRDT)。合并逻辑要么买、要么写,没有免费的。

客户端复杂度。读己之写、单调读这些承诺不会自动到来:如果你需要「先写后读必见自己写」,要么框架帮你做(etcd clientv3 同一会话内保证),要么客户端自己把读路由到刚才写过的副本。K8s 的 kubelet 写回 status 后能读到自己写,靠的是本地缓存 + 同一路径回读,而不是靠 etcd 的魔法。弱一致把「知道自己该看多新」的责任推给了调用方。

判断「框架帮你做还是自己做」有个简单测试:看框架是否保证同一会话、同一路由下的读写一致。etcd clientv3 在同一个 client 上保证 read-your-writes,K8s 的 informer 保证同一 informer 内单调;一旦你跨 client、跨缓存访问,就没人替你保证——复杂度即刻回到你身上。

举一个合并语义的具体代价:跨端购物车的 x=a 与 x=b 并发写入,重聚后 LWW 直接丢掉一个,用户购物车少一件东西;要做对,得引入版本向量逐件合并,或者让两端写不同键、最后统一汇总——无论哪种,都是多出来的应用层代码。弱一致省下的协议钱,最后几乎都花在合并与应用逻辑上。这也是为什么 K8s 宁可让 etcd 把所有写线性定序,也不允许同一键被两个分区并发写——它把合并问题在协议层一次性消灭,而不是留给应用层在每一处反复处理。

量级估算:可复算的成本

下面把各档位换算成可复算的毫秒数。先固定前提:3 节点 etcd、同机房(单跳 RTT 按 0.5ms 计)、普通 SSD(fsync 按 1ms 计)、客户端到 leader 的网络按 0.2ms 计。这些数字都可替换成你的实测值,公式本身不变。

路径组成部分量级(同机房)复算过程
线性一致写客户端 RTT + 日志广播 + 多数 fsync + 确认返回2–6 ms0.2(请求) + 0.5(广播) + 1~2(fsync) + 0.5(返回)
线性一致读read index quorum 确认 + 读本地状态机0.5–1 ms一轮 read index 确认,无 fsync
可串行化读读 leader 内存状态机快照0.05–0.2 ms无 quorum、无 fsync,纯内存 + mvcc
缓存读(informer/kubelet)本地内存命中1–10 μs0 网络、0 磁盘,纯 map 查找

注意三组数量级差距:线性一致写 ≈ 缓存读的 1000 倍以上。etcd 官方 benchmark 在 3 节点、普通 SSD 上线性一致写约为每秒几千到几万次(取决于批处理与 fsync 合并),而缓存读几乎不受限。这就是 K8s 为什么把所有「写」收敛到 etcd 一次线性提交、却把「读」铺到每台机器缓存里的根本原因——写贵,所以少写、写对;读便宜,所以多读、读旧也行。

把一次线性一致写的 2–6ms 拆成时间线,就能看清钱花在哪:

t=0.0ms  客户端 → leader 请求(0.2ms)
t=0.2ms  leader 追加到本节点 WAL,广播到 2 个 follower(并行 0.5ms)
t=0.7ms  follower 各自 fsync(1ms,并发进行)
t=1.7ms  follower 回 AppendResp(0.5ms)
t=2.2ms  leader 收齐多数确认,本节点 fsync 后提交
t=2.7ms  回复客户端(0.5ms)

三次 fsync(leader 一次、多数 follower 一次、提交前 leader 再一次)加两轮网络往返,占了 2.7ms 里的大部分。任何「把 etcd 写变快」的优化,最终都绕不开压缩 fsync 次数(批处理)与缩短网络往返(同机房部署)。

把前提换成跨可用区(单跳 RTT 按 2ms、fsync 仍按 1ms),线性一致写会膨胀到 5–12ms;节点数加到 5,多数确认多等一个 fsync,再加 1ms 左右。读路径不受影响——缓存读依然是微秒级。这组对比解释了架构选择:跨区集群的写比同机房贵一个数量级,所以多区域部署要么接受更慢的写,要么把「必须最新的写」收缩到最小集合——K8s 多集群方案选择「每个集群一个 etcd、跨集群只同步最终一致数据」,正是基于这笔账。

还有一个工程细节值得记住:etcd 的写吞吐严重依赖批处理(batching)——把一小段时间内的多个写请求合并进同一条 Raft 日志,只付一次 fsync。这也是为什么强一致写「单笔很贵、批量不贵」:批量场景下单笔均摊成本可以降到 0.1ms 以下。

批处理的原理是摊薄固定成本:一次 fsync 的成本是固定的(毫秒级),Raft 日志的广播与确认也是按「条」算的。etcd 把窗口内到达的写攒成一批,攒满或到时间窗就整体提交一次——固定成本被 N 笔写分摊,单笔成本降到原来的 1/N。这就是为什么 K8s 控制面的写入虽然是强一致,却仍能支撑一个集群规模的状态更新:高吞吐强一致靠的是批处理,而不是把单笔写做快。代价是单笔写多等一个批处理窗口的延迟(通常几毫秒),对控制面来说值得。

K8s 每层一致性档位的选择

把 2.2 节的落点表加上「为什么」这一列,就是完整的选档决策:

层一致性档位为什么这么选
etcd 写入线性一致(Raft 提交)集群状态唯一权威;两笔写必须全局定序,否则状态机漂移
etcd 线性一致读线性一致apiserver 需要绝对最新(watch 起点、写后读)
etcd 可串行化读顺序一致省掉 quorum 往返,读旧几毫秒可接受
apiserver list-watch因果一致 + 版本序事件流必须因果不颠倒,但不需要全局单一历史
informer 缓存最终一致每节点本地缓存,把读延迟从毫秒压到微秒
kubelet 期望状态读己之写 + 最终一致本地缓存 + 主动 relist,声明式收敛兜底

这张表值得背下来,因为它是「选档框架」在一套真实系统上的完整应用:每一行的档位都同时回答了延迟、可用性、吞吐三笔账。etcd 写入选线性一致,等于把「写延迟 2–6ms」「分区时少数派不可用」「写放大」全部接受;作为交换,集群状态永远不会被两笔乱序写搞坏。informer 选最终一致,等于把「读旧几百毫秒」接受;作为交换,读延迟降到微秒、分区时每个节点照常服务。没有免费的档位,只有你愿意付钱的档位。

注意两点取舍的「不对称」:

  • 写路径全线性,读路径全降档。K8s 把集群状态的一致性承诺全部押在 etcd 这一个点上,其余层全部靠缓存与收敛。你几乎找不到第二个写入口,这就是「单写点 + 多读缓存」架构的极致形态。
  • 因果一致几乎是白赚的。list-watch 本来就是按 revision 递增推流,因果性不用额外付协议成本;而 informer 的最终一致也是「读旧」而非「写乱」——写永远不乱,只是读可能旧。K8s 选档的逻辑是:让所有「写」有序,让所有「读」有界地旧。

承诺与成本的对照总账

把 2.2 的承诺与本节的价格放在同一张表里横向看,能得出本书最常用的判断工具:

档位承诺主要成本成本落在谁头上
线性一致读必见最新、全局实时串行quorum 往返 + fsync、分区不可用、写放大协议与基础设施
顺序一致全局串行(可读旧)仍需维护全局序,但省掉实时约束协议(略低于线性)
因果一致因果不颠倒、并发可乱序追踪 happens-before(版本/向量)协议 + 少量状态
读己之写 / 单调读只对「我」生效会话路由、写后读路径客户端 / 框架
最终一致收敛、有读旧窗口读旧、合并语义、客户端复杂度客户端 + 应用层

横向读这张表得到一个重要结论:成本从「协议」向「客户端」转移。档位越强,成本越集中在协议层,调用方越省心;档位越弱,协议越廉价,但每个调用方都要自己处理读旧与合并。K8s 的分层选档,本质上就是把「哪些成本交给协议、哪些成本交给客户端」逐层安排好——etcd 扛下协议成本保证写不乱,informer 把读旧成本摊给控制器,由声明式调谐兜底。

这张表也是后续章节的地图:第 4–5 章的 Raft 就是「花协议的钱买线性一致」,第 6 章讲 etcd 存储时会看到「如何把最终一致的数据(备份、镜像、索引)与线性一致的数据(主状态)隔离」。每看到一个组件,先问一句:它在这张表的哪一格?

工程师视角:为业务选档位

离开 K8s,给你自己的系统选档时,按这个顺序问:

  1. 这笔数据有多少个写入口? 多写入口且冲突频繁 → 必须强一致(或用 CRDT 消解冲突)。
  2. 谁在读、能容忍多旧? 账单、库存、权限这类「读旧会赔钱」的 → 强一致;推荐流、计数、状态展示 → 弱一致。
  3. 写贵还是读贵? 写多读少的冷数据 → 强一致无妨;读多写少的展示数据 → 缓存降档。
  4. 分区时你选什么? 先想清楚分区时的行为,再倒推档位,而不是先选档位再处理分区。

如果觉得四个问题太多,记一条快捷法则:先问「读到旧值会怎样」,再问「写冲突会怎样」,最后问「分区时怎么办」。三个答案都是「无所谓」,放心用最终一致;只要有一个答案是「出事」,就往强一致挪一档,直到代价可以接受。K8s 的每一步选档都能套进这条法则:etcd 写冲突会「状态机漂移」,所以线性一致;informer 读旧会「多调谐一轮」,无所谓,所以最终一致。

如何接受最终一致窗口,有三个具体动作:

  • 量化窗口。先测出你的传播延迟分布:p50 是多少、p99 是多少。K8s 里 informer 的滞后窗口是可观测的(watch 事件到达时间与 etcd 提交时间差),先测量再讨论「能不能接受」。
  • 给读点分级。把「必须最新的读」与「可以旧的读」在代码里分开,而不是一刀切。K8s 自己就是这样:需要最新走线性一致读,其余走缓存。
  • 用收敛兜底,不用完美兜底。接受读旧,但保证「读到旧值后一定会被修正」——K8s 靠声明式调谐,你可以在客户端靠重试、定时刷新或事件推送。最终一致不可怕,可怕的是「旧了之后永远不新」。

用一个对照案例收束选档逻辑。库存扣减:同一 SKU 会被多入口并发扣减,冲突频繁、读旧会超卖,必须线性一致写 + 强一致读。推荐流:只读多写少的展示数据,读到旧推荐不赔钱,直接走最终一致缓存,写也只做追加。中间态是用户设置:读己之写必须保证(用户改完设置刷新要立刻看到),但不要求全局一致——用单调读 + 写后读路由就够,不必上线性一致。K8s 里 kubelet 期望状态的档位,正是这个中间态的样板:写自己、读自己必见,别人读到旧无妨,靠 relist 收敛。

本节 lab

lab 在 private/labs/k8s-etcd-lab/consistency/,请先读 models.go 再运行。重点看 SetPropagation 与 visibleUpper 的关系:

  • SetPropagation(r, delay) 设置副本 r 接收远程写的传播延迟;visibleUpper 按「本地写立即可见、远程写等 delay 才可见」回溯历史。delay 就是读旧窗口的宽度。
  • 把 delay 从 5 调大到 100(在 models_test.go 的 Eventual 分支里改 SetPropagation(0, 5) 为更大的值,或在 TestEventualStaleReadWindow 里加一行 SetPropagation(1, 100)),t=3 处读到旧值的概率与窗口宽度同步变大;而 Linearizable 模型无论怎么设 delay 都立即全局可见——因为 visibleUpper 对 Linearizable 直接返回历史全量上界。

动手改一改更直观:把 Eventual 分支的 SetPropagation(0, 5) 改成 SetPropagation(0, 50),收敛被推迟到 t≈52 之后;改成 SetPropagation(0, 0),读旧窗口消失,行为逼近顺序一致。这个参数游戏验证了 2.3 节的核心公式:读旧窗口 = 传播延迟。Linearizable 模型下改无效,因为它压根没有窗口。

全量跑一致性包的三个用例(线性一致读必见最新、最终一致读旧后收敛、CAP 分区权衡):

cd private/labs/k8s-etcd-lab
go test ./consistency -v

预期三个用例全绿:TestLinearizableReadLatest、TestEventualStaleReadWindow、TestCAPPartitionTradeoff 均 PASS。把 delay 放大再跑,你能直观看到「传播延迟越大,读旧窗口越大」正是 2.3 节成本模型的量化版:强一致拒绝读旧但慢且受分区牵制,弱一致读得快但把「多旧」交给 SetPropagation 这个旋钮。

跑完这些用例,记住本节的一句话结论就够:强一致付协议的钱换「不读旧」,弱一致省协议的钱、把「读旧」换成客户端代码。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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