工作负载编排与部署策略深度解析

你创建了 3 个 Pod 副本,其中一个 Pod 所在的 Node 宕机了——谁来确保"始终有 3 个 Pod 在运行"?Pod 本身不会自愈,它是一个被动对象,挂了就挂了。你需要一个外部的"看门人"不断检查期望与实际的差异并采取行动。这正是 Kubernetes 工作负载控制器要解决的核心问题。

工作负载编排的核心问题:当故障发生时,你的应用能自动恢复吗?本篇从 Controller 的自愈机制出发,讲透 Deployment、StatefulSet、DaemonSet、Job 的设计原理和实战部署策略。


1. 工作负载控制器的设计哲学

1.1 为什么需要 Controller?

让我们从一个根本问题开始:你创建了 3 个 Pod 副本,其中一个 Pod 所在的 Node 宕机了。谁来确保"始终有 3 个 Pod 在运行"?

Pod 本身不会自愈——它是一个被动的对象。如果 Pod 挂了,它就挂了。你需要一个外部的"看门人"不断检查"期望 3 个,实际几个?"并在发现差异时采取行动。这个"看门人"就是 Controller。

所有 K8s 工作负载控制器(Deployment、StatefulSet、DaemonSet、Job)都遵循同一个核心模式:

func (c *Controller) Reconcile(key string) error {
    // 1. 获取期望状态(用户定义的 Spec)
    desired, _ := c.lister.Get(key)

    // 2. 观察实际状态(集群中真实存在的 Pod)
    actualPods := c.getOwnedPods(desired)

    // 3. 比较并调和——让实际状态向期望状态收敛
    if len(actualPods) < desired.Spec.Replicas {
        c.createPod(desired)     // 不够就创建
    } else if len(actualPods) > desired.Spec.Replicas {
        c.deletePod(actualPods)  // 多了就删除
    }
    return nil
}

这个函数有两个关键属性:

  1. Level-triggered(电平触发):它不关心"之前发生了什么事件",只看"当前状态 vs 期望状态"。即使错过了 10 个事件通知,下次循环依然能发现问题并修复。

  2. 幂等性(Idempotent):同一个状态执行多次 Reconcile,结果一样。如果已经有 3 个 Pod 在运行,Reconcile 发现"期望 3,实际 3",什么都不做——不会额外创建。

1.2 OwnerReference:谁创建了这个 Pod?

K8s 资源之间通过 OwnerReference 建立父子关系:

graph TD
  deploy["Deployment"] --> rs["ReplicaSet"]
  rs --> pod["Pod"]
  rs -.->|"ownerRef"| deploy
  pod -.->|"ownerRef"| rs

每个 Pod 的 metadata.ownerReferences 记录了它的"父亲"是谁。这不仅仅是个标记,它驱动着两个关键行为:

Controller 识别"哪些 Pod 是我的":ReplicaSet Controller 通过查找 ownerReferences 指向自己的 Pod 来统计"当前有几个副本"。如果你手动创建一个 Pod 并且没有 ownerRef,任何 Controller 都不会管它。

级联删除(Garbage Collection):当你删除一个 Deployment 时,GarbageCollector Controller 会找到所有 ownerRef 指向它的 ReplicaSet,递归删除。

三种删除策略:

策略 行为 场景
Background(默认) 立即删 Deployment,后台异步删 RS 和 Pod 大部分情况
Foreground 先删 Pod → 再删 RS → 最后删 Deployment 需要确保子资源完全清理
Orphan 只删 Deployment,保留 RS 和 Pod(移除 ownerRef) 想保留 Pod 继续运行
# 删除 Deployment 但保留 Pod(Orphan)
kubectl delete deployment nginx --cascade=orphan
# Pod 继续运行,但不再有 Controller 管理它——变成了"野生 Pod"

2. Deployment 深度解析

2.1 为什么需要 ReplicaSet 这一中间层?

Deployment 不直接管理 Pod——中间隔了一层 ReplicaSet。这不是过度设计,而是为了解决一个关键问题:滚动更新时,新旧版本的 Pod 必须同时存在。

