小胖鱼@Think· 调度器系列 博客首页
END-TO-END SCHEDULING FLOW

Kueue 完整调度流程图

从用户提交 Job / JobSet 开始,到 Pod 真正 Running 于目标节点为止 —— 覆盖 Mutating Webhook 挂起、Reconciler 投影出 Workload、LocalQueue / ClusterQueue / Cohort 三层配额体系、调度器的 Flavor 分配与四维判定、Gang 原子准入、Cohort 借用与抢占回收、AdmissionCheck / TAS 兜底、放行注入 nodeSelector 到 kube-scheduler 落地的完整链路。基于 Kueue v1beta1 / v1beta2 官方文档与源码机制核实整理。
8个主阶段
3层队列体系
4维准入判定
3种抢占策略
4道 Gang 机制
提交 / Webhook 层
Controller 投影
队列 / 配额层
Scheduler 决策
抢占 / 驱逐
放行 / 落地
贯穿机制

端到端全景图

下面两张图从同一份链路的不同视角呈现完整流程:横版以 CQ 为行、阶段为横轴,看多队列如何并行决策与互借(可左右拖动); 纵版沿主干自上而下,逐层看每一步判定。两张图与正文 8 阶段一一对应。

① 横版全景(左右拖动查看完整流水线)
Kueue 端到端调度流程(横版):从 Job 创建到 Pod 调度成功 多 LocalQueue / 多 ClusterQueue / 多 Job · 含 Webhook、投影、排序、配额、Gang、Cohort 借用、抢占、就绪监控全流程 (左右拖动查看完整横向流水线) ① 提交 & Webhook 挂起 Job-A · ns=team-a Job-B · ns=team-a Job-C · ns=team-b Mutating Webhook 拦截 注入 suspend=true 3 个 Job 均被挂起 Pod 不会被提前创建 suspend 字段在 Job 上 batch/v1 → .spec.suspend ② Reconciler 投影 jobframework reconciler 监听 W-A ← Job-A podSets: main×4 / worker×8 priority=high · q=lq-a1 W-B ← Job-B podSets: main×2 · low q=lq-a2 W-C ← Job-C podSets: main×1 · mid q=lq-b 公共: ownerReferences→Job active=true · 投影抹平框架差异 ③ 队列层级 & 排序 LocalQueue(命名空间入口) LQ-a1 / LQ-a2 → CQ-A LQ-b → CQ-B Cohort: team-ab CQ-A + CQ-B 同组,可互借 CQ-A 排序 (queueingStrategy) W-A(高) → W-B(低) · priority+时间 StrictFIFO / BestEffortFIFO(默认) CQ-B 排序:W-C 配额池 = (资源 × flavor) spot-gpu / on-demand ④ 调度器准入决策 遍历所有 CQ,各取队头 W-A 算需求:累加各 PodSet requests 算可用:nominal-used+borrowed flavor 分配:spot → on-demand nodeLabels 稍后注入 nodeSelector Cohort 借用(自己不够时) borrowingLimit / lendingLimit Gang:全部 PodSet 一起判定 仍不够 → 抢占 / 回收借用 四道机制:配额准入 / TAS waitForPodsReady / Provisioning 全 Fit 才放行,任一 Never 则 Pending ⑤ 放行 & Pod 创建 W-A 全部 PodSet Fit → 准入 Admitted=true,一次性预留配额 占用 (资源, flavor) 二维额度 suspend=false(解除挂起) 注入 nodeSelector ← flavor.nodeLabels(拓扑域) Job Controller 创建 Pod ×12 main×4 + worker×8 kube-scheduler 绑定到具体节点 Pod Running ✓ ⑥ 运行 & 收敛 waitForPodsReady 监控 所有 Pod 全部 Ready ? 是 → 运行至完成 删 Workload,归还配额 否/超时 → Evicted=True 撤销准入,suspend 回 true 带 backoff 重新排队 被抢占的 W-B 也重新入队 受害者 Job 可恢复,不丢数据 闭环:配额归还 → 调度下一个 全程只操作 Workload / suspend 主线:Job →(Webhook 挂起)→ Workload →(LQ→CQ)→ 排序 →(配额/Gang/借用/抢占)→ 准入 →(suspend=false+注入 nodeSelector)→ Pod →(就绪监控)→ 完成 / 重排 三条不变量:只操作 Workload 不碰 Pod · 所有 PodSet 原子准入 · 配额二维 (资源 × flavor) 且可在 Cohort 内借用回收
② 纵版全景(自上而下的完整链路)
Kueue 端到端调度流程(纵版):从 Job 创建到 Pod 调度成功 多 LocalQueue / 多 ClusterQueue / 多 Job · 自上而下的完整链路 ① 提交 & Webhook 挂起 Job-A · team-a queue-name=lq-a1 priority=high Job-B · team-a queue-name=lq-a2 priority=low Job-C · team-b queue-name=lq-b priority=mid Mutating Webhook 拦截 → 注入 suspend=true 3 个 Job 被挂起,Pod 不提前创建 · 字段在 Job 上 (batch/v1 .spec.suspend) 挂起的是「上层作业对象」,不是 Pod / Workload Job Controller 看到 suspend=true 后自然不建 Pod ② Reconciler 投影:Job → Workload jobframework reconciler 监听受管 Job,调用 EnsureWorkload() W-A ← Job-A podSets: main×4 / worker×8 priority → 数值 queueName=lq-a1 ownerReferences→Job W-B ← Job-B podSets: main×2 priority → low queueName=lq-a2 active=true W-C ← Job-C podSets: main×1 priority → mid queueName=lq-b active=true Workload = Job 的「调度投影」:只保留 podSets(资源诉求)+ queueName(归属)+ priority podSets 由各框架 PodSets() 提取,多角色各产一个 podSet,作为原子单元准入(Gang 基础) 队列归属优先级:Job label → namespace 默认 LocalQueue → 都没有则不接管 ③ 队列层级:LocalQueue → ClusterQueue → Cohort LocalQueue(命名空间提交入口): LQ-a1(team-a)← W-A LQ-a2(team-a)← W-B LQ-b(team-b)← W-C ClusterQueue(配额池,跨其下所有 LocalQueue 排序): CQ-A · cohortName=team-ab 排序(queueingStrategy):W-A(高) → W-B(低) StrictFIFO(队头阻塞) / BestEffortFIFO(跳过,默认) 配额池 = (资源 × flavor):spot-gpu / on-demand CQ-B · team-ab 排序:W-C nominalQuota 独立 可与 CQ-A 互借 Cohort: team-ab —— 同组成员可互借闲置 nominalQuota borrowingLimit(借入上限) / lendingLimit(借出上限, v0.17 stable);优先保障各成员自身 nominal ④ 调度器准入决策(每周期遍历所有 CQ,各取队头) 取 CQ-A 队头 W-A → 为其全部 PodSet(main×4、worker×8)一起判定,不逐 Pod / 不逐个 PodSet 算需求:累加每个 PodSet 容器的 requests(含 init 容器峰值、pod overhead) 算可用:nominal − used + borrowed((资源, flavor) 二维),受 lendingLimit 约束 flavor 分配:按 resourceGroups.flavors 顺序选(spot → on-demand),flavorFungibility 控制是否试下一个 nodeLabels 在放行时注入为 Pod 的 nodeSelector(逻辑配额与真实调度缝合) Cohort 借用:自己 nominal 不够 → 借同组闲置;borrowingLimit / lendingLimit 限幅 只能借自己 CQ 定义过的 flavor;原主人有 pending 时通过 reclaimWithinCohort 回收 Gang 判定:全部 PodSet 一起判定 —— 全 Fit 才进;部分要抢且能凑够则抢后准入;任一 Never 整体 Pending 抢占:选受害者按「优先级低 → 创建时间新」排序,只抢刚好够的最小集合;抢占=驱逐 Workload,不杀 Pod 四道机制:① 配额准入(默认) ② TAS 拓扑检查 ③ waitForPodsReady 超时兜底 ④ ProvisioningRequest 容量检查 ⑤ 放行 & Pod 创建 W-A 准入:Admitted=true,一次性预留全部 PodSet 的配额((资源, flavor) 二维额度被占用) suspend=false → 解除 Job 挂起(Kueue 通过改 Workload 状态 + Job suspend 落地决策) 注入 nodeSelector:把所选 flavor 的 nodeLabels 写进 Pod 模板 (TAS 时还会把 Pod 绑定到具体拓扑域 domain) Job Controller 创建 Pod ×12(main×4 + worker×8)→ kube-scheduler 按 nodeSelector 绑定到节点 Pod Running ✓ —— Kueue 到此为止,不直接管理 Pod 生命周期 Kueue 从挂起到放行,全程只操作 Workload / suspend,Pod 由下游控制器与 kube-scheduler 负责 ⑥ 运行 & 收敛(waitForPodsReady 兜底) 放行后监控:所有 Pod 是否全部 Ready ? Ready = 已调度 + 运行中 + 通过可选就绪探针 是 否 / 超时 ✓ 运行至完成 Job 完成 → Workload 删除 占用配额归还 CQ / Cohort 调度器处理下一个 Workload ✗ 超时未全 Ready Evicted=True,撤销准入 suspend 回 true,配额释放 带 backoff 重新排队(防死锁) 被抢占的 W-B / 借用被回收的 Workload:撤销 Admitted、重新入队;受害者 Job 可恢复,配合 checkpoint 不丢数据 recoveryTimeout 处理运行中 Pod 故障;blockAdmission 串行放行防两个半调度作业互锁 闭环:配额归还 → 调度器下一周期重新遍历 CQ → 循环往复 三条不变量:只操作 Workload 不碰 Pod · 全部 PodSet 原子准入(Gang) · 配额二维(资源×flavor)且可 Cohort 借用回收 Job → Webhook 挂起 → Workload 投影 → LQ→CQ 排序 → 配额/Gang/借用/抢占判定 → 放行+nodeSelector → Pod 创建调度 → 就绪监控收敛
0
提交层 · Job + Webhook 挂起
管理员预建配额体系,Mutating Webhook 把 Job 冻住
SUBMIT
🗂️0.1 管理员预建配额对象(CRD)

