etcd记录

已于 2024-04-19 09:50:36 修改
阅读量3.4k 收藏 1
点赞数
分类专栏： etcd 文章标签： etcd
于 2022-05-09 16:33:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_40658206/article/details/124669483
版权

文章目录

1. 下载安装

测试环境：centos7

官方给的下载方法（当前版本3.5.0）：

脚本如下：

#!/bin/bash

ETCD_VER=v3.5.0

# choose either URL
GOOGLE_URL=https://storage.googleapis.com/etcd
GITHUB_URL=https://github.com/etcd-io/etcd/releases/download
DOWNLOAD_URL=${GOOGLE_URL}

rm -f /tmp/etcd-${ETCD_VER}-linux-amd64.tar.gz
rm -rf /tmp/etcd-download-test && mkdir -p /tmp/etcd-download-test

curl -L ${DOWNLOAD_URL}/${ETCD_VER}/etcd-${ETCD_VER}-linux-amd64.tar.gz -o /tmp/etcd-${ETCD_VER}-linux-amd64.tar.gz
tar xzvf /tmp/etcd-${ETCD_VER}-linux-amd64.tar.gz -C /tmp/etcd-download-test --strip-components=1
rm -f /tmp/etcd-${ETCD_VER}-linux-amd64.tar.gz

/tmp/etcd-download-test/etcd --version
/tmp/etcd-download-test/etcdctl version
/tmp/etcd-download-test/etcdutl version

安装完成之后文件解压到了/tmp/etcd-download-test目录，可以移动到其他目录（tmp目录在机器关机重启后会被删除）

# 移动到/opt目录下
mv /tmp/etcd-download-test /opt/etcd

配置文件模板，etcd.conf.yml内容如下：

# This is the configuration file for the etcd server.

# Human-readable name for this member.
name: 'default'

# Path to the data directory.
data-dir:

# Path to the dedicated wal directory.
wal-dir:

# Number of committed transactions to trigger a snapshot to disk.
snapshot-count: 10000

# Time (in milliseconds) of a heartbeat interval.
heartbeat-interval: 100

# Time (in milliseconds) for an election to timeout.
election-timeout: 1000

# Raise alarms when backend size exceeds the given quota. 0 means use the
# default quota.
quota-backend-bytes: 0

# List of comma separated URLs to listen on for peer traffic.
listen-peer-urls: http://localhost:2380

# List of comma separated URLs to listen on for client traffic.
listen-client-urls: http://localhost:2379

# Maximum number of snapshot files to retain (0 is unlimited).
max-snapshots: 5

# Maximum number of wal files to retain (0 is unlimited).
max-wals: 5

# Comma-separated white list of origins for CORS (cross-origin resource sharing).
cors:

# List of this member's peer URLs to advertise to the rest of the cluster.
# The URLs needed to be a comma-separated list.
initial-advertise-peer-urls: http://localhost:2380

# List of this member's client URLs to advertise to the public.
# The URLs needed to be a comma-separated list.
advertise-client-urls: http://localhost:2379

# Discovery URL used to bootstrap the cluster.
discovery:

# Valid values include 'exit', 'proxy'
discovery-fallback: 'proxy'

# HTTP proxy to use for traffic to discovery service.
discovery-proxy:

# DNS domain used to bootstrap initial cluster.
discovery-srv:

# Initial cluster configuration for bootstrapping.
initial-cluster:

# Initial cluster token for the etcd cluster during bootstrap.
initial-cluster-token: 'etcd-cluster'

# Initial cluster state ('new' or 'existing').
initial-cluster-state: 'new'

# Reject reconfiguration requests that would cause quorum loss.
strict-reconfig-check: false

# Enable runtime profiling data via HTTP server
enable-pprof: true

# Valid values include 'on', 'readonly', 'off'
proxy: 'off'

# Time (in milliseconds) an endpoint will be held in a failed state.
proxy-failure-wait: 5000

# Time (in milliseconds) of the endpoints refresh interval.
proxy-refresh-interval: 30000

# Time (in milliseconds) for a dial to timeout.
proxy-dial-timeout: 1000

# Time (in milliseconds) for a write to timeout.
proxy-write-timeout: 5000

# Time (in milliseconds) for a read to timeout.
proxy-read-timeout: 0

client-transport-security:
  # Path to the client server TLS cert file.
  cert-file:

  # Path to the client server TLS key file.
  key-file:

  # Enable client cert authentication.
  client-cert-auth: false

  # Path to the client server TLS trusted CA cert file.
  trusted-ca-file:

  # Client TLS using generated certificates
  auto-tls: false

peer-transport-security:
  # Path to the peer server TLS cert file.
  cert-file:

  # Path to the peer server TLS key file.
  key-file:

  # Enable peer client cert authentication.
  client-cert-auth: false

  # Path to the peer server TLS trusted CA cert file.
  trusted-ca-file:

  # Peer TLS using generated certificates.
  auto-tls: false

# The validity period of the self-signed certificate, the unit is year.
self-signed-cert-validity: 1

# Enable debug-level logging for etcd.
log-level: debug

logger: zap

# Specify 'stdout' or 'stderr' to skip journald logging even when running under systemd.
log-outputs: [stderr]

# Force to create a new one member cluster.
force-new-cluster: false

auto-compaction-mode: periodic
auto-compaction-retention: "1"

单节点测试可以修改下列项：

# 数据保存目录
data-dir
wal-dir
# 监听地址，可改为http://0.0.0.0:2379
listen-client-urls

1.1. 单节点测试

# 在etcd命令所在目录执行启动命令
./etcd --config-file=./etcd_config.yaml

# 测试
./etcdctl put foo foo1 # --endpoints=0.0.0.0:2379
./etcdctl get foo

1.2. 集群测试

多节点测试需修改配置文件的如下项：

