Raft 一致性算法

原创 已于 2023-12-23 19:10:02 修改 · 698 阅读 · 1 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#raft
于 2023-02-16 17:54:29 首次发布

Raft

Raft提供了一种在计算系统集群中分布状态机的通用方法，确保集群中的每个节点都同意一系列相同的状态转换。
一个Raft集群包含若干个服务器节点，通常为5个，这允许整个系统容忍2个节点的失效。每个节点处于以下三种状态之一：

  1. follower（跟随者）：所有节点都以follower的状态开始。如果没有收到leader的消息则会变成candidate状态。
  2. candidate（候选人）：会向其他节点“拉选票”，如果得到大部分的票则成为leader，这个过程叫做Leader选举（Leader Election）。未当选Leader的节点会将状态转换为follower。
  3. leader（领导者）：所有对系统的修改都会先经过leader。

raft 是 etcd 和consoul的核心算法。

Raft 一致性算法

  • Raft通过选出一个leader来简化日志副本的管理，例如，日志项（log entry)只允许从leader流向follower。
  • 基于leader的方法，Raft算法可以分解成三个子问题。
    1. Leader election（领导选举）：原来的leader挂掉后，必须选出一个新的leader。
    2. Log replication（日志复制）：leader从客户端接收日志，并复制到整个集群中。
    3. Safety（安全性）：如果有任意的server将日志项回放到状态机中了，那么其他的server只会回放相同的日志项。

动画演示

地址：http://thesecretlivesofdata.com/raft/
网络节点必须是奇数个。
动画主要包含三部分内容：

  • 第一部分介绍简单版的领导者选举和日志复制的过程
  • 第二部分介绍详细版的领导者选举和日志复制过程
  • 第三部分介绍如果遇到网络分区（脑裂），raft算法是如何回复网络一致的。

Leader election（领导选举）

  • Raft 使用一种心跳机制来触发领导人选举
  • 当服务器程序启动时，节点都是 follower(跟随者) 身份
  • 如果一个跟随者在一段时间里没有接收到任何消息，也就是选举超时，然后他就会认为系统中没有可用的领导者然后开始进行选举以选出新的领导者
  • 要开始一次选举过程，follower 会给当前term加1并且转换成candidate状态，然后它会并行的向集群中的其他服务器节点发送请求投票的 RPCs 来给自己投票。
  • 候选人的状态维持直到发生以下任何一个条件发生的时候
    • 他自己赢得了这次的选举
    • 其他的服务器成为领导者
    • 一段时间之后没有任何一个获胜的人

Log replication（日志复制）

  • 当选出 leader 后，它会开始接收客户端请求，每个请求会带有一个指令，可以被回放到状态机中
  • leader 把指令追加成一个log entry，然后通过AppendEntries RPC并行地发送给其他的server，当该entry被多数server复制后，leader 会把该entry回放到状态机中，然后把结果返回给客户端
  • 当 follower 宕机或者运行较慢时，leader 会无限地重发AppendEntries给这些follower，直到所有的follower都复制了该log entry
  • raft的log replication要保证如果两个log entry有相同的index和term，那么它们存储相同的指令
  • leader在一个特定的term和index下，只会创建一个log entry

代码

package main

import (
	"os"
	"strconv"
	"fmt"
	"sync"
	"net/rpc"
	"net/http"
	"math/rand"
	"time"

	"log"
)

//对每个节点id和端口的封装类型
type nodeInfo struct {
	id   string
	port string
}

//声明节点对象类型Raft
type Raft struct {
	node nodeInfo
	mu   sync.Mutex
	//当前节点编号
	me            int
	currentTerm   int
	votedFor      int
	state         int
	timeout       int
	currentLeader int
	//该节点最后一次处理数据的时间
	lastMessageTime int64

	message   chan bool
	eclectCh  chan bool
	heartbeat chan bool
	//子节点给主节点返回心跳信号
	heartbeatRe chan bool
}

//声明leader对象
type Leader struct {
	//任期
	Term int
	//leader 编号
	LeaderId int
}

//设置节点个数
const raftCount = 2

var leader = Leader{0, -1}
//存储缓存信息
var bufferMessage = make(map[string]string)
//处理数据库信息
var mysqlMessage = make(map[string]string)
//操作消息数组下标
var messageId = 1
//用nodeTable存储每个节点中的键值对
var nodeTable map[string]string

