《Kubernetes 分布式系统原理深入解析》6.3 提交与 apply:commitIndex、matchIndex 与状态机应用

提交是复制状态机从「日志一致」到「生效」的分界线:commitIndex 只在多数派 matchIndex 确认且条目属于当前任期时才推进;leader 通过每条 AppendEntries 携带 LeaderCommit 把提交传播给 follower;apply 阶段把 (ApplyIndex, CommitIndex] 区间应用到状态机并保持幂等。「只提交当前任期日志」规则防止旧任期日志被未来 leader 覆盖而丢失已提交数据;etcd 把 commit 与 apply 分离,apply 在独立的 backend 循环批量执行。lab 用 TestLogMatchAndCommit 与 TestCommitRequiresQuorum 分别验证提交传播与多数派约束。

6.3 提交与 apply:commitIndex、matchIndex 与状态机应用

6.1 把日志复制到节点,6.2 保证日志一致。但「日志一致」还不是「命令生效」:一条命令要真正改变集群状态,必须被提交(commit)再应用(apply)到状态机。这一节讲这三个动作的边界:commitIndex 怎么推进、谁把提交传播出去、状态机怎么消费已提交日志,以及 Raft 为什么规定「只能提交当前任期的日志」。

K8s 里 apiserver 写入 etcd 后能立刻读到新值,正是提交 + apply 两个阶段都完成的结果;而 etcd 内部 commit 与 apply 是分离的两个循环,理解这层分离是读懂 etcd 写路径的前提。本节先建立两个下标的概念,再讲推进规则与那条「当前任期」限制,最后落到 lab 的可运行断言。

commitIndex 与 matchIndex:提交的两块基石

提交判定需要四个下标,先分清各自的语义:

量谁维护初始值何时更新语义
CommitIndex每个节点各自-1收到 LeaderCommit,或 leader 本地多数确认已提交的最大下标
ApplyIndex每个节点各自-1apply 完成后已应用到状态机的最大下标
MatchIndex仅 leader-1收到 Granted 的响应每个 follower 已确认复制的最大下标
NextIndex仅 leaderleader 日志末尾 + 1成功前推 / 失败回退下一条该发到哪

commitIndex 的定义要读准:它是「已知已提交」——节点自己知道不会被未来 leader 覆盖的最大日志下标。注意它不是「多数节点上都有」的同义词:一个 follower 可能已经有某条日志但没收到提交信号,它不会擅自把 commitIndex 推过去;提交信号只能来自 leader 的 LeaderCommit。同理,leader 也不能把「多数节点都有」直接等同于「已提交」——还需要 6.2 的日志匹配性质与当前任期规则兜底。

提交推进规则:多数派确认 + 只提交当前任期

leader 是唯一发起提交的节点,规则只有一句话:把 commitIndex 推进到「多数节点的 MatchIndex ≥ i」的最大下标 i,且 i 处的条目属于当前任期。lab 的 maybeCommit 逐行对应:

majority := len(n.NextIndex)/2 + 1 // 集群成员数
for i := n.lastLogIndex(); i > n.CommitIndex; i-- {
    if n.Log[i].Term != n.Term {
        break // 只能推进当前任期日志
    }
    count := 1 // 自己
    for _, mi := range n.MatchIndex {
        if mi >= i {
            count++
        }
    }
    if count >= majority {
        n.CommitIndex = i
        break
    }
}

读这段代码,三个细节值得展开:

  1. 从自身日志末尾向下找,而不是从某个固定的 quorum 位置找——因为确认进度是动态的,MatchIndex 表随时可能推进,找到的「最大多数派下标」就是新的提交点。
  2. 遇到非当前任期的条目就 break:这是「只提交当前任期日志」的编码。从末尾往下的循环里,一旦发现当前下标的 term 不等于 leader 当前 term,就停止寻找——即使下面还有更高(多数派确认)的下标,也不提交。这条规则为什么必须,见下一小节。
  3. count 从 1 开始(自己),再统计 MatchIndex 达到 i 的 follower。quorum = 成员数 / 2 + 1,成员数是固定的集群规模,不随 follower 在线状态变化。

用 5 节点集群(quorum 3)量化一次推进:leader 把命令复制到 2 个 follower(加自己共 3 个 MatchIndex ≥ i)就满足提交条件。3 节点集群(quorum 2)只需 1 个 follower 确认。多数派阈值与选举相同,这是「提交与选举用同一把尺子」的体现——都按多数裁定。

