100天后你还不会用Go写Kubernetes Operator？——Operator SDK v2.0实战通关清单（含CRD验证、Finalizer、Status子资源）

第一章：Go语言核心语法与Kubernetes Operator开发初探

Go语言以简洁、并发安全和强类型编译著称，是Kubernetes生态中Operator开发的首选语言。其结构化语法（如显式错误处理、无隐式继承、接口鸭子类型）天然契合云原生系统对可维护性与可观测性的严苛要求。

Go语言关键特性实践要点

• 结构体与方法集：Operator中资源状态管理依赖自定义结构体，例如 type MyAppSpec struct { Replicas intjson:”replicas”}，配合指针接收者方法实现状态校验逻辑；
• 错误处理范式：拒绝忽略错误，必须显式检查 if err != nil，Operator控制器中每个API调用（如 client.Get()）都需配套错误分支并记录事件；
• Context传递：所有阻塞操作（如watch或list）必须接受context.Context参数，确保超时控制与取消传播，避免goroutine泄漏。

Operator开发基础工具链

使用kubebuilder快速搭建骨架：

# 初始化项目（Kubernetes v1.28+兼容）
kubebuilder init --domain example.com --repo example.com/myapp-operator
kubebuilder create api --group apps --version v1 --kind MyApp
make manifests  # 生成CRD YAML
make install    # 安装CRD到集群

控制器核心循环逻辑

Operator控制器遵循“观察-比较-协调”三步模式：

1. 监听MyApp自定义资源变更（通过source.Kind）；
2. 获取当前集群中关联的Deployment与Service对象；
3. 比对期望状态（.spec.replicas）与实际状态（.status.replicas），缺失则创建，不一致则更新。

组件	作用	示例值
Reconcile函数	协调入口，每次事件触发一次执行	Reconcile(context, req)
Scheme	类型注册中心，支持序列化/反序列化	scheme.AddToScheme()
Manager	控制器生命周期与共享缓存管理器	ctrl.NewManager(cfg, mgrOpts)

掌握上述语法与模式后，即可构建具备生产就绪能力的Operator——它不再只是CRD定义，而是将运维逻辑编码为可测试、可调试、可版本化的Go程序。

第二章：Go语言基础与Kubernetes API编程基石

2.1 Go变量、类型系统与Kubernetes资源对象建模实践

Go 的强类型静态特性天然契合 Kubernetes 声明式资源建模需求：类型即契约，变量即状态载体。

核心建模范式

• 使用 struct 显式嵌套 metav1.TypeMeta 与 metav1.ObjectMeta
• 字段命名严格遵循 json:"fieldName,omitempty" 标签规范
• 所有非空字段必须设置 +kubebuilder:validation:Required 注解

示例：自定义 Operator 资源结构

type DatabaseSpec struct {
    Replicas *int32 `json:"replicas,omitempty"` // 指针类型支持 nil 判断，映射 YAML 中的可选字段
    Image    string `json:"image"`              // 非空必填，Operator 逻辑中直接解引用
}

Replicas 用指针实现零值语义（0 ≠ 未设置），Image 字符串则强制声明，避免运行时空值 panic。

Go 类型	Kubernetes 语义	序列化行为
*int32	可选整数字段	nil → JSON 中省略
[]string	有序标签列表	空切片 → []，非 nil
metav1.Time	RFC3339 时间戳	自动格式化与校验

graph TD
    A[Go struct] --> B{JSON Marshal}
    B --> C[K8s API Server]
    C --> D[etcd 存储]
    D --> E[Controller Reconcile]
    E --> F[Type-Safe Field Access]

2.2 Go结构体、接口与Client-go中Scheme/Codec深度解析

Go语言中，结构体（struct）是Kubernetes资源对象的底层载体，而接口（如 runtime.Object）则统一了序列化契约。client-go 的 Scheme 负责类型注册与双向映射，Codec（如 universalDeserializer）则基于 Scheme 实现 YAML/JSON ↔ Go struct 的无损编解码。

核心类型契约

• runtime.Object 接口定义 GetObjectKind() schema.ObjectKind 和 DeepCopyObject() runtime.Object
• 所有内置资源（如 v1.Pod）均实现该接口并嵌入 metav1.TypeMeta 和 metav1.ObjectMeta