提交作业前,管理员先建好一整套资源治理对象:ResourceFlavor(资源"口味",用 nodeLabels 圈定一类节点)、ClusterQueue(集群级配额池)、LocalQueue(命名空间提交入口)、可选 Cohort(可互借配额的队列组)。配额数量只写在 ClusterQueue 里,Flavor 本身不定义数量。

# kueue.x-k8s.io/v1beta1
apiVersion: kueue.x-k8s.io/v1beta1
kind: ResourceFlavor
metadata: {name: spot-gpu}
spec:
  nodeLabels:
    cloud.google.com/gke-spot: "true"   # 圈定 spot 节点
  tolerations:
    - {key: spot, operator: Equal, value: "true"}
关键:nodeLabels 是 Flavor 的核心,准入时会被注入成 Pod 的 nodeSelector,把逻辑配额和真实节点缝合起来。
📦0.2 用户提交 Job(声明归属)

用户提交的是作业对象(Job / JobSet / PyTorchJob 等)。在 Job 上打 kueue.x-k8s.io/queue-name label 指向 LocalQueue;不打则用 namespace 级默认 LocalQueue;两者都没有就不被接管。

# batch/v1.Job
apiVersion: batch/v1
kind: Job
metadata:
  name: job-a
  labels:
    kueue.x-k8s.io/queue-name: lq-a1   # ← 归属 LocalQueue
