tokenpocketapp下载载苹果版|etcd _比特派(Bitpie)官网-比特派钱包app官方下载-bitpie官网下载app

彻底搞懂 etcd 系列文章（一）：初识 etcd - 知乎

彻底搞懂 etcd 系列文章（一）：初识 etcd - 知乎首发于《彻底搞懂 etcd 系列》切换模式写文章登录/注册彻底搞懂 etcd 系列文章（一）：初识 etcdaoho 求索程序员0 专辑概述etcd 是云原生架构中重要的基础组件，由 CNCF 孵化托管。etcd 在微服务和 Kubernates 集群中不仅可以作为服务注册与发现，还可以作为 key-value 存储的中间件。《彻底搞懂 etcd 系列文章》将会从 etcd 的基本功能实践、API 接口、实现原理、源码分析，以及实现中的踩坑经验等几方面具体展开介绍 etcd。预计会有 20 篇左右的文章，笔者将会每周持续更新，欢迎关注。1 etcd 介绍etcd 是 CoreOS 团队于 2013 年 6 月发起的开源项目，它的目标是构建一个高可用的分布式键值(key-value)数据库。具有以下特点：简单：安装配置简单，而且提供了 HTTP API 进行交互，使用也很简单键值对存储：将数据存储在分层组织的目录中，如同在标准文件系统中监测变更：监测特定的键或目录以进行更改，并对值的更改做出反应安全：支持 SSL 证书验证快速：根据官方提供的 benchmark 数据，单实例支持每秒 2k+ 读操作可靠：采用 raft 算法，实现分布式系统数据的可用性和一致性etcd 采用 Go 语言编写，它具有出色的跨平台支持，很小的二进制文件和强大的社区。 etcd 机器之间的通信通过 Raft 算法处理。etcd 是一个高度一致的分布式键值存储，它提供了一种可靠的方式来存储需要由分布式系统或机器集群访问的数据。它可以优雅地处理网络分区期间的 leader 选举，以应对机器的故障，即使是在 leader 节点发生故障时。从简单的 Web 应用程序到 Kubernetes 集群，任何复杂的应用程序都可以从 etcd 中读取数据或将数据写入 etcd。etcd 于 2018 年 12 月正式加入云原生计算基金会(CNCF，全称 Cloud Native Computing Foundation)，并由 CNCF 支持。CNCF 是一个厂商中立的基金会、云原生技术推广和普及的领导者。2 使用场景etcd 比较多的应用场景是用于服务注册与发现，除此之外，也可以用于键值对存储，应用程序可以读取和写入 etcd 中的数据。一个简单的用例是将数据库连接详细信息或功能标志存储在 etcd 中作为键值对。可以观察这些值，使我们的应用在更改时可以重新配置自己。高级用法是利用 etcd 的一致性保证来实施数据库 leader 选举或在一组 follower 之间执行分布式锁定。2.1 键值对存储A highly-available key value store for shared configuration and service discovery.一个用于配置共享和服务发现的键值存储系统。归根结底，etcd 是一个键值存储的组件，其他的应用都是基于其键值存储的功能展开。etcd 的存储有如下特点：采用kv型数据存储，一般情况下比关系型数据库快。支持动态存储(内存)以及静态存储(磁盘)。分布式存储，可集成为多节点集群。存储方式，采用类似目录结构。只有叶子节点才能真正存储数据，相当于文件。叶子节点的父节点一定是目录，目录不能存储数据。etcd leader 的延迟是要跟踪的最重要的指标，并且内置仪表板具有专用于此的视图。在我们的测试中，严重的延迟会在群集内造成不稳定，因为 Raft 的速度仅与大多数机器中最慢的机器一样快。我们可以通过适当地调整群集来缓解此问题。etcd 已在具有高度可变网络的云提供商上进行了预调。2.2 服务注册与发现服务注册与发现(Service Discovery)要解决的是分布式系统中最常见的问题之一，即在同一个分布式集群中的进程或服务如何才能找到对方并建立连接。从本质上说，服务发现就是要了解集群中是否有进程在监听 UDP 或者 TCP 端口，并且通过名字就可以进行查找和链接。要解决服务发现的问题，需要下面三大支柱，缺一不可。强一致性、高可用的服务存储目录。基于 Raft 算法的 etcd 天生就是这样一个强一致性、高可用的服务存储目录。一种注册服务和服务健康状况的机制。用户可以在 etcd 中注册服务，并且对注册的服务配置 key TTL，定时保持服务的心跳以达到监控健康状态的效果。一种查找和连接服务的机制。通过在 etcd 指定的主题下注册的服务也能在对应的主题下查找到。为了确保连接，我们可以在每个服务机器上都部署一个 Proxy 模式的 etcd，这样就可以确保访问 etcd 集群的服务都能够互相连接。etcd2 中引入的 etcd/raft 库，是目前最稳定、功能丰富的开源一致性协议之一。作为 etcd、TiKV、CockcorachDB、Dgraph 等知名分布式数据库的核心数据复制引擎，etcd/raft 驱动了超过十万个集群，是被最为广泛采用一致性协议实现之一。etcd3 中引入的多版本控制、事务等功能，大大的简化了分布式应用的开发流程，提高了效率和稳定性。经过 5 年的演进，etcd 也已经成为了各种容器编排系统的默认存储选项。Kubernetes 是流行的容器平台，运行在任何环境的 Kubernetes 集群都依赖 etcd 来提供稳定而可靠的存储服务。2.3 消息发布与订阅在分布式系统中，最适用的一种组件间通信方式就是消息发布与订阅。即构建一个配置共享中心，数据提供者在这个配置中心发布消息，而消息使用者则订阅他们关心的主题，一旦主题有消息发布，就会实时通知订阅者。通过这种方式可以做到分布式系统配置的集中式管理与动态更新。应用中用到的一些配置信息放到etcd上进行集中管理。这类场景的使用方式通常是这样：应用在启动的时候主动从etcd获取一次配置信息，同时，在etcd节点上注册一个Watcher并等待，以后每次配置有更新的时候，etcd都会实时通知订阅者，以此达到获取最新配置信息的目的。分布式搜索服务中，索引的元信息和服务器集群机器的节点状态存放在etcd中，供各个客户端订阅使用。使用etcd的key TTL功能可以确保机器状态是实时更新的。分布式日志收集系统。这个系统的核心工作是收集分布在不同机器的日志。收集器通常是按照应用（或主题）来分配收集任务单元，因此可以在etcd上创建一个以应用（主题）命名的目录P，并将这个应用（主题相关）的所有机器ip，以子目录的形式存储到目录P上，然后设置一个 etcd 递归的Watcher，递归式的监控应用（主题）目录下所有信息的变动。这样就实现了机器IP（消息）变动的时候，能够实时通知到收集器调整任务分配。系统中信息需要动态自动获取与人工干预修改信息请求内容的情况。通常是暴露出接口，例如JMX接口，来获取一些运行时的信息。引入etcd之后，就不用自己实现一套方案了，只要将这些信息存放到指定的etcd目录中即可，etcd的这些目录就可以通过HTTP的接口在外部访问。2.4 分布式通知与协调这里说到的分布式通知与协调，与消息发布和订阅有些相似。在分布式系统中，最适用的一种组件间通信方式就是消息发布与订阅。即构建一个配置共享中心，数据提供者在这个配置中心发布消息，而消息使用者则订阅他们关心的主题，一旦主题有消息发布，就会实时通知订阅者。通过这种方式可以做到分布式系统配置的集中式管理与动态更新。这里用到了etcd中的Watcher机制，通过注册与异步通知机制，实现分布式环境下不同系统之间的通知与协调，从而对数据变更做到实时处理。实现方式通常是这样：不同系统都在etcd上对同一个目录进行注册，同时设置Watcher观测该目录的变化（如果对子目录的变化也有需要，可以设置递归模式），当某个系统更新了etcd的目录，那么设置了Watcher的系统就会收到通知，并作出相应处理。通过etcd进行低耦合的心跳检测。检测系统和被检测系统通过etcd上某个目录关联而非直接关联起来，这样可以大大减少系统的耦合性。通过etcd完成系统调度。某系统有控制台和推送系统两部分组成，控制台的职责是控制推送系统进行相应的推送工作。管理人员在控制台作的一些操作，实际上是修改了etcd上某些目录节点的状态，而etcd就把这些变化通知给注册了Watcher的推送系统客户端，推送系统再作出相应的推送任务。通过etcd完成工作汇报。大部分类似的任务分发系统，子任务启动后，到etcd来注册一个临时工作目录，并且定时将自己的进度进行汇报（将进度写入到这个临时目录），这样任务管理者就能够实时知道任务进度。2.5 分布式锁当在分布式系统中，数据只有一份（或有限制），此时需要利用锁的技术控制某一时刻修改数据的进程数。与单机模式下的锁不仅需要保证进程可见，分布式环境下还需要考虑进程与锁之间的网络问题。分布式锁可以将标记存在内存，只是该内存不是某个进程分配的内存而是公共内存如 Redis、Memcache。至于利用数据库、文件等做锁与单机的实现是一样的，只要保证标记能互斥就行。因为etcd使用Raft算法保持了数据的强一致性，某次操作存储到集群中的值必然是全局一致的，所以很容易实现分布式锁。锁服务有两种使用方式，一是保持独占，二是控制时序。保持独占即所有获取锁的用户最终只有一个可以得到。etcd为此提供了一套实现分布式锁原子操作CAS（CompareAndSwap）的API。通过设置prevExist值，可以保证在多个节点同时去创建某个目录时，只有一个成功。而创建成功的用户就可以认为是获得了锁。控制时序，即所有想要获得锁的用户都会被安排执行，但是获得锁的顺序也是全局唯一的，同时决定了执行顺序。etcd为此也提供了一套API（自动创建有序键），对一个目录建值时指定为POST动作，这样etcd会自动在目录下生成一个当前最大的值为键，存储这个新的值（客户端编号）。同时还可以使用API按顺序列出所有当前目录下的键值。此时这些键的值就是客户端的时序，而这些键中存储的值可以是代表客户端的编号。3. 小结本章主要介绍了 etcd 的相关概念，以及 etcd 主要的使用场景。etcd 在分布式环境中是一个利器，在一致性存储方面有广泛的应用。下一篇将会具体介绍 etcd 的安装以及使用的实践。订阅最新文章，欢迎关注我的公众号优质图书推荐欢迎购买笔者的图书，现已出版上市：原创不易，希望大家多多支持，期待与各位的交流学习。参考etcd发布于 2020-05-26 00:12云原生（Cloud Native）微服务架构分布式系统赞同 12710 条评论分享喜欢收藏申请转载文章被以下专栏收录《彻底搞懂 etcd 系列》实现中的踩坑经验等几方面具体展开介绍 et

etcd

etcdDocsBlogCommunityInstallPlayVersionsA distributed, reliable key-value store for the most critical data of a distributed systemLearn more

QuickstartWhat is etcd?etcd is a strongly consistent, distributed key-value store that

provides a reliable way to store data that needs to be accessed by a

distributed system or cluster of machines. It gracefully handles leader

elections during network partitions and can tolerate machine failure, even

in the leader node.

Learn moreFeaturesSimple interfaceRead and write values using standard HTTP tools, such as curlKey-value storageStore data in hierarchically organized directories, as in a standard filesystemWatch for changesWatch specific keys or directories for changes and react to changes in valuesOptional SSL client certificate authenticationBenchmarked at 1000s of writes/s per instanceOptional TTLs for keys expirationProperly distributed via Raft protocolUsed byetcd is a CNCF project© 2013-2024 etcd AuthorsTerms |

Privacy |

Trademarks |

License

还不了解 etcd？一文带你快速入门（万字长文）-腾讯云开发者社区-腾讯云

etcd？一文带你快速入门（万字长文）-腾讯云开发者社区-腾讯云aoho求索还不了解 etcd？一文带你快速入门（万字长文）关注作者腾讯云开发者社区文档建议反馈控制台首页学习活动专区工具TVP最新优惠活动文章/答案/技术大牛搜索搜索关闭发布登录/注册首页学习活动专区工具TVP最新优惠活动返回腾讯云官网aoho求索首页学习活动专区工具TVP最新优惠活动返回腾讯云官网社区首页 >专栏 >还不了解 etcd？一文带你快速入门（万字长文）还不了解 etcd？一文带你快速入门（万字长文）aoho求索关注发布于 2020-12-01 09:56:473.2K0发布于 2020-12-01 09:56:47举报文章被收录于专栏：aoho求索aoho求索2018年12月 etcd 作为孵化项目 CNCF（云原生计算基金会），几天前 CNCF 宣布 etcd 正式毕业，成为 CNCF 顶级项目。CNCF 官方表示 etcd 项目的采用率持续增加，也有稳定的治理流程，功能已达一定成熟度。etcd 已经被许多公司用于实际生产，其中包括亚马逊、百度、思科、EMC、谷歌、阿里、华为、IBM、Red Hat、Uber、Verizon 等；而且其身影也出现在包括 Kubernetes、CoreDNS、M3、Rook 以及 TiKV 等项目当中。前面的系列 etcd 文章已经部分介绍了 etcd。本文将会做一个快速入门的介绍，带领大家十分钟快速入门云原生存储组件 etcd，主要内容如下（本文较长，建议收藏）：etcd 简介，以及其应用场景etcd 的多种安装模式及高可用运维etcd v3 的架构解析etcdctl 的实践应用1 etcd 介绍2013 年 6 月，CoreOS 发起了 etcd 项目。etcd 使用 Go 语言实现，是分布式系统中重要的基础组件，目前最新版本为 V3.4.9。etcd 可以用来构建高可用的分布式键值数据库，根据官网介绍，总结来说有如下的特点：简单：etcd 的安装简单，且为用户提供了 HTTP API，用户使用起来也很简单存储：etcd 的基本功能，数据分层存储在文件目录中，类似于我们日常使用的文件系统Watch 机制：Watch 指定的键、前缀目录的更改，并对更改时间进行通知安全通信：SSL 证书验证高性能：etcd 单实例可以支持 2k/s 读操作，官方也有提供基准测试脚本一致可靠：基于 Raft 共识算法，实现分布式系统数据的高可用性、一致性etcd 是一个分布式键值存储数据库，支持跨平台，拥有强大的社区。etcd 的 Raft 算法，提供了可靠的方式存储分布式集群涉及的数据。etcd 广泛应用在微服务架构和 Kubernates 集群中，不仅可以作为服务注册与发现，还可以作为键值对存储的中间件。从业务系统 Web 到 Kubernetes 集群，都可以很方便地从 etcd 中读取、写入数据。2 etcd 应用场景etcd 在稳定性、可靠性和可伸缩性表现极佳，同时也为云原生应用系统提供了协调机制。etcd 经常用于服务注册与发现的场景，此外还有键值对存储、消息发布与订阅、分布式锁等场景。2.1 键值对存储如下是官方对 etcd 的描述：❝A highly-available key value store for shared configuration and service discovery.

一个用于配置共享和服务发现的键值存储系统。