Scheme 注册示例

scheme := runtime.NewScheme()
_ = corev1.AddToScheme(scheme) // 注册 v1 组所有类型
_ = appsv1.AddToScheme(scheme) // 注册 apps/v1 组

此处 AddToScheme 将 Pod, Deployment 等 struct 与其 GroupVersionKind（如 /v1, Kind=Pod）绑定，供 Codec 查表使用。

组件	职责
Scheme	类型注册中心 + GVK↔Go类型双向索引
Codec	基于 Scheme 的序列化/反序列化引擎
ParameterCodec	专用于 URL 查询参数编码（如 ?fieldSelector=）

graph TD
    A[JSON/YAML bytes] --> B[UniversalDeserializer]
    B --> C{Scheme Lookup by GVK}
    C --> D[v1.Pod struct]
    D --> E[Apply Defaulting/Conversion]

2.3 Goroutine与Channel在Operator事件驱动架构中的协同应用

事件处理流水线设计

Operator需实时响应Kubernetes资源变更（如Pod创建/删除），Goroutine提供轻量并发单元，Channel承担解耦与缓冲职责。

数据同步机制

// 事件通道：统一接收Informer的Add/Update/Delete事件
eventCh := make(chan event, 1024)

// 启动协程消费事件，避免阻塞主循环
go func() {
    for evt := range eventCh {
        handleEvent(evt) // 幂等性处理逻辑
    }
}()

eventCh 容量为1024，防止突发事件压垮内存；handleEvent 必须具备幂等性，因Kubernetes Informer可能重复投递事件。

协同模型对比

场景	仅用Goroutine	Goroutine + Channel
资源变更吞吐量	易阻塞，无背压控制	可限流、可缓冲、可超时丢弃
错误隔离性	panic可能终止整个循环	单goroutine崩溃不影响其他

graph TD
    A[Informer Event] --> B[Channel Buffer]
    B --> C1[Handler Goroutine 1]
    B --> C2[Handler Goroutine 2]
    B --> Cn[Handler Goroutine N]

2.4 错误处理机制与Kubernetes API调用的健壮性设计

Kubernetes API调用天然面临网络抖动、资源竞争与服务端限流等不确定性。健壮性设计需融合重试、退避、上下文超时与错误分类响应。

重试策略示例（带指数退避）

retry := retry.DefaultRetry
retry.RetryForever = false
retry.Attempts = 3
retry.Backoff = wait.NewExponentialBackoffManager(
    100*time.Millisecond, // base delay
    2*time.Second,        // max delay
    30*time.Second,       // max elapsed
    1.0,                  // jitter factor
    &clock.RealClock{},
)

逻辑分析：NewExponentialBackoffManager 生成递增延迟序列（100ms → 200ms → 400ms），避免雪崩式重试；Attempts=3 确保有限次容错，&clock.RealClock{} 支持测试可插拔。

常见API错误码语义对照

HTTP 状态码	含义	推荐动作
401	认证失败	刷新 token
403	权限不足	检查 RBAC 配置
409	版本冲突（Conflict）	重取最新资源后重试
429	限流（Too Many Requests）	指数退避 + 重试
500/503	服务端临时不可用	延迟重试，不立即失败

错误传播路径

graph TD
    A[ClientSet.Do] --> B{HTTP StatusCode}
    B -->|4xx| C[客户端错误：校验/权限/参数]
    B -->|5xx| D[服务端错误：重试或降级]
    C --> E[返回具体error类型<br>e.g. *errors.StatusError]
    D --> F[封装为RetriableError<br>触发BackoffManager]

2.5 Go模块管理与Operator项目依赖治理（go.mod + k8s.io/client-go v0.29+）

Operator项目升级至 k8s.io/client-go v0.29+ 后，必须严格遵循模块化依赖收敛原则，避免 replace 滥用与隐式版本冲突。

依赖对齐关键约束

• k8s.io/client-go v0.29+ 要求 k8s.io/api、k8s.io/apimachinery 等配套模块精确匹配 Kubernetes v1.29.x tag
• controller-runtime v0.17+ 已原生适配 client-go v0.29，推荐作为控制器基座

典型 go.mod 片段

module github.com/example/my-operator

go 1.21