spec:
  parallelism: 4                        # ← 4 个 Pod
  template:
    spec:
      priorityClassName: high-priority  # ← 排序/抢占用
      containers: [...]
其他框架无 queue-name label 时,用注解 kueue.x-k8s.io/queue-name;Kubeflow 类 suspend 字段在 spec.runPolicy.suspend。
🧊0.3 Mutating Webhook 注入 suspend=true

Kueue 的 mutating admission webhook 在 Job CREATE 时拦截,把工作负载对象本身的 suspend 字段设为 true。挂起的是作业对象,不是 Pod,也不是 Workload。Pod 由 Job Controller 看到 suspend 后自然不创建。

# webhook patch 后的 Job
spec:
  suspend: true       # batch/v1.Job
  # JobSet: spec.suspend
  # PyTorchJob: spec.runPolicy.suspend
  # RayJob: spec.suspend
归属:Job 的 suspend 是 K8s 原生能力(1.22 GA),框架类的 suspend 由各社区 CRD 自己定义,Kueue 只是借用,靠 integration 适配逐个 patch。
🎛️0.4 ClusterQueue 定义配额与 Flavor

ClusterQueue 用 resourceGroups 引用 Flavor,并为每个 (资源, flavor) 二维组合分配配额。配额可借用、可抢占,构成调度的坐标轴。