# 集群中的节点名称
name
# 数据保存目录
data-dir
wal-dir
# 监听地址，可改为http://0.0.0.0:2379
listen-client-urls
# 与其他节点通信的地址，可改为http://0.0.0.0:2380
listen-peer-urls
# 集群包含的所有节点，也可在后续通过客户端添加，格式为：<node_name1>=<node_url1>,<node_name2>=<node_url2>
initial-cluster

使用dockerfile构建，也可使用已有的etcd镜像，这里使用dockerfile构建

这里基于centos:7.9.2009来构建，dockerfile_etcd内容：

FROM centos:7.9.2009
ADD etcd /opt/etcd
WORKDIR /opt/etcd

CMD ["./etcd_start.sh"] #这个启动命令在将某一个节点移除时会出现该节点启动不了的问题

etcd_start.sh内容：

#!/bin/bash

CUR_DIR=`cd $(dirname $0) && pwd`

if [ -z $NODE_NAME ]; then
	NODE_NAME='default'
fi

sed -i "s#name:.*#name: ${NODE_NAME}#g" ${CUR_DIR}/etcd_config.yaml
sed -i "s#initial-cluster:.*#initial-cluster: ${INITIAL_CLUSTER}#g" ${CUR_DIR}/etcd_config.yaml

${CUR_DIR}/etcd --config-file=${CUR_DIR}/etcd_config.yaml

使用docker-compose构建集群，etcd.yaml文件内容：

version: "3"
services:
  etcd_n1:
    container_name: etcd_n1
    privileged: true
    build:
      context: .
      dockerfile: dockerfile_etcd
    image: etcd:v1.0
    ports:
      - 2379:2379
    networks:
      etcd_network:
        ipv4_address: 172.20.0.2
    environment:
      NODE_NAME: n1
      INITIAL_CLUSTER: "n1=http://172.20.0.2:2380,n2=http://172.20.0.3:2380,n3=http://172.20.0.4:2380"
  etcd_n2:
    container_name: etcd_n2
    privileged: true
    build:
      context: .
      dockerfile: dockerfile_etcd
    image: etcd:v1.0
    ports:
      - 12379:2379
    networks:
      etcd_network:
        ipv4_address: 172.20.0.3
    environment:
      NODE_NAME: n2
      INITIAL_CLUSTER: "n1=http://172.20.0.2:2380,n2=http://172.20.0.3:2380,n3=http://172.20.0.4:2380" 
  etcd_n3:
    container_name: etcd_n3
    privileged: true
    build:
      context: .
      dockerfile: dockerfile_etcd
    image: etcd:v1.0
    ports:
      - 22379:2379
    networks:
      etcd_network:
        ipv4_address: 172.20.0.4
    environment:
      NODE_NAME: n3
      INITIAL_CLUSTER: "n1=http://172.20.0.2:2380,n2=http://172.20.0.3:2380,n3=http://172.20.0.4:2380"
networks:
  etcd_network:
    driver: bridge
    ipam:
      driver: default
      config: 
        - subnet: 172.20.0.0/24

启动并查看节点情况：

# 后台启动
./docker-compose -f etcd.yaml up -d
# 选择一个节点查看运行状态和结果
docker exec -it etcd_n1 ./etcdctl member list -w table
docker exec -it etcd_n1 ./etcdctl endpoint status --cluster -w table

测试完成后删除容器和镜像

脚本rm_test_docker.sh内容

#!/bin/bash

container_ids=`docker ps -a | grep etcd | awk '{print $1}'`
images_ids=`docker images | grep etcd | awk '{print $3}' | uniq`

for i in ${container_ids[@]}
do
	echo "rm container $i"
	docker stop $i
	docker rm $i
done

for j in ${images_ids[@]}
do
	echo "rm image $j"
	docker rmi $j -f
done

2. 使用示例

注： etcd中使用的bbolt和grpc存在版本冲突的问题

解决方法：

在go.mod中替换适配的版本

// 根据go mod tidy替换bbolt版本
replace github.com/coreos/bbolt => go.etcd.io/bbolt v1.3.6
// 替换grpc版本
replace google.golang.org/grpc => google.golang.org/grpc v1.26.0

2.1. 权限管理

参考示例

package main

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

