Skip to main content

调度约束:nodeSelector / Taint / Affinity / 拓扑分布

覆盖考纲 Workloads and Scheduling(15%) 中「Understand how resource limits can affect Pod scheduling」的实现手段。 实验环境:三节点(k8s-master 带 control-plane:NoSchedule 污点 / k8s-node01 disk=ssd / k8s-node02 disk=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
  1. 只支持 key: value 精确等值,不支持 In / Exists / Gt
  2. 多个键是 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]
项requiredpreferred
选择器字段nodeSelectorTerms(复数、数组)preference(单数、对象)
weight不需要必填,1-100

那个超长字段名拆开看:required(必须)+ DuringScheduling(调度时检查)+ IgnoredDuringExecution(运行中不检查)。最后一段的含义见第八章。

3.2 operator 与实测​

operator含义
In / NotIn值在 / 不在列表
Exists / DoesNotExist标签存在 / 不存在(不管值)
Gt / Lt数值比较

Exists 的用处:表达"有 GPU 就行,不用关心型号"。

Deployment配置落点
aff-hardrequired ssd3/3 node01(node02 在 Filtering 出局)
aff-softpreferred ssd,weight 100,资源充足3/3 node01
aff-soft2同上 + cpu-hog 占满 node01 CPU3 + 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-ssdnodeSelector: disk=ssd3/3 node01
web-notol无 toleration,node02 有 env=prod:NoSchedule3/3 node01
web-tol2有 toleration2 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挨着某类 Podweb 和本地缓存(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结果
hostnamenode01 1 个 + node02 1 个 + 1 个 Pending
zone1 个 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不满足 → Pendingrequired...
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?
node0111✅
node0211✅
master——❌ 污点(在 skew 计算之前就被拒)

→ 落到 node01。计数 {1, 0, 0}

第 2 个 Pod​

计数 {node01:1, node02:0, master:0},min = 0

候选放后计数skew≤ 1?
node0122❌
node0211✅

→ 落到 node02。计数 {1, 1, 0}

第 3 个 Pod​

计数 {node01:1, node02:1, master:0},min = 0

候选放后计数skew≤ 1?
node0122❌
node0222❌
master——❌ 污点

→ 全部被拒,Pending。

要害就是 master 那个 0 —— 一个根本调度不上去的节点,把全局最小值钉在了 0。

7.5 三个对照实验​

#配置全局最小值第 3 个 Pod 的 skew结果
1maxSkew: 1(默认策略)0(含 master)2 − 0 = 2 > 1❌ Pending(2+1)
2maxSkew: 202 − 0 = 2 ≤ 2✅ 3 Running(2:1)
3maxSkew: 1 + nodeTaintsPolicy: Honor1(排除 master)2 − 1 = 1 ≤ 1✅ 3 Running(2:1)

两条路都通了,但语义完全不同:

方案改了什么语义
maxSkew: 2放宽要求"允许差 2 个"
nodeTaintsPolicy: Honor修正计算口径"调度不上去的节点不该参与比较"

后者更贴近本意 —— 你要的是"两个能用的节点之间要均衡",不是"允许差 2 个"。

7.6 副本数变化时的行为(按公式推)​

默认策略(min 恒为 0,因为有 master 这个空域):

maxSkew每域最多2 个 worker 能跑5 副本时
112 个2 Running + 3 Pending
224 个4 Running + 1 Pending
336 个5 个全跑(3:2)

nodeTaintsPolicy: Honor + maxSkew: 1(min 随填充上升):

副本数分布
32 : 1
53 : 2
74 : 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可用区要防的是"整个机房挂掉",不是"单节点挂掉"
whenUnsatisfiableScheduleAnyway宁可挤一点,也别因为只剩 1 个可用区就整个服务 Pending
maxSkew1 或 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 / nodeAffinitykube-scheduler忽略
podAffinity / podAntiAffinitykube-scheduler忽略
topologySpreadConstraintskube-scheduler忽略
Taint NoSchedule / PreferNoSchedulekube-scheduler忽略(只挡新的)
Taint NoExecuteTaintManager(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
6podAntiAffinity 里写了 matchExpressions 却用 nodeAffinity 的语法两套 selector 语法不同,matchLabels / matchExpressions 都在 labelSelector 下面
7以为改了节点标签 Pod 会被驱逐调度器只在创建时跑一次;只有 NoExecute 有 TaintManager 盯着
8以为加 toleration 就会被派到那个节点容忍只是通行证,落点由 Scoring 决定(实测 2+1)
9preferred 写成 nodeSelectorTermspreferred 用 preference(单数、对象)
10nodeSelector 想写 In 表达式它只支持等值,表达式要用 nodeAffinity
11以为调低 weight 能让资源占上风单条时 weight 被归一化掉了;两层权重隔离。唯一路径是让节点在 Filtering 出局
12topologySpreadConstraints 写成 affinity 的子字段它是顶层字段,和 affinity 平级

十、复习自测题​

基础(1-4)

  1. nodeSelector 和 nodeAffinity 的三个能力差异?
  2. requiredDuringSchedulingIgnoredDuringExecution 里三个词分别什么意思?
  3. Taint 三种 effect,哪种会驱逐已运行的 Pod?
  4. 一个 Pod 的 spec.tolerations 里通常"凭空"有哪两条 300 秒的容忍?谁加的?

亲和(5-8)

  1. podAffinity 和 podAntiAffinity 的区别?各举一个实际用途。
  2. podAntiAffinity 的 topologyKey 写 hostname 和写 zone,差别是什么?
  3. podAntiAffinity 默认在哪些命名空间里找匹配的 Pod?要跨命名空间怎么写?
  4. 一个 Deployment 有 3 副本、2 个可用节点。用 required 反亲和(hostname),结果是什么?怎么让它全部跑起来(至少两种办法)?

拓扑分布(9-12)

  1. maxSkew: 1 的精确含义?"全局最小值"怎么算?
  2. 为什么在"2 worker + 1 tainted master"的集群里,maxSkew: 1 和硬反亲和结果一样?
  3. 要让 maxSkew: 1 真正表示"域间差不超过 1",需要加什么?
  4. 同时约束"节点之间"和"可用区之间"该怎么写?

排障(13-15)

  1. 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. 怎么读?
  2. 改了节点标签,已运行的 Pod 会被驱逐吗?为什么?
  3. 节点失联后 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-skew2Filtering 放行后由 Scoring 决定
有 Pendinganti-aff、spread-test(2+1)硬约束无解
原地不动aff-hard 改标签后调度器已撒手

考前最该记住的三条:

  1. maxSkew 是"与全局最小值的差",默认还包含带污点的空域 —— Week7 最容易错的一题
  2. NoExecute 是唯一会驱逐运行中 Pod 的机制,其余约束全部"只管一次"
  3. podAntiAffinity 默认只匹配本命名空间,topologyKey 换成 zone 会更严不是更松