spec:
  resourceGroups:
    - coveredResources: ["cpu", "nvidia.com/gpu"]
      flavors:
        - name: spot-gpu
          resources:
            - {name: cpu, nominalQuota: 80}
            - {name: nvidia.com/gpu, nominalQuota: 4, borrowingLimit: 2}
        - name: on-demand
          resources:
            - {name: cpu, nominalQuota: 20, lendingLimit: 10}
二维配额:同一个 cpu,在 spot 池 80 核、on-demand 池 20 核,分别扣减互不相干。
✅ 阶段成果:API Server 里已有被 suspend=true 冻住的 Job,以及管理员配好的 Flavor / ClusterQueue / LocalQueue / Cohort。此时还没有 Workload,也没有任何 Pod。
jobframework reconciler watch 到新 Job → 调用各框架 PodSets() 投影
1
Controller 投影 · Job → Workload
把每种 Job 的差异抹平,生成统一的调度投影
PROJECT
① Job / JobSet
用户提交的 CR
已 suspend=true
→
② PodSets()
框架各自实现
抽取角色模板+count
→
③ Workload
同名同 namespace
ownerRef 指向 Job
→
④ 入 LocalQueue
按 priority+时间
排队等待配额
🔗Workload 是"调度投影"

只保留调度器需要的东西:资源诉求(podSets)+ 队列归属(queueName)+ 优先级(priority),剥掉镜像、命令、卷等执行细节——虽然 template 里带着,但调度器只看资源。

🏷️ownerReference 级联

Workload 的 ownerReferences 指向 Job,保证 Job 删除时 Workload 级联消失。同步 decisions 与 statuses,全程不直接操作 Job 之外的对象。

✂️沙箱里的 suspend 边界

Kueue 从不创建 Pod、也不直接碰 Pod。它只操作 Workload + 改 Job 的 suspend。Pod 的生死由 Job Controller 根据 suspend 决定——这是贯穿全局的统一边界。

🧬生成的 Workload 长这样(v1beta2)
apiVersion: kueue.x-k8s.io/v1beta2
kind: Workload
metadata:
  name: job-a
  namespace: team-a
  ownerReferences: [{kind: Job, name: job-a}]   # 级联
spec:
  active: true
  queueName: lq-a1                # ← LocalQueue
  priority: 100                   # ← PriorityClass 解析值
  podSets:                        # ← 可含多个:main / worker
    - name: main
      count: 4                    # parallelism=4
      template:                   # PodSpec(含 requests)
        spec: {containers: [...]}