func main() {
	cli, err := clientv3.New(clientv3.Config{Endpoints: []string{"0.0.0.0:2379"}})
	if err != nil {
		log.Fatal(err)
	}
	defer cli.Close()

	if _, err = cli.RoleAdd(context.TODO(), "root"); err != nil {
		log.Fatal(err)
	}
	if _, err = cli.UserAdd(context.TODO(), "root", "123"); err != nil {
		log.Fatal(err)
	}
	if _, err = cli.UserGrantRole(context.TODO(), "root", "root"); err != nil {
		log.Fatal(err)
	}

	if _, err = cli.RoleAdd(context.TODO(), "r"); err != nil {
		log.Fatal(err)
	}

	if _, err = cli.RoleGrantPermission(
		context.TODO(),
		"r",   // role name
		"foo", // key
		"zoo", // range end
		clientv3.PermissionType(clientv3.PermReadWrite),
	); err != nil {
		log.Fatal("RoleGrantPermission error: ", err)
	}

	if _, err = cli.UserAdd(context.TODO(), "u", "123"); err != nil {
		log.Fatal("UserAdd u error: ", err)
	}
	if _, err = cli.UserGrantRole(context.TODO(), "u", "r"); err != nil {
		log.Fatal("UserGrantRole u error: ", err)
	}
	if _, err = cli.AuthEnable(context.TODO()); err != nil {
		log.Fatal(err)
	}

	cliAuth, err := clientv3.New(clientv3.Config{
		Endpoints:   []string{"0.0.0.0:2379"},
		DialTimeout: time.Second * 5,
		Username:    "u",
		Password:    "123",
	})
	if err != nil {
		log.Fatal("new error:", err)
	}
	defer cliAuth.Close()

	if _, err = cliAuth.Put(context.TODO(), "foo1", "bar"); err != nil {
		log.Fatal(err)
	}

	_, err = cliAuth.Txn(context.TODO()).
		If(clientv3.Compare(clientv3.Value("zoo1"), ">", "abc")).
		Then(clientv3.OpPut("zoo1", "XYZ")).
		Else(clientv3.OpPut("zoo1", "ABC")).
		Commit()
	fmt.Println("txn error", err)

	// now check the permission with the root account
	rootCli, err := clientv3.New(clientv3.Config{
		Endpoints:   []string{"0.0.0.0:2379"},
		DialTimeout: time.Second * 5,
		Username:    "root",
		Password:    "123",
	})
	if err != nil {
		log.Fatal(err)
	}
	defer rootCli.Close()

	resp, err := rootCli.RoleGet(context.TODO(), "r")
	if err != nil {
		log.Fatal("RoleGet r error: ", err)
	}
	fmt.Printf("user u permission: key %q, range end %q\n", resp.Perm[0].Key, resp.Perm[0].RangeEnd)

	if _, err = rootCli.AuthDisable(context.TODO()); err != nil {
		log.Fatal("AuthDisable error: ", err)
	}

	_, err = cli.RoleDelete(context.TODO(), "r")
	if err != nil {
		log.Fatal("RoleDelete r error: ", err)
	}

	_, err = cli.RoleDelete(context.TODO(), "root")
	if err != nil {
		log.Fatal("RoleDelete root error: ", err)
	}

	_, err = cli.UserDelete(context.TODO(), "u")
	if err != nil {
		log.Fatal("UserDelete u error: ", err)
	}

	_, err = cli.UserDelete(context.TODO(), "root")
	if err != nil {
		log.Fatal("UserDelete root error: ", err)
	}
}

2.2. 集群

参考示例

package main

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

func main() {
	cli, err := clientv3.New(clientv3.Config{Endpoints: []string{"172.20.20.55:2379"}})
	if err != nil {
		log.Fatal(err)
	}
	defer cli.Close()

	resp, err := cli.MemberList(context.Background())
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("members:", len(resp.Members))
	for _, v := range resp.Members {
		fmt.Println(v)
	}

	_, err = cli.MemberRemove(context.Background(), resp.Members[1].ID)
	if err != nil {
		log.Fatal(err)
	}

	//mresp, err := cli.MemberAddAsLearner(context.Background(), []string{"http://localhost:32381"})
	//if err != nil {
	//	log.Fatal(err)
	//}
	mresp, err := cli.MemberAdd(context.Background(), resp.Members[1].PeerURLs)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("added member.PeerURLs:", mresp.Member.PeerURLs)
	fmt.Println("members count:", len(mresp.Members))

	_, err = cli.MemberUpdate(context.Background(), resp.Members[1].ID, resp.Members[1].PeerURLs)
	if err != nil {
		log.Fatal(err)
	}
}

2.3. KV操作

参考示例

package main

import (
	"context"
	"fmt"
	"github.com/coreos/etcd/clientv3"
	"github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes"
	"log"
	"time"
)

func main() {
	cli, err := clientv3.New(clientv3.Config{Endpoints: []string{"172.20.20.55:2379"}})
	if err != nil {
		log.Fatal(err)
	}
	defer cli.Close()

	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
	_, err = cli.Put(ctx, "", "sample_value")
	cancel()
	if err != nil {
		switch err {
		case context.Canceled:
			fmt.Printf("ctx is canceled by another routine: %v\n", err)
		case context.DeadlineExceeded:
			fmt.Printf("ctx is attached with a deadline is exceeded: %v\n", err)
		case rpctypes.ErrEmptyKey:
			fmt.Printf("client-side error: %v\n", err)
		default:
			fmt.Printf("bad cluster endpoints, which are not etcd servers: %v\n", err)
		}
	}

	ctx, cancel = context.WithTimeout(context.Background(), time.Second*5)
	presp, err := cli.Put(ctx, "foo", "bar1")
	cancel()
	if err != nil {
		log.Fatal(err)
	}

	ctx, cancel = context.WithTimeout(context.Background(), time.Second*5)
	_, err = cli.Put(ctx, "foo", "bar2")
	cancel()
	if err != nil {
		log.Fatal(err)
	}

	ctx, cancel = context.WithTimeout(context.Background(), time.Second*5)
	resp, err := cli.Get(ctx, "foo")
	cancel()
	if err != nil {
		log.Fatal(err)
	}
	for _, ev := range resp.Kvs {
		fmt.Printf("%s : %s\n", ev.Key, ev.Value)
	}

	ctx, cancel = context.WithTimeout(context.Background(), time.Second*5)
	resp, err = cli.Get(ctx, "foo", clientv3.WithRev(presp.Header.Revision))
	cancel()
	if err != nil {
		log.Fatal(err)
	}
	for _, ev := range resp.Kvs {
		fmt.Printf("%s : %s\n", ev.Key, ev.Value)
	}

	// sorted
	for i := range make([]int, 3) {
		ctx, cancel = context.WithTimeout(context.Background(), time.Second*5)
		_, err = cli.Put(ctx, fmt.Sprintf("key_%d", i), "value")
		cancel()
		if err != nil {
			log.Fatal(err)
		}
	}

	ctx, cancel = context.WithTimeout(context.Background(), time.Second*5)
	resp, err = cli.Get(ctx, "key", clientv3.WithPrefix(), clientv3.WithSort(clientv3.SortByKey, clientv3.SortDescend))
	cancel()
	if err != nil {
		log.Fatal(err)
	}
	for _, ev := range resp.Kvs {
		fmt.Printf("%s : %s\n", ev.Key, ev.Value)
	}

	ctx, cancel = context.WithTimeout(context.Background(), time.Second*5)
	// count keys about to be deleted
	gresp, err := cli.Get(ctx, "key", clientv3.WithPrefix())
	if err != nil {
		log.Fatal(err)
	}

	// delete the keys
	dresp, err := cli.Delete(ctx, "key", clientv3.WithPrefix())
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println("gresp.Kvs len:", len(gresp.Kvs), ", Deleted all keys:", int64(len(gresp.Kvs)) == dresp.Deleted)

	// compact 所有比此版本低的历史都将删除
	ctx, cancel = context.WithTimeout(context.Background(), time.Second*5)
	resp, err = cli.Get(ctx, "foo")
	cancel()
	if err != nil {
		log.Fatal(err)
	}
	compRev := resp.Header.Revision // specify compact revision of your choice

	ctx, cancel = context.WithTimeout(context.Background(), time.Second*5)
	_, err = cli.Compact(ctx, compRev)
	cancel()
	if err != nil {
		log.Fatal(err)
	}

	ctx, cancel = context.WithTimeout(context.Background(), time.Second*5)
	resp, err = cli.Get(ctx, "foo", clientv3.WithRev(presp.Header.Revision))
	cancel()
	fmt.Println(err) // error occurred

	// txn
	kvc := clientv3.NewKV(cli)
	_, err = kvc.Put(context.TODO(), "key", "xyz")
	if err != nil {
		log.Fatal(err)
	}

	ctx, cancel = context.WithTimeout(context.Background(), time.Second*5)
	_, err = kvc.Txn(ctx).
		// txn value comparisons are lexical
		If(clientv3.Compare(clientv3.Value("key"), ">", "abc")).
		// the "Then" runs, since "xyz" > "abc"
		Then(clientv3.OpPut("key", "XYZ")).
		// the "Else" does not run
		Else(clientv3.OpPut("key", "ABC")).
		Commit()
	cancel()
	if err != nil {
		log.Fatal(err)
	}

	gresp, err = kvc.Get(context.TODO(), "key")
	if err != nil {
		log.Fatal(err)
	}
	for _, ev := range gresp.Kvs {
		fmt.Printf("%s : %s\n", ev.Key, ev.Value)
	}

	// do
	ops := []clientv3.Op{
		clientv3.OpPut("put-key", "123"),
		clientv3.OpGet("put-key"),
		clientv3.OpPut("put-key", "456")}

	for _, op := range ops {
		if _, err := cli.Do(context.TODO(), op); err != nil {
			log.Fatal(err)
		}
	}
	ctx, cancel = context.WithTimeout(context.Background(), time.Second*5)
	resp, err = cli.Get(ctx, "put-key")
	cancel()
	if err != nil {
		log.Fatal(err)
	}
	for _, ev := range resp.Kvs {
		fmt.Printf("%s : %s\n", ev.Key, ev.Value)
	}
}