require (
    k8s.io/client-go v0.29.4
    k8s.io/api v0.29.4
    k8s.io/apimachinery v0.29.4
    sigs.k8s.io/controller-runtime v0.17.3
)

✅ 此声明确保所有 Kubernetes 核心类型与 REST 客户端使用统一版本；v0.29.4 是语义化补丁版本，兼容 v1.29.0–v1.29.9 集群。若混入 v0.28.x 的 k8s.io/api，将触发 Scheme registration mismatch 运行时 panic。

版本兼容性速查表

client-go	最低支持 K8s 集群版本	controller-runtime 推荐版本
v0.29.4	v1.29.0	v0.17.3
v0.30.0	v1.30.0	v0.18.0

依赖验证流程

graph TD
    A[go mod tidy] --> B[go list -m all \| grep k8s.io]
    B --> C{版本是否完全一致？}
    C -->|是| D[通过]
    C -->|否| E[检查 replace/indirect 并清理]

第三章：Operator SDK v2.0核心机制精讲

3.1 Controller-runtime架构剖析与Reconcile循环生命周期实战

Controller-runtime 构建于 client-go 之上，以 Manager 为调度中枢，通过 Controller 管理 Reconciler 实例，驱动声明式控制循环。

Reconcile 核心契约

Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) 是唯一入口：

• req.NamespacedName 提供待协调对象的唯一标识；
• 返回 Result.RequeueAfter 触发延迟重入，Result.Requeue=true 立即重试。

func (r *MyReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
    var pod corev1.Pod
    if err := r.Get(ctx, req.NamespacedName, &pod); err != nil {
        return ctrl.Result{}, client.IgnoreNotFound(err) // 忽略删除事件的 Get 错误
    }
    // ... 业务逻辑：确保副本数、注入标签等
    return ctrl.Result{RequeueAfter: 30 * time.Second}, nil
}

该实现体现“获取→比对→修正”三阶段：r.Get() 拉取当前状态；IgnoreNotFound 安全处理对象已删除场景；RequeueAfter 避免空转，支撑最终一致性。

控制循环生命周期关键阶段

阶段	触发条件	典型操作
Enqueue	Watch 事件（Add/Update）	将对象 key 推入工作队列
Fetch & Reconcile	Worker 从队列取出 key	调用 Reconcile 方法
Result Handling	Reconcile 返回值	延迟重入 / 清理 / 永久失败退出

graph TD
    A[Watch Event] --> B[Enqueue req.NamespacedName]
    B --> C{Worker Pop}
    C --> D[Get obj from cache]
    D --> E[Run Reconcile]
    E --> F[Handle Result]
    F -->|RequeueAfter| B
    F -->|Success| G[Idle]

3.2 CRD定义、OpenAPI v3验证Schema编写与kubectl apply验证全流程

CustomResourceDefinition（CRD）是Kubernetes扩展原生资源的核心机制，其Schema需严格遵循OpenAPI v3规范以启用服务端验证。

定义CRD资源结构

apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
  name: databases.example.com
spec:
  group: example.com
  versions:
    - name: v1
      served: true
      storage: true
      schema:
        openAPIV3Schema:
          type: object
          properties:
            spec:
              type: object
              properties:
                replicas:
                  type: integer
                  minimum: 1  # ← 强制最小副本数
                  maximum: 10

该Schema确保spec.replicas字段在创建/更新时被API Server实时校验，非法值（如0或11）将直接拒绝请求并返回422错误。

验证流程示意

graph TD
  A[kubectl apply -f crd.yaml] --> B[API Server解析CRD]
  B --> C[加载OpenAPI v3 Schema]
  C --> D[对后续CR实例执行结构+范围校验]
  D --> E[校验通过→持久化 etcd / 失败→返回详细error]

关键验证行为对比

校验类型	示例字段	触发时机	错误响应示例
类型检查	replicas: "three"	创建CR时	spec.replicas in body must be of type integer
范围约束	replicas: 0	更新CR时	spec.replicas in body should be greater than or equal to 1

3.3 Finalizer机制实现资源安全清理与跨Namespace级联删除策略

Finalizer 是 Kubernetes 中保障资源终态一致性的核心守门人。当对象被标记删除（deletionTimestamp 设置），控制器需在所有关联 Finalizer 移除后，才真正从 etcd 中清除。