graph TD
  deploy["Deployment (nginx)"]
  rs1["ReplicaSet (revision=1, replicas=0)
image: nginx:1.24(旧版本)"] rs2["ReplicaSet (revision=2, replicas=3)
image: nginx:1.25(当前版本)"] p1["Pod nginx-abc-1"] p2["Pod nginx-abc-2"] p3["Pod nginx-abc-3"] deploy --> rs1 deploy --> rs2 rs2 --> p1 rs2 --> p2 rs2 --> p3

如果 Deployment 直接管理 Pod,滚动更新时就面临一个两难:

ReplicaSet 解决了这个问题:Deployment 同时管理两个 ReplicaSet(新旧各一个),通过调整它们的 replicas 数字来实现平滑过渡。

额外的好处——版本回滚:旧 ReplicaSet 不会被删除(只是 replicas 缩为 0),回滚只需把旧 RS 的 replicas 扩回来、新 RS 缩为 0。这比重新创建 Pod 快得多。revisionHistoryLimit(默认 10)控制保留多少个历史 RS。

ReplicaSet 怎么区分新旧版本? 通过 Pod Template Hash。Deployment Controller 对 Pod Template 计算 hash,作为 pod-template-hash label 写入 ReplicaSet 和 Pod。不同的 Pod Template(比如 image 变了)→ 不同的 hash → 不同的 ReplicaSet。

2.2 滚动更新:用具体数字走完整个过程

这是 Deployment 最重要的能力。让我们用一个具体场景走完每一步。

场景:Deployment 有 4 个副本,从 nginx:1.24 更新到 nginx:1.25。

spec:
  replicas: 4
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1          # 允许临时多出 1 个 Pod
      maxUnavailable: 1    # 允许最多 1 个 Pod 不可用

约束计算:

最大总 Pod 数 = replicas + maxSurge = 4 + 1 = 5
最少可用 Pod 数 = replicas - maxUnavailable = 4 - 1 = 3

完整的更新时序(每一步 Deployment Controller 的 Reconcile 都在检查这两个约束):

步骤   旧RS(v1.24)  新RS(v1.25)  总Pod  可用Pod  Controller 动作
────   ──────────   ──────────  ────   ──────  ─────────────
初始    4 Ready      0           4      4       检测到 Pod Template 变化
                                                → 创建新 RS (replicas=0)

第1步   4 Ready      1 创建中     5      4       新 RS 扩容到 1
                                                (总数 5 ≤ 最大 5 ✓)

第2步   3 Ready      1 创建中     4      3       旧 RS 缩容到 3
                                                (可用 3 ≥ 最少 3 ✓)

第3步   3 Ready      1 Ready      4      4       新 Pod Ready!
                                                新 RS 可以继续扩

第4步   3 Ready      2 创建中     5      4       新 RS 扩容到 2
                                                (总数 5 ≤ 最大 5 ✓)

第5步   2 Ready      2 Ready      4      4       旧 RS 缩容到 2
                                                新 RS 扩容到 3...

...                                              持续交替扩新缩旧

最终    0            4 Ready      4      4       完成!旧 RS 保留
                                                 (replicas=0) 用于回滚

关键观察:

  1. 整个过程中,可用 Pod 数始终 ≥ 3(maxUnavailable=1 的保证)
  2. 总 Pod 数始终 ≤ 5(maxSurge=1 的保证)
  3. 新旧版本短暂共存——这要求你的应用能处理新旧版本同时运行的情况(比如 API 向后兼容)

不同 maxSurge/maxUnavailable 组合的效果:

组合 效果 适用场景
maxSurge=0, maxUnavailable=1 先缩旧再扩新,总 Pod 不增加 资源紧张,不允许临时多用资源
maxSurge=1, maxUnavailable=0 先扩新再缩旧,保证零停机 强调服务可用性
maxSurge=100%, maxUnavailable=0 一次性创建全部新 Pod,等都 Ready 后再删旧 蓝绿部署效果
maxSurge=25%, maxUnavailable=25% K8s 默认值,平衡速度和稳定性 大部分场景

2.3 minReadySeconds:防止"假 Ready"

Pod 通过 Readiness Probe 后立即被认为 Available。但有些应用在 Ready 后几秒内可能崩溃(比如内存泄漏在启动后 5 秒触发)。如果 Deployment Controller 看到新 Pod "Ready" 就继续缩旧 RS,而新 Pod 随后崩溃——可用 Pod 数会低于预期。

minReadySeconds 提供了一个缓冲窗口:Pod Ready 后还需要持续 Ready 达到 minReadySeconds 秒才被认为 Available。如果在这段时间内 Pod 崩溃,Deployment Controller 会暂停滚动更新。

spec:
  minReadySeconds: 30   # Pod 必须持续 Ready 30 秒
  progressDeadlineSeconds: 600  # 整个更新过程不能超过 10 分钟

progressDeadlineSeconds 是更新的超时时间。如果新 Pod 一直起不来(比如镜像拉取失败),超过这个时间后 Deployment 会被标记为 Progressing=False——但不会自动回滚。你需要手动 kubectl rollout undo。

2.4 Deployment Controller 的 Reconcile 逻辑

Deployment Controller 的核心入口是 syncDeployment(源码 pkg/controller/deployment/deployment_controller.go):

graph TD
  sync["syncDeployment(key)"] --> get["获取 Deployment + 所有关联的 ReplicaSet"]
  get --> scaling{"仅副本数变化?
(非更新场景)"} scaling -->|"是"| syncFn["sync(): 直接调整当前活跃 RS 的 replicas"] scaling -->|"否"| strategy{"strategy 类型?"} strategy -->|"Recreate"| recreate["rolloutRecreate():
1. 缩旧 RS 到 0
2. 等所有旧 Pod 终止
3. 扩新 RS 到期望数"] strategy -->|"RollingUpdate"| rolling["rolloutRolling():
1. reconcileNewReplicaSet()—扩新 RS
2. reconcileOldReplicaSets()—缩旧 RS
3. 遵守 maxSurge/maxUnavailable"]

一个重要的实现细节:Deployment Controller 的每次 Reconcile 最多只推进一步。它不会在一次 Reconcile 中把所有 Pod 都替换完——每次只做一小步(比如扩新 RS +1 或缩旧 RS -1),然后等待下一次 Reconcile。这种"小步快走"的设计确保了:即使 Controller 在中间崩溃重启,下次 Reconcile 能从当前状态继续,不会跳过步骤。


3. StatefulSet 深度解析

3.1 有状态应用的核心需求:为什么 Deployment 不够?

假设你要在 K8s 上部署一个 3 节点的 MySQL 主从集群。用 Deployment 行不行?

问题 1:Pod 名称不稳定

Deployment 创建的 Pod 名称包含随机字符(如 mysql-7bf8c77b5b-x2j9k)。Pod 被重建后名称变了。但 MySQL 从库需要知道"Master 在哪"——如果 Master 的名字不断变化,从库怎么找到它?

问题 2:存储不跟 Pod 走

Deployment 的 Pod 共享同一个 PVC 模板。Pod 被重建后,可能挂到一个全新的空 PV 上——之前的数据全没了。对数据库来说这是灾难。

问题 3:启动顺序不可控

Deployment 并行创建所有 Pod。但 MySQL 主从需要 Master 先启动完成,Slave 才能连接并开始复制。如果 3 个 Pod 同时启动,谁是 Master?

StatefulSet 解决了这三个问题:

需求 Deployment 的行为 StatefulSet 的行为
网络标识 Pod 名随机,每次重建都变 Pod 名有序(mysql-0, mysql-1, mysql-2),重建后不变
存储 Pod 共享 PVC 或随机分配 每个 Pod 有独立的 PVC,重建后自动重新绑定
部署顺序 所有 Pod 并行创建 按序号逐个创建(0 → 1 → 2)
更新顺序 随机选择 Pod 更新 从最大序号开始倒序更新(2 → 1 → 0)
缩容顺序 随机删除 Pod 从最大序号开始删除(先删 2,再删 1)

3.2 Headless Service:StatefulSet 的网络基础

StatefulSet 必须关联一个 Headless Service(clusterIP: None)。为什么?

普通 Service 分配一个 ClusterIP,DNS 解析返回这个 VIP。但 StatefulSet 的 Pod 需要被单独寻址——你需要连接"mysql-0"而不是"mysql 集群中随机一个"。

Headless Service 不分配 ClusterIP。DNS 查询 Headless Service 名时,返回的是所有 Pod 的 IP 列表。更关键的是,每个 Pod 获得一个独立的 DNS 记录:

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: mysql
spec:
  serviceName: mysql-headless    # 关联 Headless Service
  replicas: 3
  # ...
---
apiVersion: v1
kind: Service
metadata:
  name: mysql-headless
spec:
  clusterIP: None               # Headless!
  selector:
    app: mysql
  ports:
  - port: 3306

创建后,每个 Pod 获得稳定的 DNS 名:

mysql-0.mysql-headless.default.svc.cluster.local → 10.244.1.5
mysql-1.mysql-headless.default.svc.cluster.local → 10.244.2.8
mysql-2.mysql-headless.default.svc.cluster.local → 10.244.3.12

即使 Pod 被重建(比如 Node 故障),DNS 名保持不变——只是 IP 可能变化。所以 Slave 配置 Master 地址时用 DNS 名 mysql-0.mysql-headless 而不是 IP,重建后自动指向新 Pod。

3.3 volumeClaimTemplates:每个 Pod 的独立存储

StatefulSet 通过 volumeClaimTemplates 为每个 Pod 创建独立的 PVC:

spec:
  volumeClaimTemplates:
  - metadata:
      name: data
    spec:
      accessModes: [ReadWriteOnce]
      storageClassName: fast-ssd
      resources:
        requests:
          storage: 50Gi

生成的 PVC 名称遵循 {volumeName}-{statefulsetName}-{ordinal} 的规则:

data-mysql-0 → 绑定到 PV-aaa(50Gi)
data-mysql-1 → 绑定到 PV-bbb(50Gi)
data-mysql-2 → 绑定到 PV-ccc(50Gi)

关键行为:当 mysql-1 被删除重建时,新的 mysql-1 会自动重新绑定到 data-mysql-1 这个 PVC——数据完好无损。

缩容时 PVC 不会自动删除(防止数据丢失)。如果你缩容到 2 个副本,data-mysql-2 这个 PVC 还在。再扩容回 3 个副本时,mysql-2 会复用这个 PVC,数据恢复。

K8s 1.27+ 新增了 persistentVolumeClaimRetentionPolicy 来控制 PVC 的生命周期:

spec:
  persistentVolumeClaimRetentionPolicy:
    whenDeleted: Delete    # 删除 StatefulSet 时同时删除 PVC
    whenScaled: Retain     # 缩容时保留 PVC(默认)

3.4 StatefulSet 的更新策略

spec:
  updateStrategy:
    type: RollingUpdate
    rollingUpdate:
      partition: 2         # 只更新序号 >= 2 的 Pod
      maxUnavailable: 1    # K8s 1.24+

StatefulSet 的滚动更新与 Deployment 不同:

3.5 实战场景:MySQL 主从集群

graph LR
  m0["mysql-0(Master)"]
  m1["mysql-1(Slave)"]
  m2["mysql-2(Slave)"]

  m0 -->|"binlog 同步"| m1
  m0 -->|"binlog 同步"| m2
  m0 ---|"接收读写请求"| rw["读写 Service"]
  m1 ---|"只接收读请求"| r["只读 Service"]
  m2 ---|"只接收读请求"| r

关键设计:

  1. 角色分配:Init Container 通过 Pod 的 hostname 获取序号(hostname | awk -F'-' '{print $NF}')。序号 0 = Master,其他 = Slave。

  2. Master 发现:Slave 的配置文件中写 MASTER_HOST=mysql-0.mysql-headless——通过稳定的 DNS 名找到 Master,不怕 Master Pod 重建。

  3. 两个 Service:

    • 读写 Service(selector 额外加 role: master)→ 只路由到 mysql-0
    • 只读 Service(selector 选所有 Pod)→ 路由到所有 Slave
  4. 顺序保证:StatefulSet 先创建 mysql-0(Master 初始化),等 Ready 后再创建 mysql-1(Slave 连接 Master 开始复制),最后创建 mysql-2。


4. DaemonSet:每个 Node 上的守护进程

4.1 DaemonSet 解决什么问题?

有些工作负载不是"我需要 N 个副本",而是"每个 Node 上必须跑一个"。比如:

如果用 Deployment + replicas: nodeCount,你得在 Node 数变化时手动调整副本数——加一个 Node 就得改 YAML。而且 Deployment 不保证每个 Node 恰好一个。

DaemonSet 自动在每个符合条件的 Node 上调度一个 Pod。Node 加入集群时自动部署,Node 移除时自动清理。

4.2 调度机制

DaemonSet 的调度经历了一次重要演进:

早期(K8s 1.12 前):DaemonSet Controller 直接设置 Pod 的 spec.nodeName,绕过 Scheduler。这导致 DaemonSet Pod 不受 Scheduler 的资源检查、优先级抢占等机制保护——可能在资源已经紧张的 Node 上强行启动 Pod。

当前(K8s 1.12+):DaemonSet Controller 为每个 Pod 添加 nodeAffinity,交给 Scheduler 正常调度:

# DaemonSet Controller 自动生成的 nodeAffinity
spec:
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchFields:
          - key: metadata.name
            operator: In
            values: [node-1]    # 锁定到特定 Node

好处:DaemonSet Pod 也受 Taint/Toleration、资源检查、优先级抢占等机制管控。

指定 Node 子集:如果你只想在部分 Node 上运行 DaemonSet(比如只在 GPU Node 上运行 NVIDIA device plugin),使用 nodeSelector 或 nodeAffinity。

4.3 更新策略

spec:
  updateStrategy:
    type: RollingUpdate
    rollingUpdate:
      maxUnavailable: 1    # 同时更新的最大 Node 数
      maxSurge: 0          # K8s 1.22+

生产建议:对于日志收集器这类不影响业务流量的 DaemonSet,maxUnavailable: 1 就够了。对于网络插件(如 Cilium),建议 maxSurge: 1 避免网络中断。


5. Job 与 CronJob:一次性和定时任务

5.1 Job:为什么不用 Deployment 跑批处理?

批处理任务(数据迁移、报表生成、ETL 处理)和 Web 服务有根本区别:它有结束时间。Deployment 的 Pod 崩溃了会被无限重启——这是 Web 服务需要的行为。但批处理任务完成后应该退出,不需要重启。

Job Controller 的 Reconcile 逻辑和 ReplicaSet Controller 不同:它追踪的不是"当前有几个 Running Pod",而是"成功完成了几个 Pod"。

apiVersion: batch/v1
kind: Job
metadata:
  name: data-migration
spec:
  completions: 10         # 需要成功完成 10 个 Pod
  parallelism: 3          # 同时最多跑 3 个 Pod
  backoffLimit: 6          # 单个 Pod 最多重试 6 次
  activeDeadlineSeconds: 3600  # 整个 Job 超时 1 小时
  ttlSecondsAfterFinished: 86400  # 完成后 24 小时自动清理

  template:
    spec:
      containers:
      - name: worker
        image: my-migration:v1
      restartPolicy: Never   # 或 OnFailure

completions 和 parallelism 的组合:

场景 completions parallelism 行为
单次执行 1 1 跑 1 个 Pod,完成即结束
固定完成数 10 3 每次跑 3 个 Pod,累计 10 个成功后结束
工作队列 不设 5 跑 5 个 Worker Pod,直到队列为空自行退出

restartPolicy 的区别:

Indexed Job(K8s 1.24 GA):每个 Pod 获得唯一索引(0 到 completions-1),通过 annotation batch.kubernetes.io/job-completion-index 传递。适合分片处理场景——比如 100 个数据文件,Pod-0 处理 file-0,Pod-1 处理 file-1...

Pod Failure Policy(K8s 1.26 Beta,1.31 GA):精细控制什么样的失败应该重试、什么应该直接终止 Job。比如 Exit Code 42 表示"数据格式错误,重试也没用"——直接 FailJob,不浪费重试次数:

spec:
  podFailurePolicy:
    rules:
    - action: FailJob
      onExitCodes:
        containerName: worker
        operator: In
        values: [42]            # 不可恢复错误,直接终止
    - action: Ignore
      onPodConditions:
      - type: DisruptionTarget  # Node 驱逐导致的失败,不算重试次数

5.2 CronJob:定时触发的 Job

CronJob 按 cron 表达式定时创建 Job:

apiVersion: batch/v1
kind: CronJob
metadata:
  name: daily-report
spec:
  schedule: "0 2 * * *"           # 每天凌晨 2 点
  timeZone: "Asia/Shanghai"       # K8s 1.27+ 支持时区
  concurrencyPolicy: Forbid       # 不允许并发
  startingDeadlineSeconds: 200    # 错过调度的容忍时间
  successfulJobsHistoryLimit: 3   # 保留最近 3 个成功 Job
  failedJobsHistoryLimit: 1       # 保留最近 1 个失败 Job
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: report
            image: report-gen:v1
          restartPolicy: OnFailure

concurrencyPolicy——上一个 Job 还没跑完怎么办?

策略 行为 场景
Allow(默认) 允许新旧 Job 同时运行 无状态任务、执行时间短
Forbid 跳过本次调度 有状态任务(避免两个 Job 同时写数据库)
Replace 终止旧 Job,创建新 Job 只关心最新结果的场景

三个常见陷阱:

  1. 时区问题:K8s 1.27 之前,schedule 按 kube-controller-manager 所在节点的时区解析。如果你以为是 UTC 但实际是 CST(差 8 小时),凌晨 2 点的任务会在上午 10 点执行。务必使用 timeZone 字段。

  2. Job 堆积:concurrencyPolicy: Allow + Job 执行时间 > 调度间隔 = Job 不断堆积。每分钟一个 Job,每个 Job 跑 5 分钟——10 分钟后你有 10 个 Job 同时运行。解决:用 Forbid 或 Replace,或者调整调度间隔。

  3. 连续错过 100 次:如果 CronJob Controller 宕机或 startingDeadlineSeconds 导致连续错过 100 次调度,CronJob 会被标记为无法调度并停止。需要手动检查并修复。


6. 部署策略深度对比

6.1 原生策略

RollingUpdate(滚动更新)——默认策略,前面已详细分析:

v1 ████████████  →  v1 ████████  v2 ████
                →  v1 ████  v2 ████████
                →  v2 ████████████

Recreate(重建)——先全部删掉,再全部建新的:

v1 ████████████  →  (停机中...)  →  v2 ████████████

6.2 高级部署策略(需要额外工具)

原生 K8s 的 Deployment 只支持 RollingUpdate 和 Recreate。更精细的流量控制需要额外工具。

蓝绿部署(Blue-Green)

核心思路:同时维护两套完整的 Deployment(Blue = 当前版本,Green = 新版本),通过切换 Service 的 selector 瞬间切流量。

切换前:
  Service selector: version=blue
  Blue Deployment (v1): 4 Pod     ← 接收所有流量
  Green Deployment (v2): 4 Pod    (已部署,待切换)

切换:
  kubectl patch svc web -p '{"spec":{"selector":{"version":"green"}}}'

切换后:
  Service selector: version=green
  Blue Deployment (v1): 4 Pod     (可随时回滚)
  Green Deployment (v2): 4 Pod    ← 接收所有流量

优点:瞬间切换、瞬间回滚。缺点:需要双倍资源。

金丝雀发布(Canary)

核心思路:先让少量流量(如 5%)经过新版本,观察一段时间后逐步增加比例。

简单版(纯 K8s 实现):两个 Deployment 共享同一个 Service(相同的 label),通过调整 Pod 数量比例控制流量比例。比如旧版 9 个 Pod + 新版 1 个 Pod = 10% 流量到新版。但这种方式只能按 Pod 数量比例控制,粒度很粗。

精确版需要 Service Mesh 或 Ingress Controller 的流量分割能力(如 Istio 的 VirtualService、Nginx Ingress 的 canary annotation)。

6.3 Argo Rollouts:自动化的渐进式交付

Argo Rollouts 是 CNCF 项目,用一个 Rollout CRD 替代 Deployment,提供:

apiVersion: argoproj.io/v1alpha1
kind: Rollout
metadata:
  name: web
spec:
  replicas: 10
  strategy:
    canary:
      steps:
      - setWeight: 10           # 10% 流量到新版本
      - pause: {duration: 5m}   # 观察 5 分钟
      - analysis:               # 自动化指标分析
          templates:
          - templateName: success-rate
      - setWeight: 50           # 分析通过,提升到 50%
      - pause: {duration: 10m}
      - setWeight: 100          # 全量

最强大的功能是 Analysis——自动查询 Prometheus 指标判断新版本是否健康:

apiVersion: argoproj.io/v1alpha1
kind: AnalysisTemplate
metadata:
  name: success-rate
spec:
  metrics:
  - name: success-rate
    interval: 30s
    count: 10
    successCondition: result[0] >= 0.95    # 成功率 ≥ 95%
    failureLimit: 3
    provider:
      prometheus:
        address: http://prometheus:9090
        query: |
          sum(rate(http_requests_total{status=~"2.*",app="web"}[5m]))
          /
          sum(rate(http_requests_total{app="web"}[5m]))

如果连续 3 次检测成功率 < 95%,Argo Rollouts 自动回滚——不需要人值守。


7. 自动伸缩

7.1 HPA(Horizontal Pod Autoscaler):水平伸缩

问题:你的 Web 服务白天流量大、晚上流量小。固定 replicas 意味着——要么白天不够用(服务慢),要么晚上浪费(资源闲置)。

HPA 根据指标自动调整 Deployment 的 replicas 数:

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: web-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: web
  minReplicas: 2
  maxReplicas: 20
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70    # 目标:CPU 平均利用率 70%

缩放算法:

期望副本数 = ⌈ 当前副本数 × (当前指标值 / 目标指标值) ⌉

具体例子:当前 4 个 Pod,CPU 平均利用率 90%,目标 70%:

期望 = ⌈ 4 × (90/70) ⌉ = ⌈ 5.14 ⌉ = 6 个 Pod

HPA 每 15 秒(默认)执行一次这个计算。

为什么扩容要快、缩容要慢?

HPA v2 引入了 behavior 来精细控制扩缩速率:

spec:
  behavior:
    scaleUp:
      stabilizationWindowSeconds: 0     # 扩容不等待——立即响应
      policies:
      - type: Percent
        value: 100                      # 每 15 秒最多翻倍
        periodSeconds: 15
    scaleDown:
      stabilizationWindowSeconds: 300   # 缩容前等 5 分钟
      policies:
      - type: Percent
        value: 10                       # 每分钟最多缩 10%
        periodSeconds: 60

扩容要快:流量突增时,慢一秒就多一秒的延迟和错误。
缩容要慢:流量可能只是短暂下降。如果太快缩容,流量回升时又得重新扩——造成不必要的 Pod 频繁创建/销毁(称为"抖动/thrashing")。

stabilizationWindowSeconds 的作用:在窗口期内记录所有计算出的期望副本数,取最大值(缩容时)。这意味着 5 分钟内只要有一次计算结果要求更多 Pod,就不会缩。

自定义指标

CPU/Memory 不总是最好的伸缩依据。比如消息队列消费者——CPU 可能很低(等待消息),但队列堆积了 10 万条消息,需要更多消费者。

HPA 通过 Metrics API 获取自定义指标:

API 由谁提供 指标类型
metrics.k8s.io metrics-server CPU/Memory
custom.metrics.k8s.io Prometheus Adapter Pod/Object 自定义指标
external.metrics.k8s.io 外部适配器 外部系统指标(如消息队列长度)
metrics:
- type: Pods
  pods:
    metric:
      name: http_requests_per_second
    target:
      type: AverageValue
      averageValue: 1000    # 每个 Pod 每秒处理 1000 请求

7.2 VPA(Vertical Pod Autoscaler):垂直伸缩

HPA 调整 Pod 数量,VPA 调整单个 Pod 的资源配置(requests/limits)。

场景:你不确定一个 Java 应用到底需要多少 Memory。设少了 OOM,设多了浪费。VPA 根据历史使用数据推荐合理的 requests。

apiVersion: autoscaling.k8s.io/v1
kind: VerticalPodAutoscaler
metadata:
  name: web-vpa
spec:
  targetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: web
  updatePolicy:
    updateMode: "Auto"    # Auto | Initial | Off
  resourcePolicy:
    containerPolicies:
    - containerName: web
      minAllowed:
        cpu: 100m
        memory: 128Mi
      maxAllowed:
        cpu: 4
        memory: 8Gi

VPA 的三个组件:

组件 做什么
Recommender 基于 Prometheus 历史指标计算推荐的 requests
Updater 驱逐当前 Pod(因为 requests 是不可变字段,只能重建 Pod 才能修改)
Admission Plugin 新 Pod 创建时,注入推荐的 requests 值

updateMode 的选择:

VPA + HPA 的冲突:如果 HPA 基于 CPU 扩缩,VPA 同时调整 CPU requests——两者会打架。HPA 说"加 Pod",VPA 说"给每个 Pod 加 CPU",可能导致过度扩容。安全组合:VPA 管 Memory,HPA 基于自定义指标(不基于 CPU/Memory)。

7.3 KEDA:事件驱动的弹性伸缩

HPA 的局限性:最少 1 个副本(minReplicas ≥ 1),而且只能基于 Metrics API 提供的指标。

KEDA(Kubernetes Event-Driven Autoscaling)解决了两个问题:

  1. 缩容到 0:没有事件时完全释放资源——适合间歇性工作负载(如夜间没有订单的订单处理器)
  2. 60+ 事件源:直接对接 Kafka、RabbitMQ、Redis、AWS SQS 等,不需要自己写 Metrics Adapter
apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
  name: order-processor
spec:
  scaleTargetRef:
    name: order-processor
  minReplicaCount: 0          # 可以缩到 0!
  maxReplicaCount: 50
  triggers:
  - type: rabbitmq
    metadata:
      host: amqp://rabbitmq:5672
      queueName: orders
      queueLength: "5"        # 每 5 条消息分配一个 Pod

当队列中有 100 条消息时:100 / 5 = 20 个 Pod。消息消费完后:0 个 Pod。

KEDA 底层仍然通过创建 HPA 实现——它是 HPA 的增强,不是替代。

7.4 Cluster Autoscaler:Node 级别的伸缩

HPA/VPA/KEDA 都是在 Pod 级别伸缩。但如果所有 Node 的资源都用满了,新 Pod 调度不上去——Pending。

Cluster Autoscaler(CA) 在 Node 级别自动伸缩:

graph TD
  traffic["流量增加"] --> hpa["HPA 扩容 Pod"]
  hpa --> pending["Pod Pending(Node 资源不足)"]
  pending --> ca["Cluster Autoscaler 检测到 Pending Pod"]
  ca --> add["向云 API 请求新增 Node"]
  add --> join["新 Node 加入集群"]
  join --> schedule["Scheduler 将 Pending Pod 调度到新 Node"]

扩容触发:有 Pod 处于 Pending 状态且原因是资源不足。
缩容触发:Node 利用率低于阈值(默认 50%)持续 10 分钟,且上面的 Pod 可以被调度到其他 Node。

CA 不会缩掉的 Node:有 PDB 保护的 Pod、有本地存储的 Pod、有 cluster-autoscaler.kubernetes.io/safe-to-evict: "false" annotation 的 Pod。


8. 配置管理

8.1 ConfigMap 与 Secret:三种使用方式的差异

# 方式 1:单个环境变量
env:
- name: DATABASE_URL
  valueFrom:
    configMapKeyRef:
      name: app-config
      key: database_url

# 方式 2:批量环境变量(整个 ConfigMap 的所有 key 变成 env)
envFrom:
- configMapRef:
    name: app-config

# 方式 3:Volume 挂载(作为文件)
volumeMounts:
- name: config
  mountPath: /etc/config
volumes:
- name: config
  configMap:
    name: app-config

关键区别——热更新:

方式 ConfigMap 更新后 Pod 行为 原因
env / envFrom 不更新,需要重启 Pod 环境变量在容器启动时注入,运行中不可变
Volume 挂载 自动更新(约 1 分钟延迟) kubelet 定期同步,通过 symlink 原子替换

Volume 挂载的热更新机制:

graph TD
  sync["kubelet 同步周期(~60s)"] --> detect["检测到 ConfigMap 版本变化"]
  detect --> write["写入新内容到临时目录 ..data_tmp"]
  write --> rename["原子 rename: ..data_tmp → ..data"]

但应用不会自动 reload! 文件更新了,应用需要自己感知并重新读取。常见方案:

8.2 Immutable ConfigMap/Secret

apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config-v2
immutable: true       # 标记为不可变
data:
  key: value

设为 immutable 后,ConfigMap 的内容不能被修改。修改配置需要创建新的 ConfigMap(如 app-config-v3)并更新 Pod 引用。

为什么要这么麻烦?两个实际收益:

  1. 性能:kubelet 不再 Watch immutable ConfigMap——在大集群中,成千上万个 ConfigMap 的 Watch 会给 apiserver 造成显著负载
  2. 安全:防止有人手动 kubectl edit configmap 改了配置导致线上故障——改不了就不会出错

8.3 Downward API:让 Pod 知道"我是谁"

有时容器需要知道自己的 Pod 名、Node 名、IP 地址等元数据,但你不想硬编码,也不想在容器里调 apiserver 查询。Downward API 将 Pod 元数据注入环境变量或文件:

env:
- name: POD_NAME
  valueFrom:
    fieldRef:
      fieldPath: metadata.name
- name: POD_IP
  valueFrom:
    fieldRef:
      fieldPath: status.podIP
- name: NODE_NAME
  valueFrom:
    fieldRef:
      fieldPath: spec.nodeName
- name: CPU_REQUEST
  valueFrom:
    resourceFieldRef:
      containerName: app
      resource: requests.cpu

实际用途:


9. 参考资料

资源 链接 说明
Deployments 官方文档 滚动更新、回滚
StatefulSets 官方文档 有状态应用
DaemonSet 官方文档 节点守护进程
Jobs 官方文档 批处理
CronJob 官方文档 定时任务
HPA 官方文档 水平自动伸缩
ConfigMaps 官方文档 配置管理
Deployment Controller 源码 GitHub 源码级理解
Argo Rollouts 官网 渐进式交付
Flagger 官网 渐进式交付(Flux 生态)
KEDA 官网 事件驱动自动伸缩
Cluster Autoscaler FAQ GitHub 节点自动伸缩
VPA GitHub 垂直自动伸缩
Graceful Shutdown Learnk8s 优雅停机最佳实践
Prometheus Adapter GitHub 自定义指标 HPA
Stakater Reloader GitHub ConfigMap 变更自动重启
Kubernetes in Action (2nd Ed) Marko Lukša 工作负载控制器讲解最详细
Kubernetes Patterns (2nd Ed) Bilgin Ibryam, Roland Huß 设计模式系统性总结

本文基于 Kubernetes v1.30+ 版本撰写。