func main() {
	//终端接收来的是数组
	if len(os.Args) > 1 {
		//接收终端输入的信息
		userId := os.Args[1]
		//字符串转换整型
		id, _ := strconv.Atoi(userId)
		fmt.Println(id)
		//定义节点id和端口号
		nodeTable = map[string]string{
			"1": ":8000",
			"2": ":8001",
		}
		//封装nodeInfo对象
		node := nodeInfo{id: userId, port: nodeTable[userId]}
		//创建节点对象
		rf := Make(id)
		//确保每个新建立的节点都有端口对应
		//127.0.0.1:8000
		rf.node = node
		//注册rpc
		go func() {
			//注册rpc，为了实现远程链接
			rf.raftRegisterRPC(node.port)
		}()
		if userId == "1" {
			go func() {
				//回调方法
				http.HandleFunc("/req", rf.getRequest)
				fmt.Println("监听8080")
				if err := http.ListenAndServe(":8080", nil); err != nil {
					fmt.Println(err)
					return
				}
			}()
		}
	}
	for {;
	}
}

var clientWriter http.ResponseWriter

func (rf *Raft) getRequest(writer http.ResponseWriter, request *http.Request) {
	request.ParseForm()
	if len(request.Form["age"]) > 0 {
		clientWriter = writer
		fmt.Println("主节点广播客户端请求age:", request.Form["age"][0])

		param := Param{Msg: request.Form["age"][0], MsgId: strconv.Itoa(messageId)}
		messageId++
		if leader.LeaderId == rf.me {
			rf.sendMessageToOtherNodes(param)
		} else {
			//将消息转发给leader
			leaderId := nodeTable[strconv.Itoa(leader.LeaderId)]
			//连接远程rpc服务
			rpc, err := rpc.DialHTTP("tcp", "127.0.0.1"+leaderId)
			if err != nil {
				log.Fatal("\nrpc转发连接server错误:", leader.LeaderId, err)
			}
			var bo = false
			//首先给leader传递
			err = rpc.Call("Raft.ForwardingMessage", param, &bo)
			if err != nil {
				log.Fatal("\nrpc转发调用server错误:", leader.LeaderId, err)
			}
		}
	}
}

func (rf *Raft) sendMessageToOtherNodes(param Param) {
	bufferMessage[param.MsgId] = param.Msg
	// 只有领导才能给其它服务器发送消息
	if rf.currentLeader == rf.me {
		var success_count = 0
		fmt.Printf("领导者发送数据中 。。。\n")
		go func() {
			rf.broadcast(param, "Raft.LogDataCopy", func(ok bool) {
				//需要其它服务端回应
				rf.message <- ok
			})
		}()

		for i := 0; i < raftCount-1; i++ {
			fmt.Println("等待其它服务端回应")
			select {
			case ok := <-rf.message:
				if ok {
					success_count++
					if success_count >= raftCount/2 {
						rf.mu.Lock()
						rf.lastMessageTime = milliseconds()
						mysqlMessage[param.MsgId] = bufferMessage[param.MsgId]
						delete(bufferMessage, param.MsgId)
						if clientWriter != nil {
							fmt.Fprintf(clientWriter, "OK")
						}
						fmt.Printf("\n领导者发送数据结束\n")
						rf.mu.Unlock()
					}
				}
			}
		}
	}
}

//注册Raft对象，注册后的目的为确保每个节点（raft) 可以远程接收
func (node *Raft) raftRegisterRPC(port string) {
	//注册一个服务器
	rpc.Register(node)
	//把服务绑定到http协议上
	rpc.HandleHTTP()
	err := http.ListenAndServe(port, nil)
	if err != nil {
		fmt.Println("注册rpc服务失败", err)
	}
}

//创建节点对象
func Make(me int) *Raft {
	rf := &Raft{}
	rf.me = me
	rf.votedFor = -1
	//0 follower ,1 candidate ,2 leader
	rf.state = 0
	rf.timeout = 0
	rf.currentLeader = -1
	rf.setTerm(0)

	//初始化通道
	rf.message = make(chan bool)
	rf.heartbeat = make(chan bool)
	rf.heartbeatRe = make(chan bool)
	rf.eclectCh = make(chan bool)

	//每个节点都有选举权
	go rf.election()
	//每个节点都有心跳功能
	go rf.sendLeaderHeartBeat()

	return rf
}

//选举成功后，应该广播所有的节点，本节点成为了leader
func (rf *Raft) sendLeaderHeartBeat() {
	for {
		select {
		case <-rf.heartbeat:
			rf.sendAppendEntriesImpl()
		}
	}
}