还有一个容易漏掉的细节:leader 自己的 MatchIndex 不是靠响应更新的,而是每次追加日志时同步设置——lab 测试里反复出现的 l.MatchIndex[l.ID] = l.lastLogIndex() 就是这个动作。leader 的日志天然「已确认」(它自己持有,不需要等消息),这也是 maybeCommit 里 count 从 1(自己)开始的原因:自己这一票永远在场。反过来,这也意味着 leader 追加日志后不广播,提交就永远不会发生——TestCommitRequiresQuorum 正是靠「不广播」复现了这个边界。

只提交当前任期日志的必要性

这条规则是 Raft 安全性里最容易「觉得多余」的一条,但它防的是一类真实的数据丢失——已提交条目被未来 leader 覆盖。先摆规则,再讲论文 Figure 8 构造出的反例。

规则:leader 只能按多数计数提交「当前任期」的条目;旧任期条目不按计数提交,而是等一条当前任期条目被提交后、作为它的前缀被间接提交。

论文的反例(5 节点 S1–S5,quorum 3)按时间展开:

阶段事件
aterm 2 的 leader S1 把 index 2(term 2 条目)复制给 S2 后崩溃——S1、S2 持有它,S3、S4、S5 没有
bS5 在 term 3 当选(S3、S4、自己共 3 票)。它向 index 2 写入 term 3 条目并复制给 S3 后崩溃——S5、S3 的 index 2 现在是 term 3
cS1 在 term 4 当选(日志最新,含 term 2 的 index 2)。它把 term 2 的 index 2 复制给 S3、S4——现在 S1、S2、S3、S4 四节点持有它,构成多数。若 S1 此时按多数计数提交这条 term 2 条目,危险开始
dS1 崩溃。S5 在 term 5 再次当选——它的日志含 term 3 的 index 2,比 S3、S4 的 term 2 更新,所以 S3、S4 投它。S5 把 index 2 覆盖成 term 5 条目——已被「提交」的 term 2 条目被覆盖丢失

关键在 b 与 c 的叠加:S5 在 b 里曾把 index 2 写成了 term 3,这让它在 d 里「看起来更新」、能拿到 S3、S4 的票;而 c 里 S1 按多数「提交」的却是 term 2 的旧条目。两者结合,就构造出「多数节点持有 ≠ 未来 leader 必然持有」的反例。选举限制只保证新 leader 包含「已提交」的条目,而这条 term 2 条目在 c 里的提交方式恰恰绕过了它的保护——它按计数提交,却没有附带「未来 leader 必然持有」的保证。

规则的作用:S1 在 c 不提交 term 2 的 index 2,而是等一条 term 4 的条目被多数复制并提交——提交 term 4 条目时,term 2 的 index 2 作为其前缀被一并确认,且此时「未来 leader 必然持有 term 4 条目」由选举限制保证,覆盖就不可能发生。一句话总结:旧任期条目靠「新条目压上来」提交,而不是靠「自己数人头」提交;只有当前任期条目的提交,才附带「未来 leader 必然持有」的保证。

LeaderCommit 传播到 follower

leader 提交只是第一步,所有节点要就提交位置达成一致,靠的是 AppendEntries 里那个被反复强调的字段——LeaderCommit。规则:leader 的每条 AppendEntries(包括心跳)都携带自己的 CommitIndex;follower 收到后把自己的 CommitIndex 推进到 min(LeaderCommit, 自己日志末尾)。

用 lab 的 AppendEntries 最后几行对号入座:

if leaderCommit > n.CommitIndex {
    nc := leaderCommit
    if last := n.lastLogIndex(); nc > last {
        nc = last
    }
    n.CommitIndex = nc
}

min 的限制有实际含义:follower 日志还没追到 LeaderCommit 时,只能提交到自己已有的位置,剩下的等日志补齐后再补提交。这正是 6.1 字段级例子里「节点 2 落后、LeaderCommit=4 但只能推进到 2」的场景。提交传播的通道是现成的——既然每条 AppendEntries 都带 LeaderCommit,就不需要额外的「提交通知」消息,复制与提交传播共用一条通道,这是 Raft 消息种类少的又一个原因。