清理生命周期钩子

• kubernetes.io/pv-protection 防止误删绑定 PV 的 PVC
• finalizers.external-workload.example.com 由外部 Operator 注入，用于异步释放云资源

跨 Namespace 级联策略

# 示例：ServiceAccount 删除时触发跨 ns Secret 清理
apiVersion: v1
kind: ServiceAccount
metadata:
  name: app-sa
  namespace: default
  finalizers:
    - resources.cleanup.example.com  # 触发自定义控制器跨 ns 扫描 secret

此 Finalizer 由 cross-ns-cleanup-controller 监听，其通过 Cache 预加载所有命名空间的 SecretList，按 ownerReferences 反向索引定位依赖项，避免 List-Watch 全量轮询。

清理流程图

graph TD
  A[Delete API Request] --> B{Has finalizers?}
  B -->|Yes| C[Pause deletion]
  B -->|No| D[GC from etcd]
  C --> E[Controller performs cleanup]
  E --> F[Remove finalizer via PATCH]
  F --> B

阶段	操作主体	安全保障点
预删除	kube-apiserver	冻结对象，拒绝新建引用
异步清理	自定义 Controller	幂等执行 + context timeout
终态确认	Garbage Collector	基于 ownerReferences 级联

第四章：Operator生产级能力构建

4.1 Status子资源设计与StatusManager原子更新实践（避免Spec/Status耦合）

Kubernetes Operator 中，Status 应严格隔离于 Spec，避免状态写入污染声明式意图。

数据同步机制

StatusManager 提供 UpdateStatus() 原子接口，绕过常规 reconciliation 循环，直接 PATCH /status 子资源：

// 使用 client.Status().Update() 确保仅更新 status 字段
if err := r.Status().Update(ctx, instance); err != nil {
    log.Error(err, "Failed to update status")
    return ctrl.Result{}, err
}

✅ 参数说明：instance 必须是已设置 Status 字段的完整对象；r.Status() 返回专用 status 客户端，自动构造 /status REST 路径，杜绝 Spec 字段误写。

设计对比表

维度	直接 Update()	Status().Update()
更新路径	/（全量）	/status（子资源）
Spec 覆盖风险	高	零
并发安全性	依赖 ResourceVersion	内置乐观锁校验

状态更新流程

graph TD
    A[Controller 检测状态变更] --> B[构造新 Status 对象]
    B --> C[调用 Status().Update()]
    C --> D{API Server 校验}
    D -->|ResourceVersion 匹配| E[原子写入 status]
    D -->|冲突| F[返回 409，重试]

4.2 OwnerReference与BlockOwnerDeletion在多资源依赖关系中的精准控制

Kubernetes 中的 OwnerReference 是实现级联删除与生命周期绑定的核心机制，而 BlockOwnerDeletion 则提供细粒度的阻断能力。

控制逻辑解析

当某资源（如 Pod）被设置为另一资源（如 ReplicaSet）的 owner 时，Kubernetes 通过 ownerReferences 字段建立单向所有权链：

ownerReferences:
- apiVersion: apps/v1
  kind: ReplicaSet
  name: nginx-rs
  uid: a1b2c3d4-5678-90ef-ghij-klmnopqrstuv
  blockOwnerDeletion: true  # 关键：阻止父资源删除时级联删除本资源

逻辑分析：blockOwnerDeletion: true 表示即使 ReplicaSet 被删除，该 Pod 也不会被自动回收——需显式设置此字段并确保控制器有 update 权限修改该 Pod 的 metadata.ownerReferences。

BlockOwnerDeletion 生效前提

• 对应 controller 必须拥有 update 权限操作子资源的 ownerReferences
• 子资源必须处于 Terminating 状态前完成设置（否则无效）

场景	是否触发级联删除	说明
blockOwnerDeletion: false（默认）	✅	删除 Owner 后子资源被清理
blockOwnerDeletion: true + 权限完备	❌	子资源保留，等待人工/其他逻辑处理
blockOwnerDeletion: true + 权限缺失	⚠️	字段被忽略，退化为默认行为

graph TD
  A[Owner 资源删除请求] --> B{检查子资源 ownerReferences}
  B --> C[存在 blockOwnerDeletion: true？]
  C -->|是| D[验证 controller 是否有权 update 子资源]
  D -->|权限充足| E[保留子资源]
  D -->|权限不足| F[执行默认级联删除]