多角色框架:PyTorchJob 会产出 master×1 + worker×8 两个 podSet,所有 podSet 被当作一个原子单元准入——这正是 Gang Scheduling 的基础。
✅ 阶段成果:每个 Job 都有一个同名 Workload 进入 LocalQueue 排队。资源需求已按 podSet.count × requests 可计算,下一步由调度器判定配额。
Workload 入队后,Scheduler 在一个 reconcile 周期内遍历所有 ClusterQueue
2
队列层级 · 三层配额体系
LocalQueue 汇聚到 ClusterQueue,Cohort 允许互借
QUEUE
LocalQueue(命名空间级)
用户提交入口
LQ-a1 / LQ-a2 / LQ-b
→
ClusterQueue(集群级)
真正的配额池
CQ-A / CQ-B
→
Cohort(可选队列组)
team-ab
成员可互借闲置配额
🔀排序发生在 ClusterQueue 层

官方原话:queueingStrategy 决定 Workload 如何 ordered in the ClusterQueue。排序键 = priority → creationTimestamp,与具体 podSet 无关。Workload 先进 LocalQueue,但跨该 CQ 下所有 LQ 一起排——因为配额池在 CQ 层。

⚖️两种 FIFO 策略

StrictFIFO:队头装不下就阻塞后面全部(队头阻塞)。BestEffortFIFO(默认):队头装不下就跳过它,放行能装下的新 Workload 保吞吐。一个周期可取多个 Workload 准入,不是只处理一个。

🤝Cohort 借用(同组才能借)

两个 CQ 的 spec.cohort 同名才互借。借的是组内成员未用的 nominalQuota,先用自己的、用完才借。borrowingLimit 限最多借入,lendingLimit(v0.17 stable)限最多借出。

↩️借来的是临时的,会归还

原主人有 pending 作业时,通过 reclaimWithinCohort 抢占策略收回借出的份额,优先保障各成员自身 nominalQuota。借用有 flavor 限制:只能借自己定义过的 flavor。

队列层级作用域角色关键字段
LocalQueue命名空间用户提交入口,按 priority 入队spec.clusterQueue 指向上层
ClusterQueue集群真正配额池,排序 + 准入判定的发生地resourceGroups / queueingStrategy
Cohort多个 CQ允许成员互借闲置配额,提升利用率spec.cohort 同名归组
示例:CQ-A(nominal 9)+ CQ-B(nominal 12)同属 cohort,B 闲置时 A 最多可用 21 核;一旦 B 有 pending 作业,Kueue 先满足 B,A 不能一直占着借来的份额。
取队头 Workload → 进入准入决策流水线(本阶段是核心)
3
Flavor 分配 · 算需求与可用
把"需求向量"与"(资源, flavor) 可用额度"对齐
FLAVOR
① 算需求
累加各 podSet requests
含 init 峰值 / overhead
→
② 算可用
nominal − used + borrowed
受 lendingLimit 约束
→
③ 选 flavor
为每个 podSet 分配
产出 Fit/Preempt/Evict
→
④ FlavorFungibility
借当前还是试下一个
能不抢就不抢
📐需求 = Σ(podSet.requests × count)

Kueue 把每个 podSet 的容器 requests 乘以 count 再累加得到 Workload 的总诉求。请求值会按 LimitRange 默认值、RuntimeClass overhead、仅 limits 当 requests 等规则调整,校验不过标记 Inadmissible。

🧭Flavor 是调度的坐标轴

配额、借用、抢占、nodeSelector 注入全都挂在 (资源, flavor) 这个二维单位上。多 flavor 配合 flavorAssignmentMode 可实现"优先便宜 spot,不够回退按需"的成本优化。

🧠对每个 flavor 候选给出四态判定
✅ Fit

配额够 → 可直接准入。

⚡ Preempt

本队列内有更低优先级可抢。

♻️ Evict

配额被同 Cohort 其他队列借走,要回来。

⏸️ Never

谁都让不出 → 继续 Pending 等待。