2.4. 租约

参考示例

等待租约在指定时间后过期：

package main

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

func main() {
	cli, err := clientv3.New(clientv3.Config{Endpoints: []string{"0.0.0.0:2379"}})
	if err != nil {
		log.Fatal(err)
	}
	defer cli.Close()

	// minimum lease TTL is 5-second
	resp, err := cli.Grant(context.TODO(), 5)
	if err != nil {
		log.Fatal(err)
	}

	// after 5 seconds, the key 'foo' will be removed
	_, err = cli.Put(context.TODO(), "foo", "bar", clientv3.WithLease(resp.ID))
	if err != nil {
		log.Fatal(err)
	}

	gresp, err := cli.Get(context.TODO(), "foo")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(gresp.Kvs)

	time.Sleep(time.Second * 6)
	gresp, err = cli.Get(context.TODO(), "foo")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(gresp.Kvs)
}

主动撤销租约：

package main

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

func main() {
	cli, err := clientv3.New(clientv3.Config{Endpoints: []string{"0.0.0.0:2379"}})
	if err != nil {
		log.Fatal(err)
	}
	defer cli.Close()
	resp, err := cli.Grant(context.TODO(), 5)
	if err != nil {
		log.Fatal(err)
	}

	_, err = cli.Put(context.TODO(), "foo", "bar", clientv3.WithLease(resp.ID))
	if err != nil {
		log.Fatal(err)
	}

	// revoking lease expires the key attached to its lease ID
	_, err = cli.Revoke(context.TODO(), resp.ID)
	if err != nil {
		log.Fatal(err)
	}

	gresp, err := cli.Get(context.TODO(), "foo")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("number of keys:", len(gresp.Kvs))
}

增加KeepAlive使租约不过期，也可使用KeepAliveOnce只更新一次：

package main

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

func main() {
	cli, err := clientv3.New(clientv3.Config{Endpoints: []string{"0.0.0.0:2379"}})
	if err != nil {
		log.Fatal(err)
	}
	defer cli.Close()

	resp, err := cli.Grant(context.TODO(), 5)
	if err != nil {
		log.Fatal(err)
	}

	_, err = cli.Put(context.TODO(), "foo", "bar", clientv3.WithLease(resp.ID))
	if err != nil {
		log.Fatal(err)
	}

	// the key 'foo' will be kept forever
	ch, kaerr := cli.KeepAlive(context.TODO(), resp.ID)
	if kaerr != nil {
		log.Fatal(kaerr)
	}

	ka := <-ch
	if ka != nil {
		fmt.Println("ttl:", ka.TTL)
	} else {
		fmt.Println("Unexpected NULL")
	}

	time.Sleep(time.Second * 6)
	gresp, err := cli.Get(context.TODO(), "foo")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(gresp.Kvs)
}

2.5. 维护

碎片整理：

  • 从给定 etcd 成员的内部碎片中释放浪费的空间
  • 只有在删除大量key并想回收资源时才需要进行碎片整理
  • 碎片整理是一项昂贵的操作。 用户应避免同时对多个成员进行碎片整理
  • 要对集群中的多个成员进行碎片整理，用户需要使用不同的端点多次调用碎片整理

参考示例