4.3 Webhook集成：Validating/Mutating Admission Controller开发与TLS证书自动化注入

Webhook 是 Kubernetes 控制平面扩展的核心机制，其中 Validating 和 Mutating Admission Controllers 分别在资源持久化前执行校验与修改。

核心组件职责对比

类型	执行时机	是否可拒绝请求	典型用途
Mutating	CREATE/UPDATE 早期	否（仅修改）	注入 sidecar、默认字段、标签
Validating	CREATE/UPDATE 后期	是（返回 Forbidden）	RBAC 策略、命名规范、镜像签名验证

TLS 自动化注入流程

# webhook-configuration.yaml（MutatingWebhookConfiguration）
webhooks:
- name: injector.example.com
  clientConfig:
    service:
      namespace: admission-system
      name: admission-webhook
      path: "/mutate"
    caBundle: ${CA_BUNDLE}  # 由 cert-manager 自动注入

caBundle 必须为 PEM 编码的根 CA 证书（Base64），否则 kube-apiserver 拒绝连接。cert-manager 通过 Certificate 资源 + Issuer 自动生成并轮换该字段。

Mutating Webhook 处理逻辑示例

func (h *MutatingAdmissionHook) Handle(ctx context.Context, req admissionv1.AdmissionRequest) admissionv1.AdmissionResponse {
    if req.Kind.Kind != "Pod" { // 仅处理 Pod
        return admissionv1.Allowed("")
    }
    pod := &corev1.Pod{}
    if err := json.Unmarshal(req.Object.Raw, pod); err != nil {
        return admissionv1.Denied("invalid pod object")
    }
    // 注入环境变量与 volumeMount
    pod.Spec.Containers[0].Env = append(pod.Spec.Containers[0].Env,
        corev1.EnvVar{Name: "INJECTED", Value: "true"})
    return admissionv1.Allowed("").WithPatchBytes(patchBytes)
}

此 handler 解析原始 Pod 对象，在首个容器中追加环境变量，并返回 JSON Patch（RFC 6902）。WithPatchBytes() 触发 kube-apiserver 自动应用变更，无需重写整个对象。

graph TD
    A[kube-apiserver] -->|AdmissionReview| B(Admission Webhook)
    B --> C{Is Pod?}
    C -->|Yes| D[Inject Env + Volume]
    C -->|No| E[Allow Pass-through]
    D --> F[Return Patch]
    F --> A

4.4 Operator可观测性：Prometheus指标暴露、Structured Logging（Zap）与Debug端点调试

Operator的可观测性是生产就绪的关键支柱，需三位一体协同：指标采集、结构化日志、实时调试。

Prometheus指标暴露

通过controller-runtime/metrics注册自定义指标，例如：

var reconcileTotal = prometheus.NewCounterVec(
    prometheus.CounterOpts{
        Name: "myoperator_reconcile_total",
        Help: "Total number of reconciliations per resource kind",
    },
    []string{"kind", "result"}, // 标签维度
)
func init() {
    metrics.Registry.MustRegister(reconcileTotal)
}

reconcileTotal在每次Reconcile结束时调用reconcileTotal.WithLabelValues(kind, result).Inc()，标签kind和result支持多维下钻分析；metrics.Registry为全局Prometheus注册器，确保被/metrics端点自动暴露。

Structured Logging（Zap）

使用ctrl.Log.WithName("reconciler")获取层级日志实例，输出JSON格式，兼容ELK栈。

Debug端点

启用--enable-http2 --debug后，/debug/pprof/和/debug/vars提供运行时性能与变量快照。

调试端点	用途
/debug/pprof/	CPU、goroutine、heap分析
/debug/vars	Go runtime变量（如goroutines数）

graph TD
A[Reconcile Loop] --> B[记录reconcileTotal指标]
A --> C[用Zap记录结构化事件]
A --> D[触发panic时自动dump goroutine]

第五章：从零到上线——一个高可用Etcd Operator的全链路交付

构建可复现的开发环境

我们基于 Ubuntu 22.04 LTS 搭建本地开发集群，使用 Kind（Kubernetes in Docker）启动三节点高可用控制平面：

