etcd入门与实践(含go代码)

最新推荐文章于 2024-05-16 06:28:49 发布
最新推荐文章于 2024-05-16 06:28:49 发布
阅读量1k 收藏 1
点赞数
分类专栏： golang 文章标签： etcd golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/duzhenxun/article/details/105370850
版权

对比

title

一、etcd 支撑

  • 服务发现
  • 集群状态存储
  • 配置同步
  • 集群状态存储
  • 配置同步
  • 分布式锁

二、etcd原理

1、抽屉理论 大多数
2、etcd与Raft的关系
  • Raft是强一致的集群日志同步算法
  • etcd是一个分布式KV存储
  • etcd利用raft算法在集群中同步key-value
3、quorum模型

集群需要2N+1个节点
当leader复制给2N+1个节点后本地提交，返回客户端
title

4、重要特性
  • 底层存储按key有序排列的，可以顺序遍历
  • 因为key有序，天然支技按目录结构高效遍历
    • xxx/xxx/xx
  • 支持复杂事务，提供类似if…then …else…的事务能力
  • 基于租约机制实现key的TTL过期
  • mvcc多版本控制
  • watch机制 监听kv变化
    • sdk监听某个key,从n版本监听。
    • watcher 推送给sdk版本后的变化

三、命令行中使用etcd

etcdctl put /crontab/jobs/job1 job1
etcdctl put /crontab/jobs/job2 job2
etcdctl get /crontab/jobs/job1
etcdctl get /crontab/jobs/ --prefix
etcdctl delete /crontab/jobs/job1
etcdctl del /crontab/jobs/job1
etcdctl get /crontab/jobs/job1
//再开一个终端进行监听
etcdctl watch "/crontab/jobs/" --prefix

etcdctl put /crontab/jobs/job1 job11
etcdctl put /crontab/jobs/job1 job11111
//对key修改后，另一个终端会监听到变化

四、使用go操作etcd

这里我主要练习使用go调用etcd的put/get/delete/lease/watch方法

1、put,get使用

package main

import (
	"context"
	"fmt"
	"github.com/coreos/etcd/clientv3"
	"log"
	"time"
)
//连接etcd,设置key,获取key
func main(){
	var(
		config clientv3.Config
		client *clientv3.Client
		err error
		kv clientv3.KV
		putResp * clientv3.PutResponse
		getResp * clientv3.GetResponse
	)
	config = clientv3.Config{
		Endpoints:            []string{"localhost:2379"},
		DialTimeout:          5*time.Second,
	}

	if client,err=clientv3.New(config);err!=nil{
		log.Println(err.Error())
		return
	}
	defer client.Close()

	kv = clientv3.NewKV(client)
	//创建一个key
	job1:="/cron/job1"
	if putResp,err = kv.Put(context.TODO(),job1,"job1,ado",clientv3.WithPrevKV());err!=nil{
		fmt.Println(err)
	}else{
		fmt.Println(putResp.Header.Revision)
		//获取上次一的值
		//fmt.Println(string(putResp.PrevKv.Value))
	}

	//获取key 值
	if getResp,err=kv.Get(context.TODO(),job1);err!=nil{
		fmt.Println(err)
	}else{
		fmt.Println(job1+" 的值是:",getResp.Kvs)
	}


}

运行结果

21
/cron/job1 的值是: [key:"/cron/job1" create_revision:20 mod_revision:21 version:2 value:"job1,ado" ]

2、get 前缀获取

package main

import (
	"context"
	"fmt"
	"github.com/coreos/etcd/clientv3"
	"time"
)

func main()  {
	var(
		client *clientv3.Client
		err error
		kv clientv3.KV
		getResp *clientv3.GetResponse
	)

	if client,err = clientv3.New(clientv3.Config{
		Endpoints:            []string{"localhost:2379"},
		DialTimeout:          5*time.Second,
	});err!=nil{
		fmt.Println(err)
	}

	kv = clientv3.NewKV(client)

	if getResp,err = kv.Get(context.TODO(),"/cron/jobs/",clientv3.WithPrefix());err!=nil{
		fmt.Println(err)
	}else{
		//总个数
		fmt.Println(getResp.Count)
		//分别打出所有的key,value
		for k,v:=range getResp.Kvs{
			fmt.Println(k,string(v.Key),string(v.Value))
		}
	}
}