决策单位是整个 Workload:所有 podSet 一起判定,全 Fit 才进;部分要抢且能凑够就抢后准入;任一 Never 就整体 Pending。PodSet 只是 Workload 内部"同模板+count"的分组,从不逐 Pod 调度。
判定需要抢占 → 进入受害者选择与回收流程
4
抢占与驱逐 · 资源不够时的兜底
只抢"刚好够"的最小受害者集合
PREEMPT
reclaimWithinCohort
回收组内借出份额
Never/LowerPriority/Any
→
borrowWithinCohort
是否允许
为抢占而借
→
withinClusterQueue
同队列高抢低
Never/Lower/LowerOrNewer
🎯受害者选择算法

候选排序:借用的队列 → 最低优先级 → 最近准入。逐个累加受害者资源凑够缺口即停,只抢刚好够的最小集合。受害者必须优先级严格小于自己,且受策略边界约束。

🛡️抢占是最后手段

必须先经过直接准入失败、FIFO 排序判定,才进入抢占轮。默认三种策略均为 Never——不配置就不会抢,体现"尽量不冲击已有工作"的设计。

◆ 抢占 ≠ 杀 Pod:驱逐的是 Workload(撤销 Admitted、suspend 回 true),Pod 由控制器回收
✅ 抢占成功

被抢 Workload 重新入队(带 backoff),配额释放后重新走准入校验,确认额度真的腾出才放行抢占者。

❌ 无合适受害者

Workload 保持 Pending,等待后续周期;公平共享(Fair Sharing)会偏向 share 低的队列准入、偏向 share 高的队列抢占。

公平共享 Fair Sharing(v0.7 stable):给每个 CQ 算 share 值,准入偏向 share 低者、抢占偏向 share 高者,防止单一团队独占资源。
⚡ 准入判定通过 · 以下由各 Controller 落地到 API Server
5
准入落地 · Quota Reserved + 解除挂起
三个条件全满足才 Admitted,注入 nodeSelector
ADMIT
① 预留配额
标记 QuotaReserved
锁定 (资源,flavor)
→
② AdmissionCheck
外部/内部检查
状态转 Ready
→
③ Admitted
条件全满足
标记准入
→
④ 解除挂起
Job suspend=false
注入 nodeSelector
✅官方定义:一个 Workload 被 Admitted 当且仅当
① Quota Reservation

调度器已在目标 CQ 的 ResourceGroups 里锁定资源(= Workload scheduling,≠ Pod scheduling)。

② 物理容量允许(TAS)

启用拓扑感知时,确认所有 Pod 能真正放进目标拓扑域(block/rack),消除"总量够但碎片放不下"。

③ AdmissionCheck 全 Ready

所有(可选)AdmissionCheckStates 处于 Ready 状态,外部配额系统放行。

🏷️flavor 落地:注入 nodeSelector

调度器选中 flavor 后,把该 flavor 的 nodeLabels 注入成 Pod 的 nodeSelector。这一步把"Kueue 逻辑配额"和"K8s 真实调度"缝合——保证 Pod 真落在对应类型节点上。

🔓Job 被解除挂起

Reconciler 把 Job 的 suspend 置为 false,Job Controller 随即一次性创建出全部 Pod。Workload status 增加 QuotaReserved、Admitted 等 conditions。

Pod 被创建(Pending,带 nodeSelector)→ 交给 kube-scheduler 绑定节点
6
Pod 调度 · kube-scheduler 落地
Kueue 到此为止,之后是标准 K8s 调度链路
BIND
① Job Controller
建 Pod ×N
带 nodeSelector
→
② kube-scheduler
Filter / Score
选具体节点
→
③ 写 nodeName
绑定 Pod 到节点
kubelet watch 到
→
④ Pod Running
拉镜像起容器
资源占用持久化
边界再强调:Kueue 决定"何时允许创建 Pod"、注入"落在哪类节点"(nodeSelector),但不替代 kube-scheduler——具体绑到哪个节点、Filter/Score 打分,仍是标准 kube-scheduler 的职责。这也是"准入控制 ≠ 调度"的核心分界。
Pod 放行后,waitForPodsReady 开始监控是否全部 Ready(Gang 兜底)
7
运行与收敛 · 就绪监控 + 配额归还
全 Ready 保持运行,超时/失败驱逐重排,完成归还配额
DONE
🚀正常路径:全 Ready

