6.2 日志匹配性质与不一致修复
6.1 讲了 AppendEntries 的字段与心跳。这一节回答日志复制里最关键的问题:leader 的日志一定会被原样复制到所有节点吗?答案是否定的——网络分区、节点重启、慢 follower 会让各节点日志出现各种不一致。Raft 处理不一致的方式不是全量重传,而是靠一条性质加一个回退机制。这一节先证明性质,再列出不一致场景,然后讲修复算法,最后对照 etcd 的真实实现。
这套机制是 Raft 安全性的地基:日志一致了,提交才有意义;提交有意义,状态机复制才成立。反过来,如果日志可以长期不一致,5.1 的选举、6.3 的提交都建立在流沙上。所以这一节值得放慢速度,把「为什么这样设计」想清楚。
从读者的视角,这一节是把 6.1 那句「一致性检查失败就拒绝」展开成完整算法:拒绝之后发生什么、leader 怎么收敛、代价多大。带着三个问题读本节:分歧点怎么定位?定位后怎么修?修多久?三个问题的答案分别对应 nextIndex 回退、截断覆盖、以及 RejectHint 优化——本节的结构就按这三问展开。
日志匹配性质(Log Matching Property)
Raft 的安全性几乎全部可以归结为一条不变式——日志匹配性质:如果在两个日志中,某条目有相同的 index 和相同的 term,那么从这条往前的所有条目都一致(相同的 index、term、command)。
它不是一个被要求的假设,而是由两条机制推导出来的结果:
- leader 只在自己的日志末尾追加,从不修改已存在的条目——leader 日志是 append-only 的(7.2 的 TestLeaderAppendOnly 单独验证这条)。
- AppendEntries 的 consistency check——follower 只在 PrevLogIndex 处任期匹配时才接受追加,且追加后同一 index 处若 term 不同会截断覆盖。
用归纳论证走一遍:假设两条日志在 index i 处有相同 term。由规则 2,follower 接受从 i 之后追加时,i 处必须先匹配;由规则 1,两条日志都不会去修改 i 之前的任何条目。再看 i 之前:若存在最早的分歧点 j(j 处 term 不同),规则 2 会让后写入的一方向另一方看齐(截断 + 覆盖),分歧在协议层就被消除。所以「index 相同、term 相同 ⇒ 之前全部一致」是协议执行的结果,而不是设计者的美好愿望。
举一个数字例子:leader 的日志是 t1、t1、t2、t2、t3,follower 的日志可能完全一致,也可能是它的前缀 t1、t1、t2、t2,还可能是 t1、t1、t2、t9(index 3 冲突)。按性质,前两种是已对齐;第三种 index 3 不同,但 index 0–2 相同——修复锚点落在 index 2 之后即可,之前的不动。这个「只修分歧点之后」的局部性,让修复代价与分歧大小成正比,而不是与日志总量成正比。这也回答了「为什么不做全量重传」:全量重传把代价与日志总量绑死,而局部修复让代价只与「差多少」绑死。
这条性质的工程价值在于:它让「两个节点的日志是否一致」变成一个可本地判定的问题——不用传输整条日志比对,只比较一个下标处的任期。后面 6.3 的提交、7.3 的状态机安全都建立在它的肩膀上。
把性质反过来问:如果它被破坏,会怎样?最直接的结果是状态机安全失效——两个节点可能把同一条命令应用出不同结果,或者一个已提交命令被覆盖成别的值。Raft 花了整整一章(第 7 章)把「性质为什么永不破坏」拆成选举限制、leader 完整性、状态机安全三个属性分别证明,就是因为它是整座大楼的承重墙。本节聚焦复制的修复机制(复制侧的保障),第 7 章再补上选举侧的保护——两翼合起来,日志匹配性质才「在任何执行场景下」都成立。
另一个直觉:日志匹配性质是「复制侧」与「选举侧」共同维护的。复制侧靠 AppendEntries 的一致性检查与截断覆盖(本节);选举侧靠「只投给日志不落后的候选人」保证新 leader 一定包含全部已提交条目(5.2)。缺了任一侧,性质都会在某个故障组合下被打破——比如没有选举限制时,一个缺已提交日志的节点当选后会把已提交条目截断掉。
follower 日志不一致的四种场景
分歧不会凭空产生,它的来源可以追溯。健康集群里所有 follower 的日志都应当是 leader 日志的前缀,唯一的例外是「未提交的尾巴」可以不同。分歧的完整生命周期是:某任 leader 把一批条目复制到部分节点后宕机——部分节点多了未提交尾巴;新 leader 当选后按自己的日志覆盖这些尾巴,被覆盖的节点就留下冲突段;而落后节点在覆盖发生前恢复,又造成缺条目。生产里最常见的分歧其实是「落后节点缺条目」——网络或磁盘问题让节点停留在旧状态,恢复后由 leader 自动补齐。
新 leader 上任时,follower 的日志相对 leader 可能有四种偏离(Raft 论文原样列举),它们会组合出现:
| 场景 | 表现 | 典型成因 |
|---|---|---|
| 缺条目 | follower 日志比 leader 短 | follower 落后:网络慢、刚重启、分区后恢复 |
| 多条目 | follower 日志比 leader 长 | follower 在旧 leader 任内多收过未提交条目 |
| 冲突条目 | 相同 index 处 term 不同 | 旧 leader 的未提交条目被新 leader 覆盖后残留 |
| term 交错 | 相同 term 出现在不同 index | 多次选举、多任 leader 遗留的日志片段 |
第四种最隐蔽:日志里同一个 term 的条目可以出现在多个不同 index。比如 term 2 的 leader 追加过两条(index 2、3),term 3 的 leader 又追加一条(index 4),那么 term 2 就同时出现在 index 2 和 index 3。term 交错不影响匹配性质——匹配按「给定 index 处的 term 相等」判定,只要 index 2 处 term 都是 2,之前就一致,即使 term 序列看起来不单调。这也是为什么一致性检查只比对「一个下标处的任期」,而不是比对「term 序列的单调性」。
一个具体的混合场景:节点 A 在某任 leader 任内追到 index 8,但其中 index 5–7 是未提交条目;随后新 leader(只含已提交前缀)上任,节点 A 的 index 5 与 leader 冲突。此时 A 既「多条目」(比 leader 长)又「冲突条目」(index 5 处 term 不同)——修复时要先靠一致性检查定位,再截断 5 之后的全部残留。
用一份具体的日志数组把四种偏离对齐看,leader 的日志是 6 条(index 0–5,每条标 term:command):
| 节点 | index 0 | index 1 | index 2 | index 3 | index 4 | index 5 | index 6 | 偏离类型 |
|---|---|---|---|---|---|---|---|---|
| leader | t1:a | t1:b | t2:c | t3:d | t3:e | t4:f | —— | —— |
| 缺条目 | t1:a | t1:b | t2:c | —— | —— | —— | —— | 长度不足 |
| 多条目 | t1:a | t1:b | t2:c | t3:d | t3:e | t4:f | t5:g | 多出 t5:g 一条 |
| 冲突条目 | t1:a | t1:b | t2:c | t9:x | t3:e | t4:f | —— | index 3 处 t9 ≠ t3 |
| term 交错 | t1:a | t3:z | t2:c | t3:d | t3:e | t4:f | —— | index 1 处 t3 高于 t1,且 t3 出现在 index 1 与 3 |
term 交错这行值得细看:follower 的 term 序列 1、3、2、3、3、4 并不单调——index 1 出现了比 leader 更高任期的 t3,而同样的 t3 又出现在 index 3。这种「同一 term 出现在多个 index」正是多任 leader 遗留日志的典型形态。但匹配性质只看「给定 index 处的 term 是否相等」,所以 index 3 处两边都是 t3,并不因为 index 1 处不同而作废——检查的锚点落在哪里,就从哪里开始要求一致。这解释了为何 leader 逐条回退时,找到一个「term 相等」的锚点就足够重新对齐,而不需要理解整条 term 序列。
nextIndex 逐条回退机制
修复全部由 leader 驱动,靠两套进度表:nextIndex(发给每个 follower 的下一条下标,乐观估计)和 matchIndex(该 follower 已确认复制的最大下标,保守记录)。leader 当选瞬间把所有人的 nextIndex 初始化到自己日志末尾 + 1、matchIndex 初始化为 -1(node.go 的 initProgress)。
当 leader 发现某 follower 的响应是拒绝(Granted=false,即 PrevLogIndex/PrevLogTerm 一致性检查失败)时,Raft 论文给出的基本做法是 nextIndex 逐条回退:把该 follower 的 nextIndex 减 1,用更小的 PrevLogIndex 重新发送。由于回退逐个下标进行,且每次回退后的一致性检查都从新锚点重新做,算法必然收敛——最坏退到 prevIndex=-1(空前缀,总是匹配),那时把整个日志重发一遍。
为什么回退的是 nextIndex 而不是 matchIndex?两者语义不同:matchIndex 是「已确认复制到的位置」,是保守下界,只在成功时更新、只增不减;nextIndex 是「下次该发到哪」,是乐观估计,成功时前推、失败时回退。回退动作针对「该发到哪」——因为拒绝说明 leader 对 follower 的认知太超前了,要把预期拉回现实;而 matchIndex 作为「已经确认的事实」不应该被否定。这个分工让进度表既不会被失败拖垮(matchIndex 不倒退),又能对认知偏差快速纠偏(nextIndex 可回退)。
用 6.2 的 lab 场景走一遍:leader 日志 4 条(index 0–3,term 都是 T),follower 1 被注入冲突——日志被截断成 2 条、index 2 处换成 term 99 的 set:bad=x。leader 先按 nextIndex=4 发请求,prevIndex=3 处 follower 越界(termAt(3)=0)不匹配,拒绝;按逐条回退,leader 把 nextIndex 依次降到 3、2、1……直到 prevIndex=1 匹配成功,此时再发送 index ≥ 2 的条目,follower 发现 index 2 处 term 不同(99 ≠ T),截断冲突段重新追加 set:c=3、set:d=4,日志恢复与 leader 一致。
把这次修复按轮次展开成表,看清楚「回退」到底退了什么(每次回退后,leader 按新的 nextIndex 重新发送该 follower 缺的条目):
| 轮次 | leader 发送(PrevLogIndex / PrevLogTerm / 携带) | follower 1 判定 | 结果 |
|---|---|---|---|
| 1 | next=4 / prev=3 / termAt(3)=T / 空条目(next 已超末尾,退化为心跳) | termAt(3)=0 ≠ T(越界) | 拒绝,Granted=false |
| 2 | 回退到 next=3 / prev=2 / termAt(2)=T / [idx3] | termAt(2)=99 ≠ T(冲突) | 拒绝,Granted=false |
| 3 | 回退到 next=2 / prev=1 / termAt(1)=T / [idx2, idx3] | 锚点 termAt(1)=T 一致;处理条目时 idx2 处 99 ≠ T → 截断 idx2 起全部再追加 | 日志恢复 4 条,与 leader 一致 |
注意每一轮重试都带着「从新 nextIndex 起的条目」,而不是只发空请求——leader 无法预知该带多少,回退一格就带「从这一格之后的所有条目」,宁可多带。第三轮里截断与追加在同一次处理中完成:锚点匹配放行,然后逐条按 index 对齐,遇到 idx2 冲突才触发截断。真实 Raft 里第 1–2 轮也可以借助拒绝提示合并(见下文的 optimistic 优化),但判断逻辑完全相同:锚点不匹配就回退,锚点匹配就按携带的条目截断追加。
这张表也说明了为什么回退必然终止:每次回退都让 PrevLogIndex 至少减 1,下界是 -1(空前缀),所以至多退 (leader 日志长度 + 1) 轮;在每一轮,一致性检查要么成功(修复开始)要么失败(继续回退),不存在死循环的可能。复杂度是 O(分歧深度),而不是 O(日志总量)——这是修复机制可规模化的理论依据。
这个「逐条回退」的量级代价要算清楚:最坏情况下,一个落后 10000 条的 follower 需要 10000 轮「拒绝 → 回退一格 → 再试」,每轮一次网络往返。在 100ms 心跳周期下,纯逐条回退要花 1000 秒才能对齐——这显然是生产不可接受的,所以才有下面的 optimistic 优化。
consistency check 为什么够用
PrevLogIndex/PrevLogTerm 的一致性检查是 Raft 最精巧的设计之一:它不要求比较整条日志,只比较一个下标处的一个任期。为什么足够?
- 若该下标处的 term 匹配,由日志匹配性质,之前全部一致——可以安全地在此基础上追加;
- 若 term 不匹配,说明存在分歧点,但协议不必精确定位它,交给 nextIndex 回退去逼近即可。
配合「leader 从不修改已提交条目」,一致性检查还保证一件事:已提交的条目绝不会被覆盖。已提交条目一定存在于多数节点,而任何当选 leader 都包含全部已提交日志(5.2 选举限制),所以 leader 只会在这个已提交前缀之后做截断。截断动作看似危险(删日志),但删除范围永远不触及已提交区间——这是 6.3 提交安全性的前提。
再补一个边界:如果 follower 的日志比锚点还短(termAt 越界返回 0),检查同样失败——因为「下标 X 处任期是 T」这个陈述在越界处为假。所以「日志太短」也被当作一种不一致处理,缺条目的修复路径与冲突条目的修复路径共用同一套回退逻辑,leader 不需要区分两者。这正是 6.1 那个字段级例子里「节点 2 落后、LeaderCommit 只能推进到 min(4, 2)」的机制依据:commit 能推多深,受限于日志实际有多长。
把「一致性检查足够用」再严格一点:假设锚点处 term 匹配,但锚点之前的某处实际上并不一致——这在数学上不可能,因为日志匹配性质已经证明「锚点 term 相同 ⇒ 锚点之前全部相同」。所以一致性检查不只是「足够用」,而是「恰好够用」:它借助已证性质,把对整条日志的验证压缩成一个 term 的比对。反过来,如果哪一天日志匹配性质被违反(比如 leader 修改了旧条目),一致性检查就会给出错误的安全信号——这也是 7.2 把 leader append-only 作为独立安全属性单独验证的原因。
optimistic 优化:每轮回退多条
逐条回退正确但慢,etcd 的优化是在拒绝响应里携带冲突提示。follower 拒绝时,在响应中回填 RejectHint(自己日志里最后一个与 leader 一致的 index)与冲突处的 term;leader 收到后不是减 1,而是直接把 nextIndex 回退到 RejectHint 之后。若还能根据 term 定位到该 term 第一条条目的位置,甚至可以一次跳过多条。这样一次拒绝往往就对齐到位,慢 follower 的修复轮次从 O(落后条数) 降到 O(1)。
量级对比:5 节点集群里,一个落后 10000 条的 follower,纯逐条回退最多 10000 轮(100ms 心跳即约 1000 秒);带 RejectHint 的优化通常 1–2 轮就能定位到分歧点。集群越大、日志越长,这个优化越重要——这也是 etcd 能在数万条日志后仍快速恢复落后节点的原因。Raft 论文把这个优化描述为「在大多数场景下,一次拒绝就足以让 nextIndex 回到正确位置」。
用一个数值例子体会跳跃幅度:leader 日志到 index 5000,落后 follower 实际到 index 3000,且 index 2500 处与 leader 冲突。纯逐条回退要从 5000 一路试到 2499,约 2500 轮往返;follower 拒绝时回填 RejectHint=2499(自己日志里最后一个与 leader 一致的 index),leader 直接设 Next=2500,下一轮从 index 2500 重发——一轮到位。若再配合 LogTerm 回退(跳到该 term 第一条之前),即使 RejectHint 不够精确,也能在几轮内收敛。这个量级差就是「优化」二字的分量。
修复是增量的:落后 follower 不阻塞正常写入
一个值得强调的性质:日志修复只发生在 leader 与那个落后 follower 之间,不阻塞集群的其余部分。leader 为每个 follower 独立维护 nextIndex/matchIndex,落后 follower 的修复轮次与其他 follower 的正常复制互不相干。leader 无需「等所有节点对齐」才接受下一条写——它只要多数确认就能继续推进 commitIndex,落后节点在后面慢慢追。
在 etcd 里这个性质落成两件事:一是每个 peer 的发送 goroutine 相互独立(rafthttp 的 peer 通道各自背压);二是落后太远的 follower 会退化为 InstallSnapshot 直接对齐(第 9 章),而不是重放海量日志。K8s 控制面的典型场景:某台 etcd 副本刚从故障中恢复、日志落后几万条,此时 apiserver 的写入几乎不受影响,落后节点在后台快速追赶——你看到的现象是「该副本 endpoint status 的 Raft term/日志长度短暂落后,随后追上」,而不是「整个集群写路径变慢」。
这个「独立修复」还有一个隐藏的好处:它让集群对慢 follower 有天然的容忍度。只要落后节点没有进入 quorum(没参与多数判定),它甚至可以被临时允许长时间追不上——集群照常提交。只有当落后节点重新追上并需要它参与选举时,它的日志新旧才重新相关(5.2 的选举限制保证了它追不上就拿不到票)。所以日志修复的时间预算不是「硬 deadline」,而是「选举前必须完成」的软约束。
还有一个与 K8s 直接相关的观察:etcd 副本的日志长度差异是健康检查的重要信号。etcdctl endpoint status --cluster 会输出每个成员的 Raft term 与日志长度;当某副本日志长度明显落后时,通常意味着它在追(或卡在追不上)。这不是异常状态,但持续不收敛(长度差只增不减)就值得排查——通常指向网络丢包或磁盘慢。理解了本节的修复机制,你就知道「追」不是魔法,而是 leader 周期性重发 + follower 截断覆盖的必然结果,只是速度取决于两者的带宽与 RTT。
修复期间的消息成本
一次修复的消息数可以估算:每轮「拒绝 → 重发」是一条 AppendEntries + 一条响应,共 2 条消息。纯逐条回退修复 N 条分歧,最坏 2N 条消息;带 RejectHint 的优化把重试压缩到 1–2 轮,即 2–4 条。对照正常复制的成本(一次写提交约 2 条请求 + 2 条响应),优化后的修复成本与正常写同量级——这是它不会成为集群瓶颈的量化依据。在 5 节点集群里,即使一半节点同时需要修复,消息总量也只是常数倍放大,不会出现「修复风暴」把网络打满;真正打满网络的通常是 9.3 要讲的高频写 + 大对象,而不是日志修复本身。
这个量级也解释了 etcd 为什么能容忍「副本被替换」这种慢操作:新成员加进来时日志为空,若直接逐条追要复制全部历史;etcd 的做法是让新成员从当前快照起追(InstallSnapshot,第 9 章),把「复制全量日志」变成「复制一份状态 + 追少量增量」,消息量从 O(历史条数) 降到 O(状态大小 + 增量)。修复机制的正确性不变,变的只是「追的基础是什么」。
再给一个可复算的对照:假设一条日志平均 200 字节、一次复制请求带 100 条,那么一条 AppendEntries 约 20KB;修复一个落后 10000 条的 follower,一次带 100 条需要 100 轮、约 2MB 传输。相比逐条回退的 10000 轮往返,批量重发把往返次数降了两个数量级——「一次带一批」是复制与修复共用的吞吐手段,也是 6.1 里 l.Log[next:] 一次发多条的原因。
etcd 实际实现:raft/log.go 的 maybeAppend
etcd 的 raft/log.go 是这套机制的实现。follower 侧的核心是 raftLog.maybeAppend(index, logTerm, committed, ents...),四步与 lab 的 AppendEntries 一一对应:
matchTerm(index, logTerm)做一致性检查(对应 lab 的logMatchPrefix),不匹配返回 ok=false;findConflict(ents)定位第一条冲突条目(对应 lab 里n.Log[at].Term != e.Term的分支);truncateAndAppend截断冲突段并追加(对应 lab 的n.Log = n.Log[:at]再append);commitTo(min(committed, lastnewi))推进本地 commitIndex(对应 lab 的if leaderCommit > n.CommitIndex分支)。
对照签名读更清楚:maybeAppend 的入参 index/logTerm 就是 AppendEntries 请求里的 PrevLogIndex/PrevLogTerm,committed 是 LeaderCommit,ents 是待追加条目;返回值 lastnewi 对应响应里的 MatchIndex。所以 etcd 的一条 AppendEntries 处理路径,与 lab 的 AppendEntries(prevIndex, prevTerm, entries, leaderCommit) 在接口层面几乎一一同构——这是本卷选择这个 lab 的底气:小实现是真实实现的骨架,字段都能对上号。
leader 侧,sendAppend 按每个 peer 的 pr.Next 构造 AppendEntries;收到拒绝时用响应里的 RejectHint 重设 Next,而不是裸减 1。所以 Raft 论文的「逐条回退」在 etcd 里是「带提示的回退」——正确性等价,性能更好。lab 为了教学清晰保留了逐条回退的语义与一致检查的核心逻辑;读懂 lab 再读 etcd 源码,能看到同一思想、两种实现,这正是本卷推荐的学习路径。
在 etcd 的消息层,拒绝响应不是普通的 AppendEntriesResp,而是携带 Reject=true、RejectHint=index、LogTerm=term 的增强响应。leader 的 handleAppendEntriesResp 读到 Reject 后,优先按 LogTerm 回退到「该 term 第一条条目之前」,找不到再退回 RejectHint 之后。这份「term 优先、index 兜底」的顺序,正是为应对上文的 term 交错场景设计的——只按 index 回退会被交错迷惑,带上 term 才能一次跳到位。对应到代码,follower 在拒绝时用的辅助函数就是 findConflict 的反向应用:先找最后一个匹配项,把它的 index 和 term 塞回给 leader。
三个常见误解
把这一节最容易踩的坑单独列出来,避免把「机制」误读成「承诺」:
- 「日志复制失败 = 数据丢失」——拒绝响应只是「锚点没对上」,不是「数据坏了」。follower 日志里的冲突条目会被截断,但那些条目要么未提交(丢弃无损失)、要么已提交(必然存在于多数节点、leader 日志里也有)。复制机制保证收敛,不产生丢失。
- 「nextIndex 回退是逐条的,所以很慢」——论文描述逐条是正确性演示;生产实现(etcd)用 RejectHint 一次跳过。lab 保留逐条语义是为了可读性,不是性能形态。
- 「term 越大日志越新」——term 只衡量「这个条目是哪个任期产生的」,不保证整条日志谁更新。判断日志新旧用的是最后一个条目的 term、再比 index(5.2 的
logUpToDate),而不是全局最大 term。一个全是高任期条目的孤立节点,可能因为缺已提交的低任期条目而输掉选举——它的日志「新」但「不全」。 - 「修复完成后 follower 的日志就是 leader 的精确副本」——对已提交区间成立,但对未提交尾巴不成立:leader 日志里可能还有它刚追加、尚未提交的最后几条,follower 未必已有,要等这些条目复制到多数并提交后 follower 才追上。所以「对齐」指的是已提交前缀,而不是每一瞬间的整条日志。
本节 lab
本节的 lab 是 TestNextIndexBacktrack。它构造 3 节点集群,leader 先复制 4 条日志(set:a=1 到 set:d=4)到全部节点,然后人为把 follower 1 的日志截断到 2 条、在 index 2 处注入 term 99 的 set:bad=x(模拟旧 leader 遗留的冲突条目),再运行至多 400 步,断言冲突被修复:follower 1 的日志长度回到与 leader 一致,且 index 2 处恢复为 set:c=3。注入前测试还做了一步自检:先等待 follower 1 收到全部 4 条日志(len(s.Nodes[1].Log) < 4 的等待循环),确保冲突注入发生在已对齐的基础上——否则注入就变成了补齐缺条目,测的就不是冲突修复了。
cd private/labs/k8s-etcd-lab
go test ./raft -run TestNextIndexBacktrack -v
读 node.go 的两个方法对号入座:logMatchPrefix(prevIndex, prevTerm) 是一致性检查——prevIndex < 0 即空前缀总是匹配,否则要求 termAt(prevIndex) == prevTerm;AppendEntries 在检查通过后对每条 entry 按 index 对齐,同 index 不同 term 就 n.Log = n.Log[:at] 截断再追加,同 index 同 term 视为已存在跳过,超出末尾直接追加。这三行正是「截断冲突段再追加」的实现。测试注入的 term 99 条目,就是为了触发 n.Log[at].Term != e.Term 这条截断分支——它是本节的故障注入点,也是修复动作的激活条件。
测试里还能看到修复后的两个标志性结果:follower 1 的日志长度回到 4(与 leader 一致),且 index 2 处的命令从 set:bad=x 变回 set:c=3。这正是「截断冲突段再追加」的直接观测——被截断的不是整条日志,只是从冲突点(index 2)往后的部分;index 0、1 这两个一致前缀原样保留。运行测试时把 t.Fatalf 里的日志数组打印出来对比,就能看到修复前后的差异。注意 lab 固定了随机种子(NewSim(3, 9)),修复路径在每次运行中都可复现——这是本卷 lab「确定性演示」的通用手法。
对照前面 6.1 的 broadcastAppendEntries 再看一遍修复期间 leader 发什么:它始终按 NextIndex[follower] 决定携带哪些条目,修复过程就是「NextIndex 回退到匹配锚点、再带着真实条目重发」的过程。本节的要点是把这条链看成一个整体:「拒绝 → 回退 → 重试 → 截断 → 对齐」,follower 侧的半截(logMatchPrefix + AppendEntries 的截断分支)在 node.go,leader 侧的半截(进度表回退)在 Raft 协议与 etcd 的 sendAppend 里。lab 把两半都跑起来,用最终断言验证闭环的结果——不管回退是逐条还是跳跃式,最终都收敛到「follower 1 日志与 leader 逐字节一致」这一个可判定的终点。
继续阅读
探索更多技术文章
浏览归档,发现更多关于系统设计、工具链和工程实践的内容。