注意提交传播是「单向吸收」:只有 leader 的 LeaderCommit 能把 follower 的 commitIndex 推高,follower 之间不会互相传播提交,也不会有反向的提交消息。所以一次写请求的提交延迟,取决于「leader 提交」这个事件何时发生,以及下一条携带新 LeaderCommit 的消息何时到达落后节点——通常就是一两个心跳周期内。

用 3 节点集群把提交传播走成时间轴。leader 是节点 0,term 3,它的日志刚到 index 4(新命令 set:x=1),commitIndex 还是 3;follower 1 追到 index 3、commitIndex 3;follower 2 落后(日志到 2)、commitIndex 2:

tick事件节点 0节点 1节点 2
0leader 追加 index 4 条目,MatchIndex[0]=4commit 3commit 3commit 2
1leader 广播 AppendEntries(Entries=[index 4], prev=3, LeaderCommit=3)commit 3commit 3commit 2
2follower 1 一致性检查通过,追加 index 4 并回 Granted、MatchIndex=4;follower 2 日志太短(termAt(3)=0)拒绝commit 3commit 3commit 2
3leader 收到 follower 1 确认:quorum(自己 + 节点 1)达成,maybeCommit 推进commit 4commit 3commit 2
4leader 广播心跳携带 LeaderCommit=4;同时修复 follower 2——回退其 nextIndex 到匹配锚点,重发 index 3–4commit 4commit 3commit 2
5follower 1 收到心跳推进到 4;follower 2 补齐日志到 4,随后也推进到 4commit 4commit 4commit 4

这张表展示了两件事:其一,leader 提交发生在 tick 3(多数确认后),早于任何 follower 提交——提交是「多数确认即生效」,不需要等所有人;其二,follower 2 的提交被自己的落后日志卡住(tick 2 因日志太短直接拒绝),要靠 leader 修复它的 nextIndex、补发缺失条目,日志补齐后才能提交——提交传播是「先追日志、再补提交」两段式,不是同步广播。这也解释了为什么落后节点的提交总是滞后几个心跳:它要先把日志缺口补上。

apply:从 commitIndex 到状态机

提交之后是最后一步:把已提交的日志应用到状态机。每个节点独立维护自己的 ApplyIndex,只推进「(ApplyIndex, CommitIndex]」这个区间里的条目:

  • 区间的左开右闭保证每条日志恰好应用一次——ApplyIndex 记录已应用到的位置,下次从 ApplyIndex+1 开始,不会重复、不会跳过;
  • 应用顺序与日志顺序一致,因此状态机的演变顺序在所有节点相同;
  • 命令是幂等的吗?Raft 不要求命令本身幂等,它靠「每条恰好应用一次」实现语义上的幂等——这正是 6.3 与卷二控制器「幂等重试」的接口点:应用层可以安全重放,复制层保证不重复生效。

lab 的 Apply 就是这个区间的直接实现:

for i := n.ApplyIndex + 1; i <= n.CommitIndex && i < len(n.Log); i++ {
    n.StateMachine[n.Log[i].Command] = n.Log[i].Command
    applied++
}

它把命令 set:k=v 写进状态机 map(key=value),返回本次应用的条数。注意 apply 发生在每个节点各自本地,不经过网络、不需要 quorum——因为提交已经保证「该提交的已提交」,apply 只是把决定好的结果落到状态机。这也是为什么 apply 阶段可以很快:它不受网络 RTT 约束,只受本地执行速度约束。

提交与应用之间还有一层工程缓冲:节点可以在「已提交但未应用」的状态停留。Raft 允许 CommitIndex 与 ApplyIndex 之间有差距(提交领先应用),只要 apply 追得上,状态机就是最终一致的。生产里这个差距会被监控(etcd 的 applied 与 committed 指标),差距长期过大说明 apply 侧成了瓶颈——通常是慢盘或慢查询。

etcd 中 commit 与 apply 分离

etcd 把 commit 与 apply 显式拆成两个循环,这是理解 etcd 写路径的关键。Raft 核心(raft 包)只负责 commit:它维护 committed 位置,把「已提交但未应用的条目」通过 Ready().CommittedEntries 交给上层。etcdserver 的 apply 侧独立跑一个循环,从 Ready 里取这些条目,批量应用到 backend(boltdb 的 mvcc 状态机),然后推进 applied 下标,再调用 Advance() 让 Raft 核心继续。

