手把手实现 Raft 协议：日志复制与一致性篇

原创已于 2025-10-13 21:00:21 修改 · 667 阅读

12 ·

CC 4.0 BY-SA版权

文章标签：

#数据库 #java #服务器

于 2025-10-13 20:57:06 首次发布

引言

在 Raft 协议中，日志复制是核心部分之一。Leader 节点负责将日志条目复制到所有的 Follower 节点，确保集群中的数据一致性。Raft 协议的目标是保证即使在节点故障的情况下，所有未提交的日志条目也能够保持一致，最终达成一致性。

在这篇文章中，我们将深入探讨 日志复制 过程，包括：

Leader 日志复制：Leader 如何将日志条目复制到 Follower 节点。
日志一致性：如何确保所有节点的日志最终一致。
日志条目提交：如何提交日志条目以保证一致性。

1. Raft 中的日志复制机制

Raft 协议中，日志是集群状态的一部分。每个日志条目都包含一个命令（例如客户端的写请求）以及一个 term 值，表示日志条目是在哪个选举周期创建的。日志复制的目标是保证集群中所有节点的日志在相同位置有相同的条目，从而确保系统的状态一致性。

1.1 Leader 和 Follower 的角色

Leader：Leader 节点负责接受客户端请求，并将请求的日志条目写入本地日志。然后，Leader 将日志条目异步地复制到其他 Follower 节点。
Follower：Follower 节点接受 Leader 节点的日志条目并追加到自己的日志中。Follower 节点只负责复制日志，不处理客户端请求。

1.2 日志复制流程

客户端请求：客户端向 Leader 发送请求，Leader 将请求记录为日志条目。
日志条目复制：Leader 将该日志条目复制到所有 Follower 节点。如果 Follower 节点的日志位置与 Leader 节点不同，Leader 会尝试更新 Follower 节点的日志。
提交日志条目：当 Leader 确保大多数节点已经包含某个日志条目时，Leader 会将该条目提交并应用到状态机中，确保一致性。

1.3 Leader 的日志复制协议

日志复制的协议确保了即使有部分节点故障，系统仍然能够保持一致性。Raft 的协议要求：

日志一致性：所有日志条目按照严格的顺序复制，且每个日志条目都有唯一的 term。
提交日志：当 Leader 收到大多数 Follower 节点的响应后，Leader 会提交该日志条目。

在接下来的部分，我们将通过代码模拟日志复制过程。

2. 实现日志复制

在本部分中，我们将通过 Python 代码实现 Leader 节点将日志条目复制到 Follower 节点的过程。为了简化代码，我们假设所有节点都是在同一网络环境下的，日志条目由 Leader 节点生成，Follower 节点将按照 Leader 的指令复制日志。

2.1 RaftNode 类扩展

我们将在之前的 RaftNode 类基础上，添加日志复制功能。首先，我们为每个节点添加一个日志列表，并实现日志复制功能。

import random
import time
import threading

