(etcd)raft算法的学习笔记 (二)

最新推荐文章于 2024-09-14 20:59:36 发布
最新推荐文章于 2024-09-14 20:59:36 发布
阅读量495 收藏
点赞数
分类专栏： k8s etcd Golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/harbours/article/details/106517778
版权
Golang 同时被 3 个专栏收录
4 篇文章 0 订阅
订阅专栏
k8s
2 篇文章 0 订阅
订阅专栏
etcd
1 篇文章 0 订阅
订阅专栏

Raft 一致性算法

section 5几个子章节结合etcd源码讨论
一、section 5.1

  • 服务器始终处于三种状态：leader、follower、candidate（etcd新增了一个learner，在后面补充）
  • follower: 该角色处于被动位置从不会主动发起请求，仅仅是简单的回应leader和candidate的请求
  • leader:该角色处理所有客户端发来的请求。如果follower不小心接收到了客户端请求，该请求将会转发给leader
  • candidate：该角色是follower到leader的过度状态
  • RAFT将时间划分为任意长度的任期，任期为连续的整数，每一任期从选举开始
  • 不同的servers能观察到多次任期的转换。任期在raft中充当逻辑时钟的作用，这可以帮助集群探查一些过期的信息例如旧的leader等。
  • 如果一个server的任期号比其他人的小，那么他会更新自己到较新的编号。如果此时处于leader或candidate状态,将会立即变味follower
//来自于 etcd/raft/raft_paper_test.go
func TestFollowerUpdateTermFromMessage(t *testing.T) {
    //对于follower更新到较新的编号
	testUpdateTermFromMessage(t, StateFollower)
}
raft2020/06/03 10:43:33 raft.go:1521: INFO: 1 switched to configuration voters=(1 2 3)
raft2020/06/03 10:43:33 raft.go:699: INFO: 1 became follower at term 0
raft2020/06/03 10:43:33 raft.go:383: INFO: newRaft 1 [peers: [1,2,3], term: 0, commit: 0, applied: 0, lastindex: 0, lastterm: 0]
raft2020/06/03 10:43:33 raft.go:699: INFO: 1 became follower at term 1
raft2020/06/03 10:43:33 raft.go:858: INFO: 1 [term: 1] received a MsgApp message with higher term from 0 [term: 2]
raft2020/06/03 10:43:33 raft.go:699: INFO: 1 became follower at term 2

func TestCandidateUpdateTermFromMessage(t *testing.T) {
    //对于candidate更新到较新的编号，最后状态会变为follower
	testUpdateTermFromMessage(t, StateCandidate)
}
raft2020/06/03 10:43:56 raft.go:1521: INFO: 1 switched to configuration voters=(1 2 3)
raft2020/06/03 10:43:56 raft.go:699: INFO: 1 became follower at term 0
raft2020/06/03 10:43:56 raft.go:383: INFO: newRaft 1 [peers: [1,2,3], term: 0, commit: 0, applied: 0, lastindex: 0, lastterm: 0]
raft2020/06/03 10:43:56 raft.go:712: INFO: 1 became candidate at term 1
raft2020/06/03 10:43:56 raft.go:858: INFO: 1 [term: 1] received a MsgApp message with higher term from 0 [term: 2]
raft2020/06/03 10:43:56 raft.go:699: INFO: 1 became follower at term 2

func TestLeaderUpdateTermFromMessage(t *testing.T) {
    //对于leader更新到较新的编号，最后状态会变为follower
	testUpdateTermFromMessage(t, StateLeader)
}
raft2020/06/03 10:44:27 raft.go:1521: INFO: 1 switched to configuration voters=(1 2 3)
raft2020/06/03 10:44:27 raft.go:699: INFO: 1 became follower at term 0
raft2020/06/03 10:44:27 raft.go:383: INFO: newRaft 1 [peers: [1,2,3], term: 0, commit: 0, applied: 0, lastindex: 0, lastterm: 0]
raft2020/06/03 10:44:27 raft.go:712: INFO: 1 became candidate at term 1
raft2020/06/03 10:44:27 raft.go:764: INFO: 1 became leader at term 1
raft2020/06/03 10:44:27 raft.go:858: INFO: 1 [term: 1] received a MsgApp message with higher term from 0 [term: 2]
raft2020/06/03 10:44:27 raft.go:699: INFO: 1 became follower at term 2