package main

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

func main() {
	cli, err := clientv3.New(clientv3.Config{Endpoints: []string{"172.20.20.55:2379"}})
	if err != nil {
		log.Fatal(err)
	}
	defer cli.Close()

	_, err = cli.Status(context.Background(), "172.20.20.55:2379")
	if err != nil {
		log.Fatal(err)
	}

	if _, err = cli.Defragment(context.TODO(), "172.20.20.55:2379"); err != nil {
		log.Fatal(err)
	}
}

2.6. Metrics

参考示例

package main

import (
	"context"
	"fmt"
	"github.com/coreos/etcd/clientv3"
	"github.com/prometheus/client_golang/prometheus/promhttp"
	"io"
	"log"
	"net"
	"net/http"
	"strings"
)

func main() {
	cli, err := clientv3.New(clientv3.Config{Endpoints: []string{"172.20.20.55:2379"}})
	if err != nil {
		log.Fatal(err)
	}
	defer cli.Close()

	// get a key so it shows up in the metrics as a range RPC
	cli.Get(context.TODO(), "test_key")

	// listen for all Prometheus metrics
	ln, err := net.Listen("tcp", ":0")
	if err != nil {
		log.Fatal(err)
	}
	donec := make(chan struct{})
	go func() {
		defer close(donec)
		http.Serve(ln, promhttp.Handler())
	}()
	defer func() {
		ln.Close()
		<-donec
	}()

	// make an http request to fetch all Prometheus metrics
	url := "http://" + ln.Addr().String() + "/metrics"
	resp, err := http.Get(url)
	if err != nil {
		log.Fatalf("fetch error: %v", err)
	}
	b, err := io.ReadAll(resp.Body)
	resp.Body.Close()
	if err != nil {
		log.Fatalf("fetch error: reading %s: %v", url, err)
	}
	fmt.Println("resp body", string(b))
	// confirm range request in metrics
	for _, l := range strings.Split(string(b), "\n") {
		if strings.Contains(l, `grpc_client_started_total{grpc_method="Range"`) {
			fmt.Println(l)
			break
		}
	}
}

2.7. TLS

参考示例

package main

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

func main() {
	tlsInfo := transport.TLSInfo{
		CertFile:      "/tmp/test-certs/test-name-1.pem",
		KeyFile:       "/tmp/test-certs/test-name-1-key.pem",
		TrustedCAFile: "/tmp/test-certs/trusted-ca.pem",
	}
	tlsConfig, err := tlsInfo.ClientConfig()
	if err != nil {
		log.Fatal(err)
	}
	cli, err := clientv3.New(clientv3.Config{
		Endpoints:   []string{"172.20.20.55:2379"},
		DialTimeout: time.Second*5,
		TLS:         tlsConfig,
	})
	if err != nil {
		log.Fatal(err)
	}
	defer cli.Close() // make sure to close the client

	_, err = cli.Put(context.TODO(), "foo", "bar")
	if err != nil {
		log.Fatal(err)
	}
}

2.8. Watch

参考示例

2.8.1. 示例1
package main

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

func main() {
	cli, err := clientv3.New(clientv3.Config{Endpoints: []string{"172.20.20.55:2379"}})
	if err != nil {
		log.Fatal(err)
	}
	defer cli.Close()

	go func() {
		var i = 0
		for {
			time.Sleep(time.Second)
			cli.Put(context.Background(), "foo", "bar"+strconv.Itoa(i))
			i++
		}
	}()

	rch := cli.Watch(context.Background(), "foo")
	for wresp := range rch {
		for _, ev := range wresp.Events {
			fmt.Printf("%s %q : %q\n", ev.Type, ev.Kv.Key, ev.Kv.Value)
		}
	}
}
2.8.1. 示例2（WithPrefix）
package main

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

func main() {
	cli, err := clientv3.New(clientv3.Config{Endpoints: []string{"172.20.20.55:2379"}})
	if err != nil {
		log.Fatal(err)
	}
	defer cli.Close()

	go func() {
		var i = 0
		for {
			time.Sleep(time.Second)
			cli.Put(context.Background(), "foo1", "bar"+strconv.Itoa(i))
			i++
		}
	}()

	rch := cli.Watch(context.Background(), "foo", clientv3.WithPrefix())
	for wresp := range rch {
		for _, ev := range wresp.Events {
			fmt.Printf("%s %q : %q\n", ev.Type, ev.Kv.Key, ev.Kv.Value)
		}
	}
}
2.8.3. 示例3（WithRange）
package main

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

func main() {
	cli, err := clientv3.New(clientv3.Config{Endpoints: []string{"172.20.20.55:2379"}})
	if err != nil {
		log.Fatal(err)
	}
	defer cli.Close()

	go func() {
		time.Sleep(time.Second)
		cli.Put(context.Background(), "foo1", "bar1")
		cli.Put(context.Background(), "foo5", "bar5")
		cli.Put(context.Background(), "foo2", "bar2")
		cli.Put(context.Background(), "foo3", "bar3")
	}()

	rch := cli.Watch(context.Background(), "foo1", clientv3.WithRange("foo4"))
	for wresp := range rch {
		for _, ev := range wresp.Events {
			fmt.Printf("%s %q : %q\n", ev.Type, ev.Kv.Key, ev.Kv.Value)
		}
	}
}
2.8.4. 示例4（WithProgessNotify）
package main

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

func main() {
	cli, err := clientv3.New(clientv3.Config{Endpoints: []string{"172.20.20.55:2379"}})
	if err != nil {
		log.Fatal(err)
	}
	defer cli.Close()

	rch := cli.Watch(context.Background(), "foo", clientv3.WithProgressNotify())
	closedch := make(chan bool)
	go func() {
		// This assumes that cluster is configured with frequent WatchProgressNotifyInterval
		// e.g. WatchProgressNotifyInterval: 200 * time.Millisecond.
		time.Sleep(time.Second)
		err := cli.Close()
		if err != nil {
			log.Fatal(err)
		}
		close(closedch)
	}()
	wresp := <-rch
	fmt.Println("wresp.IsProgressNotify:", wresp.IsProgressNotify())
	<-closedch
}
2.8.5 示例5（实际应用）