func (rf *Raft) sendAppendEntriesImpl() {
	if rf.currentLeader == rf.me {
		var success_count = 0
		go func() {
			param := Param{Msg: "leader heartbeat",
				Arg: Leader{rf.currentTerm, rf.me}}
			rf.broadcast(param, "Raft.Heartbeat", func(ok bool) {
				rf.heartbeatRe <- ok
			})
		}()

		for i := 0; i < raftCount-1; i++ {
			select {
			case ok := <-rf.heartbeatRe:
				if ok {
					success_count++
					if success_count >= raftCount/2 {
						rf.mu.Lock()
						rf.lastMessageTime = milliseconds()
						fmt.Println("接收到了子节点们的返回信息")
						rf.mu.Unlock()
					}
				}
			}
		}
	}
}

func randomRange(min, max int64) int64 {
	//设置随机时间
	rand.Seed(time.Now().UnixNano())
	return rand.Int63n(max-min) + min
}

//获得当前时间（毫秒）
func milliseconds() int64 {
	return time.Now().UnixNano() / int64(time.Millisecond)
}

func (rf *Raft) election() {
	var result bool
	//每隔一段时间发一次心跳
	for {
		//延时时间
		timeout := randomRange(1500, 3000)
		//设置该节点最有一次处理消息的时间
		rf.lastMessageTime = milliseconds()

		select {
		//间隔时间为1500-3000ms的随机值
		case <-time.After(time.Duration(timeout) * time.Millisecond):
		}

		result = false
		for !result {
			//选择leader
			result = rf.election_one_round(&leader)
		}
	}
}

func (rf *Raft) election_one_round(args *Leader) bool {
	//已经有了leader，并且不是自己，那么return
	if args.LeaderId > -1 && args.LeaderId != rf.me {
		fmt.Printf("%d已是leader，终止%d选举\n", args.LeaderId, rf.me)
		return true
	}

	var timeout int64
	var vote int
	var triggerHeartbeat bool
	timeout = 2000
	last := milliseconds()
	success := false
	rf.mu.Lock()
	rf.becomeCandidate()
	rf.mu.Unlock()
	fmt.Printf("candidate=%d start electing leader\n", rf.me)
	for {
		fmt.Printf("candidate=%d send request vote to server\n", rf.me)
		go func() {
			rf.broadcast(Param{Msg: "send request vote"}, "Raft.ElectingLeader", func(ok bool) {
				//无论成功失败都需要发送到通道 避免堵塞
				rf.eclectCh <- ok
			})
		}()

		vote = 0
		triggerHeartbeat = false
		for i := 0; i < raftCount-1; i++ {
			fmt.Printf("candidate=%d waiting for select for i=%d\n", rf.me, i)
			select {
			case ok := <-rf.eclectCh:
				if ok {
					vote++
					success = vote >= raftCount/2 || rf.currentLeader > -1
					if success && !triggerHeartbeat {
						fmt.Println("okok", args)
						triggerHeartbeat = true
						rf.mu.Lock()
						rf.becomeLeader()
						args.Term = rf.currentTerm + 1
						args.LeaderId = rf.me
						rf.mu.Unlock()
						fmt.Printf("candidate=%d becomes leader\n", rf.currentLeader)
						rf.heartbeat <- true
					}
				}
			}
			fmt.Printf("candidate=%d complete for select for i=%d\n", rf.me, i)
		}
		if (timeout+last < milliseconds()) || (vote >= raftCount/2 || rf.currentLeader > -1) {
			break
		} else {
			select {
			case <-time.After(time.Duration(5000) * time.Millisecond):
			}
		}
	}
	fmt.Printf("candidate=%d receive votes status=%t\n", rf.me, success)
	return success
}

func (rf *Raft) becomeLeader() {
	rf.state = 2
	fmt.Println(rf.me, "成为了leader")
	rf.currentLeader = rf.me
}

//设置发送参数的数据类型
type Param struct {
	Msg   string
	MsgId string
	Arg   Leader
}

func (rf *Raft) broadcast(msg Param, path string, fun func(ok bool)) {

	//设置不要自己给自己广播
	for nodeID, port := range nodeTable {
		if nodeID == rf.node.id {
			continue;
		}

		//链接远程rpc
		rp, err := rpc.DialHTTP("tcp", "127.0.0.1"+port)
		if err != nil {
			fun(false)
			continue
		}

		var bo = false
		err = rp.Call(path, msg, &bo)
		if err != nil {
			fun(false)
			continue
		}
		fun(bo)
	}

}

func (rf *Raft) becomeCandidate() {
	if rf.state == 0 || rf.currentLeader == -1 {
		//候选人状态
		rf.state = 1
		rf.votedFor = rf.me
		rf.setTerm(rf.currentTerm + 1)
		rf.currentLeader = -1

	}
}