// testUpdateTermFromMessage tests that if one server’s current term is
// smaller than the other’s, then it updates its current term to the larger
// value. If a candidate or leader discovers that its term is out of date,
// it immediately reverts to follower state.
// Reference: section 5.1
func testUpdateTermFromMessage(t *testing.T, state StateType) {
	r := newTestRaft(1, []uint64{1, 2, 3}, 10, 1, NewMemoryStorage())   //初始化一个test raft，peers包括1、2、3
	switch state {
	case StateFollower:
		r.becomeFollower(1, 2) //1是给定的任期，2是leader的id
	case StateCandidate:
		r.becomeCandidate() //将初始化的raft状态变为candidate
	case StateLeader:
		r.becomeCandidate() //将初始化的raft状态由follower变为candidate，若follower直接转变为leader会出错
		r.becomeLeader() //candidate状态变为follower
	}

	r.Step(pb.Message{Type: pb.MsgApp, Term: 2})  //发送一个

	if r.Term != 2 {
		t.Errorf("term = %d, want %d", r.Term, 2)
	}
	if r.state != StateFollower {
		t.Errorf("state = %v, want %v", r.state, StateFollower)
	}
}
  • 如果一个server发现一个请求的任期号是旧的，这个请求将会给拒绝
// TestRejectStaleTermMessage tests that if a server receives a request with
// a stale term number, it rejects the request.
// Our implementation ignores the request instead.
// Reference: section 5.1
func TestRejectStaleTermMessage(t *testing.T) {
	called := false
	fakeStep := func(r *raft, m pb.Message) error {
		called = true
		return nil
	}
	r := newTestRaft(1, []uint64{1, 2, 3}, 10, 1, NewMemoryStorage())  //创建一个新的server
	//fmt.Printf("%+v,\n", r)
	r.step = fakeStep
	r.loadState(pb.HardState{Term: 2}) //将r的任期置为2
	//fmt.Println(r.Term)

	r.Step(pb.Message{Type: pb.MsgApp, Term: r.Term - 1}) //发送一个旧任期的请求给r

	if called {
		t.Errorf("stepFunc called = %v, want %v", called, false)
	}
}

=== RUN   TestRejectStaleTermMessage
raft2020/06/03 19:35:25 raft.go:1521: INFO: 1 switched to configuration voters=(1 2 3)
raft2020/06/03 19:35:25 raft.go:699: INFO: 1 became follower at term 0
raft2020/06/03 19:35:25 raft.go:383: INFO: newRaft 1 [peers: [1,2,3], term: 0, commit: 0, applied: 0, lastindex: 0, lastterm: 0]
raft2020/06/03 19:35:25 raft.go:900: INFO: 1 [term: 2] ignored a MsgApp message with lower term from 0 [term: 1]

一、section 5.2

  • 当服务器启动时，默认为follower状态
// TestStartAsFollower tests that when servers start up, they begin as followers.
// Reference: section 5.2
func TestStartAsFollower(t *testing.T) {
   r := newTestRaft(1, []uint64{1, 2, 3}, 10, 1, NewMemoryStorage())
   //r.state = StateCandidate
   if r.state != StateFollower {
      //如果不是follower将会报错
   	t.Errorf("state = %s, want %s", r.state, StateFollower)
   }
}
=== RUN   TestStartAsFollower
raft2020/06/04 11:48:18 raft.go:1521: INFO: 1 switched to configuration voters=(1 2 3)
raft2020/06/04 11:48:18 raft.go:699: INFO: 1 became follower at term 0
raft2020/06/04 11:48:18 raft.go:383: INFO: newRaft 1 [peers: [1,2,3], term: 0, commit: 0, applied: 0, lastindex: 0, lastterm: 0]
--- PASS: TestStartAsFollower (0.00s)
  • leader会定时发送心跳检测给其他follower以维护自己的地位