运行结果

2
0 /cron/jobs/job1 job1,ado
1 /cron/jobs/job2 job2,zhangsa

3、delete删除操作

package main

import (
	"context"
	"fmt"
	"github.com/coreos/etcd/clientv3"
	"log"
	"time"
)

func main()  {
	var(
		config clientv3.Config
		client *clientv3.Client
		err error
		kv clientv3.KV
		delResp * clientv3.DeleteResponse
	)
	config = clientv3.Config{
		Endpoints:            []string{"localhost:2379"},
		DialTimeout:          5*time.Second,
	}

	if client,err=clientv3.New(config);err!=nil{
		log.Println(err.Error())
		return
	}
	defer client.Close()

	kv = clientv3.NewKV(client)
	if delResp,err = kv.Delete(context.TODO(),"/cron/job1",clientv3.WithPrevKV());err!=nil{
		fmt.Println(err)
		return
	}
	if len(delResp.PrevKvs)!=0{
		for k,v:=range delResp.PrevKvs{
			fmt.Println(k,string(v.Key),string(v.Value))
		}
	}

}

4、lease租约

package main

import (
	"context"
	"fmt"
	"github.com/coreos/etcd/clientv3"
	"log"
	"time"
)

func main()  {
	var(
		client *clientv3.Client
		err error
	)

	if client,err = clientv3.New(clientv3.Config{
		Endpoints:            []string{"localhost:2379"},
		DialTimeout:          5*time.Second,
	});err!=nil{
		fmt.Println(err)
	}

	//申请一个lease租约
	lease := clientv3.NewLease(client)
	//申请一个10秒的租约
	leaseGrantResp,err := lease.Grant(context.TODO(),10)
	if err!=nil{
		fmt.Println(err)
		return
	}
	//put一个kv,让它与租约联系起来。实现10秒后自动过期
	leaseId:=leaseGrantResp.ID
	kv:=clientv3.NewKV(client)
	lockKey:="/cron/lock/job1"
	putResp,err := kv.Put(context.TODO(),lockKey,"",clientv3.WithLease(leaseId))
	if err!=nil{
		fmt.Println(err)
		return
	}
	log.Println(lockKey+" 写入成功",putResp.Header.Revision)

	//测试代码，定期查看一下key是否过期
	for{
		getResp,err:=kv.Get(context.TODO(),lockKey)
		if err!=nil{
			fmt.Println(err)
			return
		}
		if getResp.Count==0{
			log.Println(lockKey+" 过期了")
			break
		}
		log.Println(lockKey+" 还没有过期")
		time.Sleep(2*time.Second)
	}
}

运行结果：

2020/02/25 19:34:13 /cron/lock/job1 写入成功 24
2020/02/25 19:34:13 /cron/lock/job1 还没有过期
2020/02/25 19:34:15 /cron/lock/job1 还没有过期
2020/02/25 19:34:17 /cron/lock/job1 还没有过期
2020/02/25 19:34:19 /cron/lock/job1 还没有过期
2020/02/25 19:34:21 /cron/lock/job1 还没有过期
2020/02/25 19:34:23 /cron/lock/job1 还没有过期
2020/02/25 19:34:25 /cron/lock/job1 过期了

lease keepAlive自动续约处理

package main

import (
	"context"
	"fmt"
	"github.com/coreos/etcd/clientv3"
	"log"
	"time"
)