根据revision进行watch

package main

import (
	"flag"
	"github.com/coreos/etcd/clientv3"
	"github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes"
	"github.com/golang/glog"
	"time"
)

func main() {
	flag.Parse()
	flag.Set("v", "8")
	flag.Set("logtostderr", "true")
	cli, err := clientv3.New(clientv3.Config{
		Endpoints:            []string{"172.20.20.136:23790"},
		DialTimeout:          5 * time.Second,
		DialKeepAliveTime:    3 * time.Second,
		DialKeepAliveTimeout: 3 * time.Second,
	})
	if err != nil {
		glog.Errorln("clientv3.New err", err)
		return
	}
	defer cli.Close()

	watchKey := `/test`
	resp, err := cli.Get(cli.Ctx(), watchKey)
	if err != nil {
		glog.Errorln("get key error", err)
		return
	}
	// init rev
	var rev = resp.Header.Revision
	for {
		glog.Infoln("start watch, rev:", rev)
		// ctx := clientv3.WithRequireLeader(cli.Ctx()) // close channel when etcd no leader
		ctx := cli.Ctx()
		ch := cli.Watch(ctx, watchKey, clientv3.WithPrefix(), clientv3.WithRev(rev) /*, clientv3.WithPrevKV()*/)
		for msg := range ch {
			if msg.Err() != nil {
				if msg.Err() == rpctypes.ErrCompacted {
					// TODO: 增加处理由于etcd compation, 导致丢失的事件
					glog.Infoln("ErrCompacted occupied", msg.Err())
					rev = msg.CompactRevision
					continue
				}

				//cli.Ctx() canceled or closed?
				glog.Infoln(msg.Err())
				return
			}
			for _, e := range msg.Events {
				glog.Infoln("handle event:", e.Type, int(e.Type))
				glog.Infoln("event key:", string(e.Kv.Key), "value:", string(e.Kv.Value))
				glog.Infoln("mod revision:", e.Kv.ModRevision, "version", e.Kv.Version)
				// 忽略当前rev的事件
				if e.Kv.ModRevision == rev {
					glog.Infoln(e.Kv.ModRevision, "is equal to", rev, "ignore it")
					continue
				}
				// 更新rev, 便于ch由于出错时被关闭后(如etcd no leader), 重新watch
				if e.Kv.ModRevision > rev {
					rev = e.Kv.ModRevision
				}

				// watch带上参数WithPrevKV, 表示该事件前一个事件的kv
				if e.PrevKv != nil {
					glog.Infoln("prev kv: ", string(e.PrevKv.Key), string(e.PrevKv.Value))
				}
			}
		}

		glog.Infoln("watch ch close")
		time.Sleep(time.Second)
	}
}

2.9. 并发

2.9.1. 集群选举示例

参考示例

package main

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

func main() {
	cli, err := clientv3.New(clientv3.Config{Endpoints: []string{"0.0.0.0:2379"}})
	if err != nil {
		log.Fatal(err)
	}
	defer cli.Close()
	
  	// create two separate sessions for election competition
	s1, err := concurrency.NewSession(cli)
	if err != nil {
		log.Fatal(err)
	}
	defer s1.Close()
	e1 := concurrency.NewElection(s1, "/test/election")

	s2, err := concurrency.NewSession(cli)
	if err != nil {
		log.Fatal(err)
	}
	defer s2.Close()
	e2 := concurrency.NewElection(s2, "/test/election")

	// create competing candidates, with e1 initially losing to e2
	var wg sync.WaitGroup
	wg.Add(2)
	electc := make(chan *concurrency.Election, 2)
	go func() {
		defer wg.Done()
		// delay candidacy so e2 wins first
		time.Sleep(3 * time.Second)
		log.Println("e1.Campaign")
		if err := e1.Campaign(context.Background(), "e1"); err != nil {
			log.Fatal(err)
		}
		log.Println("e1.Campaign success")
		electc <- e1
	}()
	go func() {
		defer wg.Done()
		log.Println("e2.Campaign")
		if err := e2.Campaign(context.Background(), "e2"); err != nil {
			log.Fatal(err)
		}
		log.Println("e2.Campaign success")
		electc <- e2
	}()

	cctx, cancel := context.WithCancel(context.TODO())
	defer cancel()

	e := <-electc
	fmt.Println("completed first election with", string((<-e.Observe(cctx)).Kvs[0].Value))

	// resign so next candidate can be elected
	if err := e.Resign(context.TODO()); err != nil {
		log.Fatal(err)
	}

	e = <-electc
	fmt.Println("completed second election with", string((<-e.Observe(cctx)).Kvs[0].Value))

	wg.Wait()
}
2.9.2. 分布式锁

参考示例_高版本v3.5.0

参考示例_低版本v3.3.25

注： 注意版本，高版本才支持TryLock，Lock函数会阻塞

package main

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