❞从其定义来看，etcd 是一个「键值存储」的组件，存储是 etcd 最基本的功能，其他应用场景都是建立在 etcd 的可靠存储上。etcd 的存储有如下特点：采用键值对数据存储，读写性能一般高于关系型数据库；etcd 集群分布式存储，多节点集群更加可靠；etcd 的存储采用类似文件目录的结构：叶子节点存储数据，其他节点不存储，这些数据相当于文件；非叶节点一定是目录，这些节点不能存储数据。比如 Kubernetes 将一些元数据存储在 etcd 中，将存储状态数据的的复杂工作交给 etcd，Kubernetes 自身的功能和架构能够更加专注。2.2 服务注册与发现分布式环境中，业务服务多实例部署，这个时候涉及到服务之间调用，就不能简单使用硬编码的方式指定服务实例信息。服务注册与发现就是解决如何找到分布式集群中的某一个服务（进程），并与之建立联系。服务注册与发现涉及三个主要的角色：服务请求者、服务提供者和服务注册中心。三大支柱服务提供者启动的时候，在服务注册中心进行注册自己的服务名、主机地址、端口等信息；服务请求者需要调用对应的服务时，一般通过服务名请求服务注册中心，服务注册中心返回对应的实例地址和端口；服务请求者获取到实例地址、端口之后，绑定对应的服务提供者，实现远程调用。etcd 基于 Raft 算法，能够有力地保证分布式场景中的一致性。各个服务启动时注册到 etcd 上，同时为这些服务配置键的 TTL 时间，定时保持服务的心跳以达到监控健康状态的效果。通过在 etcd 指定的主题下注册的服务也能在对应的主题下查找到。为了确保连接，我们可以在每个服务机器上都部署一个 Proxy 模式的 etcd，这样就可以确保访问 etcd 集群的服务都能够互相连接。2.3 消息发布与订阅在分布式系统中，服务之间还可以通过消息通信，即消息的发布与订阅。通过构建一个消息中间件，服务提供者发布对应主题的消息，而消费者则订阅他们关心的主题，一旦对应的主题有消息发布，即会产生订阅事件，消息中间件就会通知该主题所有的订阅者。如微服务架构中的认证鉴权服务，Auth 服务的实例地址、端口和实例节点的状态存放在 etcd 中，客户端应用订阅对应的主题，而 etcd 设置 key TTL 可以确保存储的服务实例的健康状态。2.4 分布式锁分布式系统中涉及到多个服务实例，存在跨进程之间资源调用，对于资源的协调分配，单体架构中的锁已经无法满足需要，需要引入分布式锁的概念。分布式锁可以将资源标记存储，这里的存储不是单纯属于某个进程，而是公共存储，诸如 Redis、Memcache、关系型数据库、文件等。etcd 基于 Raft 算法，实现分布式集群的一致性，存储到 etcd 集群中的值必然是全局一致的，因此基于 etcd 很容易实现分布式锁。分布式锁有两种使用方式：保持独占和控制时序。保持独占，从字面可以知道，所有获取资源的请求，只有一个成功。etcd 通过分布式锁原子操作 CAS 的 API，设置 prevExist 值，从而保证在多个节点同时去创建某个目录时，最后只有一个成功，创建成功的请求获取到锁。控制时序，有点类似于队列缓冲，所有的请求都会被安排分配资源，但是获得锁的顺序也是全局唯一的，执行按照先后的顺序。etcd 提供了一套自动创建有序键的 API，对一个目录的建值操作，这样 etcd 会自动生成一个当前最大的值为键，并存储该值。同时还可以使用 API 按顺序列出当前目录下的所有键值。3 etcd 的多种安装方法etcd 的安装非常简单，我们在本小节实践 etcd 单机和集群的几种安装方式。3.1 etcd 概念词汇表下文的安装实践可能会涉及到 etcd 相关的概念词汇，因此我们首先了解下 etcd 的概念词汇表，以便于下文的理解。Raft：分布式一致性算法；Node：Raft 状态机实例；Member：管理着 Node 的 etcd 实例，为客户端请求提供服务；Cluster：etcd 集群，由多个 Member 构成；Peer：同一个 etcd 集群中的另一个 Member；Client：客户端，向 etcd 发送 HTTP 请求；WAL：持久化存储的日志格式，预写式日志；Snapshot：etcd 数据快照，防止 WAL 文件过多而设置的快照。在了解了 etcd 的常用术语之后，我们下面开始介绍 etcd v3 的架构。etcd 的安装有多种方式，笔者以 Centos 7 和 MacOS 10.15 为例，可以通过 yum install etcd 和 brew install etcd进行安装。然而通过系统工具安装的 etcd 版本比较滞后，如果需要安装最新版本的 etcd ，我们可以通过二进制包、源码编译以及 docker 容器安装。3.2 etcd 单机安装部署etcd 的安装有多种方式，笔者以 Centos 7 和 MacOS 10.15 为例，可以通过 yum install etcd 和 brew install etcd进行安装。然而通过系统工具安装的 etcd 版本比较滞后，如果需要安装最新版本的 etcd ，我们可以通过二进制包、源码编译以及 docker 容器安装。3.2.1 二进制安装在 macOS 下，安装 3.4.5，指定 etcd 版本，执行如下的脚本：ETCD_VER=v3.4.5

GITHUB_URL=https://github.com/etcd-io/etcd/releases/download

DOWNLOAD_URL=${GITHUB_URL}

rm -f /tmp/etcd-${ETCD_VER}-darwin-amd64.zip

rm -rf /tmp/etcd-download-test && mkdir -p /tmp/etcd-download-test

curl -L ${DOWNLOAD_URL}/${ETCD_VER}/etcd-${ETCD_VER}-darwin-amd64.zip -o /tmp/etcd-${ETCD_VER}-darwin-amd64.zip

unzip /tmp/etcd-${ETCD_VER}-darwin-amd64.zip -d /tmp && rm -f /tmp/etcd-${ETCD_VER}-darwin-amd64.zip