func main() {
	var (
		client *clientv3.Client
		err    error
	)

	if client, err = clientv3.New(clientv3.Config{
		Endpoints:   []string{"localhost:2379"},
		DialTimeout: 5 * time.Second,
	}); err != nil {
		fmt.Println(err)
	}

	//申请一个lease租约
	lease := clientv3.NewLease(client)
	//申请一个10秒的租约
	leaseGrantResp, err := lease.Grant(context.TODO(), 10)
	if err != nil {
		fmt.Println(err)
		return
	}

	leaseId := leaseGrantResp.ID
	keepRespChan, err := lease.KeepAlive(context.TODO(), leaseId)
	if err != nil {
		fmt.Println(err)
		return
	}
	go func() {
		for {
			select {
			case keepResp := <-keepRespChan:
				if keepResp == nil {
					log.Println("租约失效.服务器原因或其它的原因...")
					goto END
				} else {
					log.Println("收到续租应答", keepResp.ID)
				}
			}
		}
	END:
	}()

	//设置一个key,租约使用上面的id
	kv := clientv3.NewKV(client)
	lockKey := "/cron/lock/job1"
	putResp, err := kv.Put(context.TODO(), lockKey, "", clientv3.WithLease(leaseId))
	if err != nil {
		fmt.Println(err)
		return
	}
	log.Println(lockKey+" 写入成功", putResp.Header.Revision)

	//测试代码，定期查看一下key是否过期
	for {
		getResp, err := kv.Get(context.TODO(), lockKey)
		if err != nil {
			fmt.Println(err)
			return
		}
		if getResp.Count == 0 {
			log.Println(lockKey + " 过期了")
			break
		}
		log.Println(lockKey + " 还没有过期")
		time.Sleep(2 * time.Second)
	}
}

结果：

2020/02/25 20:50:04 收到续租应答 7587844626267763152
2020/02/25 20:50:04 /cron/lock/job1 写入成功 217
2020/02/25 20:50:04 /cron/lock/job1 还没有过期
2020/02/25 20:50:06 /cron/lock/job1 还没有过期
2020/02/25 20:50:07 收到续租应答 7587844626267763152
2020/02/25 20:50:08 /cron/lock/job1 还没有过期
2020/02/25 20:50:10 /cron/lock/job1 还没有过期
2020/02/25 20:50:11 收到续租应答 7587844626267763152

6、Watch 监听

package main

import (
	"context"
	"fmt"
	"github.com/coreos/etcd/clientv3"
	"github.com/coreos/etcd/mvcc/mvccpb"
	"log"
	"time"
)

func main() {
	var (
		config  clientv3.Config
		client  *clientv3.Client
		err     error
		kv      clientv3.KV
		getResp *clientv3.GetResponse
		watchRespChan clientv3.WatchChan
	)
	config = clientv3.Config{
		Endpoints:   []string{"localhost:2379"},
		DialTimeout: 5 * time.Second,
	}

	if client, err = clientv3.New(config); err != nil {
		log.Println(err.Error())
		return
	}
	defer client.Close()
	kv = clientv3.NewKV(client)
	go func() {
		for{
			kv.Put(context.TODO(), "/cron/jobs/ado", "watch ado")
			kv.Delete(context.TODO(),"/cron/jobs/ado")
			time.Sleep(1*time.Second)
		}

	}()

	if getResp, err = kv.Get(context.TODO(), "/cron/jobs/ado"); err != nil {
		fmt.Println(err)
		return
	}

	if len(getResp.Kvs) != 0 {
		fmt.Println(string(getResp.Kvs[0].Value))
	}

	//当前etcd集群事务ID，单调递增的
	watchStartRevision := getResp.Header.Revision + 1

	//创建一个监听器
	watcher := clientv3.NewWatcher(client)
	//返回一个chan

	//watchRespChan = watcher.Watch(context.TODO(), "/cron/jobs/ado", clientv3.WithRev(watchStartRevision))

	//TODO 这里加一个测试代码，
	//===== 模拟5秒后关闭watch监听 START
	ctx,cancelFunc:=context.WithCancel(context.TODO())
	time.AfterFunc(5*time.Second, func() {
		cancelFunc()
	})
	watchRespChan = watcher.Watch(ctx,"/cron/jobs/ado", clientv3.WithRev(watchStartRevision))
	//===== 模拟5秒后关闭watch监听 END

	//循环chan中的数据
	for watchResp := range watchRespChan {
		for _, event := range watchResp.Events {
			switch event.Type {
			case mvccpb.PUT:
				fmt.Println("修改为：", string(event.Kv.Value), "revsion:", event.Kv.CreateRevision, event.Kv.ModRevision)
			case mvccpb.DELETE:
				fmt.Println("删除了", "Revision:", event.Kv.ModRevision)
			}
		}
	}
}