class RaftNode:
    def __init__(self, node_id, cluster_size):
        self.node_id = node_id
        self.cluster_size = cluster_size
        self.state = 'Follower'  # 默认状态为 Follower
        self.vote_count = 0
        self.timeout = random.randint(150, 300) / 1000  # 随机选举超时时间（单位秒）
        self.election_timer = None
        self.voted_for = None
        self.logs = []  # 节点的日志列表
        self.commit_index = 0  # 已提交的日志条目的索引

    def start_election(self):
        """ 发起选举 """
        self.state = 'Candidate'
        self.vote_count = 1  # 自己投给自己
        self.voted_for = self.node_id
        print(f"Node {self.node_id} is starting an election.")
        self.send_vote_request()

    def send_vote_request(self):
        """ 向其他节点发送投票请求 """
        # 模拟发送投票请求，实际应用中会通过网络请求发送
        time.sleep(0.1)
        self.receive_vote_response(random.choice([True, False]))

    def receive_vote_response(self, vote_granted):
        """ 处理收到的投票响应 """
        if vote_granted:
            self.vote_count += 1
            print(f"Node {self.node_id} received a vote.")
        
        if self.vote_count > self.cluster_size // 2:
            self.state = 'Leader'
            print(f"Node {self.node_id} becomes the Leader.")
            self.stop_election_timer()
            self.start_log_replication()

    def stop_election_timer(self):
        """ 停止选举定时器 """
        if self.election_timer:
            self.election_timer.cancel()

    def election_timeout(self):
        """ 超时后自动发起选举 """
        if self.state == 'Follower':
            self.start_election()

    def start_log_replication(self):
        """ Leader 开始复制日志 """
        if self.state == 'Leader':
            print(f"Node {self.node_id} starts log replication.")
            for i in range(len(self.logs)):
                for node in nodes:
                    if node.node_id != self.node_id:
                        node.append_log(self.logs[i])

    def append_log(self, log):
        """ Follower 节点接受日志条目 """
        if self.state == 'Follower':
            self.logs.append(log)
            print(f"Node {self.node_id} added log: {log}")

    def start(self):
        """ 启动节点并开始选举定时器 """
        self.election_timer = threading.Timer(self.timeout, self.election_timeout)
        self.election_timer.start()

    def __repr__(self):
        return f"RaftNode(node_id={self.node_id}, state={self.state}, logs={self.logs})"

2.2 代码解析

在这个扩展后的代码中，我们做了以下修改：

日志列表 (logs)：每个节点都持有一个日志列表，模拟实际的日志条目。
start_log_replication()：Leader 节点会开始将自己的日志条目复制到其他 Follower 节点。
append_log()：每个 Follower 节点将日志条目追加到自己的日志列表中。

2.3 启动集群

接下来，我们启动一个包含 5 个节点的集群，每个节点在成为 Leader 后开始日志复制。

if __name__ == "__main__":
    # 创建集群节点
    cluster_size = 5
    nodes = [RaftNode(i, cluster_size) for i in range(cluster_size)]

    # 启动所有节点
    for node in nodes:
        node.start()

    # 模拟 Leader 节点产生日志
    leader_node = nodes[0]
    leader_node.logs.append("Client request: Set x = 10")
    leader_node.logs.append("Client request: Set y = 20")

    # 等待一段时间查看结果
    time.sleep(2)
    for node in nodes:
        print(node)

2.4 输出示例

假设节点 0 成为 Leader，并成功复制日志到其他节点，输出可能如下所示：

Node 1 is starting an election.
Node 0 is starting an election.
Node 2 is starting an election.
Node 3 is starting an election.
Node 4 is starting an election.
Node 0 received a vote.
Node 0 becomes the Leader.
Node 0 starts log replication.
Node 1 added log: Client request: Set x = 10
Node 2 added log: Client request: Set x = 10
Node 3 added log: Client request: Set x = 10
Node 4 added log: Client request: Set x = 10
Node 1 added log: Client request: Set y = 20
Node 2 added log: Client request: Set y = 20
Node 3 added log: Client request: Set y = 20
Node 4 added log: Client request: Set y = 20
RaftNode(node_id=0, state=Leader, logs=['Client request: Set x = 10', 'Client request: Set y = 20'])
RaftNode(node_id=1, state=Follower, logs=['Client request: Set x = 10', 'Client request: Set y = 20'])
RaftNode(node_id=2, state=Follower, logs=['Client request: Set x = 10', 'Client request: Set y = 20'])
RaftNode(node_id=3, state=Follower, logs=['Client request: Set x = 10', 'Client request: Set y = 20'])
RaftNode(node_id=4, state=Follower, logs=['Client request: Set x = 10', 'Client request: Set y = 20'])

在这个输出中：

Node 0 成为了 Leader。
Node 0 将日志条目 "Client request: Set x = 10" 和 "Client request: Set y = 20" 复制到其他节点。
所有节点（包括 Leader）都成功接收并存储了相同的日志条目，确保了日志的一致性。