func (rf *Raft) setTerm(term int) {
	rf.currentTerm = term
}

//Rpc处理
func (rf *Raft) ElectingLeader(param Param, a *bool) error {
	//给leader投票
	*a = true
	rf.lastMessageTime = milliseconds()
	return nil
}

func (rf *Raft) Heartbeat(param Param, a *bool) error {
	fmt.Println("\nrpc:heartbeat:", rf.me, param.Msg)
	if param.Arg.Term < rf.currentTerm {
		*a = false
	} else {
		leader = param.Arg
		fmt.Printf("%d收到leader%d心跳\n", rf.currentLeader, leader.LeaderId)
		*a = true
		rf.mu.Lock()
		rf.currentLeader = leader.LeaderId
		rf.votedFor = leader.LeaderId
		rf.state = 0
		rf.lastMessageTime = milliseconds()
		fmt.Printf("server = %d learned that leader = %d\n", rf.me, rf.currentLeader)
		rf.mu.Unlock()
	}
	return nil
}

//连接到leader节点
func (rf *Raft) ForwardingMessage(param Param, a *bool) error {
	fmt.Println("\nrpc:forwardingMessage:", rf.me, param.Msg)

	rf.sendMessageToOtherNodes(param)

	*a = true
	rf.lastMessageTime = milliseconds()

	return nil
}

//接收leader传过来的日志
func (r *Raft) LogDataCopy(param Param, a *bool) error {
	fmt.Println("\nrpc:LogDataCopy:", r.me, param.Msg)
	bufferMessage[param.MsgId] = param.Msg
	*a = true
	return nil
}

Reference
老男孩 Go 5期

