Raft协议实战：从脑裂到强一致

一次线上事故：MySQL主从切换丢了3秒数据

2023年双11大促期间，我们一个核心订单库的MySQL主库挂了。DBA手动切从库，结果发现从库的binlog落后主库3秒，这3秒的订单数据直接丢失。事后复盘，根本原因是主从复制是异步的，没有一致性保证。

如果当时用Raft协议管理MySQL集群，就不会出这事。Raft保证：只要多数节点活着，数据就不丢。今天我用PHP写一个迷你Raft实现，把原理讲透。

方案对比：Paxos vs Raft vs Zab

分布式一致性协议三巨头：Paxos、Raft、Zab。我直接说结论：

Paxos：理论优雅，工程实现难。Lamport的论文太抽象，Multi-Paxos的实现复杂度高。Google Chubby用Paxos，但代码不公开。
Raft：为工程而生。把一致性拆成Leader选举、日志复制、安全性三个子问题，每个都有明确算法。Etcd、Consul、TiKV都在用。
Zab：ZooKeeper专用，和Raft类似但更复杂。ZooKeeper的Zab实现有大量细节，不适合通用场景。

选Raft，因为：可理解性强，实现简单，社区成熟。Etcd v3.5.9用的就是Raft。

Raft核心机制：3个角色 + 2个阶段

Raft把节点分成三种角色：

Leader：处理所有客户端请求，负责日志复制
Follower：被动响应Leader和Candidate的请求
Candidate：选举过程中的临时角色

两个核心阶段：

Leader选举：集群启动或Leader挂了，重新选主
日志复制：Leader把客户端请求写入日志，复制到多数节点后提交

代码实现：PHP8.3实现迷你Raft

环境：PHP 8.3.6，无第三方依赖。完整代码在GitHub（文末链接），这里贴核心部分。

1. 节点状态结构

// raft_node.php
class RaftNode {
    public string $id;           // 节点ID
    public int $currentTerm = 0; // 当前任期
    public ?string $votedFor = null; // 当前任期投给谁
    public array $log = [];      // 日志条目 [term, command]
    public int $commitIndex = 0; // 已提交的最大日志索引
    public int $lastApplied = 0; // 已应用到状态机的最大索引
    
    // Leader专用
    public array $nextIndex = [];  // 每个Follower的下一个日志索引
    public array $matchIndex = []; // 每个Follower已匹配的日志索引
    
    public string $state = 'follower'; // follower, candidate, leader
    public int $electionTimeout = 150; // 选举超时ms
    public int $heartbeatInterval = 50; // 心跳间隔ms
    
    public function __construct(string $id) {
        $this->id = $id;
    }
}

2. Leader选举实现

// election.php
class RaftElection {
    private array $peers; // 其他节点
    private RaftNode $node;
    
    public function startElection(): void {
        $this->node->state = 'candidate';
        $this->node->currentTerm++;
        $this->node->votedFor = $this->node->id;
        
        $votesReceived = 1; // 自己投自己
        $lastLogIndex = count($this->node->log) - 1;
        $lastLogTerm = $lastLogIndex >= 0 ? $this->node->log[$lastLogIndex]['term'] : 0;
        
        // 并发发送RequestVote RPC
        foreach ($this->peers as $peer) {
            $this->sendRequestVote($peer, [
                'term' => $this->node->currentTerm,
                'candidateId' => $this->node->id,
                'lastLogIndex' => $lastLogIndex,
                'lastLogTerm' => $lastLogTerm
            ], function($response) use (&$votesReceived) {
                if ($response['term'] > $this->node->currentTerm) {
                    $this->becomeFollower($response['term']);
                    return;
                }
                if ($response['voteGranted']) {
                    $votesReceived++;
                    if ($votesReceived > count($this->peers) / 2) {
                        $this->becomeLeader();
                    }
                }
            });
        }
    }
    
    private function becomeLeader(): void {
        $this->node->state = 'leader';
        $lastLogIndex = count($this->node->log);
        foreach ($this->peers as $peer) {
            $this->node->nextIndex[$peer] = $lastLogIndex;
            $this->node->matchIndex[$peer] = 0;
        }
        // 立即发送心跳
        $this->sendHeartbeats();
    }
}

3. 日志复制实现

// replication.php
class RaftReplication {
    private RaftNode $node;
    private array $peers;
    