结果：

watch ado
删除了 Revision: 208
修改为： watch ado revsion: 209 209
删除了 Revision: 210
修改为： watch ado revsion: 211 211
删除了 Revision: 212
修改为： watch ado revsion: 213 213
删除了 Revision: 214
修改为： watch ado revsion: 215 215
删除了 Revision: 216

Process finished with exit code 0

7、OP操作

package main

import (
	"context"
	"fmt"
	"github.com/coreos/etcd/clientv3"
	"time"
)

func main() {
	var (
		client *clientv3.Client
		err    error
		kv     clientv3.KV
		opResp clientv3.OpResponse
	)

	if client, err = clientv3.New(clientv3.Config{
		Endpoints:   []string{"localhost:2379"},
		DialTimeout: 5 * time.Second,
	}); err != nil {
		fmt.Println(err)
	}
	kv = clientv3.NewKV(client)

	//执行OP
	if opResp, err = kv.Do(context.TODO(), clientv3.OpPut("/cron/jobs/ado", "duzhenxun")); err != nil {
		fmt.Println(err)
		return
	}
	//写入的信息版本
	fmt.Println(opResp.Put().Header.Revision)

	//读取数据
	//kv.Get("/cron/jobs/ado")
	//OP操作
	if opResp, err = kv.Do(context.TODO(), clientv3.OpGet("/cron/jobs/ado")); err != nil {
		fmt.Println(err)
		return
	}
	//读取的到信息
	fmt.Println(string(opResp.Get().Kvs[0].Value))
}

结果

221
duzhenxun

8、利用上面所学，实现一个简单的分布式锁

package main

import (
	"context"
	"fmt"
	"github.com/coreos/etcd/clientv3"
	"time"
)

//分布式集群下的乐观锁
//lease 实现锁过期
//OP操作
//txn事务 if else then

//1，上锁（创建租约，自动续租，拿着租约去抢占一个key）
//2，处理业务
//3，释放锁（取消自动续租，释放租约）
func main() {
	var (
		client *clientv3.Client
		err    error
	)

	if client, err = clientv3.New(clientv3.Config{
		Endpoints:   []string{"localhost:2379"},
		DialTimeout: 5 * time.Second,
	}); err != nil {
		fmt.Println(err)
	}

	//1，上锁（创建租约，自动续租，拿着租约去抢占一个key)
	lease := clientv3.NewLease(client)
	leaseGrantesp, _ := lease.Grant(context.TODO(), 5)
	//租约ID
	leaseId := leaseGrantesp.ID

	//函数退出后，自动续租会停止，练习时看代码了为直接一些，都写在main函数中
	ctx, cancelFunc := context.WithCancel(context.TODO())
	defer cancelFunc()
	defer lease.Revoke(context.TODO(), leaseId)

	//5秒后会自动续租
	keepRespChan, _ := lease.KeepAlive(ctx, leaseId)

	//处理续约应答的协程
	go func() {
		for {
			select {
			case keepResp := <-keepRespChan:
				if keepResp == nil {
					fmt.Println("租约失效")
					goto END
				} else {
					fmt.Println("收到租约")
				}
			}
		}
	END:
	}()

	//进行抢key
	lockKey:="/cron/lock/ado"
	kv := clientv3.NewKV(client)
	txn := kv.Txn(context.TODO())
	//if 不存在key,then 设置它，else 抢锁失败
	txn.If(clientv3.Compare(clientv3.CreateRevision(lockKey), "=", 0)).
		Then(clientv3.OpPut(lockKey,"duzhenxun",clientv3.WithLease(leaseId))).
		Else(clientv3.OpGet(lockKey))
	//提交事务
	txnResp,err:=txn.Commit()
	if err!=nil{
		return
	}
	if !txnResp.Succeeded{
		fmt.Println("锁被占用:",string(txnResp.Responses[0].GetResponseRange().Kvs[0].Value))
		return
	}

	//2,处理业务
	fmt.Println("正在处理业务中。。。。")
	time.Sleep(10*time.Second)
	fmt.Println("业务处理完成，释放锁")

	//3，释放锁(取消自动续租，释放租约)
	//defer里已处理

}