func main() {
	cli, err := clientv3.New(clientv3.Config{Endpoints: []string{"172.20.20.55:2379"}})
	if err != nil {
		log.Fatal(err)
	}
	defer cli.Close()

	s1, err := concurrency.NewSession(cli)
	if err != nil {
		log.Fatal(err)
	}
	defer s1.Close()
	m1 := concurrency.NewMutex(s1, "/test/my-lock")

	s2, err := concurrency.NewSession(cli)
	if err != nil {
		log.Fatal(err)
	}
	defer s2.Close()
	m2 := concurrency.NewMutex(s2, "/test/my-lock")

  	// 高版本示例
	// acquire lock for s1
	if err = m1.Lock(context.TODO()); err != nil {
		log.Fatal(err)
	}
	fmt.Println("acquired lock for s1")

	if err = m2.Lock(context.TODO()); err == nil {
		log.Fatal("should not acquire lock")
	}

	if err == concurrency.ErrLocked {
		fmt.Println("cannot acquire lock for s2, as already locked in another session")
	}

	if err = m1.Unlock(context.TODO()); err != nil {
		log.Fatal(err)
	}
	fmt.Println("released lock for s1")
	if err = m2.TryLock(context.TODO()); err != nil {
		log.Fatal(err)
	}
	fmt.Println("acquired lock for s2")
  
	// 低版本示例
	// acquire lock for s1
	if err := m1.Lock(context.TODO()); err != nil {
		log.Fatal(err)
	}
	fmt.Println("acquired lock for s1")
	
	m2Locked := make(chan struct{})
	go func() {
		defer close(m2Locked)
		// wait until s1 is locks /my-lock/
		if err := m2.Lock(context.TODO()); err != nil {
			log.Fatal(err)
		}
	}()

	if err := m1.Unlock(context.TODO()); err != nil {
		log.Fatal(err)
	}
	fmt.Println("released lock for s1")

	<-m2Locked
	fmt.Println("acquired lock for s2")
}

2.10. 事务

示例：

package main

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