// TestLeaderBcastBeat tests that if the leader receives a heartbeat tick,
// it will send a MsgHeartbeat with m.Index = 0, m.LogTerm=0 and empty entries
// as heartbeat to all followers.
// Reference: section 5.2
func TestLeaderBcastBeat(t *testing.T) {
   // heartbeat interval
   hi := 1
   r := newTestRaft(1, []uint64{1, 2, 3}, 10, hi, NewMemoryStorage())  //10为选举超时时间,hi为心跳超时需要进行一次检测的时间
   r.becomeCandidate()
   r.becomeLeader()  //r.tick方法此时变为了tickHeartbeat;r.step方法变为stepLeader
   for i := 0; i < 10; i++ {
   	mustAppendEntry(r, pb.Entry{Index: uint64(i) + 1})
   }

   for i := 0; i < hi; i++ {
   	r.tick()  //发送一次心跳检测，运行tickHeartbeat方法；这里hi设为1所以只需滴答一次heartbeatElapsed会等于heartbeatTimeout
   }
   msgs := r.readMessages()  //该方法将r的message读出来，并且将r的message重置
   sort.Sort(messageSlice(msgs))
   wmsgs := []pb.Message{
   	{From: 1, To: 2, Term: 1, Type: pb.MsgHeartbeat},
   	{From: 1, To: 3, Term: 1, Type: pb.MsgHeartbeat},
   }
   if !reflect.DeepEqual(msgs, wmsgs) {
   	t.Errorf("msgs = %v, want %v", msgs, wmsgs)
   }
}

// tickHeartbeat is run by leaders to send a MsgBeat after r.heartbeatTimeout.
func (r *raft) tickHeartbeat() {
   r.heartbeatElapsed++  //每运行一遍该方法heartbeatElapsed增加1，当该值大于或等于heartbeatTimeout就会重置heartbeatElapsed并传递心跳检测
   r.electionElapsed++

   if r.electionElapsed >= r.electionTimeout {
   	r.electionElapsed = 0
   	if r.checkQuorum {
   		r.Step(pb.Message{From: r.id, Type: pb.MsgCheckQuorum})
   	}
   	// If current leader cannot transfer leadership in electionTimeout, it becomes leader again.
   	if r.state == StateLeader && r.leadTransferee != None {
   		r.abortLeaderTransfer()
   	}
   }

   if r.state != StateLeader {
   	return
   }

   if r.heartbeatElapsed >= r.heartbeatTimeout {
   	r.heartbeatElapsed = 0
   	r.Step(pb.Message{From: r.id, Type: pb.MsgBeat})
   	//传递心跳检测;m.Type为MsgBeat所以在Step方法里面跳到r.step即上面说的stepLeader；
   	//最后经过的方法：stepLeader->bcastHeartbeat->bcastHeartbeatWithCtx->sendHeartbeat->send
   	//最终在send里面将MsgBeat的信息添加到r.msg切片中去
   }
}
  • 重新选举的两种情况：1⃣️follower在选举超时时间内没收到心跳检测RPC,将会增加自己的当前任期并且转变为candidate状态，此时该ratf会先给自己投一票并发送vote RPC给其他servers。2⃣️集群中有多个candidate收到了相同选票，将会进入超时并且开始一次新的选举，任期号此生也增加一位
func TestFollowerStartElection(t *testing.T) {
   testNonleaderStartElection(t, StateFollower) 
}
func TestCandidateStartNewElection(t *testing.T) {
   testNonleaderStartElection(t, StateCandidate)
}

// testNonleaderStartElection tests that if a follower receives no communication
// over election timeout, it begins an election to choose a new leader. It
// increments its current term and transitions to candidate state. It then
// votes for itself and issues RequestVote RPCs in parallel to each of the
// other servers in the cluster.
// Reference: section 5.2
// Also if a candidate fails to obtain a majority, it will time out and
// start a new election by incrementing its term and initiating another
// round of RequestVote RPCs.
// Reference: section 5.2
func testNonleaderStartElection(t *testing.T, state StateType) {
   // election timeout
   et := 10 //选举超时时间10
   r := newTestRaft(1, []uint64{1, 2, 3}, et, 1, NewMemoryStorage())
   switch state {
   case StateFollower:
   	r.becomeFollower(1, 2)  //tick方法是tickElection
   case StateCandidate:
   	r.becomeCandidate()   //tick方法是tickElection
   }
//r会生成一个randomizedElectionTimeout，当下面的loop达到这个次数时，将进行MsgVote RPC
   for i := 1; i < 2*et; i++ {
   	r.tick() 
   }

   if r.Term != 2 {
   	t.Errorf("term = %d, want 2", r.Term)
   }
   if r.state != StateCandidate {
   	t.Errorf("state = %s, want %s", r.state, StateCandidate)
   }
   if !r.prs.Votes[r.id] {
   	t.Errorf("vote for self = false, want true")
   }
   msgs := r.readMessages()
   sort.Sort(messageSlice(msgs))
   wmsgs := []pb.Message{
   	{From: 1, To: 2, Term: 2, Type: pb.MsgVote},
   	{From: 1, To: 3, Term: 2, Type: pb.MsgVote},
   }
   if !reflect.DeepEqual(msgs, wmsgs) {
   	t.Errorf("msgs = %v, want %v", msgs, wmsgs)
   }
}
  • 当开始一次选举时，follower将会增加它的当前任期并且转变为cadidate状态。该状态将会持续到：1⃣️此节点赢了选举2⃣️别的节点赢的了选举并通知到位3⃣️一段时间后没有节点胜利
