调度约束:nodeSelector / Taint / Affinity / 拓扑分布
覆盖考纲 Workloads and Scheduling(15%) 中「Understand how resource limits can affect Pod scheduling」的实现手段。 实验环境:三节点(k8s-master 带
control-plane:NoSchedule污点 / k8s-node01disk=ssd/ k8s-node02disk=hdd),v1.36.3
核心认知
K8s 调度分两个阶段:
① Filtering(过滤)—— 排除不满足【硬约束】的节点,剩下的才进入下一步
② Scoring(打分)—— 给剩下的节点打 0-100 分,选最高分
硬约束 → 在 ① 生效:不满足 = 直接出局 = Pod Pending
软约束 → 在 ② 生效:不满足 = 分低一点 = 换个节点跑
一句话:
约束决定「能不能去」,打分决定「到底去哪」。
由此推出两条铁律:
| 情形 | 结果 | 性质 |
|---|---|---|
| 硬约束不满足 | Pod Pending | 显式失败(看得见) |
| 软约束不满足 | 落到次优节点 | 静默降级(看不见) |
需要保证的约束永远用硬约束 —— Pending 会让你立刻发现问题,而软约束会悄悄把三副本挤到一个节点上。
一、五种调度约束总览
| 约束 | 作用粒度 | 支持软约束? | 域的来源 |
|---|---|---|---|
nodeName | 直接指定节点 | ❌ | — |
nodeSelector | 节点标签精确匹配 | ❌ | — |
affinity.nodeAffinity | 节点标签表达式 | ✅ | — |
affinity.podAffinity / podAntiAffinity | 其他 Pod 的位置 | ✅ | topologyKey |
topologySpreadConstraints | 域之间的数量均衡 | ✅ | topologyKey |
前三个看「节点自身的属性」,后两个看「别人的位置/数量」。这是本质分界。
全篇一句话对照:
nodeSelector / nodeAffinity → "我要去什么样的节点"
podAffinity → "我要挨着谁"
podAntiAffinity → "我要躲开谁"
topologySpreadConstraints → "大家要铺开,最多差几个"
二、nodeName / nodeSelector
2.1 nodeName —— 跳过调度器
spec:
nodeName: k8s-node01
它完全不经过 kube-scheduler:节点不存在 → Pod 永远 Pending,Events 里什么都没有;资源不足 → 照样绑上去、然后被 OOMKilled;有污点 → 照样上去(taint 对它无效)。生产上基本不用。
2.2 nodeSelector —— 只有硬约束、只能等值
spec:
nodeSelector:
disk: ssd
- 只支持
key: value精确等值,不支持In/Exists/Gt - 多个键是 AND
匹配不到时:
Warning FailedScheduling 0/3 nodes are available:
1 node(s) had untolerated taint(s),
2 node(s) didn't match Pod's node affinity/selector.
Pod's node affinity/selector 同时覆盖 nodeSelector 和 nodeAffinity —— 两者在 Filtering 里是同一类过滤器。
三、nodeAffinity —— nodeSelector 的超集
3.1 硬 / 软
spec:
affinity:
nodeAffinity:
# 硬:不满足 = 出局
requiredDuringSchedulingIgnoredDuringExecution:
nodeSelectorTerms:
- matchExpressions:
- key: disk
operator: In
values: [ssd]
# 软:不满足 = 分低
preferredDuringSchedulingIgnoredDuringExecution:
- weight: 100
preference: # ★ 注意是【单数】
matchExpressions:
- key: disk
operator: In
values: [ssd]
| 项 | required | preferred |
|---|---|---|
| 选择器字段 | nodeSelectorTerms(复数、数组) | preference(单数、对象) |
| weight | 不需要 | 必填,1-100 |
那个超长字段名拆开看:
required(必须)+DuringScheduling(调度时检查)+IgnoredDuringExecution(运行中不检查)。最后一段的含义见第八章。
3.2 operator 与实测
| operator | 含义 |
|---|---|
In / NotIn | 值在 / 不在列表 |
Exists / DoesNotExist | 标签存在 / 不存在(不管值) |
Gt / Lt | 数值比较 |
Exists 的用处:表达"有 GPU 就行,不用关心型号"。
| Deployment | 配置 | 落点 |
|---|---|---|
aff-hard | required ssd | 3/3 node01(node02 在 Filtering 出局) |
aff-soft | preferred ssd,weight 100,资源充足 | 3/3 node01 |
aff-soft2 | 同上 + cpu-hog 占满 node01 CPU | 3 + 3 |
aff-soft 全去 node01 是反直觉的,aff-soft2 才是 preferred 的真实价值 —— 下一节解释。
四、打分机制(一句话带过)
软约束不满足时不会 Pending,只是分数低;但单条
preferred的weight写 1 还是 100 完全等价(分数会被归一化),它只在「多条 preferred 之间」表达优先级。想让资源压过标签偏好,靠的不是调 weight,而是让目标节点在 Filtering 阶段资源不足出局。
分数 0-100,越高越好,同分随机选。这正好解释上面两组实测:aff-soft 的 100 分标签优势压过十几分的资源差距,全部落在 node01;aff-soft2 里 node01 资源吃满、在 Filtering 出局,才被迫分散。
preferred 永远不会让 Pod Pending —— 这是它和 required 的根本分野。
五、Taint & Toleration —— 方向反过来
前面都是「Pod 挑节点」,这个是「节点拒绝 Pod」。
| 概念 | 谁设置 | 语义 |
|---|---|---|
| Taint(污点) | 节点 | "我不接收 Pod" |
| Toleration(容忍) | Pod | "我能忍受这个污点" |
5.1 三种 effect(分水岭在"已存在的 Pod")
| effect | 新 Pod 能否调度 | 已存在的 Pod |
|---|---|---|
PreferNoSchedule | ⚠️ 尽量不调度(软) | ✅ 不受影响 |
NoSchedule | ❌ 不能 | ✅ 不受影响 |
NoExecute | ❌ 不能 | ❌ 被驱逐 |
实测:打 NoSchedule 后 node02 上已有的 Pod 纹丝不动;打 NoExecute 立刻被删除、在别处重建;撤销 NoExecute 后不会自己回来。
集群里现成的例子:k8s-master 带 node-role.kubernetes.io/control-plane:NoSchedule —— 业务 Pod 不去 master,不是"master 特殊",是它有这个污点。
5.2 Toleration 三种写法
tolerations:
- key: "env" # A. Equal:key+value+effect 全匹配
operator: "Equal"
value: "prod"
effect: "NoSchedule"
- key: "env" # B. Exists:只看 key 存在,不管 value
operator: "Exists"
effect: "NoSchedule"
- operator: "Exists" # C. 容忍所有污点(慎用,等于能去 master)
5.3 实测:容忍只是"通行证",不是"目的地"
| Deployment | 配置 | 落点 |
|---|---|---|
web-ssd | nodeSelector: disk=ssd | 3/3 node01 |
web-notol | 无 toleration,node02 有 env=prod:NoSchedule | 3/3 node01 |
web-tol2 | 有 toleration | 2 node02 + 1 node01 |
Filtering:node01(无污点)✅ node02(有污点但容忍)✅
Scoring: node02 更空闲 → 得分高 → 前两个去 node02
第三个时 node02 变忙 → 去了 node01
5.4 tolerationSeconds 与节点故障
节点失联/未就绪时,node-lifecycle-controller 自动打两个 NoExecute 污点(node.kubernetes.io/not-ready、node.kubernetes.io/unreachable)。Pod 没显式定义时,准入控制器会自动注入 300 秒容忍,所以随便拿一个 Pod 看 -o yaml 都能看到:
tolerations:
- key: node.kubernetes.io/not-ready
operator: Exists
effect: NoExecute
tolerationSeconds: 300 # ★ 默认值
- key: node.kubernetes.io/unreachable
operator: Exists
effect: NoExecute
tolerationSeconds: 300
这就是"节点挂了,Pod 5 分钟后才开始重建"的原因 —— 不是慢,是默认容忍 300 秒。
不写 tolerationSeconds 则一直容忍,Pod 永远留在故障节点上;写了 30 就是"再待 30 秒然后被驱逐"。
六、podAffinity / podAntiAffinity —— 按「别人的位置」调度
这一节开始才是调度里真正复杂的部分。
6.1 两个方向
| 语义 | 典型用途 | |
|---|---|---|
podAffinity | 挨着某类 Pod | web 和本地缓存(Redis sidecar)同节点,减少跨节点延迟 |
podAntiAffinity | 躲开某类 Pod | 同一服务的多个副本不要挤在一个节点(高可用) |
注意方向性:判断依据是"新 Pod 看已有 Pod 的位置",不是反过来。已有 Pod 不会因为新 Pod 出现而移动。
6.2 字段结构
spec:
affinity:
podAntiAffinity:
requiredDuringSchedulingIgnoredDuringExecution:
- labelSelector: # ① 谁(按标签找 Pod)
matchLabels:
app: anti-aff
namespaces: ["default"] # ② 在哪些命名空间里找(可省)
topologyKey: kubernetes.io/hostname # ③ "同一处"的判定单位
| # | 读法 | 易错点 |
|---|---|---|
| ① | matchLabels / matchExpressions | 和 nodeAffinity 的 matchExpressions 是两套语法,不能混写 |
| ② | namespaces 列表或 namespaceSelector | 省略 = 只在本命名空间找 |
| ③ | topologyKey | 决定全部语义 |
6.3 topologyKey 决定"什么算同一处"
| topologyKey | 域的含义 | 反亲和的效果 |
|---|---|---|
kubernetes.io/hostname | 一个节点 | 同一节点不能有两个 |
topology.kubernetes.io/zone | 一个可用区 | 同一可用区不能有两个(跨节点也不行) |
自定义标签(如 rack) | 按标签值分组 | 同一机架不能有两个 |
同一个 podAntiAffinity,换个 topologyKey,效果天差地别。
举例对比(3 副本、2 节点、1 个可用区):
| topologyKey | 结果 |
|---|---|
hostname | node01 1 个 + node02 1 个 + 1 个 Pending |
zone | 1 个 Running + 2 个 Pending(全集群只有 1 个可用区) |
写 zone 时反亲和变得更强,不是更弱 —— 这点容易想反。
6.4 跨命名空间匹配
默认只看本命名空间。 要匹配其他命名空间的 Pod(例如"所有租户都要避开日志采集器"):
podAntiAffinity:
requiredDuringSchedulingIgnoredDuringExecution:
- labelSelector:
matchLabels: {app: log-collector}
namespaces: ["logging", "kube-system"] # 显式列名单
# 或
namespaceSelector:
matchLabels:
tier: logging # 按命名空间标签选
topologyKey: kubernetes.io/hostname
注意 namespaceSelector 只选命名空间,labelSelector 只选 Pod,两者是 AND。
这和 NetworkPolicy 的坑同源 —— 别把两个选择器写成两项以为能"或"。
6.5 多条规则 = AND
podAntiAffinity:
requiredDuringSchedulingIgnoredDuringExecution:
- labelSelector: {matchLabels: {app: web}}
topologyKey: kubernetes.io/hostname # 规则 1:同节点不能有 web
- labelSelector: {matchLabels: {app: web}}
topologyKey: topology.kubernetes.io/zone # 规则 2:同可用区不能有 web
两条都要满足 —— 结果是"每个可用区里只能有一个 web,且每个节点只能一个"。
6.6 实测:3 副本 × 2 节点
anti-aff-...-98mzk Running k8s-node02
anti-aff-...-hvpx8 Running k8s-node01
anti-aff-...-pngtl Pending <none>
Events:
Warning FailedScheduling 0/3 nodes are available:
1 node(s) had untolerated taint(s),
2 node(s) didn't match pod anti-affinity rules.
no new claims to deallocate,
preemption: 0/3 nodes are available:
1 Preemption is not helpful for scheduling,
2 No preemption victims found for incoming pod.
Events 读法(CKA 排障标准格式):
0/N nodes are available: 后面把【每一类拒绝原因 + 涉及节点数】列全
各项相加必须等于 N
后面 preemption: 段是调度器尝试抢占也失败 —— 两个 worker 上是同类 Pod(抢不了自己),master 是污点(抢了也没用)。
6.7 关键:replicas: 3 ≠ 三副本高可用
默认调度下,3 个 Pod 各自独立走 Filtering + Scoring、彼此不知道对方存在 → 全部落在同一节点是正常结果 → 该节点故障,整个服务同时挂掉。要保证分散,必须显式配置反亲和或拓扑分布。
6.8 两个容易忽略的点
| 点 | 说明 |
|---|---|
| 只看标签不看内容 | 匹配靠 labelSelector,标签是人工维护的,标签错了就匹配错了 |
| 计算代价 | InterPodAffinity 插件要遍历匹配的 Pod,几千 Pod 的集群下单次调度会明显变慢,大集群更适合 topologySpreadConstraints |
(podAffinity 和 nodeAffinity 可以同时用,都在 Filtering 阶段生效。)
七、topologySpreadConstraints —— 从"禁止"到"允许不均衡"
7.1 它解决反亲和的什么死板
5 个副本、2 个节点、要求高可用
反亲和(required):每节点最多 1 个 → 只能跑 2 个,3 个 Pending
去掉反亲和: 全挤一个节点 → 没有高可用
↑ 中间没有任何选择
topologySpreadConstraints 提供的是"可以接受的不均衡" —— 允许多个副本在同一域,但限制域之间的差距。
7.2 字段结构
spec:
topologySpreadConstraints: # ★ 顶层字段,和 affinity 平级
- maxSkew: 1 # 允许的最大差值
topologyKey: kubernetes.io/hostname # 域的单位
whenUnsatisfiable: DoNotSchedule # 硬 / 软
labelSelector:
matchLabels: {app: spread-test}
whenUnsatisfiable 就是"硬/软"的表达方式:
| 取值 | 含义 | 等价于 |
|---|---|---|
DoNotSchedule | 不满足 → Pending | required... |
ScheduleAnyway | 只影响打分,永远能跑 | preferred... |
7.3 maxSkew 的精确定义
maxSkew= 「某个域中的匹配 Pod 数」与「全局最小值」之间允许的最大差值。全局最小值 = 所有【合格域】计数里的最小值,包括 0 个 Pod 的空域。
两个子概念:
| 概念 | 定义 | 默认 |
|---|---|---|
| 合格域 | 有 topologyKey 标签的节点,再受下面两个策略过滤 | — |
nodeAffinityPolicy | 不满足 Pod 的 nodeAffinity/nodeSelector 的节点不计入域 | Honor |
nodeTaintsPolicy | 带不可容忍污点的节点是否计入域 | Ignore(计入!) |
所以 maxSkew 不是"每节点最多几个",而是"最多比最少的域多几个"。
7.4 逐 Pod 推演:3 副本 / 2 worker + 1 tainted master
域 = 3 个(三个节点都有 kubernetes.io/hostname 标签),maxSkew: 1
第 1 个 Pod
计数 {node01:0, node02:0, master:0},min = 0
| 候选 | 放后计数 | skew = 计数 − 0 | ≤ 1? |
|---|---|---|---|
| node01 | 1 | 1 | ✅ |
| node02 | 1 | 1 | ✅ |
| master | — | — | ❌ 污点(在 skew 计算之前就被拒) |
→ 落到 node01。计数 {1, 0, 0}
第 2 个 Pod
计数 {node01:1, node02:0, master:0},min = 0
| 候选 | 放后计数 | skew | ≤ 1? |
|---|---|---|---|
| node01 | 2 | 2 | ❌ |
| node02 | 1 | 1 | ✅ |
→ 落到 node02。计数 {1, 1, 0}
第 3 个 Pod
计数 {node01:1, node02:1, master:0},min = 0
| 候选 | 放后计数 | skew | ≤ 1? |
|---|---|---|---|
| node01 | 2 | 2 | ❌ |
| node02 | 2 | 2 | ❌ |
| master | — | — | ❌ 污点 |
→ 全部被拒,Pending。
要害就是 master 那个 0 —— 一个根本调度不上去的节点,把全局最小值钉在了 0。
7.5 三个对照实验
| # | 配置 | 全局最小值 | 第 3 个 Pod 的 skew | 结果 |
|---|---|---|---|---|
| 1 | maxSkew: 1(默认策略) | 0(含 master) | 2 − 0 = 2 > 1 | ❌ Pending(2+1) |
| 2 | maxSkew: 2 | 0 | 2 − 0 = 2 ≤ 2 | ✅ 3 Running(2:1) |
| 3 | maxSkew: 1 + nodeTaintsPolicy: Honor | 1(排除 master) | 2 − 1 = 1 ≤ 1 | ✅ 3 Running(2:1) |
两条路都通了,但语义完全不同:
| 方案 | 改了什么 | 语义 |
|---|---|---|
maxSkew: 2 | 放宽要求 | "允许差 2 个" |
nodeTaintsPolicy: Honor | 修正计算口径 | "调度不上去的节点不该参与比较" |
后者更贴近本意 —— 你要的是"两个能用的节点之间要均衡",不是"允许差 2 个"。
7.6 副本数变化时的行为(按公式推)
默认策略(min 恒为 0,因为有 master 这个空域):
| maxSkew | 每域最多 | 2 个 worker 能跑 | 5 副本时 |
|---|---|---|---|
| 1 | 1 | 2 个 | 2 Running + 3 Pending |
| 2 | 2 | 4 个 | 4 Running + 1 Pending |
| 3 | 3 | 6 个 | 5 个全跑(3:2) |
nodeTaintsPolicy: Honor + maxSkew: 1(min 随填充上升):
| 副本数 | 分布 |
|---|---|
| 3 | 2 : 1 |
| 5 | 3 : 2 |
| 7 | 4 : 3 |
Honor 下的 maxSkew: 1 等价于"两域之差不超过 1",也就是 ceil(n/2) : floor(n/2) —— 这才是"尽量均衡"的自然语义。
7.7 多条 constraints 同时生效(AND)
同时限制节点和可用区,是最常见的生产写法:
topologySpreadConstraints:
- maxSkew: 1
topologyKey: kubernetes.io/hostname # 同可用区内,节点之间要均衡
whenUnsatisfiable: ScheduleAnyway
labelSelector: {matchLabels: {app: web}}
- maxSkew: 1
topologyKey: topology.kubernetes.io/zone # 可用区之间要均衡
whenUnsatisfiable: DoNotSchedule
labelSelector: {matchLabels: {app: web}}
语义:先保证可用区之间严格均衡(硬),再在可用区内部让节点尽量均衡(软)。
注意两条的 whenUnsatisfiable 可以不同 —— 可用区是"必须分散"(业务连续性),节点是"尽量分散"(性能)。
7.8 minDomains —— 最少要有几个域
- maxSkew: 1
minDomains: 3 # 至少要 3 个合格域
topologyKey: topology.kubernetes.io/zone
whenUnsatisfiable: DoNotSchedule
规则:合格域数量 少于 minDomains 时,全局最小值强制置为 0。
用途:
三可用区集群,某个 zone 临时故障只剩 2 个 zone
→ 不设 minDomains:maxSkew 1 下 2 个 zone 各放一些,勉强能跑
→ 设 minDomains: 3:全局最小值变 0,skew 立刻超标 → Pending
→ 宁可等第三个 zone 恢复,也不接受"只有 2 个 zone"的降级部署
这是"业务上必须跨 3 个机房"才会用的参数,普通场景不用写。
7.9 与 podAntiAffinity 的完整对照
podAntiAffinity(required) | topologySpreadConstraints | |
|---|---|---|
| 约束形式 | "同域不能有第 2 个" | "域之间最多差 N 个" |
| 性质 | 绝对(与 Pod 数无关) | 相对(看差值) |
| 空域(无匹配 Pod 的节点) | 不算 | 算(Ignore 时含污点节点) |
| 能否允许"每域 2 个" | ❌ 只有 1 个这一种粒度 | ✅ maxSkew: 2 |
| 副本数 > 节点数时 | 必然 Pending | 可以跑满(放宽 maxSkew) |
| 大规模集群性能 | 较差(遍历匹配 Pod) | 较好 |
maxSkew: 1 且域数 ≥ 副本数时,两者结果完全一样 —— 因为默认 nodeTaintsPolicy: Ignore 让空域把 min 拉到 0,退化成"每域最多 1 个"。
7.10 生产配方
topologySpreadConstraints:
- maxSkew: 1
topologyKey: topology.kubernetes.io/zone # ★ 域 = 可用区
whenUnsatisfiable: ScheduleAnyway
labelSelector:
matchLabels: {app: xxx}
| 参数 | 选择 | 原因 |
|---|---|---|
topologyKey | 可用区 | 要防的是"整个机房挂掉",不是"单节点挂掉" |
whenUnsatisfiable | ScheduleAnyway | 宁可挤一点,也别因为只剩 1 个可用区就整个服务 Pending |
maxSkew | 1 或 2 | 尽量拉开 |
ScheduleAnyway 的实际效果:它变成打分项(PodTopologySpread 插件,权重 2),分布会尽量均衡但不保证。
八、IgnoredDuringExecution —— 调度器只管一次
实测:把 node01 的 disk=ssd 改成 hdd 后,已经跑在上面的 3 个 Pod 全部原地不动(AGE 持续增长、一个都没重建)。但手动删掉一个让它重建,新 Pod 立刻 Pending(Events: 2 node(s) didn't match Pod's node affinity/selector);把标签改回来,它立刻又调上去。
同一时刻,老 Pod 在"不符合约束"的节点上跑得好好的,新 Pod 却调度不上去。
原因很简单:调度器只在 Pod 创建那一刻跑一遍 Filtering + Scoring,绑定完就撒手,之后没有任何循环回头检查。 字段名里的 IgnoredDuringExecution 就是这个意思 —— 不是"选择忽略",而是"没有代码去管"。
8.1 唯一例外:NoExecute
| 机制 | 谁负责 | Pod 已运行、条件变了 |
|---|---|---|
nodeSelector / nodeAffinity | kube-scheduler | 忽略 |
podAffinity / podAntiAffinity | kube-scheduler | 忽略 |
topologySpreadConstraints | kube-scheduler | 忽略 |
Taint NoSchedule / PreferNoSchedule | kube-scheduler | 忽略(只挡新的) |
Taint NoExecute | TaintManager(kube-controller-manager 内) | 驱逐 |
TaintManager 持续 watch 节点污点和 Pod,发现"节点有 Pod 不容忍的 NoExecute 污点、且 tolerationSeconds 已过"→ 删除该 Pod(不是"迁移"),再由上游控制器重建。它只负责删,不负责搬。
想让 Pod 按新约束重排:kubectl rollout restart deploy/<name>,或直接删 Pod 让它重建。
九、踩坑实录
| # | 坑 | 真相 |
|---|---|---|
| 1 | 以为 maxSkew: 1 允许每节点 2 个 | maxSkew 是"与全局最小值的差",默认包含带污点的空域(master),所以 maxSkew: 1 = 每节点 1 个 |
| 2 | 以为 nodeTaintsPolicy 默认排除污点节点 | 默认是 Ignore(照样计入),要改成 Honor |
| 3 | 以为 topologyKey: zone 比 hostname 更松 | 更严:zone 是更大的域,同一 zone 内的所有节点都算同处 |
| 4 | 以为 podAntiAffinity 会移动已有 Pod | 只看"新 Pod 看老 Pod",已有 Pod 永不因新 Pod 而重调度 |
| 5 | 以为 podAntiAffinity 默认跨命名空间 | 默认只匹配本命名空间,跨 ns 要写 namespaces 或 namespaceSelector |
| 6 | podAntiAffinity 里写了 matchExpressions 却用 nodeAffinity 的语法 | 两套 selector 语法不同,matchLabels / matchExpressions 都在 labelSelector 下面 |
| 7 | 以为改了节点标签 Pod 会被驱逐 | 调度器只在创建时跑一次;只有 NoExecute 有 TaintManager 盯着 |
| 8 | 以为加 toleration 就会被派到那个节点 | 容忍只是通行证,落点由 Scoring 决定(实测 2+1) |
| 9 | preferred 写成 nodeSelectorTerms | preferred 用 preference(单数、对象) |
| 10 | nodeSelector 想写 In 表达式 | 它只支持等值,表达式要用 nodeAffinity |
| 11 | 以为调低 weight 能让资源占上风 | 单条时 weight 被归一化掉了;两层权重隔离。唯一路径是让节点在 Filtering 出局 |
| 12 | topologySpreadConstraints 写成 affinity 的子字段 | 它是顶层字段,和 affinity 平级 |
十、复习自测题
基础(1-4)
nodeSelector和nodeAffinity的三个能力差异?requiredDuringSchedulingIgnoredDuringExecution里三个词分别什么意思?- Taint 三种 effect,哪种会驱逐已运行的 Pod?
- 一个 Pod 的
spec.tolerations里通常"凭空"有哪两条 300 秒的容忍?谁加的?
亲和(5-8)
podAffinity和podAntiAffinity的区别?各举一个实际用途。podAntiAffinity的topologyKey写hostname和写zone,差别是什么?podAntiAffinity默认在哪些命名空间里找匹配的 Pod?要跨命名空间怎么写?- 一个 Deployment 有 3 副本、2 个可用节点。用 required 反亲和(hostname),结果是什么?怎么让它全部跑起来(至少两种办法)?
拓扑分布(9-12)
maxSkew: 1的精确含义?"全局最小值"怎么算?- 为什么在"2 worker + 1 tainted master"的集群里,
maxSkew: 1和硬反亲和结果一样? - 要让
maxSkew: 1真正表示"域间差不超过 1",需要加什么? - 同时约束"节点之间"和"可用区之间"该怎么写?
排障(13-15)
- Pod Pending,Events 是
0/3 nodes are available: 1 node(s) had untolerated taint(s), 2 node(s) didn't match pod anti-affinity rules.怎么读? - 改了节点标签,已运行的 Pod 会被驱逐吗?为什么?
- 节点失联后 Pod 多久被驱逐?由哪个组件执行?
十一、自测题答案
1. ① 支持 In/NotIn/Exists/DoesNotExist/Gt/Lt 表达式;② 支持 preferred 软约束;③ 支持 Exists(只判标签存在,不管值)。
2. required = 必须满足;DuringScheduling = 调度时检查;IgnoredDuringExecution = 运行中不检查(不是选择忽略,是调度器没有持续检查的循环)。
3. NoExecute。NoSchedule / PreferNoSchedule 只影响新调度。
4. node.kubernetes.io/not-ready 和 node.kubernetes.io/unreachable,各 tolerationSeconds: 300。由准入控制器在 Pod 创建时自动注入。
5. podAffinity = 挨着某类 Pod(web 和本地缓存同节点,降低延迟);podAntiAffinity = 躲开某类 Pod(同一服务副本不要挤在一个节点,保证高可用)。
6. hostname = "同一节点不能有两个";zone = "同一可用区不能有两个"(跨节点也不行)。后者域更大,约束更强。
7. 只在本命名空间。跨 ns 用 namespaces: [ns1, ns2] 显式列名单,或用 namespaceSelector 按命名空间标签选。注意 namespaceSelector 和 labelSelector 是 AND。
8. 结果:2 Running + 1 Pending。让它全跑的办法:① required → preferred(失去分散保证);② 改用 topologySpreadConstraints + maxSkew: 2 或 nodeTaintsPolicy: Honor;③ 加第三个 worker 节点。
9. maxSkew = 「某域匹配 Pod 数」− 「全局最小值」的最大允许差值。全局最小值 = 所有合格域(含 0 个 Pod 的空域,默认还含带污点节点)计数中的最小值。
10. 因为默认 nodeTaintsPolicy: Ignore,带污点的 master 也算一个计数为 0 的合格域 → 全局最小值恒为 0 → maxSkew: 1 变成"每域最多 1 个",与硬反亲和等价。
11. 加 nodeTaintsPolicy: Honor(把不可调度的节点排除出域的计算),或把 maxSkew 调到 2 以上。
12. 写两条 topologySpreadConstraints(AND 关系):一条 topologyKey: kubernetes.io/hostname,一条 topologyKey: topology.kubernetes.io/zone,两条的 whenUnsatisfiable 可以不同(常用:可用区用 DoNotSchedule,节点用 ScheduleAnyway)。
13. 3 个节点全部不可用:① 1 个被污点挡住(master 的 control-plane);② 2 个不满足反亲和(两个 worker 上各已有 1 个同类 Pod)。各项相加 = 3,与 0/3 对应。
14. 不会。 调度器只在 Pod 创建时运行一次,之后不检查已绑定 Pod 是否还满足 nodeAffinity。唯一例外是 NoExecute(TaintManager 负责驱逐)。
15. 默认 300 秒。由 node-lifecycle-controller 打 node.kubernetes.io/unreachable:NoExecute 污点,再由 TaintManager 执行删除。
十二、速记卡片
调度两阶段
① Filtering → 硬约束在这里排除节点
② Scoring → 软约束在这里打分(0-100,越高越好)
五种约束(按"看谁"分)
看节点属性:nodeSelector / nodeAffinity
看别人位置:podAffinity(挨着)/ podAntiAffinity(躲开)
看域均衡 :topologySpreadConstraints
硬 vs 软的表达
nodeAffinity required... / preferred...(weight 必填但单条无意义)
podAffinity required... / preferred...
spread DoNotSchedule / ScheduleAnyway
后果 硬 → Pending(显式) 软 → 降级(静默)
weight 一句话
单条 preferred 时 weight 1 和 100 等价(归一化);只在多条之间排优先级
想让资源压过偏好 → 让节点在 Filtering 出局,不是调 weight
Taint 三 effect
PreferNoSchedule 尽量不来,来了不动
NoSchedule 别来,来了的不动
NoExecute 别来,已经来的【赶走】← 唯一会驱逐的
podAntiAffinity 三看
看 labelSelector:躲谁
看 namespaces :默认只本 ns
看 topologyKey :hostname=每节点1个 / zone=每可用区1个(更严)
topologySpread 的坑(最高频)
maxSkew = 与【全局最小值】的差
全局最小值默认含带污点的空域(master),因为 nodeTaintsPolicy 默认 Ignore
→ 2 可用节点 + 1 tainted、maxSkew 1 = 每节点最多 1 个 = 反亲和
修正:nodeTaintsPolicy: Honor
两种"差"的语义
反亲和 :每域最多 1 个(绝对)
spread N :域间最多差 N 个(相对)
调度器只管一次
标签改了 / 加了非 NoExecute 污点 → 已运行的 Pod 全部不动
想让它按新约束重排:rollout restart / delete pod
十三、Part1 小结
一条主线:
「谁来做决定、什么时候做」
kube-scheduler → 只在 Pod 创建那一刻做决定,之后撒手
TaintManager → 持续盯着 NoExecute,会推翻已做的决定
八个实验,本质是五种结局:
| 结局 | 实验 | 机制 |
|---|---|---|
| 全挤一个节点 | aff-hard、aff-soft | 硬约束只留 node01 / 软约束分数压倒一切 |
| 被迫分散 | aff-soft2(3+3) | 目标节点资源出局,软约束让路 |
| 正常分散 | web-tol2(2+1)、spread-honor、spread-skew2 | Filtering 放行后由 Scoring 决定 |
| 有 Pending | anti-aff、spread-test(2+1) | 硬约束无解 |
| 原地不动 | aff-hard 改标签后 | 调度器已撒手 |
考前最该记住的三条:
maxSkew是"与全局最小值的差",默认还包含带污点的空域 —— Week7 最容易错的一题NoExecute是唯一会驱逐运行中 Pod 的机制,其余约束全部"只管一次"podAntiAffinity默认只匹配本命名空间,topologyKey换成 zone 会更严不是更松