分离的价值有三层:

  1. 延迟解耦:commit 依赖网络与 quorum(慢的、不确定的),apply 依赖本地 I/O(快的、可预测的)。两者各自成环,commit 不会被慢 apply 拖住,apply 也不会因为一次网络抖动而空转。
  2. 批量收益:apply 循环可以攒一批(etcd 通常每批几百条)一次性写 backend,摊薄单条的处理开销。这是 15.2 批量提交思想的落地点。
  3. 可观测性:committed 与 applied 两个指标分别暴露,K8s 运维能一眼看出差距在哪一侧。如果 applied 落后 committed 持续增长,问题在 apply 侧(磁盘/backend);如果 committed 停滞,问题在 commit 侧(quorum/网络)。

中间的传送带是 Raft 的 Ready 结构。Raft 核心每次通过 Ready() 暴露一批「该让上层处理」的内容,其中 CommittedEntries 就是已提交未应用的条目;上层(etcdserver)处理完后调用 Advance() 进入下一轮。这个「Ready → 处理 → Advance」循环是 etcd Raft 的对外接口,CommittedEntries 只是 Ready 的一类字段,还有 Msgs(要发出的消息)、Snapshot 等。理解了这条传送带,etcd 的写路径就清晰了:commit 在 Raft 核心内部完成,apply 在 etcdserver 完成,两者靠 Ready 对接,互不阻塞。

用一次 etcdctl put 串起来:客户端写请求到达 leader → Raft 核心把命令追加为日志 → 复制到多数、commitIndex 推进(commit 完成)→ Ready 携带 CommittedEntries → apply 循环把命令写进 mvcc backend → applied 推进 → 响应返回客户端。apiserver 感知到的「写入成功」发生在 commit 完成之后、apply 完成之后——所以它读到的数据一定是已应用的,这是 K8s 控制面一致性的基础。

三个常见误解

提交与 apply 的边界最容易在排障时被混淆,单独列出三个高频误解:

  • 「commitIndex 高 = 日志已被应用」——不对,commit 与 apply 是两个独立下标。一个节点可能 commitIndex=100、ApplyIndex=80(apply 还没追上),状态机只包含前 80 条的效果。监控两个指标的差距才能判断瓶颈在 apply 侧,而不是误以为提交出问题。
  • 「多数节点有这条日志 = 已提交」——「有」不等于「已提交」:还要满足日志匹配性质与「只提交当前任期」规则。多数持有是提交的必要条件,不是充分条件;反之,提交一定意味着多数持有。
  • 「follower 会主动提交自己有的日志」——follower 从不自行推进 commitIndex,只被动接受 leader 的 LeaderCommit。即使它日志里已有某条,没有提交信号它也不会把它标记为已提交。这是「提交由 leader 独占发起」的直接推论,也是整个系统提交位置能保持一致的保证。

本节 lab

本节的 lab 是两个测试:TestLogMatchAndCommit 与 TestCommitRequiresQuorum,分别验证提交传播与多数派约束。

TestLogMatchAndCommit 构造 5 节点集群,leader 提交 2 条命令后,断言所有节点日志与 leader 完全一致(日志匹配性质),且每个节点的 CommitIndex 都等于 leader 日志末尾——提交通过 LeaderCommit 传播到了全部节点。它验证的是本节「传播」那一半:leader 提交后,follower 在若干轮内全部跟上。

TestCommitRequiresQuorum 构造 3 节点集群,leader 把 2 条命令追加进自己的日志,但不广播(只运行 1 步让消息进入 in-flight,不送达),随后断言 CommitIndex == -1——没有多数确认的日志绝不推进提交。它验证的是「多数派」那一半:仅 leader 持有不算提交,即使 leader 自己 MatchIndex 已到 1。

cd private/labs/k8s-etcd-lab
go test ./raft -run 'TestLogMatchAndCommit|TestCommitRequiresQuorum' -v

读 node.go 把两个测试对着实现看:maybeCommit 是提交推进的完整逻辑(从末尾向下找多数派下标、遇到旧 term 就 break);Apply 是 apply 区间的实现。TestCommitRequiresQuorum 里只运行 1 步的设计很关键——消息固定延迟 1 tick,所以 1 步之后 AppendEntries 还在路上、没有送达任何 follower,MatchIndex 表里只有 leader 自己,maybeCommit 的 count=1 < quorum=2,提交必然不推进。把运行步数从 1 改成 3 再跑,就能看到「日志送达 follower、响应回到 leader、多数确认后提交立即推进」的完整对照——第 2 步送达、第 3 步推进,这正是多数派判定的边界。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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