开启2个客户端看看是否只有一个可以处理业务

  • 客户端A
➜  简单的分布式 git:(master) ✗ go run main.go
收到租约
正在处理业务中。。。。
收到租约
收到租约
收到租约
收到租约
收到租约
业务处理完成，释放锁
  • 客户端B
➜  简单的分布式 git:(master) ✗ go run main.go
收到租约
锁被占用: duzhenxun
duzhenxun
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
微服务自动化跨主机集群
m0_60375943的博客
03-02 748
容器间内部通信 bridge模式 host模式 自定义网络 Container模式 None模式 跨主机通信 Docker默认的网络环境下,单台主机上的Docker容器可以通过docker0网桥直接通信,而不同主机上的Docker容器之间只能通过在主机上做端口映射进行通信。 这种端口映射方式对很多集群应用来说极不方便。 如果能让Docker容器之间直接使用自己的IP地址进行通信,会解决很多问题。 按实现原理可分别直接路由方式、桥接方式(如pipework)、Overlay隧道方式(
【代码】基于etcd的分布式队列（golang版）
01-08
基于go+etcd实现分布式锁 clientv3文档example： 文档example client.go package etcdq import ( context v3 go.etcd.io/etcd/clientv3 time ) type Client interface { ReadItem(string) KV ReadItems(string...
python kivy kv模板调用,Kivy：如何在Python中引用kv ID？
weixin_39904268的博客
02-09 382
I'm new to Kivy and I would have to think this is possible, but I can't figure it out - How can I update a Kivy label when a button is pressed, but only by referencing that Kivy id within Python? (The...
etcd 监听key --prefix
梦醒了该散了的博客
12-31 1598
使用方法etcdctl watch key--prefix=true 例如：etcdctl watch /company/outPark/ --prefix=true
Go最全Etcd教程 — 第一章 Etcd简介、Etcd单机安装_etcd 安装，我的Golang春季历程
最新发布
2401_84904355的博客
05-16 327
加完后按esc键退出编辑模式，输入：wq保存退出。：需要将etcd加入到环境变量中，否则会在。将etcd环境变量添加到文件末尾。Q1： 提示仓库里没有。
闲谈etcd（三）etcd的使用
06-21 1078
连接 client type Client struct { Cluster KV Lease Watcher Auth Maintenance // Username is a user name for authentication. Username string // Password is a password for authentication. Password string } Cluster：向集群
爱上开源boot4go系列之 etcd的管理工具
05-24 648
etcd是一个高可用、强一致性的服务发现存储仓库的，是k8s里的一个基础组件，现在随着k8s的不断的被企业所使用，etcd也越来越被看好作为服务发现的好的组件之一， 今天推荐的是一款用来对etcd进行管理的图形化管理工具 etcdv3-browser， 目前在etcd这块的管理工具产品统一来看，都没有一个比较亮眼的产品出现，这个etcdv3-browser，可谓是独树一帜了。 etcdv3-browser在传统的etcd管理工具的功能基础上，添加了很多非常实用的新的特性。 1. 支持根据前缀的集合管理
go语言构建一个基于etcd的服务注册与发现系统.zip
05-26
综上所述，通过Go语言和Etcd，我们可以构建一个高效、可靠的分布式服务注册与发现系统，实现服务的自动化管理和监控，提高系统的可扩展性和容错性。在这个项目中，`etcd-master` 可能包含了Etcd的源代码或示例，帮助...
etcd源代码
03-18
etcd 是一个高可用的 Key/Value 存储系统，主要用于分享配置和服务发现。etcd 的灵感来自于 ZooKeeper 和 Doozer，侧重于： 简单：支持 curl 方式的用户 API (HTTP+JSON) 安全：可选 SSL 客户端证书认证 快速：单...
go-discovery:使用etcd的golang发现服务
05-17
go-discoverydiscovery service for golang注意：目前对etcd watch方式做下测试，效果不是很理想。本库慎用与生产环境！！！后续会对 go-discovery 实现机制做回炉改造！！！功能封装etcd，提供事件触发接口节点自...
etcd:etcd原始解析&& go语言学习
03-24
etcd是用于分布式系统最关键数据的分布式可靠键值存储，重点是： 简单：定义明确，面向用户的API（gRPC） 安全：具有可选客户端证书身份验证的自动TLS 快速：基准10,000次写入/秒可靠：使用Raft正确分发etcd用Go编写...
etcd v3管理界面webui
weixin_34326179的博客
10-29 8585
etcd v3管理界面 https://github.com/shiguanghuxian/etcd-manage 本项目是 e3w 的一个副本，修改了里边etcd库(etcd原来饮用地址不可以)的引入地址，和加了允许跨域请求。 webui最新加入英文和中文语言支持 可以使用我编写的docker-compose，快速在docker中启动e...
Go操作etcd
weixin_30470643的博客
09-13 449
目录 一、etcd 二、etcd介绍 三、etcd应用场景 3.1 服务发现 3.2 配置中心 3.3 分布式锁 四、为什么用 etcd 而不用ZooKeeper？ 4.1 为什么不选择ZooKeeper？...
go接入etcd服务端使用
蒙强的博客
03-23 718
server代码逻辑 将grpc服务注册到etcd #EtcdAddr指的是etcd服务的地址，多个用“;”隔开 #ServiceName指的是Gprc服务名称， #addr指的是grpc服务的ip地址 #5指的是租约5秒过期 etcdservice.Register(EtcdAddr, ServiceName, addr, 5) etcd注册服务 连接etcd服务器 循环心跳检测 心跳发生器 KeepAlive 创建租约（Lease） 自动续租（KeepAlive） 清空续租响应消息
Go 学习笔记（58）— Go 第三方库之 etcd/clientv3（连接客户端、PUT、GET、Lease、Op、Txn、Watch 基础概念说明）
热门推荐
wohu1104的专栏
09-15 1万+
1. 安装 Golang 的 Etcd 包 我们使用 v3 版本的 etcd client ， 首先通过 go get 下载并编译安装 etcd clinet v3。 go get -v github.com/coreos/etcd/clientv3 该命令会将包下载到 $GOPATH/src/github.com/coreos/etcd/clientv3 中，所有相关依赖包会自动下载编译，包括protobuf、grpc等。 我们主要梳理一下使用 etcd 时经常用到的主要 API 并进行演示。 2. 连
Go gRPC etcd实现服务注册发现与负载均衡
small_to_large的博客
05-13 1658
使用Go +grpc + etcd实现服务注册发现和负载均衡方案，可以监控服务上下线，客户端实现负载均衡
Etcd教程 — 第五章 Etcd之etcdctl的使用
Mr_XiMu的博客
06-26 6801
Etcd教程 — 第五章 Etcd之etcdctl的使用
etcd入门和常用操作
margu_168的博客
07-26 2041
etcd 是一个高可用的分布式键值（key-value）数据库，采用了更为简洁的Raft共识算法来实现数据强一致。基于Go语言实现，主要用于共享配置和服务发现。
Java中使用etcd，包括基本的set、get、超时设置，watch监听等
tianyaleixiaowu的专栏
12-12 9223
etcd的使用文章。 etcd来zookeeper类似，常用的主要有set，get，getPrefix：获取指定前缀的所有数据，grant：key的超时设置，watch：监听回调事件，watchPrefix：监听某个前缀的事件，keepAlive：为某个key设置自动续约、自动刷新过期时间。 zk的大部分功能，etcd都有。但有一个，譬如虚拟节点，zk可以做到当客户端断开时，立马监听到，etc...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值