所有 Pod 就绪(已调度 + 运行中 + 通过可选就绪探针)→ Workload condition PodsReady=True → 保持 Admitted 稳定运行。Job 完成后 Workload 被删除,配额归还 ClusterQueue,调度器继续处理下一个(可抢占低优先级任务)。

⏰异常路径:waitForPodsReady 超时

若 timeout(默认 5 分钟,较新版本 1 小时)内未全 Ready:撤销准入 → Job 重新 suspend → Workload 带 backoff 重新排队,配额释放。blockAdmission 可串行放行防两个半调度作业互锁。

状态字段 / 事件含义
status.requeueState.count / requeueAt因 PodsReadyTimeout 被驱逐后的指数退避重排次数与下次入队时间
status.schedulingStats.evictions[]按 reason(Preempted / PodsReadyTimeout / Deactivated)+ underlyingCause 记录驱逐历史,支撑 metrics
spec.active: false停用 Workload:运行中会被驱逐且不重排;maximumExecutionTimeSeconds 超时也会自动 deactivate
status.reclaimablePods[]动态回收:声明某些 podSet 不再需要的配额,逐步释放(Dynamic Reclaim)
🔁 闭环:Workload 完成归还配额 / 超时驱逐重排 → 释放的 (资源, flavor) 回到 ClusterQueue → 下一个 reconcile 周期继续准入等待中的 Workload。整条链路:提交 Job → Webhook 挂起 → 投影 Workload → 三层队列排序 → Flavor 分配四态判定 → 抢占回收 → 准入落地(QuotaReserved + Admitted + nodeSelector)→ kube-scheduler 绑定 → waitForPodsReady 监控 → 完成归还 / 超时驱逐。
🧩附录 A · 对象归属:K8s 原生 / 框架 CRD / Kueue 自有
类别对象 / 字段谁提供
① K8s 核心batch/v1 Job 的 .spec.suspend(1.22 GA)Kubernetes 原生
② 第三方框架 CRDJobSet .spec.suspend · PyTorchJob/TFJob .spec.runPolicy.suspend · RayJob .spec.suspend微软 / Kubeflow / KubeRay 社区
③ Kueue 自有 CRDWorkload · ClusterQueue · LocalQueue · ResourceFlavor · Cohort · AdmissionCheck · Topology · WorkloadPriorityClassKueue 项目(无 suspend 概念)
一句话:作业对象和 suspend 能力是"别人给的",Kueue 贡献的是上面那层"编排控制"——决定谁排队、谁有配额、何时放行。它像交通指挥:车(Job)和红绿灯(suspend)都不是它造的,但它决定何时亮绿灯。
🛡️附录 B · Gang(all-or-nothing)四道机制
① 配额准入(基础,默认)

所有 PodSet 的配额能一次性同时预留才 unsuspend;默认不部分准入。这是 Gang 的第一层。

② TAS 拓扑感知(强烈推荐)

准入前检查所有 Pod 能否真放进目标拓扑域,消除"总量够但碎片化放不下"——经典场景:8 卡分散在两台 4 卡节点,8 卡 Pod 永远卡住。

③ waitForPodsReady(新版默认)

放行后监控全 Pod Ready,超时未全 Ready → 撤销准入、驱逐重排。启发式:不阻止部分调度,但保证不会永久占着资源。

④ ProvisioningRequest(按需)

自动扩缩容场景,等容量就绪后才准入,配合 Cluster Autoscaler 避免"配额有了但节点还没起来"。