func main() {
	cli, err := clientv3.New(clientv3.Config{Endpoints: []string{"172.20.20.57:2379"}, DialTimeout: 10 * time.Second})
	if err != nil {
		log.Fatal("clientv3.New", err)
	}
	defer cli.Close()
	ctx := context.Background()
	_, err = cli.Delete(ctx, "test")
	if err != nil {
		log.Fatal(err)
	}

	// 事务，key不存在，则设置初始值
	r, err := cli.Txn(ctx).If(clientv3.Compare(clientv3.CreateRevision("test"), "=", 0)).Then(clientv3.OpPut("test", "abc")).Commit()
	if err != nil {
		log.Fatal(err)
	}
	log.Println(err, r)
	if !r.Succeeded {
		log.Println(r.Responses)
	}

	// 事务，比较后修改
	cmp := clientv3.Compare(clientv3.Value("test"), "=", "123")
	opPut := clientv3.OpPut("test", "abc")
	opGet := clientv3.OpGet("test")
	resp, err := cli.Txn(ctx).If(cmp).Then(opPut).Else(opGet).Commit()
	if err != nil {
		log.Fatal(err)
	}

	// 如果事务执行中比较失败，则获取值
	if !resp.Succeeded {
		log.Println("resp:", resp.Responses[0].GetResponseRange().Kvs[0])
	}
}
edycm
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
etcd之日志和快照管理
不务正业随手记
08-30 6333
系列文章目录 浅谈分布式系统与一致性协议（一） 浅谈分布式系统与一致性协议（二） 浅谈分布式系统与一致性协议（三） 深入浅出之etcd 深入浅出之etcd(二) etcd版本之v3 etcd之安全性阐述 etcd的多版本并发控制 目录系列文章目录概述数据的持久化和复制etcd的日志管理WAL文件物理格式WAL文件的初始化WAL追加日志项etcd v2的快照管理创建快照 概述 etcd对数据的持久化采用的是binlog（日志，也称为WAL，即Write-Ahead-Log）加Snapshot（快照）的方式
etcd-json-logs:原始 etcd 日志输入。JSON 日志记录输出
06-19
etcd-json-日志 原始 etcd 日志行输入。JSON 日志记录输出。 npm -g install etcd-json-logs cat /var/log/etcd.log | etcd-json-logs 使用记录 JSON 记录。 执照 。
etcd配置文件详解
IChen.的博客
05-11 601
【代码】etcd配置文件详解。
etcd 日志压缩_etcd调优(Tuning)
weixin_42600407的博客
01-14 339
调优(Tuning)etcd默认设置适用于网络低延迟。但网络延迟高，如网络跨域数据中心，那么心跳间隔和选举超时的设置就需要优化(tuning).网络慢不仅仅由于延迟，还可能被Leader和follower的低速磁盘IO影响。每一次超时设置应该包含一个请求发出到响应成功的时间。时间参数当一个节点挂掉(stalls)变慢或者下线，分布式协议(distributed consensus protocol...
WdatePicker设置日期范围和使用
大气的名字
10-20 972
WdatePicker日历控件使用方法 1.跨无限级框架显示 无论你把日期控件放在哪里,你都不需要担心会被外层的iframe所遮挡进而影响客户体验,因为My97日期控件是可以跨无限级框架显示的 示例2-7 跨无限级框架演示 可无限跨越框架iframe,无论怎么嵌套框架都不必担心了,即使有滚动条也不怕 2.民国年日历和其他特殊日历 当年份格式设置为yyy格式时,利用年份差量属性yearOffset(默认值1911民国元年),可实现民国年日历和其他特殊日历 示例2...
etcd 日志压缩_etcd快速入门
weixin_39754831的博客
12-20 189
安装下载地址：https://github.com/etcd-io/etcd/releases下载完成解压后，目录中有两个二进制文件， etcd以及 etcdctl。其中 etcd就是运行etcd服务的二进制文件， etcdctl是官方提供的命令行etcd客户端，使用 etcdctl可以在命令行中访问etcd服务。查看etcd版本 ./etcd --version运行单点启动查看启动帮助 ./et...
【深入浅出etcd系列】3. 日志同步
华为云官方博客
06-20 2808
概论 分布式共识算法(consensus algorithm)通常的做法就是在多个节点上复制状态机。分布在不同服务器上的状态机执行着相同的状态变化，即使其中几台机器挂掉，整个集群还能继续运作。 复制状态机正确运行的核心的同步日志，日志是保证各节点状态同步的关键，日志中保存了一系列状态机命令，共识算法的核心是保证这些不同节点上的日志以相同的顺序保存相同的命令，由于状态机是确定的，所以相同的命令以相...
etcd压缩包安装下载
09-24
7. **版本控制**: 每个键值都有版本信息，可以追踪历史记录和进行回滚操作。 **安装etcd** 1. **下载**: 针对Windows平台，你可以找到对应的二进制包，例如`etcd-v3.2.22-windows-amd64.zip`，下载后解压。 2. **...
etcd-main依赖包
07-06
etcd的日志记录了所有的变更操作，可以通过这些日志进行数据恢复。定期备份etcd的数据是必要的，以防止数据丢失。在`pkg`压缩包中可能包含了etcd的相关依赖包，这些包可能是用于构建、运行或管理etcd服务的组件。 ...
etcd安装包etcdlinux
05-13
提供详细的监控指标和日志记录，便于排查问题和优化性能。 在实际部署和使用etcd时，还需要关注其性能调优、备份策略、安全性配置等多个方面，确保系统的稳定和高效。同时，随着etcd版本的迭代，新功能和优化也在...
微服务etcd配置中心.zip
08-17
5. **版本控制**：Etcd为每个键记录版本历史，可以查看或回滚到之前的配置状态，增强了系统的可恢复性。 **在微服务中使用Etcd作为配置中心：** 1. **服务注册与发现**：每个微服务在启动时向Etcd注册自己的地址和...
Go资源etcd-v3.5.13.zip
最新发布
05-15
5. **监控和日志**：可能增强了监控指标和日志记录，帮助开发者更好地理解和调试系统。 **etcd的使用场景** 1. **服务发现**：etcd可以作为微服务架构中的服务注册与发现中心，每个服务在启动时将自己注册到etcd，...
【网络摘抄】开源日志解决方案ELK
the_fool_的博客
10-16 305
--原文地址 ELK简介： ELK是三个开源软件的缩写，分别表示：Elasticsearch , Logstash, Kibana , 它们都是开源软件。新增了一个FileBeat，它是一个轻量级的日志收集处理工具(Agent)，Filebeat占用资源少，适合于在各个服务器上搜集日志后传输给Logstash，官方也推荐此工具。 Elasticsearch 是个开源分布式搜索引擎，提供搜集、分析、存储数据三大功能。它的特点有：分布式，零配置，自动发现，索引自动分片，索引副本机制，restful风格接口，
etcd 日志 timeout
喝醉酒的小白
05-31 1385
具体地，该消息中的数字 “156.ms” 表示发送心跳的时间，而 “100ms” 则是预期的时间限制。预期的心跳发送间隔一般为 100ms，如果某个节点在发送心跳时超过了这个时间限制（如本例中的 156ms），就会出现该错误消息。优化集群负载：如果 etcd 集群的负载过重，可以考虑优化应用程序或减少其他任务的负载，以确保节点能够及时发送心跳信号。检查网络：确保节点之间的网络连接稳定，并且延迟较低。通过以上步骤，可以改善 etcd 服务器发送心跳信号的性能，减少超时错误的发生，提高集群的可靠性和性能。
Etcd介绍
zyy247796143的博客
06-10 1421
Etcd 是 CoreOS 基于 Raft 开发的分布式 key-value 存储，可用于服务发现、共享配置以及一致性保障（如数据库选主、分布式锁等）。安全性是用于保证每个节点都执行相同序列的安全机制，如当某个 Follower 在当前 Leader commit Log 时变得不可用了，稍后可能该 Follower 又会被选举为 Leader，这时新 Leader 可能会用新的 Log 覆盖先前已 committed 的 Log，这就是导致节点执行不同序列；Safety 就是用于保证选举出来的 Leade
Kubernetes Etcd不可用日志:NOSPACE 的问题修复
专注基础架构领域
10-23 942
两套k8s集群同一天同时出现etcd集群空间超过配额，时发现所有的均返回503报错，查看etcd的告警发现有的信息且 中的DB SIZE大于2GiB。 版本信息kubernetes版本：v1.17.0etcd版本：3.3.10，运行方式为docker容器 1、将API版本调整为3 2、声明变量ETCD_ENDPOINT 如果不清楚etcd证书存放的位置可以使用命令查看，当然endpoint也可以用这种方法 3、备份etc
etcd 启动分析_如何阅读 etcd 源码
weixin_33312000的博客
12-31 116
在前面的几篇文章中，我们已经学习了 Raft 协议、raftexample 和 etcd 常用命令。Raft 和 raftexample 主要对 Raft 协议的认识和实践，etcd 常用命令只能算是揭开 etcd 使用的面纱。此时解读源码，从哪里开始呢？有的同学可能会说：“从 etcdctl 命令开始，从 etcd server 开始 或 从 raft 模块开始“。如果对于一个项目没有整体的认识...
etcd log level 日志级别修改
weixin_33785108的博客
04-04 3360
为什么80%的码农都做不了架构师？>>> ...
ETCD（二）配置文件说明
weixin_44477424的博客
04-20 614
从配置文件参数了解ETCD的一些特性。
etcd数据写满，指令级恢复
05-25
当etcd的数据写满时，可以考虑采取指令级恢复的方式来解决。指令级恢复是一种非常复杂的恢复方式，它需要在系统中记录每个操作的详细信息，以便在需要时可以回放这些操作来恢复系统状态。 在etcd中，可以使用指令级恢复来恢复数据。具体步骤如下： 1. 停止所有对etcd的写入操作，以便记录所有未被提交的写入操作。 2. 将所有未提交的写入操作记录下来，包括操作类型、键、值和时间戳等信息。 3. 清空etcd中的所有数据，以便重新开始。 4. 依次回放所有未提交的写入操作，以恢复etcd中的数据。 需要注意的是，指令级恢复可能会导致数据丢失，因为所有在恢复开始时未提交的写入操作都将被忽略。因此，在执行指令级恢复之前，需要确保所有重要的数据已经备份好。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值