kind create cluster --config kind-ha.yaml  # 启用 etcd 多副本、kube-apiserver 负载均衡

kind-ha.yaml 明确配置 etcd 为 external 模式，并预留 /etc/kubernetes/pki/etcd 卷挂载路径，确保 Operator 启动时能直接接管外部 etcd 实例。

Operator 核心控制器设计

采用 Kubebuilder v3.11 构建项目骨架，定义 EtcdCluster CRD 支持 spec.size: 3、spec.backup 和 spec.tls 字段。控制器关键逻辑包括：

• 基于 etcdctl endpoint status 自动检测成员健康状态；
• 当某节点失联超 90 秒，触发 remove-member → add-member 安全替换流程；
• TLS 证书轮换通过 cert-manager Issuer + Secret 引用实现，避免硬编码。

高可用部署拓扑与资源约束

生产环境采用跨 AZ 部署策略，节点标签与容忍度严格对齐：

节点角色	标签键值	容忍度	CPU 请求/限制
etcd-0	topology.kubernetes.io/zone=us-west-2a	etcd-node:NoSchedule	2/4
etcd-1	topology.kubernetes.io/zone=us-west-2b	etcd-node:NoSchedule	2/4
etcd-2	topology.kubernetes.io/zone=us-west-2c	etcd-node:NoSchedule	2/4

所有 Pod 设置 affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution，强制分散调度。

自动化灰度发布流水线

GitOps 流水线基于 Argo CD v2.8 实现，包含三阶段同步策略：

1. 预检阶段：运行 etcdctl check perf --load=500 验证新版本 etcd 二进制兼容性；
2. 金丝雀阶段：仅更新 etcd-0，持续观测 etcd_disk_wal_fsync_duration_seconds P99
3. 全量阶段：当 Prometheus 查询 count by (job) (up{job=~"etcd.*"}) == 3 成立后自动推进。

故障注入验证方案

使用 Chaos Mesh 注入真实故障场景：

apiVersion: chaos-mesh.org/v1alpha1
kind: NetworkChaos
metadata:
  name: etcd-partition
spec:
  action: partition
  mode: one
  selector:
    labelSelectors:
      app.kubernetes.io/name: etcd-cluster
  direction: to
  target:
    selector:
      labelSelectors:
        app.kubernetes.io/name: etcd-cluster

监控告警闭环体系

集成 Prometheus Operator，关键指标覆盖：

• etcd_server_is_leader{job="etcd"}（Leader 切换次数/5m > 2 触发 P1 告警）；
• etcd_debugging_mvcc_db_fsync_duration_seconds_bucket{le="0.05"}（P99 > 0.05s 触发磁盘 I/O 诊断）；
• etcd_network_peer_round_trip_time_seconds{quantile="0.99"}（跨 AZ RTT > 50ms 自动降级为单 AZ 拓扑）。

生产就绪检查清单

• ✅ 所有 etcd 成员 initial-advertise-peer-urls 使用私有 DNS（如 etcd-0.etcd-headless.namespace.svc.cluster.local:2380）；
• ✅ --auto-tls=true 关闭，全部 TLS 由 Operator 管理 Secret 动态挂载；
• ✅ --quota-backend-bytes=8589934592（8GB）已设为硬上限，防 WAL 文件无限增长；
• ✅ 每日 02:00 UTC 执行 etcdctl snapshot save /backup/$(date -u +%Y%m%d).db 并上传至 S3 版本化存储。

上线后性能基线数据

在 16C32G 节点、NVMe SSD 存储下实测：

• 写入吞吐：23,840 ops/sec（etcdctl put 循环，value=1KB）；
• 读取延迟：P99 = 1.2ms（etcdctl get 1000次并发）；
• Leader 选举耗时：中位数 147ms（模拟网络分区后恢复）；
• 内存占用：稳定在 2.1GB（无内存泄漏，GC 周期 3.2s）。

滚动升级原子性保障

Operator 在执行 etcdctl member update 前，先调用 etcdctl alarm list 清除所有 NOSPACE 或 CORRUPT 告警；升级过程中禁止任何 put/delete 写操作，通过 admission webhook 拦截非 GET/HEAD 请求，直至 etcdctl endpoint health --cluster 返回全部 true。