    public function appendEntries(string $command): void {
        if ($this->node->state !== 'leader') {
            throw new RuntimeException('Only leader can append entries');
        }
        
        // 追加到本地日志
        $this->node->log[] = [
            'term' => $this->node->currentTerm,
            'command' => $command
        ];
        $lastIndex = count($this->node->log) - 1;
        
        // 并行复制到所有Follower
        $successCount = 1; // 自己算一个
        foreach ($this->peers as $peerId) {
            $prevLogIndex = $this->node->nextIndex[$peerId] - 1;
            $prevLogTerm = $prevLogIndex >= 0 ? $this->node->log[$prevLogIndex]['term'] : 0;
            
            $entries = array_slice(
                $this->node->log, 
                $this->node->nextIndex[$peerId]
            );
            
            $this->sendAppendEntries($peerId, [
                'term' => $this->node->currentTerm,
                'leaderId' => $this->node->id,
                'prevLogIndex' => $prevLogIndex,
                'prevLogTerm' => $prevLogTerm,
                'entries' => $entries,
                'leaderCommit' => $this->node->commitIndex
            ], function($response) use ($peerId, &$successCount, $lastIndex) {
                if ($response['success']) {
                    $this->node->nextIndex[$peerId] = $lastIndex + 1;
                    $this->node->matchIndex[$peerId] = $lastIndex;
                    $successCount++;
                    
                    // 如果多数节点复制成功，提交日志
                    if ($successCount > count($this->peers) / 2) {
                        $this->node->commitIndex = $lastIndex;
                        $this->applyLogs();
                    }
                } else {
                    // 日志不一致，回退nextIndex
                    $this->node->nextIndex[$peerId]--;
                }
            });
        }
    }
}

4. 心跳与超时检测

// heartbeat.php
class RaftHeartbeat {
    private RaftNode $node;
    private array $peers;
    private int $lastHeartbeat;
    
    public function sendHeartbeats(): void {
        while ($this->node->state === 'leader') {
            foreach ($this->peers as $peer) {
                $this->sendAppendEntries($peer, [
                    'term' => $this->node->currentTerm,
                    'leaderId' => $this->node->id,
                    'prevLogIndex' => 0,
                    'prevLogTerm' => 0,
                    'entries' => [], // 空表示心跳
                    'leaderCommit' => $this->node->commitIndex
                ]);
            }
            usleep($this->node->heartbeatInterval * 1000);
        }
    }
    
    public function checkElectionTimeout(): void {
        while (true) {
            $elapsed = (microtime(true) - $this->lastHeartbeat) * 1000;
            if ($elapsed > $this->node->electionTimeout) {
                if ($this->node->state === 'follower') {
                    $this->startElection();
                }
            }
            usleep(10000); // 10ms检查一次
        }
    }
}

5. 完整启动脚本

#!/bin/bash
# start_raft_cluster.sh
# 启动3节点Raft集群

# 节点配置
NODES=("node1:127.0.0.1:8001" "node2:127.0.0.1:8002" "node3:127.0.0.1:8003")

# 启动每个节点
for node in "${NODES[@]}"; do
    IFS=':' read -r id ip port <<< "$node"
    php raft_server.php --id=$id --ip=$ip --port=$port --peers="${NODES[*]}" &
    echo "Started $id on $ip:$port"
done

# 等待集群稳定
sleep 2
echo "Raft cluster started with ${#NODES[@]} nodes"

效果数据：压测对比

测试环境：3台阿里云ECS，4核8G，内网延迟0.3ms。PHP 8.3.6，Swoole 5.1.0。

场景	方案	QPS	P99延迟(ms)	数据一致性
单节点写入	无Raft	12000	2.1	无保证
Raft 3节点	同步复制	3800	8.5	强一致
Raft 5节点	同步复制	2100	15.2	强一致
异步复制	MySQL主从	9500	3.8	最终一致

结论：Raft牺牲了约68%的吞吐量，换来了强一致性保证。3节点集群P99延迟8.5ms，对大多数业务可接受。

避坑指南：我踩过的5个坑

坑1：选举超时设置不当。一开始设了100ms，网络抖动频繁触发选举。后来改成150-300ms随机值，问题解决。
坑2：日志复制不回退。Follower日志和Leader不一致时，必须逐条回退nextIndex。我一开始直接跳过，导致日志丢失。
坑3：心跳和选举超时冲突。心跳间隔必须小于选举超时，否则Leader正常也会触发选举。我设心跳50ms，选举150ms，留了3倍余量。
坑4：单点写入性能瓶颈。所有写请求必须经过Leader，Leader成为瓶颈。解决方案：批量提交，合并多个命令到一个日志条目。
坑5：脑裂恢复后数据冲突。旧Leader恢复后，发现自己的日志被新Leader覆盖。必须严格遵循Raft的日志匹配规则：比较term和index，只追加不修改。

总结

Raft不是银弹，但它是目前工程实现一致性最好的选择。Etcd v3.5.9、Consul 1.17.0、TiKV 7.5.0都在用。如果你需要强一致性，又不想自己造轮子，直接用Etcd。

完整代码：github.com/your-repo/raft-php