// TestLeaderElectionInOneRoundRPC tests all cases that may happen in
// leader election during one round of RequestVote RPC:
// a) it wins the election
// b) it loses the election
// c) it is unclear about the result
// Reference: section 5.2
func TestLeaderElectionInOneRoundRPC(t *testing.T) {
   tests := []struct {
   	size  int
   	votes map[uint64]bool
   	state StateType
   }{
   	// win the election when receiving votes from a majority of the servers
   	{1, map[uint64]bool{}, StateLeader},
   	{3, map[uint64]bool{2: true, 3: true}, StateLeader},
   	{3, map[uint64]bool{2: true}, StateLeader},
   	{5, map[uint64]bool{2: true, 3: true, 4: true, 5: true}, StateLeader},
   	{5, map[uint64]bool{2: true, 3: true, 4: true}, StateLeader},
   	{5, map[uint64]bool{2: true, 3: true}, StateLeader},

   	// return to follower state if it receives vote denial from a majority
   	{3, map[uint64]bool{2: false, 3: false}, StateFollower},
   	{5, map[uint64]bool{2: false, 3: false, 4: false, 5: false}, StateFollower},
   	{5, map[uint64]bool{2: true, 3: false, 4: false, 5: false}, StateFollower},

   	// stay in candidate if it does not obtain the majority
   	{3, map[uint64]bool{}, StateCandidate},
   	{5, map[uint64]bool{2: true}, StateCandidate},
   	{5, map[uint64]bool{2: false, 3: false}, StateCandidate},
   	{5, map[uint64]bool{}, StateCandidate},
   }
   for i, tt := range tests {
   	fmt.Println(i)
   	fmt.Println(tt)
   	r := newTestRaft(1, idsBySize(tt.size), 10, 1, NewMemoryStorage())

   	r.Step(pb.Message{From: 1, To: 1, Type: pb.MsgHup}) //对外发出投票请求
   	for id, vote := range tt.votes {
   		fmt.Println(id)
   		r.Step(pb.Message{From: id, To: 1, Term: r.Term, Type: pb.MsgVoteResp, Reject: !vote}) //模拟接收投票回来的结果，
   		//当发现投票超过了半数就becomeleader,当继续传回MsgVoteResp将不回有任何操作了
   	}

   	if r.state != tt.state {
   		t.Errorf("#%d: state = %s, want %s", i, r.state, tt.state)
   	}
   	if g := r.Term; g != 1 {
   		t.Errorf("#%d: term = %d, want %d", i, g, 1)
   	}
   }
}
  • 如果一个candidate在等待选票的时候，收到了一个追加日志的rpc，并且该rpc发出者的任期大于或等于该candidate，那么就认为这个发出追加日志rpc的leader是合法的。最后，该candidate会转变为follower
// TestCandidateFallback tests that while waiting for votes,
// if a candidate receives an AppendEntries RPC from another server claiming
// to be leader whose term is at least as large as the candidate's current term,
// it recognizes the leader as legitimate and returns to follower state.
// Reference: section 5.2
func TestCandidateFallback(t *testing.T) {
   tests := []pb.Message{
   	{From: 2, To: 1, Term: 1, Type: pb.MsgApp},
   	{From: 2, To: 1, Term: 2, Type: pb.MsgApp},
   }
   for i, tt := range tests {
   	r := newTestRaft(1, []uint64{1, 2, 3}, 10, 1, NewMemoryStorage())

   	r.Step(pb.Message{From: 1, To: 1, Type: pb.MsgHup})  //新建立的raft选举超时进行新的选举并向2和3发出投票RP，增加了一次任期
   	if r.state != StateCandidate {
   		t.Fatalf("unexpected state = %s, want %s", r.state, StateCandidate)
   	}

   	r.Step(tt)  //当回传的包里的任期参数大于当前raft时，1会变成follower；其他情况只要选票还没超过半数节点1还是处于candidate状态

   	if g := r.state; g != StateFollower {
   		t.Errorf("#%d: state = %s, want %s", i, g, StateFollower)
   	}
   	if g := r.Term; g != tt.Term {
   		t.Errorf("#%d: term = %d, want %d", i, g, tt.Term)
   	}
   }
}

