Kubernetes leader election 源码分析

于 2024-05-01 19:18:28 发布
阅读量886 收藏 30
点赞数 8
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZL4120505/article/details/138378101
版权

1. leader election

leader election 通过多个副本抢占资源锁的方式实现单实例运行。在 Kubernetes 中，[Configmap|Lease|Endpoint] 可以作为资源锁的实现。

1.1 示例

直接看 leader election 代码容易晕，这里从示例入手，看 leader election 是怎么运行的。

// lease.go
/*
package main

func buildConfig(kubeconfig string) (*rest.Config, error) {
	...
}

func main() {
	klog.InitFlags(nil)
	var kubeconfig string
	var leaseLockName string
	var leaseLockNamespace string
	var id string

	flag.StringVar(&kubeconfig, "kubeconfig", "", "absolute path to the kubeconfig file")
	flag.StringVar(&id, "id", uuid.New().String(), "the holder identity name")
	flag.StringVar(&leaseLockName, "lease-lock-name", "kube-scheduler", "the lease lock resource name")
	flag.StringVar(&leaseLockNamespace, "lease-lock-namespace", "kube-system", "the lease lock resource namespace")
	flag.Parse()

	if leaseLockName == "" {
		klog.Fatal("unable to get lease lock resource name (missing lease-lock-name flag).")
	}
	if leaseLockNamespace == "" {
		klog.Fatal("unable to get lease lock resource namespace (missing lease-lock-namespace flag).")
	}

	config, err := buildConfig(kubeconfig)
	if err != nil {
		klog.Fatal(err)
	}
	client := clientset.NewForConfigOrDie(config)

	run := func(ctx context.Context) {
		klog.Info("Controller loop...")
	}

	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	ch := make(chan os.Signal, 1)
	signal.Notify(ch, os.Interrupt, syscall.SIGTERM)
	go func() {
		<-ch
		klog.Info("Received termination, signaling shutdown")
		cancel()
	}()

	lock := &resourcelock.LeaseLock{
		LeaseMeta: metav1.ObjectMeta{
			Name:      leaseLockName,
			Namespace: leaseLockNamespace,
		},
		Client: client.CoordinationV1(),
		LockConfig: resourcelock.ResourceLockConfig{
			Identity: id,
		},
	}

	leaderelection.RunOrDie(ctx, leaderelection.LeaderElectionConfig{
		Lock: lock,
		ReleaseOnCancel: true,
		LeaseDuration:   60 * time.Second,
		RenewDeadline:   15 * time.Second,
		RetryPeriod:     5 * time.Second,
		Callbacks: leaderelection.LeaderCallbacks{
			OnStartedLeading: func(ctx context.Context) {
				// we're notified when we start - this is where you would
				// usually put your code
				run(ctx)
			},
			OnStoppedLeading: func() {
				// we can do cleanup here
				klog.Infof("leader lost: %s", id)
				os.Exit(0)
			},
			OnNewLeader: func(identity string) {
				// we're notified when new leader elected
				if identity == id {
					// I just got the lock
					return
				}
				klog.Infof("new leader elected: %s", identity)
			},
		},
	})
}

运行 id 为 1 的进程抢占 lease：

# go run lease.go --kubeconfig=/root/.kube/config -id=1 -lease-lock-name=example -lease-lock-namespace=default 
I0222 09:44:40.389093 4054932 leaderelection.go:250] attempting to acquire leader lease default/example...
I0222 09:44:40.400607 4054932 leaderelection.go:260] successfully acquired lease default/example
I0222 09:44:40.402998 4054932 lease.go:87] Controller loop...

可以看到，id 为 1 的进程（简称进程 1）抢占到 lease，接着进入进程的运行逻辑。

继续运行 id 为 2 的进程（简称进程 2）抢占 lease：

# go run lease.go --kubeconfig=/root/.kube/config -id=2 -lease-lock-name=example -lease-lock-namespace=default
I0222 10:26:53.162990 4070458 leaderelection.go:250] attempting to acquire leader lease default/example...
I0222 10:26:53.170046 4070458 lease.go:151] new leader elected: 1

进程 2 抢占不到 lease，因为此时进程 1 是 leader，且 lease 未被释放或者过期。

kill 掉进程 1（注：此 id 不是进程的 PID），查看进程 2 能否抢占到 lease：

# go run lease.go --kubeconfig=/root/.kube/config -id=2 -lease-lock-name=example -lease-lock-namespace=default
I0222 10:26:53.162990 4070458 leaderelection.go:250] attempting to acquire leader lease default/example...
I0222 10:26:53.170046 4070458 lease.go:151] new leader elected: 1
I0222 10:31:54.704714 4070458 leaderelection.go:260] successfully acquired lease default/example
I0222 10:31:54.704931 4070458 lease.go:87] Controller loop...

可以看到，进程 2 成功抢占 lease。

1.2 源码分析

1.2.1 lease 资源

lease 作为 leader election 的资源锁存在，多副本抢占 lease 实际是对 lease 进行 [Get|Create|Update] 操作的过程。我们看 lease 在 Kubernetes 的资源表示：

# kubectl describe lease example -n default
Name:         example
Namespace:    default
Labels:       <none>
Annotations:  <none>
API Version:  coordination.k8s.io/v1
Kind:         Lease
Metadata:
  ...
Spec:
  Acquire Time:            2024-02-22T08:31:54.696415Z
  Holder Identity:         2
  Lease Duration Seconds:  60
  Lease Transitions:       5
  Renew Time:              2024-02-22T08:51:47.060020Z
Events:                    <none>

在 Spec 域中有五个字段，分别介绍如下：

  • Acquire Time: 首次获取 lease 的时间。
  • Holder Identity: 当前持有 lease 的用户身份。
  • Lease Duration Seconds: lease 过期时间。
  • Lease Transitions: lease 被多少 Holder 持有过。
  • Renew Time: Holder 刷新 lease 的时间。lease 的持有者需要 renew lease，否则其它副本将抢占过期的 lease。

多副本抢占 lease 的信息将被记录到这几个字段中。lease 存储在 etcd 中，通过 Raft 算法实现 lease 资源的唯一性和原子性，以保证多副本仅可抢占唯一的 lease。

1.2.2 抢占状态图

多副本抢占 lease 的状态图如下，结合状态图看源码会更加清晰。

image

1.2.3 创建 lease

我们从创建 lease 开始分析。

首先，删掉 lease 资源。

# kubectl get lease
NAME      HOLDER   AGE
example   2        23h
# kubectl delete lease example
lease.coordination.k8s.io "example" deleted

然后，调式模式下运行 lease.go，进入 leaderelection.RunOrDie 查看函数做了什么。

// k8s.io/client-go/tools/leaderelection/leaderelection.go
func RunOrDie(ctx context.Context, lec LeaderElectionConfig) {
	// 创建 leader elector 实例 le
	le, err := NewLeaderElector(lec)
	if err != nil {
		panic(err)
	}
	...

	// 运行 leader elector 实例
	le.Run(ctx)
}

进入 LeaderElector.Run：

// k8s.io/client-go/tools/leaderelection/leaderelection.go
func (le *LeaderElector) Run(ctx context.Context) {
	...

	if !le.acquire(ctx) {
		return // ctx signalled done
	}
	
	...

	le.renew(ctx)
}

LeaderElector.Run 中有两个重要的函数 LeaderElector.acquire 和 LeaderElector.renew。LeaderElector.acquire 负责获取（抢占）锁资源。LeaderElector.renew 负责更新锁资源，从而一直持有锁。

进入 LeaderElector.acquire：

// k8s.io/client-go/tools/leaderelection/leaderelection.go
func (le *LeaderElector) acquire(ctx context.Context) bool {
	...
	succeeded := false
	desc := le.config.Lock.Describe()
	klog.Infof("attempting to acquire leader lease %v...", desc)

	wait.JitterUntil(func() {
		// 重点是这里，tryAcquireOrRenew 负责获取锁，或者更新已经获取锁的信息
		succeeded = le.tryAcquireOrRenew(ctx)
		le.maybeReportTransition()
		if !succeeded {
			klog.V(4).Infof("failed to acquire lease %v", desc)
			return
		}
		le.config.Lock.RecordEvent("became leader")
		le.metrics.leaderOn(le.config.Name)
		klog.Infof("successfully acquired lease %v", desc)
		cancel()
	}, le.config.RetryPeriod, JitterFactor, true, ctx.Done())
	return succeeded
}

LeaderElector.acquire 函数的重点是 LeaderElector.tryAcquireOrRenew：

// k8s.io/client-go/tools/leaderelection/leaderelection.go
func (le *LeaderElector) tryAcquireOrRenew(ctx context.Context) bool {
	now := metav1.NewTime(le.clock.Now())
	leaderElectionRecord := rl.LeaderElectionRecord{
		HolderIdentity:       le.config.Lock.Identity(),
		LeaseDurationSeconds: int(le.config.LeaseDuration / time.Second),
		RenewTime:            now,
		AcquireTime:          now,
	}

	// 1. obtain or create the ElectionRecord
	oldLeaderElectionRecord, oldLeaderElectionRawRecord, err := le.config.Lock.Get(ctx)
	if err != nil {
		if !errors.IsNotFound(err) {
			klog.Errorf("error retrieving resource lock %v: %v", le.config.Lock.Describe(), err)
			return false
		}
		if err = le.config.Lock.Create(ctx, leaderElectionRecord); err != nil {
			klog.Errorf("error initially creating leader election record: %v", err)
			return false
		}

		le.setObservedRecord(&leaderElectionRecord)

		return true
	}

	...
	return true
}

LeaderElector.tryAcquireOrRenew 实现的就是状态转移图中的逻辑，这里我们仅关注创建锁这一流程。

首先，LeaderElector.config.Lock.Get 通过 client-go 获取 etcd 中锁的信息。

// k8s.io/client-go/tools/leaderelection/resourcelock/leaselock.go
func (ll *LeaseLock) Get(ctx context.Context) (*LeaderElectionRecord, []byte, error) {
	// 获取锁（lease）
	lease, err := ll.Client.Leases(ll.LeaseMeta.Namespace).Get(ctx, ll.LeaseMeta.Name, metav1.GetOptions{})
	if err != nil {
		return nil, nil, err
	}

	...
	return record, recordByte, nil
}

没有找到锁，进入 LeaderElector.config.Lock.Create 创建锁。

// k8s.io/client-go/tools/leaderelection/resourcelock/leaselock.go
func (ll *LeaseLock) Create(ctx context.Context, ler LeaderElectionRecord) error {
	var err error
	ll.lease, err = ll.Client.Leases(ll.LeaseMeta.Namespace).Create(ctx, &coordinationv1.Lease{
		ObjectMeta: metav1.ObjectMeta{
			Name:      ll.LeaseMeta.Name,
			Namespace: ll.LeaseMeta.Namespace,
		},
		Spec: LeaderElectionRecordToLeaseSpec(&ler),
	}, metav1.CreateOptions{})
	return err
}

查看创建锁的信息：

# kubectl describe lease example -n default
Name:         example
Namespace:    default
Labels:       <none>
Annotations:  <none>
API Version:  coordination.k8s.io/v1
Kind:         Lease
Metadata:
  ...
Spec:
  Acquire Time:            2024-02-23T05:42:07.781552Z
  Holder Identity:         1
  Lease Duration Seconds:  60
  Lease Transitions:       0
  Renew Time:              2024-02-23T05:42:07.781552Z

1.2.4 更新 lease

接着看状态转移图中的更新 lease 的流程，场景是 lease 资源已存在并过期，holder 是 id 为 1 的进程。

进入 LeaderElector.tryAcquireOrRenew：

func (le *LeaderElector) tryAcquireOrRenew(ctx context.Context) bool {
	...
	// 1. obtain or create the ElectionRecord
	oldLeaderElectionRecord, oldLeaderElectionRawRecord, err := le.config.Lock.Get(ctx)
	if err != nil {
		...
	}

	// 2. Record obtained, check the Identity & Time
	if !bytes.Equal(le.observedRawRecord, oldLeaderElectionRawRecord) {
		le.setObservedRecord(oldLeaderElectionRecord)

		le.observedRawRecord = oldLeaderElectionRawRecord
	}
	if len(oldLeaderElectionRecord.HolderIdentity) > 0 &&
		le.observedTime.Add(time.Second*time.Duration(oldLeaderElectionRecord.LeaseDurationSeconds)).After(now.Time) &&
		!le.IsLeader() {
		klog.V(4).Infof("lock is held by %v and has not yet expired", oldLeaderElectionRecord.HolderIdentity)
		return false
	}

	// 3. We're going to try to update. The leaderElectionRecord is set to it's default
	// here. Let's correct it before updating.
	if le.IsLeader() {
		leaderElectionRecord.AcquireTime = oldLeaderElectionRecord.AcquireTime
		leaderElectionRecord.LeaderTransitions = oldLeaderElectionRecord.LeaderTransitions
	} else {
		leaderElectionRecord.LeaderTransitions = oldLeaderElectionRecord.LeaderTransitions + 1
	}

	// update the lock itself
	if err = le.config.Lock.Update(ctx, leaderElectionRecord); err != nil {
		klog.Errorf("Failed to update lock: %v", err)
		return false
	}
}

在 LeaderElector.tryAcquireOrRenew 中获取锁，记录锁信息，比较锁 holder 是否是当前请求的 holder。如果是，记录锁的 AcquireTime 和 LeaderTransitions。最后，进入 LeaderElector.config.Lock.Update 更新锁：

func (ll *LeaseLock) Update(ctx context.Context, ler LeaderElectionRecord) error {
	...

	lease, err := ll.Client.Leases(ll.LeaseMeta.Namespace).Update(ctx, ll.lease, metav1.UpdateOptions{})
	if err != nil {
		return err
	}

	ll.lease = lease
	return nil
}

查看更新的 lease 信息：

# kubectl describe lease example -n default
Name:         example
Namespace:    default
Labels:       <none>
Annotations:  <none>
API Version:  coordination.k8s.io/v1
Kind:         Lease
Metadata:
  ...
Spec:
  Acquire Time:            2024-02-23T05:42:07.781552Z
  Holder Identity:         1
  Lease Duration Seconds:  60
  Lease Transitions:       0
  Renew Time:              2024-02-23T06:00:52.802923Z

可以看到，holder 更新了 Renew Time，并且这里的 Lease Transitions 未更新。

1.2.5 renew lease

当 holder 拿到 lease 后需要 renew lease，以一直持有 lease。renew 是在获取锁之后，实现如下：

func (le *LeaderElector) Run(ctx context.Context) {
	...

	if !le.acquire(ctx) {
		return // ctx signalled done
	}

	...
	le.renew(ctx)
}

func (le *LeaderElector) renew(ctx context.Context) {
	...
	wait.Until(func() {
		...
		err := wait.PollImmediateUntil(le.config.RetryPeriod, func() (bool, error) {
			// 获取并且 renew lease
			return le.tryAcquireOrRenew(timeoutCtx), nil
		}, timeoutCtx.Done())

		le.maybeReportTransition()
		desc := le.config.Lock.Describe()
		if err == nil {
			klog.V(5).Infof("successfully renewed lease %v", desc)
			return
		}
		le.metrics.leaderOff(le.config.Name)
		klog.Infof("failed to renew lease %v: %v", desc, err)
		cancel()
	}, le.config.RetryPeriod, ctx.Done())

	// if we hold the lease, give it up
	if le.config.ReleaseOnCancel {
		le.release()
	}
}

renew lease 也是通过 LeaderElector.tryAcquireOrRenew 更新 lease 信息实现的，这里就不多赘述了。

2. kube-scheduler 和 leader election

kube-scheduler 中调度和 leader election 结合的部分在 kube-schduler 的 Run 函数：

func Run(ctx context.Context, cc *schedulerserverconfig.CompletedConfig, sched *scheduler.Scheduler) error {
	...
	// If leader election is enabled, runCommand via LeaderElector until done and exit.
	// 配置 leader election
	if cc.LeaderElection != nil {
		cc.LeaderElection.Callbacks = leaderelection.LeaderCallbacks{
			// OnStartedLeading 回调函数，当抢占到 lease 时回调
			OnStartedLeading: func(ctx context.Context) {
				...
				// 作为 leader 运行调度器的调度逻辑
				sched.Run(ctx)
			},
			OnStoppedLeading: func() {
				...
				}
			},
		}

		leaderElector, err := leaderelection.NewLeaderElector(*cc.LeaderElection)
		if err != nil {
			return fmt.Errorf("couldn't create leader elector: %v", err)
		}

		// 运行 leader election 抢占 lease
		leaderElector.Run(ctx)

		return fmt.Errorf("lost lease")
	}

	// Leader election is disabled, so runCommand inline until done.
	close(waitingForLeader)
	sched.Run(ctx)
	return fmt.Errorf("finished without leader elect")
}

3. 小结

本文从源码角度分析 leader election 的实现，并且介绍了 leader election 和 kube-scheduler 结合实现是怎么实现多副本，单实例运行的。

ZL4120505
关注
Kubernetes Scheduler源码分析
WaltonWang's Blog
01-15 3万+
本文是对Kubernetes 1.5的Scheduler源码层面的剖析，包括对应的源码目录结构分析、kube-scheduler运行机制分析、整体代码流程图、核心代码走读分析等内容。阅读本文前，请先了解kubernetes scheduler原理解析。Kubernetes源码目录结构分析Kubernetes Scheduler是作为kubernetes的一个plugin来设计的，这种可插拔的设计极大
kubernetes源码分析controller-manager启动
comprel的博客
03-17 657
kube controller manager 代码分析 1.目录: cmd/kube-controller-manager 2.main函数定义在cmd/kube-controller-manager/controller-manager.go func main() { rand.Seed(time.Now().UnixNano()) command := app.NewControllerManagerCommand() // TODO: once we switch everything
利用 Kubernetes 中的 leaderelection 实现组件高可用
qingdao666666的博客
03-24 476
https://blog.csdn.net/RA681t58CJxsgCkJ31/article/details/104386126/ 利用 Kubernetes 中的 leaderelection 实现组件高可用 在Kubernetes中，通常kube-schduler和kube-controller-manager都是多副本进行部署的来保证高可用，而真正在工作的实例其实只有一个。...
听GPT 讲K8s源代码--pkg(六)
最新发布
techdashen的博客
07-19 1438
这些结构体的作用是提供不支持的Pod容器管理器的实现，用于当Kubernetes集群中没有安装或配置任何支持的容器管理器时使用。内存管理器的主要职责是跟踪和管理每个节点上容器和Pod的内存使用情况，确保不超出节点的内存限制，并根据容器的请求分配和释放内存资源。Store结构体定义了kubelet的状态信息的数据结构和相关方法，例如记录和更新节点和Pod的信息、存储和更新kubelet的健康状态等。在筛选过程中，它会根据Pod的节点信息，过滤出与指定节点相匹配的Endpoints，以保证网络传输的最佳性能。
Kubernetes源码学习
niwoxiangyu的博客
03-07 1022
kubernetes源码剖析。
[bug]:记一个k8s client-go leaderelection的bug
qq_26572567的博客
12-31 420
环境：k8s 1.17.2 申请租约后，进程异常结束没有正常释放租约 leaderelection.go:308] Failed to release lock: Lease.coordination.k8s.io "go-demo" is invalid: spec.leaseDurationSeconds: Invalid value: 0: must be greater than 0 源码： client-go/leaderelection.go at v0.17.2 · kuberne
client-go之tools/leaderelection包源码分析
qq_36407557的博客
03-02 683
client-go之tools/leaderelection包源码分析 tools/leaderelection包源码分析client-go之tools/leaderelection包源码分析tools/leaderelection包healthzadaptor.gometrics.goleaderelection.goresourcelock包 tools/leaderelection包 用于需要进行leader控制的controller等. healthzadaptor.go 函数// 创建一个基本的
Kubernetes Nginx Ingress Controller源码分析
热门推荐
WaltonWang's Blog
08-07 1万+
本博文对Nginx Ingress Controller源码分析。
kubernetes源码解析——scheduler
ZQZ_QiZheng的博客
02-12 1490
scheduler 源码解析上一篇文章主要介绍了kubernetes scheduler的原理kubernetes原理解读——scheduler 本文主要对kubernetes的scheduler模块的源码进行分析。scheduler源码结构kubernetes scheduler 模块在kubernetes源码目录的/kubernetes/plugin下，由于调度算法不同公司往往会依据自己的需求
kubernetes endpoint 代码阅读
process的博客
07-01 598
“ 想了解service和pod之间的关系”kubernetes的服务可用性通过endpoint来控制，直接决定是否能够将流量打入到后端服务中。01—endpoint controller首先看一些常量参数：maxRetries: 服务在退出队列之前的重试次数。会因为限速控制器，重试间隔越来越长。maxCapacity: 存储在endpoint资源中的最大地址数，在未来的版本中可能会超过此长度的控制。const ( // maxRetries is the number of times a
kubernetes k8s v1.10源码
08-14
git 下载太慢 k8s 1.10源码包 希望对有需要的人有帮助。
Kubernetes
02-09
K8S更新了针对多主节点的文档（3个主3个工人）： : Kubernetes Kubernetes是一个开源容器编排系统，用于自动化容器化应用程序的部署，扩展和管理。 它最初是由Google设计的，现在由Cloud Native Computing Foundation维护。 如今，几乎所有应用程序都需要对诸如 复制组件 自动缩放 负载均衡 滚动更新 跨组件记录 监控和健康检查 服务发现 认证方式 Google为Kubernetes或简称为K8s的解决方案提供了组合解决方案 K8S体系结构 词汇表 荚 微服务紧密耦合，形成一组容器，这些容器通常在非容器化设置中在一台服务器上一起运行。 该组是可以计划通过K8部署的最小单元，称为吊舱。 这组容器将共享存储，Linux名称空间，cgroup和IP地址。 它们位于同一位置，因此共享资源，并且总是一起调度。 豆荚不宜长寿。 根据服务器和服
【kubernetes/k8s源码分析】kube-scheduler 源码分析
zhonglinzhang
08-15 8906
kubernetes 1.12.1版本 前言 在 kubernetes 体系中，scheduler 是以 plugin 形式存在的模块，这种可插拔的设计方便用户自定义所需要的调度算法，所以源码路径为 plugin 目录下的 cmd 以及 pkg/scheduler Scheduler 负责安排 Pod 到具体的Node，通过监听API server提供的wat...
膜拜！终于读完谷歌高级架构师分享的Kubernetes源码剖析文档，特此分享！
程序员高级码农
12-24 1079
Kubernetes是Google开源的一个容器编排引擎，它支持自动化部署、大规模可伸缩、应用容器化管理。在生产环境中部署一个应用程序时，通常要部署该应用的多个实例以便对应用请求进行负载均衡。 在Kubernetes中，我们可以创建多个容器，每个容器里面运行一个应用实例，然后通过内置的负载均衡策略，实现对这一组应用实例的管理、发现、访问，而这些细节都不需要运维人员去进行复杂的手工配置和处理。 Kubernetes 特点 可移植: 支持公有云，私有云，混合云，多重云（multi-cloud） 可扩展:
利用Kubernetes中的leaderelection实现组件高可用
学点程序
02-15 891
在Kubernetes中，通常kube-schduler和kube-controller-manager都是多副本进行部署的来保证高可用，而真正在工作的实例其实只有一个。这里就利用到 leaderelection的选主机制，保证leader是处于工作状态，并且在leader挂掉之后，从其他节点选取新的leader保证组件正常工作。 不单单只是k8s中的这两个组件用到，在其他服务中也可以看到这个包...
我是怎么阅读kubernetes源代码的？
weixin_33877885的博客
12-13 311
2019独角兽企业重金招聘Python工程师标准>>> ...
kubernetes源码解读——源码结构
ZQZ_QiZheng的博客
01-25 6110
kubernetes源码初识 kubernetes源码地址：https://github.com/kubernetes/kubernetes 整体结构 kubernetes源码主要分为包括pkg、cmd、plugin、test四个目录。其中各个包的主要功能如下： pkg是kubernetes的主题代码，里面实现了kubernetes的主体逻辑 cmd是kubernetes的所
k8s源码架构目录分析
hahachenchen789的博客
06-06 4233
api: 输出接口文档用，基本是json源码build：构建脚本cmd：所有的二进制可执行文件入口代码，也就是各种命令的接口代码。pkg：项目diamante主目录，cmd只是接口，这里是具体实现。cmd类似业务代码，pkg类似核心plugin：插件test：测试相关的工具third_party：第三方工具docs：文档example：使用例子Godeps：项目依赖的Go的第三方包，比如docke...
Kubernetes源码分析(一)
weixin_46253576的博客
06-30 2178
Kubernetes源码分析，目前还在学习中，全部学习完会重新发布一次
深入理解Zookeeper Leader选举机制的源码实现
本文将深入剖析 Zookeeper 的源码，具体分析 Leader 选举机制的实现。 在阅读源码之前，需要了解阅读源码的重要性。阅读源码可以提升技术功底、深度掌握技术框架、快速定位线上问题、对面试大有裨益、知其然知其...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值