为什么需要多层:配额只追踪"总量",而实际调度依赖节点布局、物理可用性和碎片情况。TAS 与 waitForPodsReady 专门补这个洞。例外:显式开启 Partial Admission(podSetUpdates/minCount)才允许部分准入,用于可缩容训练,非默认。
⚖️附录 C · StrictFIFO vs BestEffortFIFO 与抢占策略默认值
维度StrictFIFOBestEffortFIFO(默认)
队头装不下时阻塞后面所有 Workload,即使后面的更小跳过队头,放行能装下的新 Workload
取舍严格顺序公平,可能队头阻塞保吞吐,可能"后来居上"
抢占策略可选值默认
reclaimWithinCohortNever / LowerPriority / AnyNever
borrowWithinCohortNever / LowerPriority / AnyNever
withinClusterQueueNever / LowerPriority / LowerOrNewerEqualPriorityNever
版本提示:borrowingLimit / lendingLimit 在 v1beta1 里曾是 alpha(默认门关),lendingLimit 自 v0.17 起 stable。TAS 自 v0.14 起 beta 默认开启。查文档/面试时注意版本差异。
🔄附录 D · 一次调度全景(多队列多 Job 的纵 / 横视图)

以「3 个 Job / 3 个 LocalQueue / 2 个 ClusterQueue(同 Cohort)」为背景。上面 8 阶段讲「从提交到落地的生命周期」,这里两张图讲「一个 reconcile 周期内部怎么转」。

附图 D-1 · 纵向:一次 reconcile 周期的判定主干
LQ-a1 / LQ-a2 → CQ-A
job-A high · main×4+worker×8
job-B low · main×2
LQ-b → CQ-B
job-C mid · main×4
Cohort: team-ab
CQ-A ↔ CQ-B 互借闲置 nominal
↓ 各 CQ 按 queueingStrategy 排序 Workload → 取队头 ↓
准入决策流水线 · 直接准入一轮 → 无进展再抢占一轮
① 取队头:CQ-A 取 job-A(high),算需求 = 4+8 podSet 的 requests 之和
↓
② 可用额度:spot-gpu nominal 4 卡 − used 2 + borrowed 0 = 2 卡可用
↓
③ 四态判定:2 卡 < 需求 → 本队列有低优先级 job-B → 判 Preempt;或 Cohort 内 CQ-B 闲置 → 判 Evict
↓
◆ ④ 选受害者:借用的队列 → 最低优先级 → 最近准入,凑够即停(最小集合)
✅ 凑够 → 驱逐 job-B,预留配额,job-A Admitted
❌ 任一 Never → 整体 Pending,等下周期
⑤ 被驱 Workload 带 backoff 重新入队;释放的配额回到 CQ。⟲ 下一个周期继续。
附图 D-2 · 横向泳道:队列为行、阶段为从左到右的时间轴
队列/阶段
① 排序
② 算额度
③ 判定
④ 抢占
⑤ 准入
⑥ 落地
CQ-Acohort team-ab
job-A high
job-B low
spot 2 卡
可借 +?
Preempt
需求>可用
驱逐 job-B
最小集合
job-A ✅
Admitted
Pod ×12
→ Running
CQ-Bcohort team-ab
job-C mid
nominal 20
闲置可借出
Fit
自身够用
无需抢占
job-C ✅
Admitted
Pod ×4
→ Running
读法:纵向图沿主干看每一步判定(取队头→算额度→四态→选受害者→准入);横向图以 CQ 为行、阶段为横轴,看多队列如何并行决策与互借。本轮结果:job-A(抢占 job-B 后)+ job-C 准入落地,job-B 重排等下轮。全程只操作 Workload / suspend,从不直接碰 Pod。
← 返回调度器系列目录 Kueue 原理详解 →
参考来源:Kueue 官方文档(Concepts / Workload / Cluster Queue / All-or-nothing Scheduling / Preemption / Topology-Aware Scheduling)· 基于前序讨论整理核实 · 本文档由对话内容生成 · 2026-11-18 · 小胖鱼@Think · 调度器系列