工作负载编排与部署策略深度解析
你创建了 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
}
这个函数有两个关键属性:
-
Level-triggered(电平触发):它不关心"之前发生了什么事件",只看"当前状态 vs 期望状态"。即使错过了 10 个事件通知,下次循环依然能发现问题并修复。
-
幂等性(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,滚动更新时就面临一个两难:
- 你不能先把所有旧 Pod 删了再创建新的(有停机时间)
- 你也不能简单地"替换"Pod(Pod 是不可变的,改 image 必须删旧建新)
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) 用于回滚
关键观察:
- 整个过程中,可用 Pod 数始终 ≥ 3(maxUnavailable=1 的保证)
- 总 Pod 数始终 ≤ 5(maxSurge=1 的保证)
- 新旧版本短暂共存——这要求你的应用能处理新旧版本同时运行的情况(比如 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 不同:
- 从最大序号开始倒序更新:
mysql-2 → mysql-1 → mysql-0。这在数据库场景中很有意义——先更新 Slave,最后更新 Master,保证 Master 始终在线。 - Partition 是金丝雀发布的利器:设
partition: 2意味着只有mysql-2会被更新到新版本。你可以验证mysql-2没问题后,把 partition 改为 1(更新mysql-2和mysql-1),最后改为 0(全量更新)。 - OnDelete 策略:只有手动删除 Pod 时才会用新版本重建——完全手动控制,适合需要严格操作窗口的场景。
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
关键设计:
-
角色分配:Init Container 通过 Pod 的 hostname 获取序号(
hostname | awk -F'-' '{print $NF}')。序号 0 = Master,其他 = Slave。 -
Master 发现:Slave 的配置文件中写
MASTER_HOST=mysql-0.mysql-headless——通过稳定的 DNS 名找到 Master,不怕 Master Pod 重建。 -
两个 Service:
- 读写 Service(selector 额外加
role: master)→ 只路由到 mysql-0 - 只读 Service(selector 选所有 Pod)→ 路由到所有 Slave
- 读写 Service(selector 额外加
-
顺序保证:StatefulSet 先创建 mysql-0(Master 初始化),等 Ready 后再创建 mysql-1(Slave 连接 Master 开始复制),最后创建 mysql-2。
4. DaemonSet:每个 Node 上的守护进程
4.1 DaemonSet 解决什么问题?
有些工作负载不是"我需要 N 个副本",而是"每个 Node 上必须跑一个"。比如:
- 日志收集(Fluentd/Fluent Bit):每个 Node 上收集该 Node 所有容器的日志
- 监控 Agent(Node Exporter):每个 Node 上采集系统指标
- 网络插件(Calico/Cilium Agent):每个 Node 上配置 Pod 网络
- 存储插件(CSI Node Plugin):每个 Node 上处理 Volume 挂载
如果用 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+
maxUnavailable: 1, maxSurge: 0(默认):每次 1 个 Node——先删旧 Pod,旧 Pod 终止后再创建新 Pod。期间该 Node 上有短暂的服务间隙。maxUnavailable: 0, maxSurge: 1:先在 Node 上启动新 Pod,新 Pod Ready 后再删旧 Pod。零停机,但该 Node 上临时有两个 DaemonSet Pod 同时运行。
生产建议:对于日志收集器这类不影响业务流量的 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 的区别:
Never:Pod 失败后 不重启,Job Controller 创建新 Pod 重试。好处是失败的 Pod 保留在那里(可以看日志排查),坏处是可能堆积大量失败 Pod。OnFailure:Pod 失败后在原 Node 上重启。好处是不创建新 Pod,坏处是如果是 Node 问题(比如磁盘满),在原 Node 重启也还是会失败。
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 | 只关心最新结果的场景 |
三个常见陷阱:
-
时区问题:K8s 1.27 之前,
schedule按 kube-controller-manager 所在节点的时区解析。如果你以为是 UTC 但实际是 CST(差 8 小时),凌晨 2 点的任务会在上午 10 点执行。务必使用timeZone字段。 -
Job 堆积:
concurrencyPolicy: Allow+ Job 执行时间 > 调度间隔 = Job 不断堆积。每分钟一个 Job,每个 Job 跑 5 分钟——10 分钟后你有 10 个 Job 同时运行。解决:用Forbid或Replace,或者调整调度间隔。 -
连续错过 100 次:如果 CronJob Controller 宕机或
startingDeadlineSeconds导致连续错过 100 次调度,CronJob 会被标记为无法调度并停止。需要手动检查并修复。
6. 部署策略深度对比
6.1 原生策略
RollingUpdate(滚动更新)——默认策略,前面已详细分析:
v1 ████████████ → v1 ████████ v2 ████
→ v1 ████ v2 ████████
→ v2 ████████████
- 零停机,但新旧版本短暂共存——需要应用 API 向后兼容
- 回滚速度取决于 Pod 数量和滚动速度
Recreate(重建)——先全部删掉,再全部建新的:
v1 ████████████ → (停机中...) → v2 ████████████
- 有停机时间——适用于不能多版本共存的场景(如数据库 Schema 升级不兼容旧版本代码)
- 简单,不用担心版本兼容性
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 的选择:
Off:只推荐,不自动应用。适合先观察推荐值是否合理Initial:只在 Pod 创建时应用推荐值,不会驱逐已运行的 PodAuto:会驱逐 Pod 来应用新值——注意!这意味着 Pod 会被重建
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)解决了两个问题:
- 缩容到 0:没有事件时完全释放资源——适合间歇性工作负载(如夜间没有订单的订单处理器)
- 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! 文件更新了,应用需要自己感知并重新读取。常见方案:
- 应用代码用 inotify 监听配置文件变化
- Sidecar 容器监听文件变化后给应用进程发 SIGHUP 信号
- 使用 Stakater Reloader 自动触发 Deployment rollout restart
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 引用。
为什么要这么麻烦?两个实际收益:
- 性能:kubelet 不再 Watch immutable ConfigMap——在大集群中,成千上万个 ConfigMap 的 Watch 会给 apiserver 造成显著负载
- 安全:防止有人手动
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
实际用途:
POD_NAME注入日志和 Prometheus 指标的 label——知道这条日志/指标来自哪个 PodCPU_REQUEST动态设置线程数——Java 应用根据 CPU requests 设置-XX:ActiveProcessorCount,避免容器内看到 Node 的全部 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+ 版本撰写。