待续

小胡貓
关注
专栏目录
zookeeper学习笔记之-Raft算法（一）：如何选举领导者？
huanglei_hacker的博客
07-25 1592
Raft算法（一）：如何选举领导者？ 参考动画更容易理解：http://thesecretlivesofdata.com/raft/（自备梯子） Raft算法官网：https://raft.github.io/ （官网上也有动画教程） Raft 算法属于 Multi-Paxos 算法，它是在兰伯特 Multi-Paxos 思想的基础上，做了一些简化和限制，比如增加了日志必须是连续的，只支持领导者、跟随者和候选人三种状态，在理解和算法实现上都相对容易许多。 除此之外，Raft 算法是现在分..
zookeeper学习笔记之-Raft算法（三）：如何解决成员变更的问题？
huanglei_hacker的博客
07-25 557
在日常工作中，你可能会遇到服务器故障的情况，这时你就需要替换集群中的服务器。如果遇到需要改变数据副本数的情况，则需要增加或移除集群中的服务器。总的来说，在日常工作中，集群中的服务器数量是会发生变化的。 讲到这儿，也许你会问：“老韩，Raft 是共识算法，对集群成员进行变更时（比如增加 2 台服务器），会不会因为集群分裂，出现 2 个领导者呢？” 在我看来，的确会出现这个问题，因为 Raft 的领导者选举，建立在“大多数”的基础之上，那么当成员变更时，集群成员发生了变化，就可能同时存在新旧配置..
Raft学习传送门
weixin_34355715的博客
01-06 233
Raft官网 官方可视化动画1 官方可视化动画2 论文中文翻译 论文英文地址 Paxos Made Simple论文翻译 Raft理解 技术分享 《分布式一致性raft算法实现原理》 状态机 MIT： raft实现 分布式系统学习2-Raft算法分析与实现 分布式系统MIT 6.824学习资源 知乎大神的：Raft实现指南 mit-6.824 Lab 2: Raft Students'...
etcd入门指南：分布式事务、分布式锁及核心API详解
最新发布
zhangj1125的专栏
09-14 1098
etcd client v3使用gRPC进行远程过程调用，定义了交互过程中protobuf数据结构。
etcd - 相关知识整理
weixin_39873598的博客
09-19 387
Follower：追随者，即从领导接收数据，并且同步到自己的blotDb。不接收数据变更，如果有数据发送给它，则会通过一致性模块转发给leader，由leader完成数据一致性保证。Leader：领导者，接收数据并且把数据同步给其他Follower，超过半数Follower确认之后，写入WAL。
Raft
qq_37157498的博客
08-30 324
Raft协议在nebula中的实现： 一个raft group中有三种类型节点：leader、follower、candidate（新增learner）。 简单来说，一个raft节点的组成如下图： ​ 图1：raft节点组成 **Log entries：**日志中的每一个条目包含了一条指令，交给状态机执行。 **leader：**同一时刻raft gro...
etcd原理剖析一
qq_61039408的博客
05-01 2450
你可以理解一旦一个值更新成功，随后任何通过线性读的 client 都能及时访问到。虽然集群中有多个节点，但 client 通过线性读就如访问一个节点一样。etcd 默认读模式是线性读，因为它需要经过 Raft 协议模块，反应的是集群共识，因此在延时和吞吐量上相比串行读略差一点，适用于对数据一致性要求高的场景。如果你的 etcd 读请求显示指定了是串行读，就不会经过架构图流程中的流程三、四。默认是线性读，因此接下来我们看看读请求进入线性读模块，它是如何工作的。
分布式学习笔记1-分布式算法Raft
自由之路
03-01 732
简介 Raft是今比较流行的一个分布式选举算法。在它出来之前，业界只有Paxos一种算法。但是Paxos是非常难以理解，更不用说有统一的算法方案。Raft的出现，就是为了提供一个通俗易懂，容易实现的分布式方案。研究论文和相关源码已久，写下此文笔记，希望能对你也有一些启发。 基本原理 Server状态 集群的每个机器可以有3种角色状态 Leader 每个集群只能有一个，处理所有client的请求，...
k8s学习笔记（5）--- kubernetes核心组件之etcd详解
梦谜的博客
12-29 4283
kubernetes核心组件之etcd详解一、etcd二、etcd部署1.采用etcd镜像的方式部署1.1 将服务器添加进集群的两种方式1.1.1 将服务器挨个添加进集群 一、etcd         etcd是一个高可用的键值存储系统，主要用于共享配置和服务发现。etcd是由CoreOS开发并维护的，灵感来自于 Zo...
k8s学习笔记
A_BCDEF_的博客
02-26 345
pod生命周期：init c（初始化容器，0个或多个 eg：某pod需要xx文件才可以运行，此时则在创建文件，上一个initc成功结束，才能开启下一个initc，正常退出结果为0，如果异常退出，结果非0，则根据策略进行重新运行或结束。eg：一个pod中有两个容器 ab，a先启动，b再启动，顺序是 initcA -》initcB + maincA -》maincA +maincB或maincB，可能b容器启动好的时候a容器还未启动完成，则出错-》退出，重启，若容器不存在就绪探测，默认状态为success。
etcd源码分析之Follower抢主流程
u012631731的博客
04-11 290
Etcd教程 — 第二章 Etcd集群静态发现
Mr_XiMu的博客
06-06 2950
Etcd教程 — 第二章 Etcd集群静态发现
​云原生 etcd 系列｜Leader 是怎么选举出来的？
EDDYCJY的博客
01-13 884
坚持思考，就会很酷raft 核心问题raft 是针对 paxos 的简化版本，拆解为三个核心问题：Leader 选举；日志复制；正确性的保证；奇伢本次不对 raft 算法做详细的证明和阐述...
etcd系列-----raft协议：重要数据结构介绍(raftlog、raft)
cyq6239075的博客
04-09 1342
raftlog结构体 Raft 协议中日志复制部分的核心就是在集群中各个节点之间完成日志的复制，因此在raft模块的实现中使用raftLog结构来管理节点上的日志， 它依赖于前面介绍的Storage接口和unstable结构体。 raftLog中主要字段的含义与功能 storage ( Storage类型）：实际上就是前面介绍的MemoryStorage实例，其中存储了快照数据及该快照之后的E...
etcd入门详解
热门推荐
weixin_39540280的博客
12-18 3万+
1. etcd简介 简介 Etcd是CoreOS基于Raft协议开发的分布式key-value存储，可用于服务发现、共享配置以及一致性保障（如数据库选主、分布式锁等）。 在分布式系统中，如何管理节点间的状态一直是一个难题，etcd像是专门为集群环境的服务发现和注册而涉及，它提供了数据TTL失效、数据改变监视、多值、目录监听、分布式锁原子操作等功能，可以方便的跟踪并管理集群节点的状态。 特点 简单：curl可访问的用户的API（HTT...
Ratis学习(二): Ratis peer身份管理
看了就会
06-20 319
ratis服务中，每一个节点可能有三种身份，Leader,Candidate,Follower. Ratis在org.apache.ratis.server.impl.RoleInfo中实现身份管理。
爱上开源之etcd集群管理工具
06-10 917
作为原生云和K8s的底层重要组件etcd一直不断的得到Kubernetes和istio等厂商的关注，以前对标过同类的zookeeper，基本上在各个主要方面都显示出其优点。 一直都没有一款合适的etcd管理维护的工具，今天就介绍通过etcdv3-browser这款工具，来实例一下，通过使用这个工具，来看看如何来维护一个etcd的集群首先，安装第一台单节点的etcd实例，单节点的etcd安装，比较简单了，可以直接解压缩etcd的程序包，按单节点的方式启动以下是我的启动配置信息 可以按照参数的说明进行配置注
etcd 配置优化
IT老男孩
09-04 4658
本文永久链接: https://www.xtplayer.cn/etcd/etcd-optimize/注意： 以下操作中所指的 K8S 集群，均是 rancher 或者 rke 创建的集群。存储空间配额--quota-backend-bytes存储空间配额可以理解为 ETCD 数据库大小，默认限制 2G(推荐最大 8G)。当数据写入耗尽存储空间时，ETCD 会引发整个集群范围的警告，该警告将会导致...
好文推荐 | etcd 问题、调优、监控
朱小厮的博客
05-27 4279
点击上方“朱小厮的博客”，选择“设为星标”后台回复"加群"，加入新技术来源：www.xuyasong.com/?p=1983etcd 原理解析：读《etcd 技术内幕》这...
解密etcd：如何在项目中应用raft一致性算法
"etcd中raft算法的使用方法与实践" raft算法是一种一致性算法，用于在多台机器间确保数据的一致性，被设计为比PAXOS算法更易理解和实现。etcd是一个广泛使用的开源分布式键值存储系统，它内建了raft算法来保证其...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值