raft一致性算法中文版
11-29
raft一致性算法的论文中文版 斯坦福大学分布式计算课程的一部分
详解分布式共识（一致性）算法Raft
02-23
所谓分布式共识（consensus），与CAP理论中的一致性（consistency）其实是异曲同工，就是在分布式系统中，所有节点对同一份数据的认知能够达成一致。保证集群共识的算法就叫共识算法，它与一致性协议这个词也经常互相通用。当今最著名的共识算法就是Paxos算法。它由LeslieLamport在1990年提出，很长时间以来都是一致性的事实标准。但是它有两个不小的缺点：难以理解和证明，难以在实际工程中实现。GoogleChubby的工程师就曾有以下的评论：于是2014年，来自斯坦福的两位大佬DiegoOngaro与JohnOusterhout通过论文《InSearchofanUnderst
Raft一致性算法（精简和扩展）
arthur.dy.lee的专栏
04-17 1392
⼀ 致性算法在构建可信赖的⼤规模软件系统中扮演着重要的⾓⾊。强领导⼈：和其他⼀致性算法相⽐，Raft 使⽤⼀种更强的领导能⼒形式。⽐如，⽇志条⽬只从领导⼈发送给其他 的服务器。这种⽅式简化了对复制⽇志的管理并且使得 Raft 算法更加易于理解。领导选举：Raft 算法使⽤⼀个随机计时器来选举领导⼈。这种⽅式只是在任何⼀致性算法都必须实现的⼼跳机制 上增加了⼀点机制。在解决冲突的时候会更加简单快捷。
Raft一致性算法逻辑详解
zhangxm_qz的博客
11-09 1801
文章目录Raft算法基本概念领袖选举日志复制 Raft算法基本概念 一般情况下，分布式系统中存在如下两种节点关系模型 对称 所有节点都是平等的 不存在主节点 。 客户端可以与任意节点进 行交互 。 **非对称 ** 基于选主模型，只有主节点拥有决策权 。 任意时刻有且仅有一 个主节点，客户端只与主节点进行交互 。 基于简化操作和效率等因素考虑， Raft 算法采用的是非对称节点关系模型 。Raft 协议组织的集群中，一共包含如下 3 类角色 Leader （领袖） Candidate （候选人） Follo
一致性算法之Raft算法
aichojie的博客
11-19 2337
一致性raft算法简单理解
raft一致性算法-零散整理
fofcn的专栏
03-16 1027
分布式 一致性 raft 算法 这你
【分布式】一致性算法 Raft
_山月
02-18 1683
Raft 算法是共识算法（也叫一致性算法）的一种，用来解决分布式一致性问题，主要作为 Paxos 的替代算法。文章有一万多个字，对算法的主要内容进行了整理，加上了对关键问题的消化和理解，希望对大家学习 Raft 算法能提供一些帮助。
一致性算法Raft
最新发布
xxz610的博客
04-14 937
在分布式系统中，一致性算法允许机器集群在部分成员故障时作为一个协调一致的整体工作，对构建可靠大规模软件系统至关重要。Raft 通过选举领导者来管理复制日志，将共识问题分解为领导者选举、日志复制和安全性等子问题。
一致性算法Raft详解
小小本科生成长之路
06-21 1万+
原文出处：http://www.solinx.co/archives/415?utm_source=tuicool&utm_medium=referral 一致性算法Raft详解 背景 　　熟悉或了解分布性系统的开发者都知道一致性算法的重要性，Paxos一致性算法从90年提出到现在已经有二十几年了，而Paxos流程太过于繁杂实现起来也比较复杂，可能也是以为过于复杂
一致性算法 - Raft
我不是大牛
05-24 5554
一致性算法 - Raft Raft 状态 一个 Raft 集群包含若干个服务器节点；通常是 5 个，这允许整个系统容忍 2 个节点的失效，每个节点处于以下三种状态之一： follower（跟随者） ：所有结点都以 follower 的状态开始。如果没收到 leader消息则会变成 candidate状态。 candidate（候选人）：会向其他结点“拉选票”，如果得到大部分的票则成为lea...
Raft 一致性算法论文
跨链技术践行者
05-17 1万+
本篇博客为著名的 RAFT 一致性算法论文的中文翻译，论文名为《In search of an Understandable Consensus Algorithm (Extended Version)》(寻找一种易于理解的一致性算法)。 Raft 是一种用来管理日志复制的一致性算法。它和 Paxos 的性能和功能是一样的，但是它和 Paxos 的结构不一样；这使得 Raft 更容易理解并且更易...
Raft一致性算法整理【原理笔记】
gaoliang1719的专栏
08-25 486
目录一、Raft概述 1.Raft定义 2.复制状态机 3.Raft一致性 4.Raft新的特性 二、Raft一致性算法 1.State（状态） 2.AppendEntries RPC（...
Raft一致性算法中文翻译版(格式同原论文)
12-16
读者学习过程中，发现网上的翻译版的格式混乱，然后使用ieee的latex的论文格式按照原论文格式进行了翻译，希望读者可以比对原论文阅读，及节约时间又可以快读理解raft论文。如果觉得翻译的存在问题，可以到https://github.com/brandonwang001/raft_translation提建议或改进。如果有侵权，请联系作者进行删除。
一致性算法 - Raft共识算法
qq_43350524的博客
03-18 1347
Raft共识算法
分布式之raft一致性算法
txh1873749380的博客
12-11 383
分布式一致性算法
一致性算法分析
热门推荐
phantom_111的博客
01-18 1万+
目的 ：一致性算法的出现是为了解决一致性问题，一致性问题是指对于一组服务器（集群），给定一组操作，需要使用一种协议使得它们的结果最终达成一致，看起来好像是一台服务器一样。 作用 ：一致性算法在构建可信赖的大规模软件中扮演者重要的角色，常用的一致性算法Raft、Paxos算法等。 提出背景： 一致性算法是在复制状态机的背景下产生的，复制状态机用于解决分布式系统中的各种容错问题。复制状态机通过
RAFT一致性算法
zhangyanling316的博客
07-23 282
3.RAFT通过将客户端的请求转化成日志追加到文件中，同时向从节点发送日志条目并附带了日志条目索引和任期。从节点将收到的日志条目进行匹配，如果不匹配就要求重新发送。每个节点上带有一个计时器，在一个计时器超时时间内，如果未选举出一个超过绝大部分票数的leader会重置计时器，并开启新一轮投票，直到选举出leader。2.当leader选举出后，通过心跳机制，来确保其他节点，不会在任期内发起重新选举请求。如果follower节点在一个计时器超时时间内，未获得主节点的心跳信息，就会发起候选者请求。
分布式与一致性——Raft算法详解
zekser的博客
03-29 1967
详细解释Raft算法的复制过程，选举过程，任期，以及异常情况的处理等
22张图，带你入门分布式一致性算法Raft
阳阳的博客
10-30 3706
Raft节点的角色划分与任期 在Raft中，有以下三种角色： Follower 跟随者 所有节点的初始状态，内部都会有一个超时时间。对于每一个Follower，其超时时间是随机的。 这个超时时间，规定了在倒计时结束后仍然收不到Leader的心跳，Follower就会转变为Candidate。 为什么每个Follower的超时时间是随机的，改成一样的可以吗？ 不可以，相同的超时时间会造成多个Follower同时转变为Candidate，选票被瓜分，导致获取不到半数以上的选票，就需要进行新一轮的选举
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

metabit

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值