mv /tmp/etcd-${ETCD_VER}-darwin-amd64/* /tmp/etcd-download-test && rm -rf mv /tmp/etcd-${ETCD_VER}-darwin-amd64

/tmp/etcd-download-test/etcd --version

/tmp/etcd-download-test/etcdctl version

复制执行完上面的脚本，控制台即可输出如下的结果：etcd Version: 3.4.5

Git SHA: c65a9e2dd

Go Version: go1.12.12

Go OS/Arch: darwin/amd64

复制根据控制台的显示，etcd 安装成功，版本为 etcd 3.4.5，基于的 Go 语言版本为 1.12.12。Linux 上的操作也类似，Centos 7 系统执行的脚本可以参考 etcd 官方提供的脚本。我们在这一小节演示了单机 etcd 在 macOS 和 Linux 上的安装。etcd 在 Windows 系统的安装比较简单，下载可执行文件，其中 etcd.exe 是 etcd Server，etcdctl.exe 命令行工具。3.2.2 源码安装对于那些想尝试最新版本的同学，可以从 master 分支构建 etcd。使用源码安装，首先需要确保本地的 Go 语言环境。如未安装，请参考 https://golang.org/doc/install。需要 Go 版本为 1.13+，来构建最新版本的 etcd。本地的 Go 版本为：$ go version

go version go1.14.2 darwin/amd64

复制基于 master 分支构建 etcd，脚本如下：git clone https://github.com/etcd-io/etcd.git

cd etcd

./build

复制安装完记得执行测试命令，确保 etcd 源码编译安装成功。3.3 etcd 集群部署etcd 是分布式环境中重要的中间件，一般在生产环境不会单节点部署 etcd，为了 etcd 的高可用，避免单点故障，etcd 通常都是集群部署。本小节将会介绍如何进行 etcd 集群部署。引导 etcd 集群的启动有以下三种方式：静态指定etcd 动态发现DNS 发现静态指定的方式需要事先知道集群中的所有节点。在许多情况下，群集成员的信息是动态生成。这种情况下，可以在动态发现服务的帮助下启动 etcd 群集。下面我们将会分别介绍这几种方式。3.3.1 静态方式启动 etcd 集群如果想要在一台机器上实践 etcd 集群的搭建，可以通过 goreman 工具。goreman 是一个 Go 语言编写的多进程管理工具，是对 Ruby 下广泛使用的 foreman 的重写（foreman 原作者也实现了一个 Go 版本：forego，不过没有 goreman 好用）。我们需要确认 Go 安装环境，然后直接执行：go get github.com/mattn/goreman

复制编译后的文件放在 GOPATH/bin 中，GOPATH/bin目录已经添加到了系统 HostNameip客户端交互端口peer 通信端口infra1127.0.0.123792380infra2127.0.0.12237922380infra3127.0.0.13237932380Procfile 脚本如下：其他两个 etcd 成员的配置类似，不在赘述。配置项说明如下：--name：etcd 集群中的节点名；--listen-peer-urls：用于节点之间通信的地址，可以监听多个；--initial-advertise-peer-urls：与其他节点之间通信的地址；--listen-client-urls：监听客户端通信的地址，可以有多个；--advertise-client-urls：用于客户端与节点通信的地址；--initial-cluster-token：标识不同 etcd 集群的 token；--initial-cluster：即指定的 initial-advertise-peer-urls 的所有节点；--initial-cluster-state：new，新建集群的标志。注意上面的脚本，etcd 命令执行时需要根据本地实际的安装地址进行配置。下面我们启动 etcd 集群。goreman -f /opt/procfile start

复制使用如上的命令启动启动 etcd 集群，启动完成之后查看集群内的成员。$ etcdctl --endpoints=http://localhost:22379 member list

8211f1d0f64f3269, started, infra1, http://127.0.0.1:12380, http://127.0.0.1:12379, false

91bc3c398fb3c146, started, infra2, http://127.0.0.1:22380, http://127.0.0.1:22379, false

fd422379fda50e48, started, infra3, http://127.0.0.1:32380, http://127.0.0.1:32379, false

复制我们在单机搭建的伪集群成功，需要注意的是在集群启动时，我们通过静态的方式指定集群的成员，在实际环境中，集群成员的地址端口等信息可能不会事先知道。这时候就需要采用动态发现的机制。3.3.2 docker 启动集群etcd 使用 gcr.io/etcd-development/etcd 作为容器的主要加速器， quay.io/coreos/etcd 作为辅助的加速器。可惜这两个加速器我们都没法访问，如果下载不了，可以使用笔者提供的地址：docker pull bitnami/etcd:3.4.7

复制然后将拉取的镜像重新 tag：docker image tag bitnami/etcd:3.4.7 quay.io/coreos/etcd:3.4.7

复制镜像设置好之后，我们启动 3 个节点的 etcd 集群，脚本命令如下：REGISTRY=quay.io/coreos/etcd

# For each machine

ETCD_VERSION=3.4.5

TOKEN=my-etcd-token

CLUSTER_STATE=new

NAME_1=etcd-node-0

NAME_2=etcd-node-1

NAME_3=etcd-node-2

HOST_1= 192.168.202.128

HOST_2= 192.168.202.129

HOST_3= 192.168.202.130

CLUSTER=${NAME_1}=http://${HOST_1}:2380,${NAME_2}=http://${HOST_2}:2380,${NAME_3}=http://${HOST_3}:2380

DATA_DIR=/var/lib/etcd

# For node 1

THIS_NAME=${NAME_1}

THIS_IP=${HOST_1}

docker run \

-p 2379:2379 \

-p 2380:2380 \

--volume=${DATA_DIR}:/etcd-data \

--name etcd ${REGISTRY}:${ETCD_VERSION} \

/usr/local/bin/etcd \

--data-dir=/etcd-data --name ${THIS_NAME} \

--initial-advertise-peer-urls http://${THIS_IP}:2380 --listen-peer-urls http://0.0.0.0:2380 \

--advertise-client-urls http://${THIS_IP}:2379 --listen-client-urls http://0.0.0.0:2379 \

--initial-cluster ${CLUSTER} \

--initial-cluster-state ${CLUSTER_STATE} --initial-cluster-token ${TOKEN}

# For node 2

THIS_NAME=${NAME_2}

THIS_IP=${HOST_2}

docker run \

-p 2379:2379 \

-p 2380:2380 \

--volume=${DATA_DIR}:/etcd-data \

--name etcd ${REGISTRY}:${ETCD_VERSION} \

/usr/local/bin/etcd \

--data-dir=/etcd-data --name ${THIS_NAME} \

--initial-advertise-peer-urls http://${THIS_IP}:2380 --listen-peer-urls http://0.0.0.0:2380 \

--advertise-client-urls http://${THIS_IP}:2379 --listen-client-urls http://0.0.0.0:2379 \

--initial-cluster ${CLUSTER} \

--initial-cluster-state ${CLUSTER_STATE} --initial-cluster-token ${TOKEN}

# For node 3

THIS_NAME=${NAME_3}

THIS_IP=${HOST_3}

docker run \

-p 2379:2379 \

-p 2380:2380 \

--volume=${DATA_DIR}:/etcd-data \

--name etcd ${REGISTRY}:${ETCD_VERSION} \

/usr/local/bin/etcd \

--data-dir=/etcd-data --name ${THIS_NAME} \

--initial-advertise-peer-urls http://${THIS_IP}:2380 --listen-peer-urls http://0.0.0.0:2380 \

--advertise-client-urls http://${THIS_IP}:2379 --listen-client-urls http://0.0.0.0:2379 \

--initial-cluster ${CLUSTER} \

--initial-cluster-state ${CLUSTER_STATE} --initial-cluster-token ${TOKEN}

复制注意，上面的脚本是部署在三台机器上面，每台机器执行对应的脚本即可。在运行时可以指定 API 版本：docker exec etcd /bin/sh -c "export ETCDCTL_API=3 && /usr/local/bin/etcdctl put foo bar"

复制docker 的安装方式比较简单，读者根据需要可以定制一些配置。3.4 动态发现启动 etcd 集群在大部分的情况下，集群成员的地址端口号等信息，并不会提前知道。在这种情况下，需要使用自动发现来引导 etcd 集群，而不是指定静态配置，这个过程被称为「发现」。我们启动三个 etcd，具体对应如下：HostNameip客户端交互端口peer 通信端口etcd1192.168.202.12823792380etcd2192.168.202.12923792380etcd3192.168.202.130237923803.4.1 协议的原理基于 Discovery Service Protocol ，新的 etcd 节点加入时，使用共享 URL 在启动阶段发现集群中的其它成员。需要注意的是，发现协议仅在集群启动阶段生效，不能用于其它阶段。这其中涉及到发现令牌，用来标识唯一的 etcd 集群。一个发现令牌只能代表一个 etcd 集群。只要此令牌上的发现协议启动，即使启动失败，也不能用于引导其他的 etcd 集群。所有 etcd 节点都与发现服务通信，并生成集群成员列表。随后每个新节点使用此列表启动服务，该列表与 --initial-cluster 选项具有相同的功能，用以设置集群的成员信息。3.4.2 获取 discovery 的 token生成将标识新集群的唯一令牌。在以下步骤中，它将用作发现键空间中的唯一前缀。一种简单的方法是使用 uuidgen，我们运行之后的结果为：$ uuidgen

9CBAF7C8-123B-4E72-89C9-F81E4BC5F173

复制3.4.3 指定集群的大小获取令牌时，必须指定群集大小。发现服务使用该大小来了解何时发现了最初将组成集群的所有成员。curl -X PUT http://10.0.10.10:2379/v2/keys/discovery/9CBAF7C8-123B-4E72-89C9-F81E4BC5F173/_config/size -d value=3

复制我们需要把该 url 地址 http://10.0.10.10:2379/v2/keys/discovery/9CBAF7C8-123B-4E72-89C9-F81E4BC5F173 作为 --discovery 参数来启动 etcd。节点会自动使用 http://10.0.10.10:2379/v2/keys/discovery/9CBAF7C8-123B-4E72-89C9-F81E4BC5F173 目录进行 etcd 的注册和发现服务。3.4.4 公共发现服务如果我们没有可用的本地 etcd 集群，则可以使用 etcd 官方提供的公共访问的 etcd 集群地址。公共发现服务 discovery.etcd.io 以相同的方式工作，但是有一层修饰，可以提取丑陋的 URL，自动生成 UUID，并提供针对过多请求的保护。公共发现服务在其上仍然使用 etcd 群集作为数据存储。$ curl http://discovery.etcd.io/new?size=3

http://discovery.etcd.io/3e86b59982e49066c5d813af1c2e2579cbf573de

复制3.4.5 以动态发现方式启动集群etcd 发现模式下，启动 etcd 的命令如下：# etcd1 启动

$ /opt/etcd/bin/etcd --name etcd1 --initial-advertise-peer-urls http://192.168.202.128:2380 \

--listen-peer-urls http://192.168.202.128:2380 \

--data-dir /opt/etcd/data \

--listen-client-urls http://192.168.202.128:2379,http://127.0.0.1:2379 \

--advertise-client-urls http://192.168.202.128:2379 \

--discovery https://discovery.etcd.io/3e86b59982e49066c5d813af1c2e2579cbf573de

# etcd2 启动

/opt/etcd/bin/etcd --name etcd2 --initial-advertise-peer-urls http://192.168.202.129:2380 \

--listen-peer-urls http://192.168.202.129:2380 \

--data-dir /opt/etcd/data \

--listen-client-urls http://192.168.202.129:2379,http://127.0.0.1:2379 \

--advertise-client-urls http://192.168.202.129:2379 \

--discovery https://discovery.etcd.io/3e86b59982e49066c5d813af1c2e2579cbf573de

# etcd3 启动

/opt/etcd/bin/etcd --name etcd3 --initial-advertise-peer-urls http://192.168.202.130:2380 \

--listen-peer-urls http://192.168.202.130:2380 \

--data-dir /opt/etcd/data \

--listen-client-urls http://192.168.202.130:2379,http://127.0.0.1:2379 \

--advertise-client-urls http://192.168.202.130:2379 \

--discovery https://discovery.etcd.io/3e86b59982e49066c5d813af1c2e2579cbf573de

复制我们在每次启动新 etcd 集群时，使用新的 discovery token 进行注册。如果初始化启动的节点超过了请求 token 时指定的数量，则多的节点会自动转为 Proxy 模式的 etcd。需要注意的是，在我们完成了集群的初始化后，这些信息就失去了作用。当需要增加节点时，需要使用 etcdctl 进行操作。3.4.6 结果验证集群启动好之后，进行验证，我们看一下集群的成员：$ /opt/etcd/bin/etcdctl member list

# 结果如下

40e2ac06ca1674a7, started, etcd3, http://192.168.202.130:2380, http://192.168.202.130:2379, false

c532c5cedfe84d3c, started, etcd1, http://192.168.202.128:2380, http://192.168.202.128:2379, false

db75d3022049742a, started, etcd2, http://192.168.202.129:2380, http://192.168.202.129:2379, false

复制可以看到，集群中的三个节点都是健康的正常状态。以动态发现方式启动集群成功。4 etcd v3 的架构解析etcd v2 和 v3 在底层使用同一套 Raft 算法的两个独立应用，相互之间接口不一样、存储不一样，两个版本的数据互相隔离。由 etcd v2 升级到 etcd v3 的情况下，原有数据只能通过 etcd v2 接口访问，v3 接口创建的数据只能通过新的 v3 的接口访问。本文重点讲解 v3 版本。etcd 总体的架构图如下所示：分布式集群一般由奇数个节点组成，etcd 同样也是，多个 etcd 节点通过 Raft 算法相互协作。Raft 算法会选择一个主节点作为 Leader，负责数据同步和分发。当 Leader 发生故障时，系统会自动选择另一个节点作为 Leader，以再次完成数据同步。当 etcd 完成内部状态和数据协作时，仅需选择一个节点即可读取和写入数据。Quorum（翻译成法定人数，简单理解为定义一个最少写入同步到多少个节点才算成功写入）机制是 etcd 中的关键概念。它定义为 (n + 1)/2，表示群集中超过一半的节点构成 Quorum。在三节点集群中，只要有两个节点可用，etcd 仍将运行。同样，在五节点集群中，只要有三个节点可用，etcd 仍会运行。这是 etcd 群集高可用性的关键。为了使 etcd 在某些节点出现故障后继续运行，必须解决分布式一致性问题。在 etcd 中，分布式共识算法由 Raft 实现。下面简要描述该算法。Raft 共识算法仅在任何两个 Quorum 具有共享成员时才可以工作。也就是说，任何有效的仲裁必须包含一个共享成员，该成员包含集群中所有已确认和已提交的数据。基于此，etcd 为 Raft 共识算法设计了一种数据同步机制，用于在更新 Leader 后同步最后 Quorum 所提交的所有数据。这样可以确保在群集状态更改时数据的一致性。etcd 具有复杂的内部机制，但为客户端提供了简单直接的 API。如上图所示，我们可以通过 etcd 客户端访问群集数据，或通过 HTTP 直接访问 etcd，这与 curl 命令类似。etcd 中的数据结构很简单，我们可以将 etcd 的数据存储理解为存储键值数据的有序映射。etcd 还提供了一种 Watch 机制来为客户端订阅数据更改的事件。Watch 机制实时获取 etcd 中的增量数据更新，以使数据与 etcd 同步。5 etcdctl 的实践应用etcdctl 是 etcd 的命令行客户端，用户通过 etcdctl 直接跟 etcd 进行交互，可以实现 HTTP API 的功能。在测试阶段，etcdctl 可以方便对服务进行操作或更新数据库内容。对于刚入门的同学，建议通过 etdctl 来熟悉 etcd 相关操作。需要注意的是，etcdctl 在两个不同的 etcd 版本下的行为方式也完全不同。export ETCDCTL_API=2

export ETCDCTL_API=3

复制这里主要以讲解 API 3 为主。etcdctl 的命令分为数据库和非数据库两类操作。5.1 常用命令介绍首先查看一下 etcd 的版本：$ etcd --version

etcd Version: 3.4.7

Git SHA: e784ba73c

Go Version: go1.12.12

Go OS/Arch: linux/amd64

复制我们的版本是 etcd 3.4.7 ，下面介绍下 etcdctl 常用的命令。$ etcdctl -h

NAME:

etcdctl - A simple command line client for etcd3.

USAGE:

etcdctl [flags]

VERSION:

3.4.7

API VERSION:

3.4

COMMANDS:

alarm disarm Disarms all alarms

alarm list Lists all alarms

auth disable Disables authentication

auth enable Enables authentication

check datascale Check the memory usage of holding data for different workloads on a given server endpoint.

check perf Check the performance of the etcd cluster

compaction Compacts the event history in etcd

defrag Defragments the storage of the etcd members with given endpoints

del Removes the specified key or range of keys [key, range_end)

elect Observes and participates in leader election

endpoint hashkv Prints the KV history hash for each endpoint in --endpoints

endpoint health Checks the healthiness of endpoints specified in `--endpoints` flag

endpoint status Prints out the status of endpoints specified in `--endpoints` flag

get Gets the key or a range of keys

help Help about any command

lease grant Creates leases

lease keep-alive Keeps leases alive (renew)

lease list List all active leases

lease revoke Revokes leases

lease timetolive Get lease information

lock Acquires a named lock

make-mirror Makes a mirror at the destination etcd cluster

member add Adds a member into the cluster

member list Lists all members in the cluster

member promote Promotes a non-voting member in the cluster

member remove Removes a member from the cluster

member update Updates a member in the cluster

migrate Migrates keys in a v2 store to a mvcc store

move-leader Transfers leadership to another etcd cluster member.

put Puts the given key into the store

role add Adds a new role

role delete Deletes a role

role get Gets detailed information of a role

role grant-permission Grants a key to a role

role list Lists all roles

role revoke-permission Revokes a key from a role

snapshot restore Restores an etcd member snapshot to an etcd directory

snapshot save Stores an etcd node backend snapshot to a given file

snapshot status Gets backend snapshot status of a given file

txn Txn processes all the requests in one transaction

user add Adds a new user

user delete Deletes a user

user get Gets detailed information of a user

user grant-role Grants a role to a user

user list Lists all users

user passwd Changes password of user

user revoke-role Revokes a role from a user

version Prints the version of etcdctl

watch Watches events stream on keys or prefixes

OPTIONS:

--cacert="" verify certificates of TLS-enabled secure servers using this CA bundle

--cert="" identify secure client using this TLS certificate file

--command-timeout=5s timeout for short running command (excluding dial timeout)

--debug[=false] enable client-side debug logging

--dial-timeout=2s dial timeout for client connections

-d, --discovery-srv="" domain name to query for SRV records describing cluster endpoints

--discovery-srv-name="" service name to query when using DNS discovery

--endpoints=[127.0.0.1:2379] gRPC endpoints

-h, --help[=false] help for etcdctl

--hex[=false] print byte strings as hex encoded strings

--insecure-discovery[=true] accept insecure SRV records describing cluster endpoints

--insecure-skip-tls-verify[=false] skip server certificate verification

--insecure-transport[=true] disable transport security for client connections

--keepalive-time=2s keepalive time for client connections

--keepalive-timeout=6s keepalive timeout for client connections

--key="" identify secure client using this TLS key file

--password="" password for authentication (if this option is used, --user option shouldn't include password)

--user="" username[:password] for authentication (prompt if password is not supplied)

-w, --write-out="simple" set the output format (fields, json, protobuf, simple, table)

复制可以看到，etcdctl 支持的命令很多，常用的命令选项：--debug 输出 CURL 命令，显示执行命令的时候发起的请求

--no-sync 发出请求之前不同步集群信息

--output, -o 'simple' 输出内容的格式(simple 为原始信息，json 为进行 json 格式解码，易读性好一些)

--peers, -C 指定集群中的同伴信息，用逗号隔开(默认为: "127.0.0.1:4001")

--cert-file HTTPS 下客户端使用的 SSL 证书文件

--key-file HTTPS 下客户端使用的 SSL 密钥文件

--ca-file 服务端使用 HTTPS 时，使用 CA 文件进行验证

--help, -h 显示帮助命令信息

--version, -v 打印版本信息

复制下面我们将介绍其中常用的数据库命令。5.2 数据库操作etcd 在键的组织上采用了如同类似文件目录的结构，即层次化的空间结构，我们可以为键指定单独的名字。etcd 数据库提供的操作，则主要围绕对键值和目录的增删改查。5.2.1 键操作set 指定某个键的值。例如：$ etcdctl put /testdir/testkey "Hello world"

$ etcdctl put /testdir/testkey2 "Hello world2"

$ etcdctl put /testdir/testkey3 "Hello world3"

复制成功写入三对键值，/testdir/testkey、/testdir/testkey2 和 /testdir/testkey3。get 获取指定键的值。例如：$ etcdctl get /testdir/testkey

Hello world

复制get 十六进制读指定的值：$ etcdctl get /testdir/testkey --hex

\x2f\x74\x65\x73\x74\x64\x69\x72\x2f\x74\x65\x73\x74\x6b\x65\x79 #键

\x48\x65\x6c\x6c\x6f\x20\x77\x6f\x72\x6c\x64 #值

复制加上 --print-value-only 可以读取对应的值。get 范围内的值 $ etcdctl get /testdir/testkey /testdir/testkey3

/testdir/testkey

Hello world

/testdir/testkey2

Hello world2

复制可以看到，获取了大于等于 /testdir/testkey，且小于 /testdir/testkey3 的键值对。testkey3 不在范围之内，因为范围是半开区间 [testkey, testkey3), 不包含 testkey3。获取某个前缀的所有键值对，通过 --prefix 可以指定前缀：$ etcdctl get --prefix /testdir/testkey

/testdir/testkey

Hello world

/testdir/testkey2

Hello world2

/testdir/testkey3

Hello world3

复制这样既可获取所有以 /testdir/testkey 开头的键值对。当前缀获取的结果过多时，还可以通过 --limit=2 限制获取的数量：etcdctl get --prefix --limit=2 /testdir/testkey

复制读取键过往版本的值应用可能想读取键的被替代的值。例如，应用可能想通过访问键的过往版本来回滚到旧的配置。或者，应用可能想通过多个请求来得到一个覆盖多个键的统一视图，而这些请求可以通过访问键历史记录而来。因为 etcd 集群上键值存储的每个修改都会增加 etcd 集群的全局修订版本，应用可以通过提供旧有的 etcd 修改版本来读取被替代的键。现有如下这些键值对：foo = bar # revision = 2

foo1 = bar2 # revision = 3

foo = bar_new # revision = 4

foo1 = bar1_new # revision = 5

复制以下是访问以前版本 key 的示例：$ etcdctl get --prefix foo # 访问最新版本的 key

foo

bar_new

foo1

bar1_new

$ etcdctl get --prefix --rev=4 foo # 访问第 4 个版本的 key

foo

bar_new

foo1

bar1

$ etcdctl get --prefix --rev=3 foo # 访问第 3 个版本的 key

foo

bar

foo1

bar1

$ etcdctl get --prefix --rev=2 foo # 访问第 3 个版本的 key

foo

bar

$ etcdctl get --prefix --rev=1 foo # 访问第 1 个版本的 key

复制读取大于等于指定键的 byte 值的键应用可能想读取大于等于指定键的 byte 值的键。假设 etcd 集群已经有下列键：a = 123

b = 456

z = 789

复制读取大于等于键 b 的 byte 值的键的命令：$ etcdctl get --from-key b

456

789

复制删除键。客户端应用可以从 etcd 数据库中删除指定的键。假设 etcd 集群已经有下列键：foo = bar

foo1 = bar1

foo3 = bar3

zoo = val

zoo1 = val1

zoo2 = val2

a = 123

b = 456

z = 789

复制删除键 foo 的命令：$ etcdctl del foo

1 # 删除了一个键

复制删除从 foo to foo9 范围的键的命令：$ etcdctl del foo foo9

2 # 删除了两个键

复制删除键 zoo 并返回被删除的键值对的命令：$ etcdctl del --prev-kv zoo

1 # 一个键被删除

zoo # 被删除的键

val # 被删除的键的值

复制删除前缀为 zoo 的键的命令：$ etcdctl del --prefix zoo

2 # 删除了两个键

复制删除大于等于键 b 的 byte 值的键的命令：$ etcdctl del --from-key b

2 # 删除了两个键

复制5.2.2 watch 历史改动watch 可以用来监测一个键值的变化，当该键值更新，控制台就会输出最新的值。例如：用户更新 watchkey 键值为 newwatchvalue。$ etcdctl watch watchkey

# 在另外一个终端: etcdctl put watchkey newwatchvalue

watchkey

newwatchvalue

复制从 foo to foo9 范围内键的命令：$ etcdctl watch foo foo9

# 在另外一个终端: etcdctl put foo bar

PUT

foo

bar

# 在另外一个终端: etcdctl put foo1 bar1

PUT

foo1

bar1

复制以 16 进制格式在键 foo 上进行观察的命令：$ etcdctl watch foo --hex

# 在另外一个终端: etcdctl put foo bar

PUT

\x66\x6f\x6f # 键

\x62\x61\x72 # 值

复制观察多个键 foo 和 zoo 的命令：$ etcdctl watch -i

$ watch foo

$ watch zoo

# 在另外一个终端: etcdctl put foo bar

PUT

foo

bar

# 在另外一个终端: etcdctl put zoo val

PUT

zoo

val

复制查看 key 的历史修订版本。客户端应用需要获取某个键的所有修改。那么客户端应用连接到 etcd，watch 对应的 key 即可。如果 Watch 的过程中，etcd 或者客户端应用出错，又恰好发生了改动，这种情况下客户端应用可以在 Watch 时指定历史修订版本。

假设我们完成了下列操作序列：$ etcdctl put foo bar # revision = 2

$ etcdctl put foo1 bar1 # revision = 3

$ etcdctl put foo bar_new # revision = 4

$ etcdctl put foo1 bar1_new # revision = 5

复制观察历史改动：# 从修订版本 2 开始观察键 `foo` 的改动

$ etcdctl watch --rev=2 foo

PUT

foo

bar

PUT

foo

bar_new

复制从上一次历史修改开始观察：# 在键 `foo` 上观察变更并返回被修改的值和上个修订版本的值

$ etcdctl watch --prev-kv foo

# 在另外一个终端: etcdctl put foo bar_latest

PUT

foo # 键

bar_new # 在修改前键 foo 的上一个值

foo # 键

bar_latest # 修改后键 foo 的值

复制压缩修订版本。etcd 保存了历史修订版本，客户端应用可以读取键的历史版本。大量的历史版本数据，会占据很多存储，因此需要压缩历史修订版本。经过压缩，etcd 会删除历史修订版本，释放出资源。压缩修订版本之前的版本数据不可访问。压缩修订版本的命令如下所示：$ etcdctl compact 5

compacted revision 5 $ etcdctl get --rev=4 foo

{"level":"warn","ts":"2020-05-04T16:37:38.020+0800","caller":"clientv3/retry_interceptor.go:62","msg":"retrying of unary invoker failed","target":"endpoint://client-c0d35565-0584-4c07-bfeb-034773278656/127.0.0.1:2379","attempt":0,"error":"rpc error: code = OutOfRange desc = etcdserver: mvcc: required revision has been compacted"}

Error: etcdserver: mvcc: required revision has been compacted

复制5.2.3 租约授予租约客户端应用可以为 etcd 数据库存储内的键授予租约。当 etcd 中的键被授予租约时，该键的存活时间与租约的时间绑定，而租约的存活时间相应的被 time-to-live (TTL)管理。在租约授予时每个租约的最小 TTL 值由客户端应用指定。当租约的 TTL 到期，即代表租约就过期，此时该租约绑定的键都将被删除。# 授予租约，TTL 为 100 秒

$ etcdctl lease grant 100

lease 694d71ddacfda227 granted with TTL(10s)

# 附加键 foo 到租约 694d71ddacfda227

$ etcdctl put --lease=694d71ddacfda227 foo10 bar

复制建议时间设置久一点，否则来不及操作会出现如下的错误：复制撤销租约应用通过租约 id 可以撤销租约。撤销租约将删除所有它附带的 key。假设我们完成了下列的操作：$ etcdctl lease revoke 694d71ddacfda227

lease 694d71ddacfda227 revoked

$ etcdctl get foo10

复制刷新租期

应用程序可以通过刷新其 TTL 来保持租约活着，因此不会过期。$ etcdctl lease keep-alive 694d71ddacfda227

lease 694d71ddacfda227 keepalived with TTL(100)

...

复制查询租期应用程序可能想要了解租赁信息，以便它们可以续订或检查租赁是否仍然存在或已过期。应用程序也可能想知道特定租约所附的 key。假设我们完成了以下一系列操作：$ etcdctl lease grant 300

lease 694d71ddacfda22c granted with TTL(300s)

$ etcdctl put --lease=694d71ddacfda22c foo10 bar

复制获取有关租赁信息以及哪些 key 使用了租赁信息：$ etcdctl lease timetolive 694d71ddacfda22c

lease 694d71ddacfda22c granted with TTL(300s), remaining(282s)

$ etcdctl lease timetolive --keys 694d71ddacfda22c

lease 694d71ddacfda22c granted with TTL(300s), remaining(220s), attached keys([foo10])

复制6 etcd 安全运维etcd 支持通过 TLS 协议进行的加密通信。TLS 通道可用于对等体之间的加密内部群集通信以及加密的客户端流量。6.1 TLS 与 SSL互联网信息明文传播，带来了窃听风险，即第三方可以窃取通信内容；篡改风险，通信内容被篡改；冒充风险，身份被冒充，从而参与通信。通过 SSL/TLS 协议实现互联网的通信安全。SSL/TLS 协议可以解决上述提到的三个问题，通信加密，使得第三方无法窃听；校验机制防止篡改，一旦被篡改，通信双方会立刻发现；安全身份证书防止身份被冒充。TLS 是安全传输层协议，如果需要实现 HTTPS 加密访问，保障通信数据的安全，就需要 SSL 证书，下面我们开始实践如何实现 etcd 集群成员之间的通信。6.2 进行 TLS 加密实践为了进行实践，我们将会安装一些实用的命令行工具，这包括 cfssl、cfssljson。CFSSL 是 CloudFlare 的 PKI/TLS 工具，既是一个命令行工具，同时又可以用于签名，作为 HTTP API 服务器，验证和绑定 TLS 证书。它需要 Go 1.12+ 才能构建。环境配置如下：HostNameip客户端交互端口peer 通信端口etcd1192.168.202.12823792380etcd2192.168.202.12923792380etcd3192.168.202.130237923806.2.1 安装 cfssl$ ls ~/Downloads/cfssl

cfssl-certinfo_1.4.1_linux_amd64 cfssl_1.4.1_linux_amd64 cfssljson_1.4.1_linux_amd64

复制chmod +x cfssl_1.4.1_linux_amd64 cfssljson_1.4.1_linux_amd64 cfssl-certinfo_1.4.1_linux_amd64

mv cfssl_1.4.1_linux_amd64 /usr/local/bin/cfssl

mv cfssljson_1.4.1_linux_amd64 /usr/local/bin/cfssljson

mv cfssl-certinfo_1.4.1_linux_amd64 /usr/bin/cfssl-certinfo

复制安装完成之后，查看版本信息的结果：$ cfssl version

Version: 1.4.1

Runtime: go1.12.12

复制6.2.2 配置 CA 并创建 TLS 证书我们将使用 CloudFlare's PKI 工具 cfssl 来配置 PKI Infrastructure，然后使用它去创建 Certificate Authority（CA），并为 etcd 创建 TLS 证书。首先创建 ssl 配置目录：mkdir /data/etcd/{bin,cfg,ssl} -p

cd /data/etcd/ssl/

复制etcd ca 配置：cat << EOF | tee ca-config.json

{

"signing": {

"default": {

"expiry": "87600h"

"profiles": {

"etcd": {

"expiry": "87600h",

"usages": [

"signing",

"key encipherment",

"server auth",

"client auth"

]

}

EOF

复制etcd ca 证书：cat << EOF | tee ca-csr.json

{

"CN": "etcd CA",

"key": {

"algo": "rsa",

"size": 2048

"names": [

{

"C": "CN",

"L": "Shanghai",

"ST": "Shanghai"

}

]

}

EOF

复制生成 CA 凭证和私钥：$ cfssl gencert -initca ca-csr.json | cfssljson -bare ca

2020/04/30 20:36:58 [INFO] generating a new CA key and certificate from CSR

2020/04/30 20:36:58 [INFO] generate received request

2020/04/30 20:36:58 [INFO] received CSR

2020/04/30 20:36:58 [INFO] generating key: rsa-2048

2020/04/30 20:36:58 [INFO] encoded CSR

2020/04/30 20:36:58 [INFO] signed certificate with serial number 252821789025044258332210471232130931231440888312

$ ls

ca-config.json ca-csr.json ca-key.pem ca.csr ca.pem

复制etcd server 证书：cat << EOF | tee server-csr.json

{

"CN": "etcd",

"hosts": [

"192.168.202.128",

"192.168.202.129",

"192.168.202.130"

"key": {

"algo": "rsa",

"size": 2048

"names": [

{

"C": "CN",

"L": "Beijing",

"ST": "Beijing"

}

]

}

EOF

复制生成 server 证书：cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=etcd server-csr.json | cfssljson -bare server

2020/04/30 20:44:37 [INFO] generate received request

2020/04/30 20:44:37 [INFO] received CSR

2020/04/30 20:44:37 [INFO] generating key: rsa-2048

2020/04/30 20:44:37 [INFO] encoded CSR

2020/04/30 20:44:37 [INFO] signed certificate with serial number 73061688633166283265484923779818839258466531108

ca-config.json ca-csr.json ca-key.pem ca.csr ca.pem server-csr.json server-key.pem server.csr server.pem

复制启动 etcd 集群，命令的配置如下：#etcd1 启动

$ /data/etcd/bin/etcd --name etcd1 --initial-advertise-peer-urls https://192.168.202.128:2380 \

--listen-peer-urls https://192.168.202.128:2380 \

--listen-client-urls https://192.168.202.128:2379,https://127.0.0.1:2379 \

--advertise-client-urls https://192.168.202.128:2379 \

--initial-cluster-token etcd-cluster-1 \

--initial-cluster etcd1=https://192.168.202.128:2380, etcd2=https://192.168.202.129:2380, etcd3=https://192.168.202.130:2380 \

--initial-cluster-state new \

--client-cert-auth --trusted-ca-file=/data/etcd/ssl/ca.pem \

--cert-file=/opt/etcd/ssl/server.pem --key-file=/data/etcd/ssl/server-key.pem \

--peer-client-cert-auth --peer-trusted-ca-file=/data/etcd/ssl/ca.pem \

--peer-cert-file=/opt/etcd/ssl/server.pem --peer-key-file= /data/etcd/ssl/server-key.pem

#etcd2、etcd3 类似，此处省略

复制通过三台服务器的控制台可以知道，集群已经成功建立，我们进行验证：查看三个节点的健康状况，endpoint health ；其次，查看集群的成员列表，是否输出三个成员；最后，经过 TLS 加密的 etcd 集群，在进行操作时，需要加上认证相关的信息，尝试先写再读的操作是否能够正常。按照上述的步骤进行操作，这个验证的实践交给读者自行尝试。6.2.3 自动证书如果集群需要加密的通信但不需要经过身份验证的连接，则可以将 etcd 配置为自动生成其密钥。在初始化时，每个成员都基于其通告的 IP 地址和主机创建自己的密钥集。在每台机器上，etcd 将使用以下标志启动：$ etcd --name etcd1 --initial-advertise-peer-urls https://192.168.202.128:2380 \

--listen-peer-urls https://192.168.202.128:2380 \

--listen-client-urls https://192.168.202.128:2379,https://127.0.0.1:2379 \

--advertise-client-urls https://10.0.1.10:2379 \

--initial-cluster-token etcd-cluster-1 \

--initial-cluster infra0=https://192.168.202.128:2380,infra1=https://192.168.202.129:2380,infra2=https://192.168.202.130:2380 \

--initial-cluster-state new \

--auto-tls \

--peer-auto-tls

复制由于自动签发证书并不认证身份，因此直接 curl 会返回错误。需要使用 curl 的 -k 命令屏蔽对证书链的校验。7 小结etcd 具有极佳的稳定性、可靠性、可伸缩性，为云原生分布式系统提供了必要的协调机制。本文主要介绍了 etcd 的入门知识以及相关的实践。etcd 被设计为大型分布式系统的存储基石，etcd 以一致且容错的方式存储元数据。etcd 集群旨在提供具有稳定性、可靠性、可伸缩性和性能的键值存储。使用 etcd 的常见分布式场景包括领导者选举、键值对存储、分布式锁和消息订阅与发布等。实践是最好的学习方式，在看完本文之后，希望大家能够参照本文的介绍，进行相应的实践，期待你的讨论交流。本文参与腾讯云自媒体分享计划，分享自微信公众号。原始发表：2020-11-27，如有侵权请联系 cloudcommunity@tencent.com 删除etcd分布式raftSSL 证书存储本文分享自 aoho求索微信公众号，前往查看如有侵权，请联系 cloudcommunity@tencent.com 删除。本文参与腾讯云自媒体分享计划，欢迎热爱写作的你一起参与！etcd分布式raftSSL 证书存储评论登录后参与评论0 条评论热度最新登录后参与评论推荐阅读LV.关注文章0获赞0目录1 etcd 介绍2 etcd 应用场景2.1 键值对存储2.2 服务注册与发现2.3 消息发布与订阅2.4 分布式锁3 etcd 的多种安装方法3.1 etcd 概念词汇表3.2 etcd 单机安装部署3.2.1 二进制安装3.2.2 源码安装3.3 etcd 集群部署3.3.1 静态方式启动 etcd 集群3.3.2 docker 启动集群3.4 动态发现启动 etcd 集群3.4.1 协议的原理3.4.2 获取 discovery 的 token3.4.3 指定集群的大小3.4.4 公共发现服务3.4.5 以动态发现方式启动集群3.4.6 结果验证4 etcd v3 的架构解析5 etcdctl 的实践应用5.1 常用命令介绍5.2 数据库操作5.2.1 键操作5.2.2 watch 历史改动5.2.3 租约6 etcd 安全运维6.1 TLS 与 SSL6.2 进行 TLS 加密实践6.2.1 安装 cfssl6.2.2 配置 CA 并创建 TLS 证书6.2.3 自动证书7 小结相关产品与服务对象存储对象存储（Cloud Object Storage，COS）是由腾讯云推出的无目录层次结构、无数据格式限制，可容纳海量数据且支持 HTTP/HTTPS 协议访问的分布式存储服务。腾讯云 COS 的存储桶空间无容量上限，无需分区管理，适用于 CDN 数据分发、数据万象处理或大数据计算与分析的数据湖等多种场景。免费体验产品介绍产品文档COS新用户专享存储包低至1元，新老同享存储容量低至0.02元/GB/月，立即选购！

领券社区专栏文章阅读清单互动问答技术沙龙技术视频团队主页腾讯云TI平台活动自媒体分享计划邀请作者入驻自荐上首页技术竞赛资源技术周刊社区标签开发者手册开发者实验室关于社区规范免责声明联系我们友情链接腾讯云开发者扫码关注腾讯云开发者领取腾讯云代金券热门产品域名注册云服务器区块链服务消息队列网络加速云数据库域名解析云存储视频直播热门推荐人脸识别腾讯会议企业云CDN加速视频通话图像分析MySQL 数据库SSL 证书语音识别更多推荐数据安全负载均衡短信文字识别云点播商标注册小程序开发网站监控数据迁移Copyright © 2013 - 2024 Tencent Cloud. All Rights Reserved. 腾讯云版权所有深圳市腾讯计算机系统有限公司 ICP备案/许可证号：粤B2-20090059 深公网安备号 44030502008569腾讯云计算（北京）有限责任公司京ICP证150476号 | 京ICP备11018762号 | 京公网安备号11010802020287问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档Copyright © 2013 - 2024 Tencent Cloud.All Rights Reserved. 腾讯云版权所有登录后参与评论00

Introduction | etcd官方文档中文版

oduction | etcd官方文档中文版etcd官方文档中文版SearchCtrl + KIntroduction官方文档开发指南搭建本地集群和 etcd 交互核心 API 参考文档并发 API 参考文档gRPC 网关gRPC 命名和发现试验性的 API 和特性系统限制运维指南搭建 etcd 集群运行时重配置运行时重配置的设计搭建 etcd 网关在容器内运行 etcd 集群配置gRPC代理(TBD)L4 网关支持平台硬件推荐(TBD)性能评测调优(TBD)安全模式基于角色的访问控制(TBD)常见问题(TBD)监控(TBD)维护理解失败灾难恢复版本学习为什么是etcd理解数据模型理解API术语API保证认证子系统(TBD)核心 API 参考文档KV serviceRange方法Put方法DeleteRange方法Txn方法Compact方法Watch serviceWatch方法Lease serviceLeaseGrant方法LeaseRevoke方法LeaseKeepAlive方法LeaseTimeToLive方法并发 API 参考文档Lock serviceLock方法Unlock方法Election serviceCampaign方法Proclaim方法Leader方法Observe方法Resign方法全文标签总览Powered by GitBookIntroductionEtcd官方文档中文版.当前内容：官方文档(翻译)API参考文档(翻译)并发API参考文档(翻译)Next官方文档Last updated 5 years agoOn this p

讲真的，etcd 服务入门一篇文章足够了！ - 知乎

讲真的，etcd 服务入门一篇文章足够了！ - 知乎首发于民工哥专栏切换模式写文章登录/注册讲真的，etcd 服务入门一篇文章足够了！民工哥Etcd 是一个使用一致性哈希算法(Raft)在分布式环境下的 key/value 存储服务。利用 Etcd 的特性，应用程序可以在集群中共享信息、配置或作服务发现，Etcd 会在集群的各个节点中复制这些数据并保证这些数据始终正确。System Requirements >= 8v CPU + 16GB RAM + 50GB SSD安装使用静态就是在配置服务之前已经知道了节点的地址和集群的大小源码编译安装############################

# Build the latest version

############################

# 1.下载项目并编译

$ git clone https://github.com/etcd-io/etcd.git && cd etcd

$ ./build

To build a vendored etcd from the master branch via go get:

# 2.设置GOPATH环境变量

$ export GOPATH='/Users/example/go'

$ go get -v go.etcd.io/etcd

$ go get -v go.etcd.io/etcd/etcdctl

# 3.启动服务

$ ./bin/etcd

$ $GOPATH/bin/etcd

# 4.简单使用

$ ./bin/etcdctl put foo bar

部署单机单服务(静态)##################################

# Running etcd in standalone mode

##################################

# 1.设置启动的Node地址

$ export NODE1='172.16.176.52'

# 2.创建一个逻辑存储

$ docker volume create --name etcd-data

# 3.启动etcd服务

# 正式的ectd端口是2379用于客户端连接，而2380用于伙伴通讯

# --data-dir: 到数据目录的路径

# --initial-advertise-peer-urls: 集群中节点间通讯的URL地址

# --listen-peer-urls: 集群中节点间通讯的URL地址

# --advertise-client-urls: 客户端监听的URL地址

# --listen-client-urls: 客户端监听的URL地址

# --initial-cluster: 启动初始化集群配置

$ docker run -p 2379:2379 -p 2380:2380 --name etcd \

--volume=etcd-data:/etcd-data \

quay.io/coreos/etcd:latest \

/usr/local/bin/etcd \

--data-dir=/etcd-data --name node1 \

--initial-advertise-peer-urls http://${NODE1}:2380 \

--listen-peer-urls http://0.0.0.0:2380 \

--advertise-client-urls http://${NODE1}:2379 \

--listen-client-urls http://0.0.0.0:2379 \

--initial-cluster node1=http://${NODE1}:2380

# 4.列出现在集群中的服务状态

$ etcdctl --endpoints=http://${NODE1}:2379 member list

部署分布式集群服务(静态)################################

# Running a 3 node etcd cluster

################################

# node1

docker run -p 2379:2379 -p 2380:2380 --name etcd-node-1 \

--volume=/var/lib/etcd:/etcd-data \

quay.io/coreos/etcd:latest \

/usr/local/bin/etcd \

--data-dir=/etcd-data \

--initial-advertise-peer-urls "http://10.20.30.1:2380" \

--listen-peer-urls "http://0.0.0.0:2380" \

--advertise-client-urls "http://10.20.30.1:2379" \

--listen-client-urls "http://0.0.0.0:2379" \

--initial-cluster "etcd-node-1=http://10.20.30.1:2380, etcd-node-2=http://10.20.30.2:2380, etcd-node-3=http://10.20.30.3:2380" \

--initial-cluster-state "new" \

--initial-cluster-token "my-etcd-token"

# node2

docker run -p 2379:2379 -p 2380:2380 --name etcd-node-2 \

--volume=/var/lib/etcd:/etcd-data \

quay.io/coreos/etcd:latest \

/usr/local/bin/etcd \

--data-dir=/etcd-data \

--initial-advertise-peer-urls "http://10.20.30.2:2380" \

--listen-peer-urls "http://0.0.0.0:2380" \

--advertise-client-urls "http://10.20.30.2:2379" \

--listen-client-urls "http://0.0.0.0:2379" \

--initial-cluster "etcd-node-1=http://10.20.30.1:2380, etcd-node-2=http://10.20.30.2:2380, etcd-node-3=http://10.20.30.3:2380" \

--initial-cluster-state "new" \

--initial-cluster-token "my-etcd-token"

# node3

docker run -p 2379:2379 -p 2380:2380 --name etcd-node-3 \

--volume=/var/lib/etcd:/etcd-data \

quay.io/coreos/etcd:latest \

/usr/local/bin/etcd \

--data-dir=/etcd-data \

--initial-advertise-peer-urls "http://10.20.30.3:2380" \

--listen-peer-urls "http://0.0.0.0:2380" \

--advertise-client-urls "http://10.20.30.3:2379" \

--listen-client-urls "http://0.0.0.0:2379" \

--initial-cluster "etcd-node-1=http://10.20.30.1:2380, etcd-node-2=http://10.20.30.2:2380, etcd-node-3=http://10.20.30.3:2380" \

--initial-cluster-state "new" \

--initial-cluster-token "my-etcd-token"

# run etcdctl using API version 3

docker exec etcd /bin/sh -c "export ETCDCTL_API=3 && /usr/local/bin/etcdctl put foo bar"

部署分布式集群服务# 编辑docker-compose.yml文件

version: "3.6"

services:

node1:

image: quay.io/coreos/etcd

volumes:

- node1-data:/etcd-data

expose:

- 2379

- 2380

networks:

cluster_net:

ipv4_address: 172.16.238.100

environment:

- ETCDCTL_API=3

command:

- /usr/local/bin/etcd

- --data-dir=/etcd-data

- --name

- node1

- --initial-advertise-peer-urls

- http://172.16.238.100:2380

- --listen-peer-urls

- http://0.0.0.0:2380

- --advertise-client-urls

- http://172.16.238.100:2379

- --listen-client-urls

- http://0.0.0.0:2379

- --initial-cluster

- node1=http://172.16.238.100:2380,node2=http://172.16.238.101:2380,node3=http://172.16.238.102:2380

- --initial-cluster-state

- new

- --initial-cluster-token

- docker-etcd

node2:

image: quay.io/coreos/etcd

volumes:

- node2-data:/etcd-data

networks:

cluster_net:

ipv4_address: 172.16.238.101

environment:

- ETCDCTL_API=3

expose:

- 2379

- 2380

command:

- /usr/local/bin/etcd

- --data-dir=/etcd-data

- --name

- node2

- --initial-advertise-peer-urls

- http://172.16.238.101:2380

- --listen-peer-urls

- http://0.0.0.0:2380

- --advertise-client-urls

- http://172.16.238.101:2379

- --listen-client-urls

- http://0.0.0.0:2379

- --initial-cluster

- node1=http://172.16.238.100:2380,node2=http://172.16.238.101:2380,node3=http://172.16.238.102:2380

- --initial-cluster-state

- new

- --initial-cluster-token

- docker-etcd

node3:

image: quay.io/coreos/etcd

volumes:

- node3-data:/etcd-data

networks:

cluster_net:

ipv4_address: 172.16.238.102

environment:

- ETCDCTL_API=3

expose:

- 2379

- 2380

command:

- /usr/local/bin/etcd

- --data-dir=/etcd-data

- --name

- node3

- --initial-advertise-peer-urls

- http://172.16.238.102:2380

- --listen-peer-urls

- http://0.0.0.0:2380

- --advertise-client-urls

- http://172.16.238.102:2379

- --listen-client-urls

- http://0.0.0.0:2379

- --initial-cluster

- node1=http://172.16.238.100:2380,node2=http://172.16.238.101:2380,node3=http://172.16.238.102:2380

- --initial-cluster-state

- new

- --initial-cluster-token

- docker-etcd

volumes:

node1-data:

node2-data:

node3-data:

networks:

cluster_net:

driver: bridge

ipam:

driver: default

config:

subnet: 172.16.238.0/24

# 使用启动集群

docker-compose up -d

# 之后使用如下命令登录到任一节点测试etcd集群

docker exec -it node1 bash

# etcdctl member list

422a74f03b622fef, started, node1, http://172.16.238.100:2380, http://172.16.238.100:2379

ed635d2a2dbef43d, started, node2, http://172.16.238.101:2380, http://172.16.238.101:2379

daf3fd52e3583ffe, started, node3, http://172.16.238.102:2380, http://172.16.238.102:2379

etcd 常用配置参数--name #指定节点名称

--data-dir #指定节点的数据存储目录，用于保存日志和快照

--addr #公布的 IP 地址和端口；默认为 127.0.0.1:2379

--bind-addr #用于客户端连接的监听地址；默认为–addr 配置

--peers #集群成员逗号分隔的列表；例如 127.0.0.1:2380,127.0.0.1:2381

--peer-addr #集群服务通讯的公布的 IP 地址；默认为 127.0.0.1:2380

-peer-bind-addr #集群服务通讯的监听地址；默认为-peer-addr 配置

--wal-dir #指定节点的 wal 文件的存储目录，若指定了该参数 wal 文件会和其他数据文件分开存储

--listen-client-urls #监听 URL；用于与客户端通讯

--listen-peer-urls #监听 URL；用于与其他节点通讯

--initial-advertise-peer-urls #告知集群其他节点 URL

--advertise-client-urls #告知客户端 URL

--initial-cluster-token #集群的 ID

--initial-cluster #集群中所有节点

--initial-cluster-state new #表示从无到有搭建 etcd 集群

--discovery-srv #用于 DNS 动态服务发现，指定 DNS SRV 域名

--discovery #用于 etcd 动态发现，指定 etcd 发现服务的 URL

数据存储etcd 的数据存储有点像 PG 数据库的存储方式etcd 目前支持 V2 和 V3 两个大版本，这两个版本在实现上有比较大的不同，一方面是对外提供接口的方式，另一方面就是底层的存储引擎，V2 版本的实例是一个纯内存的实现，所有的数据都没有存储在磁盘上，而 V3 版本的实例就支持了数据的持久化。我们都知道 etcd 为我们提供了 key/value 的服务目录存储。# 设置键值对

$ etcdctl set name escape

# 获取方式

$ etcdctl get name

escape使用 etcd 之后，我们会疑问数据都存储到的那里呢？数据默认会存放在 /var/lib/etcd/default/ 目录。我们会发现数据所在的目录，会被分为两个文件夹中，分别是 snap 和 wal目录。snap存放快照数据，存储etcd的数据状态etcd防止WAL文件过多而设置的快照wal存放预写式日志最大的作用是记录了整个数据变化的全部历程在etcd中，所有数据的修改在提交前都要先写入到WAL中# 目录结构

$ tree /var/lib/etcd/default/

default

└── member

├── snap

│ ├── 0000000000000006-0000000000046ced.snap

│ ├── 0000000000000006-00000000000493fe.snap

│ ├── 0000000000000006-000000000004bb0f.snap

│ ├── 0000000000000006-000000000004e220.snap

│ └── 0000000000000006-0000000000050931.snap

└── wal

└── 0000000000000000-0000000000000000.wal

使用 WAL 进行数据的存储使得 etcd 拥有两个重要功能，那就是故障快速恢复和数据回滚/重做。故障快速恢复就是当你的数据遭到破坏时，就可以通过执行所有 WAL 中记录的修改操作，快速从最原始的数据恢复到数据损坏前的状态。数据回滚重做就是因为所有的修改操作都被记录在 WAL 中，需要回滚或重做，只需要方向或正向执行日志中的操作即可。既然有了 WAL 实时存储了所有的变更，为什么还需要 snapshot 呢？随着使用量的增加，WAL 存储的数据会暴增。为了防止磁盘很快就爆满，etcd 默认每 10000 条记录做一次 snapshot 操作，经过 snapshot 以后的 WAL 文件就可以删除。而通过 API 可以查询的历史 etcd 操作默认为 1000 条。首次启动时，etcd 会把启动的配置信息存储到 data-dir 参数指定的数据目录中。配置信息包括本地节点的ID、集群ID和初始时集群信息。用户需要避免 etcd 从一个过期的数据目录中重新启动，因为使用过期的数据目录启动的节点会与集群中的其他节点产生不一致。所以，为了最大化集群的安全性，一旦有任何数据损坏或丢失的可能性，你就应该把这个节点从集群中移除，然后加入一个不带数据目录的新节点。Raft 算法保证一致性的共识算法在每一个分布式系统中，etcd 往往都扮演了非常重要的地位，由于很多服务配置发现以及配置的信息都存储在 etcd 中，所以整个集群可用性的上限往往就是 etcd 的可用性，而使用 3 ~ 5 个 etcd 节点构成高可用的集群往往都是常规操作。正是因为 etcd 在使用的过程中会启动多个节点，如何处理几个节点之间的分布式一致性就是一个比较有挑战的问题了。解决多个节点数据一致性的方案其实就是共识算法，etcd 使用的就是 Raft 共识算法。Raft 从一开始就被设计成一个易于理解和实现的共识算法，它在容错和性能上与 Paxos 协议比较类似，区别在于它将分布式一致性的问题分解成了几个子问题，然后一一进行解决。每一个 Raft 集群中都包含多个服务器，在任意时刻，每一台服务器只可能处于 Leader、Follower 以及 Candidate 三种状态；在处于正常的状态时，集群中只会存在一个 Leader 状态，其余的服务器都是 Follower 状态。所有的 Follower 节点都是被动的，它们不会主动发出任何的请求，只会响应 Leader 和 Candidate 发出的请求。对于每一个用户的可变操作，都会被路由给 Leader 节点进行处理，除了 Leader 和 Follower 节点之外，Candidate 节点其实只是集群运行过程中的一个临时状态。Raft 集群中的时间也被切分成了不同的几个任期(Term)，每一个任期都会由 Leader 的选举开始，选举结束后就会进入正常操作的阶段，直到 Leader 节点出现问题才会开始新一轮的选择。每一个服务器都会存储当前集群的最新任期，它就像是一个单调递增的逻辑时钟，能够同步各个节点之间的状态，当前节点持有的任期会随着每一个请求被传递到其他的节点上。Raft 协议在每一个任期的开始时都会从一个集群中选出一个节点作为集群的 Leader 节点，这个节点会负责集群中的日志的复制以及管理工作。我们将 Raft 协议分成三个子问题：节点选举、日志复制以及安全性。服务发现服务发现是 etcd 服务的主要的用途之一服务发现要解决的也是分布式系统中最常见的问题之一，即在同一个分布式集群中的进程或服务，要如何才能找到对方并建立连接。本质上来说，服务发现就是想要了解集群中是否有进程在监听 UDP 或 TCP 端口，并且通过名字就可以查找和连接。要解决服务发现的问题，需要有下面三大支柱，缺一不可。一个强一致性、高可用的服务存储目录基于 Raft 算法的 etcd 天生就是这样一个强一致性高可用的服务存储目录一种注册服务和监控服务健康状态的机制用户可以在 etcd 中注册服务，并且对注册的服务设置 key TTL 值，定时保持服务的心跳以达到监控服务健康状态的效果。一种查找和连接服务的机制为了确保连接，我们可以在每个服务机器上都部署一个 Proxy 模式的 etcd，这样就可以确保能访问 etcd 集群的服务都能互相连接。日常开发集群管理功能中，如果要设计可以动态调整集群大小。那么首先就要支持服务发现，就是说当一个新的节点启动时，可以将自己的信息注册给 master，然后让 master 把它加入到集群里，关闭之后也可以把自己从集群中删除。etcd 提供了很好的服务注册与发现的基础功，我们采用 etcd 来做服务发现时，可以把精力用于服务本身的业务处理上。使用方法etcd 在键的组织上采用了层次化的空间结构，类似于文件系统中目录的概念，数据库操作围绕对键值和目录的 CRUD 完整生命周期的管理。etcdctl 是一个命令行的客户端，它提供了一下简洁的命令，可理解为命令工具集，可以方便我们在对服务进行测试或者手动修改数据库内容。etcdctl 与其他 xxxctl 的命令原理及操作类似，如 systemctl 等等。对象为键值对象为目录非数据库操作命令# 列出etcd集群中的实例

$ etcdctl member list

# 添加etcd集群中的实例

$ etcdctl member add <实例>

# 删除etcd集群中的实例

$ etcdctl member remove <实例>

# 更新etcd集群中的实例

$ etcdctl member update <实例>

etcdctl 常用配置参数--name #指定节点名称

灾备恢复Etcd 集群备份和数据恢复以及优化运维etcd 被设计为能承受集群自动从临时失败(例如机器重启)中恢复，而且对于一个有 N 个成员的集群能容许 (N-1)/2 的持续失败。当一个成员持续失败时，不管是因为硬件失败或者磁盘损坏，它丢失到集群的访问。如果集群持续丢失超过 (N-1)/2 的成员，则它只能悲惨的失败，无可救药的失去法定人数(quorum)。一旦法定人数丢失，集群无法达到一致性而导致无法继续接收更新。为了从灾难失败中恢复数据，etcd v3 提供快照和修复工具来重建集群而不丢失 v3 键数据。etcd 证书制作由于 v3 版本的 etcd 证书是基于 IP 的，所以每次新增 etcd 节点都需要重新制作证书。为了我们更方便的使用，可以查看这个链接来 etcd 证书制作。详情: https://github.com/cloudflare/cfssl。快照键空间恢复集群，首先需要来自 etcd 成员的键空间的快照。快速可以是用 etcdctl snapshot save 命令从活动成员中获取。或者是从 etcd 数据目录复制 member/snap/db 文件。例如，下列命令快照在 $ENDPOINT 上服务的键空间到文件 snapshot.db。# 集群备份etcd数据快照

# $ENDPOINT => http://10.20.30.1:2379

$ ETCDCTL_API=3 etcdctl --endpoints $ENDPOINT snapshot save snapshot.db

# 在单节点etcd上执行下面的命令就可以对etcd进行数据备份

# 每两个小时备份一次数据并上传到S3上，并保留最近两天的数据

$ ETCDCTL_API=3 etcdctl snapshot save /var/lib/etcd_backup/etcd_$(date "+%Y%m%d%H%M%S").db

恢复集群为了恢复集群，使用之前任意节点上备份的快照 "db" 文件。恢复的手，可以使用 etcdctl snapshot restore 命令来恢复 etcd 数据目录，此时所有成员应该使用相同的快照恢复。因为恢复数据死后，会覆盖某些快照元数据(特别是成员ID和集群ID)信息，集群内的成员可能会丢失它之前的标识。因此为了从快照启动集群，恢复必须启动一个新的逻辑集群。在恢复时，快照完整性的检验是可选的。如果快照是通过 etcdctl snapshot save 得到的话，使用 etcdctl snapshot restore 命令恢复的时候，会检查 hash 值的完整性。如果快照是从数据目录复制而来，则没有完整性校验，因此它只能通过使用 --skip-hash-check 来恢复。下面为一个 3 成员的集群创建新的 etcd 数据目录：$ etcdctl snapshot restore snapshot.db \

--name m1 \

--initial-cluster m1=http:/host1:2380,m2=http://host2:2380,m3=http://host3:2380 \

--initial-cluster-token etcd-cluster-1 \

--initial-advertise-peer-urls http://host1:2380

$ etcdctl snapshot restore snapshot.db \

--name m2 \

--initial-cluster m1=http:/host1:2380,m2=http://host2:2380,m3=http://host3:2380 \

--initial-cluster-token etcd-cluster-1 \

--initial-advertise-peer-urls http://host2:2380

$ etcdctl snapshot restore snapshot.db \

--name m3 \

--initial-cluster m1=http:/host1:2380,m2=http://host2:2380,m3=http://host3:2380 \

--initial-cluster-token etcd-cluster-1 \

--initial-advertise-peer-urls http://host3:2380

下一步, 用新的数据目录启动 etcd 服务，现在恢复的集群可以使用并提供来自快照的键空间服务。$ etcd \

--name m1 \

--listen-client-urls http://host1:2379 \

--advertise-client-urls http://host1:2379 \

--listen-peer-urls http://host1:2380 &

$ etcd \

--name m2 \

--listen-client-urls http://host2:2379 \

--advertise-client-urls http://host2:2379 \

--listen-peer-urls http://host2:2380 &

$ etcd \

--name m3 \

--listen-client-urls http://host3:2379 \

--advertise-client-urls http://host3:2379 \

--listen-peer-urls http://host3:2380 &

作者: Escape 原文：https://escapelife.github.io/posts/90d30a1e.html推荐阅读最新、最全、最详细的 K8S 学习笔记总结（2021最新版）最新、最全、最详细的 MySQL 数据库学习笔记总结（2021最新版）备战金三银四跳槽季！面试准备与面试题总结已撸完（Linux系统运维篇）！分享一些技术资料（架构、数据库、java等），建议收藏！强大，10k+点赞的 SpringBoot 后台管理系统竟然出了详细教程！分享一套基于SpringBoot和Vue的企业级中后台开源项目，代码很规范！能挣钱的，开源 SpringBoot 商城系统，功能超全，超漂亮！如有错误或其它问题，欢迎小伙伴留言评论、指正。如有帮助，欢迎点赞+转发分享。更多相关开源技术文章，请持续关注：民工哥知乎技术专栏发布于 2021-05-08 10:40etcd分布式存储程序员赞同 61 条评论分享喜欢收藏申请转载文章被以下专栏收录民工哥专栏专注IT互联网开源技

一文看懂 etcd 是什么？了解 K8s etcd 的作用

Skip to content精选链接服务支持控制台开发人员开始试用

全部内容面向客户客户支持文档支持案例订阅管理红帽生态系统目录查找合作伙伴面向合作伙伴合作伙伴门户合作伙伴支持成为合作伙伴试用购买与出售红帽市场红帽商店联系销售代表开始试用学习资源培训和认证面向开发人员混合云学习中心互动实验室学习社区红帽 TV开源社区Ansible面向系统管理员面向架构师Red Hat产品解决方案培训与服务资源合作伙伴关于红帽了解更多平台产品红帽企业 Linux使用灵活、稳定的操作系统支持混合云创新。

红帽 OpenShift用于大规模构建、现代化和部署应用的容器平台。

红帽 Ansible 自动化平台实施企业级自动化的基础。

试用与购买开始试用通过免费试用评估产品。

在线购买在红帽商店选购产品和服务。

与主要云提供商集成使用提供商的承诺支出购买红帽解决方案，包括:

精选云服务快速构建、部署和扩展应用。剩下的都交给我们。

AWS 上的红帽 OpenShift 服务

红帽 OpenShift AI

微软 Azure 红帽 OpenShift

查看所有云服务

查看所有产品

类别

应用平台

人工智能

边缘计算

IT 自动化

Linux 标准化

机构类型

汽车行业

金融服务

医疗保健

工业部门

媒体娱乐

公共部门

电信行业

客户案例

英国陆军

阿根廷电力公司 Edenor

HCA 医疗保健公司

麦格理银行

塔塔咨询服务有限公司

美国联合包裹服务公司 UPS

查看所有成功案例

了解服务详情

服务

咨询服务

开放创新实验室

技术客户经理服务

培训 & 认证

全部课程

所有认证

验证认证

技能评估

培训订阅服务

培训社区

红帽院校合作

常见问题

联系培训专家

特色产品

红帽系统管理一 (RH124)

红帽 OpenShift 管理一 (DO280)

红帽认证工程师 (RHCE)

了解服务与支持

主题

应用现代化

自动化

云计算

云原生应用

容器

DevOps

边缘计算

Linux

虚拟化

查看所有主题

文章

什么是云服务？

什么是边缘计算？

什么是混合云？

造云大计，为什么选择红帽？

云 VS 边缘，关系与区别是什么？

红帽 OpenShift vs. Kubernetes

Ansible 入门基础教程

什么是 Linux 系统？

了解更多

博客

客户成功案例

活动和网络研讨会

新闻中心

播客和视频系列

资源库

培训和认证

浏览资源

面向客户

我们的合作伙伴

红帽生态系统目录

查找合作伙伴

面向合作伙伴

Partner Connect

成为合作伙伴

培训

服务支持

访问合作伙伴门户

关于红帽

公司介绍

企业文化

社会责任

发展模式

订阅模式

产品支持

开源

开源承诺

我们参与贡献的方式

红帽 GitHub

公司信息

行业分析师关系

博客

全球办事处

新闻中心

社区

Ansible

面向系统管理员

面向架构师

客户倡导计划

进一步了解红帽

联系我们

面向客户客户支持文档支持案例订阅管理红帽生态系统目录查找合作伙伴面向合作伙伴合作伙伴门户合作伙伴支持成为合作伙伴试用购买与出售红帽市场红帽商店联系销售代表开始试用学习资源培训和认证面向开发人员混合云学习中心互动实验室学习社区红帽 TV开源社区Ansible面向系统管理员面向架构师

etcd 快速入门 - 知乎

etcd 快速入门 - 知乎首发于ETCD切换模式写文章登录/注册etcd 快速入门chapin666Talk is cheap, show me the code.一、认识etcd1.1 etcd 概念从哪里说起呢？官网第一个页面，有那么一句话："A distributed, reliable key-value store for the most critical data of a distributed system"即 etcd 是一个分布式、可靠 key-value 存储的分布式系统。当然，它不仅仅用于存储，还提供共享配置及服务发现。1.2 etcd vs Zookeeper提供配置共享和服务发现的系统比较多，其中最为大家熟知的是 Zookeeper，而 etcd 可以算得上是后起之秀了。在项目实现、一致性协议易理解性、运维、安全等多个维度上，etcd 相比 zookeeper 都占据优势。本文选取 Zookeeper 作为典型代表与 etcd 进行比较，而不考虑 Consul 项目作为比较对象，原因为 Consul 的可靠性和稳定性还需要时间来验证（项目发起方自身服务并未使用Consul，自己都不用)。一致性协议： etcd 使用 Raft 协议，Zookeeper 使用 ZAB（类PAXOS协议），前者容易理解，方便工程实现；运维方面：etcd 方便运维，Zookeeper 难以运维；数据存储：etcd 多版本并发控制（MVCC）数据模型，支持查询先前版本的键值对项目活跃度：etcd 社区与开发活跃，Zookeeper 感觉已经快死了； API：etcd 提供 HTTP+JSON, gRPC 接口，跨平台跨语言，Zookeeper 需要使用其客户端；访问安全方面：etcd 支持 HTTPS 访问，Zookeeper 在这方面缺失； ...1.3 etcd 应用场景etcd 比较多的应用场景是用于服务发现，服务发现 (Service Discovery) 要解决的是分布式系统中最常见的问题之一，即在同一个分布式集群中的进程或服务如何才能找到对方并建立连接。和 Zookeeper 类似，etcd 有很多使用场景，包括：配置管理服务注册发现选主应用调度分布式队列分布式锁1.4 etcd 工作原理1.4.1 如何保证一致性etcd 使用 raft 协议来维护集群内各个节点状态的一致性。简单说，etcd 集群是一个分布式系统，由多个节点相互通信构成整体对外服务，每个节点都存储了完整的数据，并且通过 Raft 协议保证每个节点维护的数据是一致的。每个 etcd 节点都维护了一个状态机，并且，任意时刻至多存在一个有效的主节点。主节点处理所有来自客户端写操作，通过 Raft 协议保证写操作对状态机的改动会可靠的同步到其他节点。1.4.2 数据模型etcd 的设计目标是用来存放非频繁更新的数据，提供可靠的 Watch插件，它暴露了键值对的历史版本，以支持低成本的快照、监控历史事件。这些设计目标要求它使用一个持久化的、多版本的、支持并发的数据数据模型。当 etcd 键值对的新版本保存后，先前的版本依然存在。从效果上来说，键值对是不可变的，etcd 不会对其进行 in-place 的更新操作，而总是生成一个新的数据结构。为了防止历史版本无限增加，etcd 的存储支持压缩（Compact）以及删除老旧版本。逻辑视图从逻辑角度看，etcd 的存储是一个扁平的二进制键空间，键空间有一个针对键（字节字符串）的词典序索引，因此范围查询的成本较低。键空间维护了多个修订版本（Revisions），每一个原子变动操作（一个事务可由多个子操作组成）都会产生一个新的修订版本。在集群的整个生命周期中，修订版都是单调递增的。修订版同样支持索引，因此基于修订版的范围扫描也是高效的。压缩操作需要指定一个修订版本号，小于它的修订版会被移除。一个键的一次生命周期（从创建到删除）叫做 “代 (Generation)”，每个键可以有多个代。创建一个键时会增加键的版本（version），如果在当前修订版中键不存在则版本设置为1。删除一个键会创建一个墓碑（Tombstone），将版本设置为0，结束当前代。每次对键的值进行修改都会增加其版本号 — 在同一代中版本号是单调递增的。当压缩时，任何在压缩修订版之前结束的代，都会被移除。值在修订版之前的修改记录（仅仅保留最后一个）都会被移除。物理视图etcd 将数据存放在一个持久化的 B+ 树中，处于效率的考虑，每个修订版仅仅存储相对前一个修订版的数据状态变化（Delta）。单个修订版中可能包含了 B+ 树中的多个键。键值对的键，是三元组（major，sub，type）：major：存储键值的修订版sub：用于区分相同修订版中的不同键type：用于特殊值的可选后缀，例如 t 表示值包含墓碑键值对的值，包含从上一个修订版的 Delta。B+ 树 —— 键的词法字节序排列，基于修订版的范围扫描速度快，可以方便的从一个修改版到另外一个的值变更情况查找。etcd 同时在内存中维护了一个 B 树索引，用于加速针对键的范围扫描。索引的键是物理存储的键面向用户的映射，索引的值则是指向 B+ 树修该点的指针。1.5 etcd 读写性能按照官网给出的数据，在 2CPU，1.8G 内存，SSD 磁盘这样的配置下，单节点的写性能可以达到 16K QPS, 而先写后读也能达到12K QPS。这个性能还是相当可观。1.6 etcd 术语二、安装和运行构建需要Go 1.9以上版本：cd $GOPATH/src

mkdir go.etcd.io && cd go.etcd.io

git clone https://github.com/etcd-io/etcd.git

cd etcd

./build使用 build 脚本构建会在当前项目的 bin 目录生产 etcd 和 etcdctl 可执行程序。etcd 就是 etcd server 了，etcdctl 主要为 etcd server 提供了命令行操作。静态集群如果Etcd集群成员是已知的，具有固定的IP地址，则可以静态的初始化一个集群。每个节点都可以使用如下环境变量：ETCD_INITIAL_CLUSTER="radon=http://10.0.2.1:2380,neon=http://10.0.3.1:2380"

ETCD_INITIAL_CLUSTER_STATE=new或者如下命令行参数--initial-cluster radon=http://10.0.2.1:2380,neon=http://10.0.3.1:2380

--initial-cluster-state new来指定集群成员。初始化集群完整的命令行示例：etcd --name radon --initial-advertise-peer-urls http://10.0.2.1:2380

--listen-peer-urls http://10.0.2.1:2380

--listen-client-urls http://10.0.2.1:2379,http://127.0.0.1:2379

--advertise-client-urls http://10.0.2.1:2380

# 所有以-initial-cluster开头的选项，在第一次运行（Bootstrap）后都被忽略

--initial-cluster-token etcd.gmem.cc

--initial-cluster radon=http://10.0.2.1:2380,neon=http://10.0.3.1:2380

--initial-cluster-state new使用TLSEtcd支持基于TLS加密的集群内部、客户端-集群通信。每个集群节点都应该拥有被共享CA签名的证书：# 密钥对、证书签名请求

openssl genrsa -out radon.key 2048

export SAN_CFG=$(printf "\n[SAN]\nsubjectAltName=IP:127.0.0.1,IP:10.0.2.1,DNS:radon.gmem.cc")

openssl req -new -sha256 -key radon.key -out radon.csr \

-subj "/C=CN/ST=BeiJing/O=Gmem Studio/CN=Server Radon" \

-reqexts SAN -config <(cat /etc/ssl/openssl.cnf <(echo $SAN_CFG))

# 执行签名

openssl x509 -req -sha256 -in radon.csr -out radon.crt -CA ../ca.crt -CAkey ../ca.key -CAcreateserial -days 3650 \

-extensions SAN -extfile <(echo "${SAN_CFG}")初始化集群命令需要修改为： etcd --name radon --initial-advertise-peer-urls https://10.0.2.1:2380

--listen-peer-urls https://10.0.2.1:2380

--listen-client-urls https://10.0.2.1:2379,https://127.0.0.1:2379

--advertise-client-urls https://10.0.2.1:2380

# 所有以-initial-cluster开头的选项，在第一次运行（Bootstrap）后都被忽略

--initial-cluster-token etcd.gmem.cc

--initial-cluster radon=https://10.0.2.1:2380,neon=https://10.0.3.1:2380 # 指定集群成员列表

--initial-cluster-state new # 初始化新集群时使用

--initial-cluster-state existing # 加入已有集群时使用

# 客户端TLS相关参数

--client-cert-auth

--trusted-ca-file=/usr/share/ca-certificates/GmemCA.crt

--cert-file=/opt/etcd/cert/radon.crt

--key-file=/opt/etcd/cert/radon.key

# 集群内部TLS相关参数

--peer-client-cert-auth

--peer-trusted-ca-file=/usr/share/ca-certificates/GmemCA.crt

--peer-cert-file=/opt/etcd/cert/radon.crt

--peer-key-file=/opt/etcd/cert/radon.key三、与 etcd 交互etcd 提供了 etcdctl 命令行工具和 HTTP API 两种交互方法。etcdctl命令行工具用 go 语言编写，也是对 HTTP API 的封装，日常使用起来也更容易。所以这里我们主要使用 etcdctl 命令行工具演示。put应用程序通过 put 将 key 和 value 存储到 etcd 集群中。每个存储的密钥都通过 Raft 协议复制到所有 etcd 集群成员，以实现一致性和可靠性。这里是设置键的值的命令 foo 到 bar：$ etcdctl put foo bar

OKget应用程序可以从一个 etcd 集群中读取 key 的值。假设 etcd 集群已经存储了以下密钥：foo = bar

foo1 = bar1

foo2 = bar2

foo3 = bar3

a = 123

b = 456

z = 789读取键为 foo 的命令：$ etcdctl get foo

foo // key

bar // value上面同时返回了 key 和 value，怎么只读取 key 对应的值呢：$ etcdctl get foo --print-value-only

bar以十六进制格式读取键为foo的命令：$ etcdctl get foo --hex

\x66\x6f\x6f

\x62\x61\x72查询可以读取单个key，也可以读取一系列key：$ etcdctl get foo foo3

foo

bar

foo1

bar1

foo2

bar2 请注意，foo3由于范围超过了半开放时间间隔 [foo, foo3)，因此不包括在内foo3。按前缀读取：$ etcdctl get --prefix foo

foo

bar

foo1

bar1

foo2

bar2

foo3

bar3按结果数量限制读取$ etcdctl get --limit=2 --prefix foo

foo

bar

foo1

bar1读取大于或等于指定键的字节值的键：$ etcdctl get --from-key b

456

789应用程序可能希望通过访问早期版本的 key 来回滚到旧配置。由于对 etcd 集群键值存储区的每次修改都会增加一个 etcd 集群的全局修订版本，因此应用程序可以通过提供旧的 etcd 修订版来读取被取代的键。假设一个 etcd 集群已经有以下 key：foo = bar # revision = 2

foo1 = bar1 # revision = 3

foo = bar_new # revision = 4

foo1 = bar1_new # revision = 5以下是访问以前版本 key 的示例：$ etcdctl get --prefix foo # 访问最新版本的key

foo

bar_new

foo1

bar1_new

$ etcdctl get --prefix --rev=4 foo # 访问第4个版本的key

foo

bar_new

foo1

bar1

$ etcdctl get --prefix --rev=3 foo # 访问第3个版本的key

foo

bar

foo1

bar1

$ etcdctl get --prefix --rev=2 foo # 访问第3个版本的key

foo

bar

$ etcdctl get --prefix --rev=1 foo # 访问第1个版本的keydel应用程序可以从一个 etcd 集群中删除一个 key 或一系列 key。假设一个 etcd 集群已经有以下key：foo = bar

foo1 = bar1

foo3 = bar3

zoo = val

zoo1 = val1

zoo2 = val2

a = 123

b = 456

z = 789删除 key 为 foo 的命令：$ etcdctl del foo

1删除键值对的命令：$ etcdctl del --prev-kv zoo

zoo

val删除从 foo 到 foo9 的命令：$ etcdctl del foo foo9

2删除具有前缀的键的命令：$ etcdctl del --prefix zoo

2删除大于或等于键的字节值的键的命令:$ etcdctl del --from-key b

2watch应用程序可以使用watch观察一个键或一系列键来监视任何更新。打开第一个终端，监听 foo的变化，我们输入如下命令：$ etcdctl watch foo再打开另外一个终端来对 foo 进行操作：$ etcdctl put foo 123

$ etcdctl put foo 456

$ ./etcdctl del foo

1第一个终端结果如下：$ etcdctl watch foo

PUT

foo

123

PUT

foo

456

DELETE

foo除了以上基本操作，watch 也可以像 get、del 操作那样使用 prefix、rev、 hex等参数，这里就不一一列举了。lock Distributed locks: 分布式锁，一个人操作的时候，另外一个人只能看，不能操作 lock 可以通过指定的名字加锁。注意，只有当正常退出且释放锁后，lock命令的退出码是0，否则这个锁会一直被占用直到过期（默认60秒）在第一个终端输入如下命令：$ etcdctl lock mutex1

mutex1/326963a02758b52d在第二个终端输入同样的命令：$ etcdctl lock mutex1从上可以发现第二个终端发生了阻塞，并未返回像 mutex1/326963a02758b52d 的字样。此时我们需要结束第一个终端的 lock ，可以使用 Ctrl+C 正常退出lock命令。第一个终端 lock 退出后，第二个终端的显示如下：$ etcdctl lock mutex1

mutex1/694d6ee9ac069436txntxn 从标准输入中读取多个请求，将它们看做一个原子性的事务执行。事务是由条件列表，条件判断成功时的执行列表（条件列表中全部条件为真表示成功）和条件判断失败时的执行列表（条件列表中有一个为假即为失败）组成的。$ etcdctl put user frank

$ ./etcdctl txn -i

compares:

value("user") = "frank"

success requests (get, put, del):

put result ok

failure requests (get, put, del):

put result failed

SUCCESS

$ etcdctl get result

result

ok解释如下：先使用 etcdctl put user frank 设置 user 为 franketcdctl txn -i 开启事务（-i表示交互模式）第2步输入命令后回车，终端显示出 compares：输入 value("user") = "frank"，此命令是比较 user 的值与 frank 是否相等第 4 步完成后输入回车，终端会换行显示，此时可以继续输入判断条件（前面说过事务由条件列表组成），再次输入回车表示判断条件输入完毕第 5 步连续输入两个回车后，终端显示出 success requests (get, put, delete):，表示下面输入判断条件为真时要执行的命令与输入判断条件相同，连续两个回车表示成功时的执行列表输入完成终端显示 failure requests (get, put, delete)：后输入条件判断失败时的执行列表为了看起来简洁，此实例中条件列表和执行列表只写了一行命令，实际可以输入多行总结上面的事务，要做的事情就是 user 为 frank 时设置 result 为 ok，否则设置 result 为 failed事务执行完成后查看 result 值为 okcompact正如我们所提到的，etcd保持修改，以便应用程序可以读取以前版本的 key。但是，为了避免累积无限的历史，重要的是要压缩过去的修订版本。压缩后，etcd删除历史版本，释放资源供将来使用。在压缩版本之前所有被修改的数据都将不可用。$ etcdctl compact 5

compacted revision 5

$ etcdctl get --rev=4 foo

Error: etcdserver: mvcc: required revision has been compactedlease 与 TTLetcd 也能为 key 设置超时时间，但与 redis 不同，etcd 需要先创建 lease，然后 put 命令加上参数 –lease= 来设置。lease 又由生存时间（TTL）管理，每个租约都有一个在授予时间由应用程序指定的最小生存时间（TTL）值。以下是授予租约的命令：$ etcdctl lease grant 30

lease 694d6ee9ac06945d granted with TTL(30s)

$ etcdctl put --lease=694d6ee9ac06945d foo bar

OK以下是撤销同一租约的命令：$ etcdctl lease revoke 694d6ee9ac06945d

lease 694d6ee9ac06945d revoked

$ etcdctl get foo应用程序可以通过刷新其TTL来保持租约活着，因此不会过期。假设我们完成了以下一系列操作：$ etcdctl lease grant 10

lease 32695410dcc0ca06 granted with TTL(10s)以下是保持同一租约有效的命令：$ etcdctl lease keep-alive 32695410dcc0ca06

lease 32695410dcc0ca06 keepalived with TTL(10)

...应用程序可能想要了解租赁信息，以便它们可以续订或检查租赁是否仍然存在或已过期。应用程序也可能想知道特定租约所附的 key。假设我们完成了以下一系列操作：$ etcdctl lease grant 200

lease 694d6ee9ac06946a granted with TTL(200s)

$ etcdctl put demo1 val1 --lease=694d6ee9ac06946a

$ etcdctl put demo2 val2 --lease=694d6ee9ac06946a

OK以下是获取有关租赁信息的命令：$ etcdctl lease timetolive 694d6ee9ac06946a

lease 694d6ee9ac06946a granted with TTL(200s), remaining(178s)以下是获取哪些 key 使用了租赁信息的命令：$ etcdctl lease timetolive --keys 694d6ee9ac06946a

lease 694d6ee9ac06946a granted with TTL(200s), remaining(129s), attached keys([demo1 demo2])四、服务发现实战如果有一个让系统可以动态调整集群大小的需求，那么首先就要支持服务发现。就是说当一个新的节点启动时，可以将自己的信息注册到 master，让 master 把它加入到集群里，关闭之后也可以把自己从集群中删除。这个情况，其实就是一个 membership protocol，用来维护集群成员的信息。整个代码的逻辑很简单，worker 启动时向 etcd 注册自己的信息，并设置一个带 TTL 的租约，每隔一段时间更新这个 TTL，如果该 worker 挂掉了，这个 TTL 就会 expire 并删除相应的 key。发现服务监听 workers/ 这个 etcd directory，根据检测到的不同 action 来增加，更新，或删除 worker。首先我们要建立一个 etcd client：func NewMaster(endpoints []string) *Master {

// etcd 配置

cfg := client.Config{

Endpoints: endpoints,

DialTimeout: 5 * time.Second,

}

// 创建 etcd 客户端

etcdClient, err := client.New(cfg)

if err != nil {

log.Fatal("Error: cannot connect to etcd: ", err)

}

// 创建 master

master := &Master{

members: make(map[string]*Member),

API: etcdClient,

}

return master

}

这里我们先建立一个 etcd client，然后把它的 key API 放进 master 里面，这样我们以后只需要通过这个 API 来跟 etcd 进行交互。Endpoints 是指 etcd 服务器们的地址，如 ”http://127.0.0.1:2379“ 等。go master.WatchWorkers() 这一行启动一个 Goroutine 来监控节点的情况。下面是 WatchWorkers 的代码:func (master *Master) WatchWorkers() {

// 创建 watcher channel

watcherCh := master.API.Watch(context.TODO(), "workers", client.WithPrefix())

// 从 chanel 取数据

for wresp := range watcherCh {

for _, ev := range wresp.Events {

key := string(ev.Kv.Key)

if ev.Type.String() == "PUT" { // put 方法

info := NodeToWorkerInfo(ev.Kv.Value)

if _, ok := master.members[key]; ok {

log.Println("Update worker ", info.Name)

master.UpdateWorker(key,info)

} else {

log.Println("Add worker ", info.Name)

master.AddWorker(key, info)

}

} else if ev.Type.String() == "DELETE" { // del 方法

log.Println("Delete worker ", key)

delete(master.members, key)

}

worker 这边也跟 master 类似，保存一个 etcd KeysAPI，通过它与 etcd 交互，然后用 heartbeat 来保持自己的状态，在 heartbeat 定时创建租约，如果租用失效，master 将会收到 delete 事件。代码如下：func NewWorker(name, IP string, endpoints []string) *Worker {

// etcd 配置

cfg := client.Config {

Endpoints: endpoints,

DialTimeout: 5 * time.Second,

}

// 创建 etcd 客户端

etcdClient, err := client.New(cfg)

if err != nil {

log.Fatal("Error: cannot connect to etcd: ", err)

}

// 创建 worker

worker := &Worker {

Name: name,

IP: IP,

API: etcdClient,

}

return worker

}

func (worker *Worker) HeartBeat() {

for {

// worker info

info := &WorkerInfo{

Name: worker.Name,

IP: worker.IP,

CPU: runtime.NumCPU(),

}

key := "workers/" + worker.Name

value, _ := json.Marshal(info)

// 创建 lease

leaseResp, err := worker.API.Lease.Grant(context.TODO(), 10)

if err != nil {

log.Fatalf("设置租约时间失败:%s\n", err.Error())

}

// 创建 watcher channel

_, err = worker.API.Put(context.TODO(), key, string(value), client.WithLease(leaseResp.ID))

if err != nil {

log.Println("Error update workerInfo:", err)

}

time.Sleep(time.Second * 3)

}

启动的时候需要有多个 worker 节点（至少一个）和一个 master 节点，所以我们在启动程序的时候，可以传递一个 “role” 参数。代码如下：var role = flag.String("role", "", "master | worker")

flag.Parse()

endpoints := []string{"http://127.0.0.1:2379"}

if *role == "master" {

master := discovery.NewMaster(endpoints)

master.WatchWorkers()

} else if *role == "worker" {

worker := discovery.NewWorker("localhost", "127.0.0.1", endpoints)

worker.HeartBeat()

} else {

...

}

项目地址： https://github.com/chapin666/etcd-service-discovery五、总结etcd 默认只保存 1000 个历史事件，所以不适合有大量更新操作的场景，这样会导致数据的丢失。etcd 典型的应用场景是配置管理和服务发现，这些场景都是读多写少的。相比于 zookeeper，etcd 使用起来要简单很多。不过要实现真正的服务发现功能，etcd 还需要和其他工具（比如 registrator、confd 等）一起使用来实现服务的自动注册和更新。编辑于 2019-12-10 09:19分布式系统分布式计算赞同 1025 条评论分享喜欢收藏申请转载文章被以下专栏收录E

GitHub - etcd-io/etcd: Distributed reliable key-value store for the most critical data of a distributed system

Toggle navigation

Product

Actions

Automate any workflow

Packages

Host and manage packages

Security

Find and fix vulnerabilities

Codespaces

Instant dev environments

Copilot

Write better code with AI

Code review

Manage code changes

Issues

Plan and track work

Discussions

Collaborate outside of code

Explore

All features

Documentation

GitHub Skills

Blog

Solutions

For

Enterprise

Teams

Startups

Education

By Solution

CI/CD & Automation

DevOps

DevSecOps

Resources

Learning Pathways

White papers, Ebooks, Webinars

Customer Stories

Partners

Open Source

GitHub Sponsors

Fund open source developers

The ReadME Project

GitHub community articles

Repositories

Topics

Trending

Collections

Pricing

Search or jump to...

Search code, repositories, users, issues, pull requests...

Clear

Search syntax tips

Provide feedback

We read every piece of feedback, and take your input very seriously.

Include my email address so I can be contacted

Cancel

Submit feedback

Saved searches

Use saved searches to filter your results more quickly

Name

Query

To see all available qualifiers, see our documentation.

Cancel

Create saved search

You signed in with another tab or window. Reload to refresh your session.

You signed out in another tab or window. Reload to refresh your session.

You switched accounts on another tab or window. Reload to refresh your session.

Dismiss alert

etcd-io

etcd

Public

Notifications

Fork

9.5k

Star

46k

Distributed reliable key-value store for the most critical data of a distributed system

etcd.io

License

Apache-2.0 license

46k

stars

9.5k

forks

Branches

什么是 etcd？ | IBM

什么是 etcd？

了解有关 etcd 的更多信息；etcd 是一种容错式开源键值数据库，可用作 Kubernetes 和其他分布式平台的主要数据支柱。

订阅 IBM 时事通讯

什么是 etcd？

etcd 是一种开源的分布式键值存储库，用于保存和管理分布式系统保持运行所需的关键信息。最值得注意的是，它可以管理 Kubernetes（流行的容器编排平台）的配置数据、状态数据和元数据。

与所有分布式工作负载一样，容器化工作负载也具有复杂的管理要求，而且这些要求随着工作负载的扩展而变得更加复杂。 Kubernetes 通过跨所有集群（可在多个地点的多台机器上运行）协调配置、部署、服务发现、负载均衡、作业调度和运行状况监控等任务，简化了这些工作负载的管理过程。

但为了实现这种协调，Kubernetes 需要一个数据存储库，可在任一给定时间点提供有关系统状态（包括所有集群和 Pod 以及其中的应用实例）的单一且一致的事实来源。 etcd 是用于创建和维护此事实版本的数据存储库。

对于 Cloud Foundry（链接位于 ibm.com 外部，这是一个开源的多云平台即服务 (PaaS)），etcd 发挥着类似的作用，并且可用于跨任何分布式应用集群来协调关键系统和元数据。 “etcd”这个名字源自 Linux 目录结构中的命名约定：在 UNIX 中，单个系统的所有系统配置文件都包含在一个名为“/etc”的文件夹中；“d”代表“分布式”。

观看视频“什么是 etcd？”(6:09)，以深入了解 etcd：

为何选择 etcd？

etcd 作为保持分布式工作负载运行的数据支柱，它的作用不容小觑。 etcd 正是为这个任务而构建的，它采用全新的设计，具有以下特性：

完全复制：etcd 集群中的每个节点都可以访问完整的数据存储库。

高度可用：etcd 被设计为没有单点故障，并且可以稳定地容忍硬件故障和网络分区。

完全一致：每次数据“读取”都会返回所有集群中最新的“写入”数据。

运行迅速：etcd 的基准测试速度为每秒 10,000 次写入。

安全可靠：etcd 支持自动传输层安全性 (TLS) 和可选的安全套接字层 (SSL) 客户机证书认证。由于 etcd 存储重要且高度敏感的配置数据，因此管理员应在部署中实施基于角色的访问控制，并确保与 etcd 交互的团队成员只具有执行其工作所需的最低级别的访问权限。

操作简单：任何应用（从简单的 Web 应用到 Kubernetes 等高度复杂的容器编排引擎）都可以使用标准的 HTTP/JSON 工具在 etcd 中读写数据。

请注意，由于 etcd 的性能在很大程度上取决于存储磁盘的速度，因此强烈建议在 etcd 环境中使用 SSD。有关此 etcd 存储要求和其他存储要求的更多信息，请查看“使用 Fio 判断您的存储器是否足以运行 etcd”。

Raft 共识算法

etcd 基于 Raft 共识算法而构建，可确保集群中所有节点之间的数据存储一致性 - 这就是具有容错能力的分布式系统的目标。

Raft 通过所选的领导节点实现这种一致性，该领导节点负责管理集群中其他节点（称为跟随节点）的复制。领导节点将接受来自客户机的请求，然后将这些请求转发给跟随节点。一旦领导节点确定大多数跟随节点已将每个新请求存储为日志条目，它就会将该条目应用于本地状态机，并将这次执行（一个“写入”操作）的结果返回至客户机。如果跟随节点崩溃或网络数据包丢失，那么领导节点将会重试，直到所有跟随节点都一致地存储了所有日志条目。

如果某个跟随节点在指定的时间间隔内未能收到来自领导节点的消息，那么将推选出新的领导节点。该跟随节点会将自己声明为候选者，其他跟随节点则会根据其可用性为它或任何其他节点投票。一旦选出了新的领导节点，该节点就会开始管理复制，并且这个过程会自行重复。这个过程让所有 etcd 节点能够维护高度可用且一致的数据存储副本。

etcd 与 Kubernetes

etcd 是 Kubernetes 的核心组件之一，充当主要键值存储库，用于创建可正常运行且具有容错能力的 Kubernetes 集群。 Kubernetes API 服务器会将每个集群的状态数据都存储在 etcd 中。 Kubernetes 使用 etcd 的“观察”功能来监控这些数据，并在发生变化时自行重新配置。 “观察”功能会存储代表集群实际状态和理想状态的值，并且可以在这两种状态不同时作出响应。

有关 Kubernetes 如何管理集群、服务和工作程序节点的简要概述，请观看我们的视频“Kubernetes 详解”：

CoreOS 与 etcd 的历史记录和维护

etcd 由负责设计 CoreOS Container Linux 的团队所创建；CoreOS Container Linux 是一种广泛使用的容器操作系统，可大规模地高效运行和管理。起初，研发团队在 Raft 上构建了 etcd 来同时协调多个 Container Linux 副本，确保应用不间断正常运行。

2018 年 12 月，该团队将 etcd 贡献给云原生计算基金会 (CNCF)，这是一个中立的非营利性组织，以基于容器的云开发社区的开源资源形式维护 etcd 的源代码、域、托管服务、云基础架构和其他项目财产。 CoreOS 已被 Red Hat 并购。

etcd、ZooKeeper 与 Consul

为了管理分布式应用集群之间的协调信息，人们已开发出了其他数据库。 ZooKeeper 和 Consul 是可与 etcd 相提并论的两个最常见的工具。

ZooKeeper

ZooKeeper 的创建目的是协调 Apache Hadoop 集群中的配置数据和元数据。（Apache Hadoop（链接位于 ibm.com 外部）是一个开源框架或应用集合，用于在商业硬件集群上存储和处理大量数据。） ZooKeeper 的历史比 etcd 更悠久；ZooKeeper 的使用经验影响了 etcd 的设计。

因此，etcd 可提供一些 ZooKeeper 无法提供的重要功能。例如，etcd 可执行以下 ZooKeeper 无法执行的操作：

支持动态重新配置集群成员资格。

在高负载的情况下稳定地执行读/写操作。

维护多版本并发控制数据模型。

提供可靠的关键监控，未发出通知的情况下绝不会丢弃事件。

使用将连接与会话分离的并发原语。

支持广泛的语言和框架（ZooKeeper 具有自己的定制 Jute RPC 协议，只支持有限的语言绑定）。

Consul

Consul 是用于分布式系统的服务网络解决方案，其功能介于 etcd 与 Kubernetes 的 Istio 服务网格之间。与 etcd 一样，Consul（链接位于 ibm.com 外部）包含一个基于 Raft 算法的分布式键值存储库，并支持 HTTP/JSON 应用程序编程接口 (API)。它们都提供动态集群成员资格配置，但 Consul 对多个并发版本的配置数据没有那么强的控制，并且在稳定工作时使用的最大数据库更小。

etcd 与 Redis

与 etcd 一样，Redis 也是一个开源工具，但是它们的基本功能有所不同。

Redis 是一种内存中数据存储库，可用作数据库、缓存或消息代理。 Redis 支持的数据类型和结构比 etcd 多，其读/写性能也快得多。

但是，etcd 具有超强的容错能力以及更强的故障转移和持续数据可用性能力，最重要的是，etcd 将所有数据都持久存储在磁盘上，这从本质上是牺牲速度来提升可靠性和保证一致性。因此，Redis 更适合用作分布式内存缓存系统，而不是存储分布式系统配置信息。

入门篇：从 etcd 名字的由来，到安装部署和使用姿势-腾讯云开发者社区-腾讯云

从 etcd 名字的由来，到安装部署和使用姿势-腾讯云开发者社区-腾讯云程序员荒生入门篇：从 etcd 名字的由来，到安装部署和使用姿势关注作者腾讯云开发者社区文档建议反馈控制台首页学习活动专区工具TVP最新优惠活动文章/答案/技术大牛搜索搜索关闭发布登录/注册首页学习活动专区工具TVP最新优惠活动返回腾讯云官网程序员荒生首页学习活动专区工具TVP最新优惠活动返回腾讯云官网社区首页 >专栏 >入门篇：从 etcd 名字的由来，到安装部署和使用姿势入门篇：从 etcd 名字的由来，到安装部署和使用姿势程序员荒生关注发布于 2022-07-14 08:36:455860发布于 2022-07-14 08:36:45举报文章被收录于专栏：公众号：程序员荒生公众号：程序员荒生大家好，我是三十一[0]，本次分享分布式神器etcd[1]的 5 种部署方式和 10 种使用姿势，阅读全文预计花费 15 分钟。在学习 etcd 之前，我们先来聊一聊 etcd 名字的由来[2]。etcd 中的 etc 取自 unix 系统的/etc目录，再加上一个d代表distributed system就组成了 etcd。在 unix 系统中 /etc 目录用于存储系统的配置数据，单从名字看 etcd 可用于存储分布式系统的配置数据，有时候也把 etcd 简单理解为分布式 /etc 配置目录。etcd 简介etcd 是一个可靠的分布式 key-value 存储系统，主要用于配置共享和服务注册和发现，具有以下特性：简单：基于 gRPC 定义了清晰、面向用户的 API。安全：支持可选的客户端 TLS 证书自动认证特性。快速：支持每秒 10000 次的写入。可靠：基于 Raft 算法协议保证一致性。etcd 使用 Go 语言开发，底层基于 Raft 共识算法管理高可用的复制日志。当前已经被许多公司用于关键生产项目，比如：Kubernetes、locksmith、vulcand、Doorman 等。当然，也有其他组件可以提供配置共享和服务注册和发现的功能，比如最为广泛和大家最为熟知的 Zookeeper，也被很多 Java 系的知名开源项目认可和使用，比如：Hadoop、HBase、Kafka 等。但 etcd 是唯一一个可以媲美甚至超越 Zookeeper 的组件。相较之下，Zookeeper 有如下缺点[3]：复杂：Zookeeper 基于 ZAB 协议，属于类 Paxos 协议，而 Paxos 算法素以复杂难懂闻名；Zookeeper 的使用也比较复杂，需要安装客户端，而官方目前只提供了 Java 和 C 两种语言接口。发展慢：由于基金会庞大的结构以及松散的管理，导致项目发展缓慢。而 etcd 作为后起之秀，其优点也很明显：简单：使用 Go 语言编写部署简单；使用 gRPC 定义接口，支持跨语言、跨平台特性；使用了易于用户理解的 Raft 算法保证一致性，优于 Paxos 算法。发展快：etcd 正处于高速迭代开发中。性能优越：官方提供的基准测试数据中，etcd 集群可以支持每秒 10000+ 次的写入，性能优于 Zookeeper。安全性：etcd 支持 TLS 访问，而 ZooKeeper 在权限控制方面做得略显粗糙。环境搭建一、本地安装包部署「下载」：下载最新的安装包（当前最新：v3.5.4），下载地址：https://github.com/etcd-io/etcd/releases/「安装」：在解压后的文件目录下etcd、etcdctl分别为安装包和客户端的编译后的执行文件，可使用三种方法进行运行配置。方法一：解压目录下直接运行方法二：把etcd、etcdctl文件复制到GOBIN目录下。方法三：在环境变量里添加etcd、etcdctl文件所在的目录。注：运行过程中，可能会涉及权限问题，授权即可。「验证」：# 验证 etcd 版本

$ etcd --version

etcd Version: 3.5.4

Git SHA: 08407ff76

Go Version: go1.16.15

Go OS/Arch: darwin/amd64

# 验证 etcdctl 版本

$ etcdctl version

etcdctl version: 3.5.4

API version: 3.5

复制二、本地编译部署「下载」：使用以下命令克隆代码# 下载最新版

$ git clone https://github.com/etcd-io/etcd.git

# 指定版本下载

$ git clone -b v3.5.4 https://github.com/etcd-io/etcd.git

复制「编译安装」：# 编译

$ cd etcd

$ make build

# 安装

$ export PATH="$PATH:`pwd`/bin"

复制「验证」：# 验证 etcd 版本

$ etcd --version

# 验证 etcdctl 版本

$ etcdctl version

# 验证 etcdutl 版本

$ etcdutl version

复制三、本地集群部署首先需要安装goreman组件，它基于 Procfile 配置文件管理 etcd 应用进程。$ go install github.com/mattn/goreman@latest

复制「启动集群」：源码目录下Procfile脚本已经构建好了本地演示集群，直接运行启动即可$ goreman start

复制「验证」$ etcdctl member list

8211f1d0f64f3269, started, infra1, http://127.0.0.1:12380, http://127.0.0.1:2379, false

91bc3c398fb3c146, started, infra2, http://127.0.0.1:22380, http://127.0.0.1:22379, false

fd422379fda50e48, started, infra3, http://127.0.0.1:32380, http://127.0.0.1:32379, false

复制该脚本创建包含 3 个 etcd 成员节点的集群，每个集群成员都接收键值的读取和写入。也可以按照Procfile.learner脚本指导，学习集群新增节点的操作。四、Docker 单机部署此处通过docker-compose进行实验配置。「镜像拉取」$ docker pull bitnami/etcd:3.5.2

复制「编辑docker-compose.yml」version: '3.5'

services:

etcd:

container_name: builder-etcd

image: bitnami/etcd:3.5.2

ports:

- 2379:2379

environment:

- ALLOW_NONE_AUTHENTICATION=yes

- ETCD_AUTO_COMPACTION_MODE=revision

- ETCD_AUTO_COMPACTION_RETENTION=1002

- ETCD_QUOTA_BACKEND_BYTES=4294967296

volumes:

- ${DOCKER_ROOT_DIR:-.}/volumes/etcd/data:/bitnami/etcd

networks:

default:

name: builder_dev

复制「启动服务」$ docker-compose -f docker-compose.yml up

复制「验证」：验证集群节点的版本$ docker exec -it builder-etcd /bin/bash -c "etcd --version"

etcd Version: 3.5.2

Git SHA: 99018a77b

Go Version: go1.16.3

Go OS/Arch: linux/amd64

复制五、Docker 集群部署「编辑docker-compose.yml」version: '3.5'

services:

etcd1:

container_name: builder-etcd1

image: bitnami/etcd:3.5.2

ports:

- 12379:2379

environment:

- ALLOW_NONE_AUTHENTICATION=yes

- ETCD_AUTO_COMPACTION_MODE=revision

- ETCD_AUTO_COMPACTION_RETENTION=1002

- ETCD_QUOTA_BACKEND_BYTES=4294967296

- ETCD_NAME=etcd1

- ETCD_INITIAL_ADVERTISE_PEER_URLS=http://etcd1:2380

- ETCD_LISTEN_PEER_URLS=http://0.0.0.0:2380

- ETCD_LISTEN_CLIENT_URLS=http://0.0.0.0:2379

- ETCD_ADVERTISE_CLIENT_URLS=http://etcd1:2379

- ETCD_INITIAL_CLUSTER_TOKEN=etcd-cluster

- ETCD_INITIAL_CLUSTER=etcd1=http://etcd1:2380,etcd2=http://etcd2:2380,etcd3=http://etcd3:2380

- ETCD_INITIAL_CLUSTER_STATE=new

volumes:

- ${DOCKER_ROOT_DIR:-.}/volumes/etcd/data1:/bitnami/etcd

etcd2:

container_name: builder-etcd2

image: bitnami/etcd:3.5.2

ports:

- 22379:2379

environment:

- ALLOW_NONE_AUTHENTICATION=yes

- ETCD_AUTO_COMPACTION_MODE=revision

- ETCD_AUTO_COMPACTION_RETENTION=1002

- ETCD_QUOTA_BACKEND_BYTES=4294967296

- ETCD_NAME=etcd2

- ETCD_INITIAL_ADVERTISE_PEER_URLS=http://etcd2:2380

- ETCD_LISTEN_PEER_URLS=http://0.0.0.0:2380

- ETCD_LISTEN_CLIENT_URLS=http://0.0.0.0:2379

- ETCD_ADVERTISE_CLIENT_URLS=http://etcd2:2379

- ETCD_INITIAL_CLUSTER_TOKEN=etcd-cluster

- ETCD_INITIAL_CLUSTER=etcd1=http://etcd1:2380,etcd2=http://etcd2:2380,etcd3=http://etcd3:2380

- ETCD_INITIAL_CLUSTER_STATE=new

volumes:

- ${DOCKER_ROOT_DIR:-.}/volumes/etcd/data2:/bitnami/etcd

etcd3:

container_name: builder-etcd3

image: bitnami/etcd:3.5.2

ports:

- 32379:2379

environment:

- ALLOW_NONE_AUTHENTICATION=yes

- ETCD_AUTO_COMPACTION_MODE=revision

- ETCD_AUTO_COMPACTION_RETENTION=1002

- ETCD_QUOTA_BACKEND_BYTES=4294967296

- ETCD_NAME=etcd3

- ETCD_INITIAL_ADVERTISE_PEER_URLS=http://etcd3:2380

- ETCD_LISTEN_PEER_URLS=http://0.0.0.0:2380

- ETCD_LISTEN_CLIENT_URLS=http://0.0.0.0:2379

- ETCD_ADVERTISE_CLIENT_URLS=http://etcd3:2379

- ETCD_INITIAL_CLUSTER_TOKEN=etcd-cluster

- ETCD_INITIAL_CLUSTER=etcd1=http://etcd1:2380,etcd2=http://etcd2:2380,etcd3=http://etcd3:2380

- ETCD_INITIAL_CLUSTER_STATE=new

volumes:

- ${DOCKER_ROOT_DIR:-.}/volumes/etcd/data3:/bitnami/etcd

networks:

default:

name: builder_dev

复制部署配置文件 docker-compose.yml 细节，详见etcd docker-compose yml[4]「启动服务」$ docker-compose -f docker-compose.yml up

复制「验证」：验证集群节点的版本$ docker exec -it builder-etcd1 /bin/bash -c "etcd --version"

$ docker exec -it builder-etcd2 /bin/bash -c "etcd --version"

$ docker exec -it builder-etcd3 /bin/bash -c "etcd --version"

# 输出

etcd Version: 3.5.2

Git SHA: 99018a77b

Go Version: go1.16.3

Go OS/Arch: linux/amd64

复制API 学习此处，通过使用etcdctl[5]进行 API 学习验证，etcdctl 是一个用于与 etcd 服务器交互的命令行工具。「1.查看版本」$ etcdctl version

etcdctl version: 3.6.0-alpha.0

API version: 3.6

复制「2.写入 key」$ etcdctl put foo bar

复制「3.读取 key」$ etcdctl get foo

foo

bar

# 只是获取值

$ etcdctl get foo --print-value-only

bar

复制「4.批量取值」$ etcdctl put foo1 bar1

$ etcdctl put foo3 bar2

$ etcdctl put foo3 bar3

# 获取从 foo 到 foo3 的值，不包括 foo3

$ etcdctl get foo foo3 --print-value-only

bar

bar1

bar2

# 获取前缀为 foo 的值

$ etcdctl get --prefix foo --print-value-only

bar

bar1

bar2

bar3

# 获取符合前缀的前两个值

$ etcdctl get --prefix --limit=2 foo --print-value-only

bar

bar1

复制「5.删除 key」# 删除 foo 的值

$ etcdctl del foo

# 删除 foo 到 foo2 且不包括 foo2 的值

$ etcdctl del foo foo2

# 删除前缀为 foo 的所有值

$ etcdctl del --prefix foo

复制「6.监听」# 监听 foo 单个 key

$ etcdctl watch foo

# 另一个控制台执行：etcdctl put foo bar

PUT

foo

bar

# 同时监视多个值

$ etcdctl watch -i

$ watch foo

$ watch zoo

# 另一个控制台执行: etcdctl put foo bar

PUT

foo

bar

# 另一个控制台执行: etcdctl put zoo val

PUT

zoo

val

# 监视 foo 前缀命中的 key

$ etcdctl watch --prefix foo

# 另一个控制台执行：etcdctl put foo1 bar1

PUT

foo1

bar1

# 另一个控制台执行：etcdctl put fooz1 barz1

PUT

fooz1

barz1

复制「7.设置租约」当一个 key 被绑定到一个租约上时，它的生命周期与租约的生命周期即绑定。# 设置10秒后过期时间

$ etcdctl lease grant 10

lease 32698142c52a170a granted with TTL(10s)

# 把 foo 和租约绑定，设置成 10 秒后过期

$ etcdctl put --lease=32698142c52a170a foo bar

$ etcdctl get foo

foo

bar

# 10 秒后，获取不到 foo

$ etcdctl get foo

# 返回空

复制「8.撤销租约」通过租约 ID 撤销租约，撤销租约将删除其所有绑定的 key。$ etcdctl lease grant 10

lease 32698142c52a170c granted with TTL(10s)

$ etcdctl put --lease=32698142c52a170c foo bar

# 撤销租约

$ etcdctl lease revoke 32698142c52a170c

lease 32698142c52a170c revoked

$ etcdctl get foo

# 返回空

复制「9.续约」通过刷新 TTL 值来保持租约的有效，使其不会过期。# 设置 10 秒后过期租约

$ etcdctl lease grant 10

lease 32698142c52a170f granted with TTL(10s)

# 把 foo 和租约绑定，设置成 10 秒后过期

$ etcdctl put foo bar --lease=32698142c52a170f

# 自动定时执行续约，续约成功后每次租约为 10 秒

$ etcdctl lease keep-alive 32698142c52a170f

lease 32695410dcc0ca06 keepalived with TTL(10)

...

复制「10.查看租约」查看租约信息，以便续租或查看租约是否仍然存在或已过期# 设置 50 秒 TTL

$ etcdctl lease grant 50

lease 32698142c52a1711 granted with TTL(50s)

# zoo1 绑定 32698142c52a1711 租约

$ etcdctl put --lease=32698142c52a1711 zoo1 val1

# 查看租约，remaining(32s) 剩余有效时间32秒；--keys 获取租约绑定的 key

$ etcdctl lease timetolive --keys 32698142c52a1711

lease 32698142c52a1711 granted with TTL(50s), remaining(32s), attached keys([zoo1])

复制注：一个租约支持绑定多个 key$ etcdctl lease grant 50

lease 32698142c52a1713 granted with TTL(50s)

$ etcdctl put --lease=32698142c52a1713 zoo1 val1

$ etcdctl put --lease=32698142c52a1713 zoo2 val2

$ etcdctl put --lease=32698142c52a1713 zoo3 val3

复制租约过期后，所有 key 值都会被删除，因此：当租约只绑定了一个 key 时，想删除这个 key，最好的办法是撤销它的租约，而不是直接删除这个 key。当租约没有绑定key时，应主动把它撤销掉，单纯删除 key 后，续约操作持续进行，会造成内存泄露。# 方法一：直接删除`key`

# 设置租约并绑定 zoo1

$ etcdctl lease grant 50

lease 32698142c52a1715 granted with TTL(50s)

$ etcdctl --lease=32698142c52a1715 put zoo1 val1

# 续约

$ etcdctl lease keep-alive 32698142c52a1715

lease 32698142c52a1715 keepalived with TTL(50)

# 另一个控制台执行：etcdctl del zoo1

# 单纯删除 key 后，续约操作持续进行，会造成内存泄露

lease 32698142c52a1715 keepalived with TTL(50)

...

# 方法二：撤销`key`的租约

# 设置租约并绑定 zoo1

$ etcdctl lease grant 50

lease 32698142c52a1717 granted with TTL(50s)

$ etcdctl --lease=32698142c52a1717 put zoo1 val1

# 续约

$ etcdctl lease keep-alive 32698142c52a1717

lease 32698142c52a1717 keepalived with TTL(50)

# 另一个控制台执行：etcdctl lease revoke 32698142c52a1717

# 续约撤销并退出

lease 32698142c52a1717 expired or revoked.

$ etcdctl get zoo1

# 返回空

复制以上，就是今天的全部内容，几乎包含了 etcd 安装和使用的各种姿势，欢迎各位号友敬请尝试。References[0] 三十一: http://www.lee31.cn/assets/image/ThirtyOneLee.jpeg[1] etcd: https://github.com/etcd-io/etcd[2] etcd 名字的由来: https://etcd.io/docs/v3.5/faq/[3] https://www.infoq.cn/article/etcd-interpretation-application-scenario-implement-principle/[4] etcd docker-compose yml: https://github.com/liyaodev/docker-compose[5] etcdctl: https://etcd.io/docs/v3.5/dev-guide/interacting_v3/本文参与腾讯云自媒体分享计划，分享自微信公众号。原始发表：2022-06-09，如有侵权请联系 cloudcommunity@tencent.com 删除容器镜像服务容器zookeeperhttps网络安全本文分享自李三十一微信公众号，前往查看如有侵权，请联系 cloudcommunity@tencent.com 删除。本文参与腾讯云自媒体分享计划，欢迎热爱写作的你一起参与！容器镜像服务容器zookeeperhttps网络安全评论登录后参与评论0 条评论热度最新登录后参与评论推荐阅读LV.关注文章0获赞0目录etcd 简介环境搭建一、本地安装包部署二、本地编译部署三、本地集群部署四、Docker 单机部署五、Docker 集群部署API 学习References相关产品与服务容器镜像服务容器镜像服务（Tencent Container Registry，TCR）为您提供安全独享、高性能的容器镜像托管分发服务。您可同时在全球多个地域创建独享实例，以实现容器镜像的就近拉取，降低拉取时间，节约带宽成本。TCR 提供细颗粒度的权限管理及访问控制，保障您的数据安全。产品介绍产品文档2024新春采购节领券社区专栏文章阅读清单互动问答技术沙龙技术视频团队主页腾讯云TI平台活动自媒体分享计划邀请作者入驻自荐上首页技术竞赛资源技术周刊社区标签开发者手册开发者实验室关于社区规范免责声明联系我们友情链接腾讯云开发者扫码关注腾讯云开发者领取腾讯云代金券热门产品域名注册云服务器区块链服务消息队列网络加速云数据库域名解析云存储视频直播热门推荐人脸识别腾讯会议企业云CDN加速视频通话图像分析MySQL 数据库SSL 证书语音识别更多推荐数据安全负载均衡短信文字识别云点播商标注册小程序开发网站监控数据迁移Copyright © 2013 - 2024 Tencent Cloud. All Rights Reserved. 腾讯云版权所有深圳市腾讯计算机系统有限公司 ICP备案/许可证号：粤B2-20090059 深公网安备号 44030502008569腾讯云计算（北京）有限责任公司京ICP证150476号 | 京ICP备11018762号 | 京公网安备号11010802020287问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档Copyright © 2013 - 2024 Tencent Cloud.All Rights Reserved. 腾讯云版权所有登录后参与评论00

imtoken钱包下载app 数字资产服务平台

tokenpocketapp下载载苹果版|etcd

彻底搞懂 etcd 系列文章（一）：初识 etcd - 知乎

etcd

还不了解 etcd？一文带你快速入门（万字长文）-腾讯云开发者社区-腾讯云

Introduction | etcd官方文档中文版

讲真的，etcd 服务入门一篇文章足够了！ - 知乎

一文看懂 etcd 是什么？了解 K8s etcd 的作用

etcd 快速入门 - 知乎

GitHub - etcd-io/etcd: Distributed reliable key-value store for the most critical data of a distributed system

什么是 etcd？ | IBM

入门篇：从 etcd 名字的由来，到安装部署和使用姿势-腾讯云开发者社区-腾讯云

imtoken钱包下载app
数字资产服务平台