Apache YuniKorn技术深潜 封面
DAT401 · Technical Deep Dive · 2026-09
Containers & Data Analytics
Apache YuniKorn 技术深潜
把 YARN 的队列语义搬到 Kubernetes:它解决什么、怎么工作、在 EKS 上怎么协同,以及在什么规模下才值得做。
问题 › 机制 › AWS 协同 › 决策 Why · How · On EKS · Decide
Neo SUN
Solutions Architect Amazon Web Services
Agenda · 本次分享的四条主线

四章分别回答四个问题 为什么 · 怎么工作 · 在 AWS 上怎么用 · 该不该做

Ⅰ

为什么需要它

The Problem
  • 批处理 vs 在线服务
  • 资源死锁
  • 它的能与不能
Ⅱ

它怎么工作

Mechanism
  • 队列 · Gang · 抢占
  • 调度循环与吞吐模型
  • 三个静默失效的坑
Ⅲ

在 AWS 上怎么用

On EKS
  • EMR on EKS 官方路径
  • Karpenter 协同真相
  • 生态集成矩阵
Ⅳ

怎么决策

Decide
  • 成本模型与盈亏平衡
  • 选型对比
  • 迁移剧本

How to read this deck · 怎么用这份材料

  • 如果你的问题是「Spark 作业互相等死」,看第 Ⅱ 章的 Gang 部分——那是它最硬的价值。
  • 如果你的问题是「多团队抢资源」,看第 Ⅱ 章的队列与抢占,以及第 Ⅲ 章的身份链路。
  • 如果你要决定做不做,可以直接跳到第 Ⅳ 章——那里有盈亏平衡点,而它可能会劝你别做。
Apache YuniKorn 技术深潜 · Agenda04 章 · 65 页 · 120 分钟2
01
The Problem
为什么需要它
这一章不讲 YuniKorn,只讲问题。如果这些问题你没有,后面三章都不用听。
批处理与在线服务的分歧 资源死锁 ResourceQuota 不是配额 它的能与不能
Apache YuniKorn 技术深潜
3
Ch.1 · 为什么需要它 · First Principle

批处理与在线服务对调度器的要求是相反的 这是抽象层次的错配,不是性能问题

维度在线服务(Deployment)批处理(Spark / 训练作业)
调度单位单个 pod,彼此独立一组 pod,必须同生共死
资源不足时扩容或降级,pod 可以一直 Pending必须排队,而且要公平地排
生命周期长期运行,几乎不结束分钟到小时,跑完就走
延迟目标单 pod 调度延迟要低整个作业的完成时间要短,单 pod 慢一点无所谓
资源利用目标留余量应对流量峰值尽可能榨干,别浪费
失败语义重启这个 pod一个成员失败可能整个作业重来
所以问题不是「默认调度器写得不好」——它为左边那一列设计,而且设计得很好。 问题是它的调度单位(pod)与批处理的调度单位(作业)不匹配。这是抽象层次的错配,调参解决不了。
结论:kube-scheduler 的核心循环是「取一个 pod → 过滤节点 → 打分 → 绑定」,这个循环里没有任何「作业」的概念。
做法:判断自己要不要换调度器,先问一句:我的负载的最小有意义单位是一个 pod,还是一组 pod?
注意:如果你的批处理是「很多互相独立的单 pod 任务」,那你在左边这一列,不需要 YuniKorn。
Ch.1 · 为什么需要它 — 第一性原理4
Ch.1 · 为什么需要它 · Deadlock

失效一:资源死锁 集群 100% 满载,零个作业能推进

默认调度器 · 5 个 Spark 作业进同一个 10 slot 集群
T0:5 个 driver 全部被调度成功 → 占 5/10
T1:每个 driver 各申请 4 个 executor → 需要 20 slot,只剩 5
T2:5 个剩余 slot 被瓜分(各拿 1 个)
T3:每个作业都在等剩下 3 个 executor → 集群满载、零进展、没有任何 pod 会自己退出
→
YuniKorn Gang 调度 · 同样的 5 个作业
按 taskGroups 声明的 minMember × minResource 先创建 placeholder pod 把坑占满;
占满了才把真实 pod 换进去;占不满就整体排队。
⇒ 第 2 个作业根本拿不到 driver 的坑,它会排队
⇒ 第 1 个作业能完整跑完,然后释放全部资源给第 2 个
100%
死锁时的集群占用率
0
死锁时推进的作业数
人工
默认调度器下的唯一解法

这里有一个反直觉的结论,也是整份材料最值得带走的一句

  • 限制并发反而提高吞吐。Gang 让第 2 个作业排队,看起来是「少跑了一个作业」,实际是消除了死锁——这是排队论里的经典结果。
  • 但 Gang 也会引入新的死锁形态:如果队列配额本身就小于 gang 的最小需求,它永远凑不齐。YuniKorn 用「入队前静态可行性检查」来防这个,第二章会给实测证据。
Ch.1 · 为什么需要它 — 资源死锁5
Ch.1 · 为什么需要它 · Quota Semantics

失效二:ResourceQuota 不是配额,是准入拒绝 最被低估的一条差异

维度K8s ResourceQuotaYuniKorn 队列
超额时会怎样 pod 创建失败准入期拒绝,kubectl apply 直接报错 pod 创建成功,在队列里排队等
结构 扁平,一个 namespace 一份 层级树,父队列约束所有子孙之和
由谁执行准入控制器(apiserver)调度器(调度时判断)
有「顺序」概念吗 没有,谁先 apply 谁占 FIFO / Fair / 优先级排序
能借用空闲容量吗 不能 能,借到 max 为止🔴 headroom 公式里没有 guaranteed —— 它不参与准入
能保障最低量吗 只有上限,没有下限 guaranteed 是抢占的锚点
「配额」这个词在两个系统里含义不同。K8s 的是硬门禁(超了不让进), YuniKorn 的是调度约束 + 排队(超了就等)。批处理平台需要的是后者——你不会希望半夜的 ETL 因为白天的作业还没跑完就 apply 失败。
YuniKorn 自己的原话:"In most of the cases, YuniKorn queue can be used to replace the namespace resource quota, in order to provide more scheduling features."
注意:两者可以并存,而且并存时 K8s 的 ResourceQuota 先生效(它在准入期)。混用会得到「YuniKorn 说可以排队、apiserver 说不许创建」的矛盾。要么迁移,要么放宽 ResourceQuota。
Ch.1 · 为什么需要它 — ResourceQuota 语义6
Ch.1 · 为什么需要它 · The Other Two & The Answer

另外两个失效,以及 YuniKorn 给出的三个答案 公平性 · 作业级能力

失效三 · 租户之间没有公平性

默认调度器没有「租户」概念,也没有「这个用户已经比别人用得多」这种状态。 一个配错的作业能吃掉整个 namespace,把同 namespace 的其他作业饿死——而这不会触发任何告警,因为从 K8s 视角看一切正常。

失效四 · pod 级视角看不到「作业」

一旦调度器有了 Application 这个一等对象,下面这些能力才成为可能: Gang(要知道这一组 pod 属于同一作业且最少要 N 个)、作业级排队与排序、作业级配额(maxapplications)、 动态优先级、历史用量追踪。这些不是 feature 清单,是同一个抽象带来的推论。

答案 ①
层级队列

解决配额与公平

  • 任意深度的队列树 + guaranteed / max
  • 队列 / 应用 / 用户三层公平共享
  • ACL 多租户 + 放置规则自动路由
答案 ②
Gang 调度

解决资源死锁

  • placeholder 先占位,凑齐再换手
  • 凑不齐则整体排队或整体失败
  • 实测:占位 2.1 秒、换手 0.15 秒
答案 ③
抢占

让保障量真的兑付

  • 七条定律,锚点是 guaranteed
  • 实测:精确停在 guaranteed,不多抢
  • 可用围栏限制在租户子树内
Ch.1 · 为什么需要它 — 另外两个失效与三个答案7
Ch.1 · 为什么需要它 · Honest Boundary

它做不到什么 这一页决定后面三章的可信度

❌ 它不能做(全部有官方文档或源码依据)

  • 拓扑 / NUMA / NVLink 感知调度 —— GPU 大规模训练的关键能力,它没有,路线图上也没有
  • 多集群 —— 一个调度器 = 一个 shim = 一个集群 = 一个 partition,硬编码(K8s shim 只支持 default,YUNIKORN-22)
  • DAG 依赖编排 —— 「A 完成后起 B」是 Argo / Airflow 的职责
  • 任何写操作 API —— 25 条路由里唯一非 GET 的是 POST /ws/v1/validate-conf,只做校验 ⇒ 配额变更只能改 ConfigMap,GitOps 是唯一正规通道
  • 主备高可用 —— 单副本 + 重启后状态重建,没有 leader election
  • 闲置回收 —— notebook 挂着不用照样占配额,那是别的工具的事
  • Red Hat 认证 / OperatorHub 上架 —— YUNIKORN-354「改用 UBI 基础镜像」= Closed / Won't Fix

⚠️ 三条「看起来像 bug 其实是设计」

  • 装上之后所有 pod 的 schedulerName 都被改写 —— mutating webhook 默认作用于全集群所有工作负载类型,包括显式写了 default-scheduler 的。这是设计行为,第三章会讲唯一的正确出口。
  • 抢占之后有一批 pod 永远 Pending —— 官方设计文档专门分析过 ReplicaSet 场景并预期了这个结局。它防住了抢占循环,代价是永久 Pending。
  • 调度器挂着的时候新 pod 全部 Pending —— 已运行的 pod 不受影响(它们已 bind)。这是单副本模型的必然,不是故障。
对客户的正确表述:它是单副本 + 快速重建模型,不是 active-active。 不要说成「高可用」。
Ch.1 · 为什么需要它 — 诚实边界8
02
Mechanism
它怎么工作
这一章全部有源码或实测支撑。三个「会静默失效」的坑都在这里。
三仓库一条接口契约 队列模型 Gang 调度 抢占七定律 可观测性
Apache YuniKorn 技术深潜
9
Ch.2 · 它怎么工作 · Architecture

三个仓库,一条接口契约 🔴 不是 gRPC 网络跳 —— v1.9.0 里三者在同一个进程里

三件套与职责(官方原话摘要)

组件Go 行数职责
yunikorn-core87,925全部调度算法;与平台无关,只通过 SI 通信
yunikorn-k8shim53,063与 K8s 对话:informer、翻译资源与请求、把 pod bind 到节点、admission controller
yunikorn-scheduler-interface3,469抽象层,gRPC / protobuf。只有 Go binding
yunikorn-release2,487Helm chart(values.yaml 仅 166 行)
核心两件合计140,988—
口径提醒:官方自称 "light-weight",指的是运行时开销(镜像 35.5 MB、requests 200m CPU), 不是代码规模。核心逻辑 8.8 万行 Go。演讲时别把这两件事混着讲。

SI 这层的收益与代价

  • ✅ 收益 ① core 完全不依赖 K8s 类型,可独立单测
  • ✅ 收益 ② 平台细节(informer / bind / webhook)全在 shim,边界清晰
  • ✅ 收益 ③ 理论上可换平台
  • 🔴 代价 ① 一个改动要跨三个仓库:改 SI protobuf → 重新生成 binding → core 与 shim 各自适配、各自发版
  • 🔴 代价 ② 多一次序列化 / 反序列化
  • 🔴 代价 ③ 排障要跨两个进程边界看日志
「universal」到哪一步了:架构上留了 shim 抽象, 但实际只有一个 shim(Kubernetes)。PMC 成员原话: "We focused purely on the Kubernetes side of things. We left the Yarn thing to the side."
Ch.2 · 它怎么工作 — 架构10
Ch.2 · 它怎么工作 · 图解 · Architecture

三个仓库,一条接口契约(不是 gRPC 网络跳) 同一个二进制 · 同进程 · si.proto 只是合约的书写语言

Kubernetes API ServerPod / Node 事实来源 —— shim 的 informer 把它们转成 si.NodeInfo / si.AllocationRequest 再交给 coregRPC 在 v1.9.0 只是合约的书写语言,不是运行时传输实线 = 真实调用路径  虚线 = 合约定义存在、运行时零调用yunikorn-scheduler(单一二进制):shim 与 core 编译进同一进程,用 Go 接口互调 —— 无 dial / 无 endpoint / 无 gRPC 端口yunikorn-k8shimyunikorn-scheduler-interfaceyunikorn-coreKubernetesShimshim 主控与注册cache.Contextcache.Application · cache.TaskAsyncRMCallback实现 api.ResourceManagerCallback 全 8 个方法api.SchedulerAPIshim 调 core:4 个同名方法 + UpdateConfiguration(合约外)api.ResourceManagerCallbackcore 回调 shim:8 个方法4 个方法在 gRPC 合约之外si.protoservice Scheduler4 RPC 未启用RMProxycore 的 RM 网关pendingAllocEventspendingNodeEventspendingInfraEventsScheduler.HandleEvent 扇出三队列Scheduler / ClusterContextcore 调度主循环pendingRMEvents反方向队列 · RMProxy 自持RMProxy.HandleEvent 写入plugins 注册表RegisterSchedulerPlugink8shim 侧没有 gRPC 客户端K8s informer 事件RegisterResourceManager1UpdateNode / UpdateApplication / UpdateAllocation2同进程直调 · 无 dial / 无序列化3456handleRMEvents → triggerUpdateAllocation7同进程回调,不经网络89GetResourceManagerCallbackPlugin()10▸① 合约不对称:Go 接口比 si.proto 的 service Scheduler 多 5 个方法 —— UpdateConfiguration、Predicates、PreemptionPredicates、SendEvent、UpdateContainerSchedulingState;真要远程部署得先补齐这 5 个 RPC▸② 注册要同步等结果:RMProxy 发 RMRegistrationEvent 进 pendingInfraEvents,阻塞等 *rmevent.Result,Succeeded 才落地 rmIDToCallback + RegisterSchedulerPlugin(rmproxy.go:238,245,247,251)▸③ 全仓唯一 grpc.NewServer = NonBlockingGRPCServer(core/pkg/common/server.go:129,si.RegisterSchedulerServer 在 :133),只被 core/cmd/simplescheduler 用 —— gRPC 参考实现 / dev 命令、非部署件Pod / Node 事实来源;k8shim 用 informer 订阅,shim 侧不直接调度,只把事实转成 si.* 结构交给 corek8shim/pkg/cmd/shim/main.go:54 serviceContext := entrypoint.StartAllServicesWithLogger(...) 在本进程拉起 core 全部服务;:57 NewShimScheduler(serviceContext.RMProxy, ...),该字段静态类型即 api.SchedulerAPI(core/pkg/entrypoint/service_context.go:33)。Makefile:69-70 只产 yunikorn-scheduler 与 yunikorn-admission-controllerk8shim/pkg/shim/scheduler.go:78 rmCallback := cache.NewAsyncRMCallback(context);:133 registerShimLayer();:148 构造 si.RegisterResourceManagerRequest(rmID / version / policyGroup / buildInfo / config / extraConfig 全 6 字段);:162 SchedulerAPI.RegisterResourceManager(...)。Run() :187 顺序 dispatcher → phManager → apiFactory → registerShimLayer:203 → initSchedulerState:210 → doScheduling步骤 6 cache.Context.registerNodesInternal(context.go:1543,上报走 :1577;cordon/uncordon :238 用 si.NodeInfo_DRAIN_NODE / si.NodeInfo_DRAIN_TO_SCHEDULABLE;容量更新 :1597/:1602/:1623);步骤 7 cache.Application.handleSubmitApplicationEvent(application.go:425,提交 :430、移除 :752);步骤 8 cache.Task(task.go:319 CreateAllocationForTask → :330,释放 :502 与 context.go:421/451/505)。7 与 8 是稳态事件驱动,无固定先后;步骤 4 早于步骤 6 成立k8shim 侧唯一的回调实现体,另外还实现 api.StateDumpPlugin:GetStateDump(interface.go:81),core 侧调用方是 REST handler core/pkg/webservice/handlers.go:1098,1105 —— 它同样不在 si.proto 的 service Scheduler 里lib/go/api/interface.go —— RegisterResourceManager / UpdateAllocation / UpdateApplication / UpdateNode 与 si.proto 同名,另有 :36 UpdateConfiguration 在 gRPC 合约之外。serviceContext.RMProxy 的静态类型就是这个接口lib/go/api/interface.go:56 Predicates / :61 PreemptionPredicates / :65 SendEvent / :74 UpdateContainerSchedulingState —— 这 4 个都不在 si.proto 的 service Scheduler 里。core 侧反向调用点:core/pkg/scheduler/objects/node.go:502 Predicates、predicates.go:140 PreemptionPredicatessi.proto:29-49 service Scheduler:RegisterResourceManager(unary)+ UpdateAllocation / UpdateApplication / UpdateNode(三个双向 stream)。lib/go/si 已生成 si.pb.go / si_grpc.pb.go,但 k8shim/pkg 对 grpc. / NewSchedulerClient / RegisterSchedulerServer 零命中,k8shim/go.mod:117 grpc 标着 // indirect ⇒ 4 个 RPC 一行都没被启用core/pkg/rmproxy/rmproxy.go:247 rmp.rmIDToCallback[request.RmID] = callback、:251 plugins.RegisterSchedulerPlugin(callback);:280 UpdateAllocation 先归一化 partition 名再 HandleEvent;UpdateApplication → RMUpdateApplicationEvent、UpdateNode → RMUpdateNodeEvent 同理core/pkg/scheduler/scheduler.go:38-40,53-57,133-141 —— pendingAllocEvents 1024*1024 / pendingNodeEvents 100*1000 / pendingInfraEvents 1000。注册也走这里:RMProxy 发 RMRegistrationEvent{Registration, Channel} 后 :245 result := <-c 阻塞等 *rmevent.Result;重注册路径 :220-231 先发 RMPartitionsRemoveEvent 清分区再等。上行三队列与下行 pendingRMEvents 是两条反方向队列,不要混core/pkg/scheduler —— 消费三队列做调度;产出经 RMProxy 回写。另外 core/pkg/scheduler/objects 会绕过事件泵,直接用 plugins 注册表里的回调做同步反向调用(node.go:502、predicates.go:140)core/pkg/rmproxy/rmproxy.go:46,77 pendingRMEvents(1024*1024)—— :70 RMProxy.HandleEvent 写入,:187 handleRMEvents 消费,处理 RMNewAllocationsEvent / RMApplicationUpdateEvent / RMReleaseAllocationEvent / RMRejectedAllocationEvent / RMNodeUpdateEvent 五类,再由 :146 triggerUpdateAllocation → :148 callback.UpdateAllocation 下行。它是下行队列,与上行的 pendingAllocEvents 等三队列方向相反core/pkg/plugins/plugins.go:34-45 用 Go type assertion 把 callback 分流到 ResourceManagerCallbackPlugin / StateDumpPlugin 等;写入方是 RMProxy(rmproxy.go:251),读取方是 core 调度对象(plugins.GetResourceManagerCallbackPlugin())
这张图的一句话:v1.9.0 里 gRPC 只是「合约的书写语言」,不是运行时传输 —— k8shim 与 core 编译进同一个 yunikorn-scheduler 二进制、同进程用两个 Go 接口互调(main.go:54/57 把 core 的 *RMProxy 直接当 SchedulerAPI 注入)。整条链上没有一次 gRPC 网络跳。
Ch.2 · 图解 — Architecture11
Ch.2 · 它怎么工作 · 图解 · Submit Path

从 kubectl apply 到 pod 被绑定:完整时序 延迟不来自网络,来自两个独立时钟

同一个 Pod / 同一个进程 yunikorn-scheduler:k8shim ⇄ core 是 Go 直调 + channel,si.proto 只是接口契约K8s 控制面SI 边界(同进程调用)kubectl提交 Podkube-apiserverwatch 事件源admission-controller改写 schedulerNameshim Contextpkg/cache · Informershim App / Task FSMschedule() · dispatcherRMProxycore · SI 入口ClusterContextPartitionContextQueue→App→Node100ms 兜底主循环si.proto v1.9.0 · 接口契约,不是网络协议(字段节选)AddApplicationRequest{ applicationID, queueName, ugi, tags, executionTimeoutMilliSeconds, placeholderAsk, gangSchedulingStyle}Allocation{ allocationKey, resourcePerAlloc, nodeID, applicationID, taskGroupName, placeholder, originator, allocationTags }nodeID 为空 ⇒ 这是一个请求(1.9.0 已删 AllocationAsk:reserved "asks")apply Pod / Deployment1POST /mutate2JSONPatch: add /spec/schedulerName = yunikorn3watch 全部 Pod(无 FieldSelector)PodInformerHandlers: AddPod / UpdatePod / DeletePod4AddPod → updateYuniKornPod → SchedulerCacheensureAppAndTaskCreated:建 Application(New) + Task5tick #1 · service.schedulingInterval = 1s(默认值)schedule() 扫到 New app → SubmitApplicationapp FSM:New → Submitted6UpdateApplication(ApplicationRequest{ new })经 RMProxy → RMUpdateApplicationEvent → PlaceApplication(放置规则 → 挂队列)78ApplicationResponse{ accepted: AcceptedApplication }shim app FSM:Submitted → Accepted9每个 tick 只推进一个状态 ⇒ 冷启动是秒级,不是毫秒级≥1s(第二个 tick)Accepted 分支:postAppAccepted → skipReservationStage无 taskGroup ⇒ RunApplication → Running;有 ⇒ TryReserve → Reserving再下一 tick 的 Running 分支:scheduleTasks → InitTask → Pending → Scheduling9bUpdateAllocation(AllocationRequest{ allocations })nodeID 为空 = 请求 · RMUpdateAllocationEvent → partition.UpdateAllocation10tryAllocate 选节点11plugin.Predicates(si.PredicatesArgs)12同步返回:这个节点能不能放 —— 整条链唯一一次 core → shim 反向同步调用shim scheduler_callback.go:196 → context.go:675 IsPodFitNode → :690 predManager.Predicates(kube-scheduler 原生 framework 插件)AllocationResponse{ new } → AsyncRMCallbackRMNewAllocationsEvent(context.go:797 发、:803 同步等 channel)· AssumePod 重试 30×1s13bind Pod 到 nodeIDTaskBound · K8s event reason:Scheduling / Scheduled / PodBindSuccessful14带走这一句这条链上没有一次 gRPC 网络跳:k8shim 与 core 同进程(main.go:54 起 core、:57 直接注入 *RMProxy),si.proto 只是接口契约。延迟来自两个独立时钟:· shim:每 1s 一个 tick,每 tick 只推进一个状态· core:事件驱动 + 100ms 兜底,每个 partition 每轮只产出 1 个 allocationAC 的 FailurePolicy 默认 Ignore ⇒ AC 挂了,Pod会被 default-scheduler 起走,而不是被拒绝。v1.9.0 里确实存在 grpc.NewServer()(core/pkg/common/server.go:129、:133 si.RegisterSchedulerServer),但唯一调用方是 core/cmd/simplescheduler/simplescheduler.go:38 这个独立 demo 二进制,默认的 yunikorn-scheduler 部署从不启它 ⇒ 这条链上没有一次网络跳。kubectl apply -f pod.yaml / Deployment —— 用户侧唯一动作对象存进 etcd,并把 Pod 变化以 watch 事件推给所有 informer完整名 yunikorn-admission-controller(独立 Pod)。MutatingWebhookConfiguration yunikorn-admission-controller-mutations,webhook admission-webhook.yunikorn.mutate-pods,path=/mutate,Operations=[Create,Update]。收 POST 的是 cmd/admissioncontroller/main.go:153 → admission_controller.go:631 Serve → :125 mutate → :157 processPod → :197。Deployment/StatefulSet/Job 等 workload 只被打 user-info annotation(:220 processWorkload),不改 schedulerName。k8shim/pkg/cache/context.go —— informer 回调 PodInformerHandlers(:146-150)、SchedulerCache、Application/Task 对象、AssumePod 与 Predicates 回调都在这里两个不同的执行体:KubernetesShim.schedule() 每 1s 扫一遍所有 app(shim/scheduler.go:128、:171-185);Task 状态机跑在 dispatcher goroutine 上(task.go:339 Dispatch(NewSubmitTaskEvent) 是异步分界)yunikorn-core/pkg/rmproxy —— Scheduler Interface 的实现方。k8shim/pkg/cmd/shim/main.go:54 在同进程里起 core、:57 把 *RMProxy 直接注入 SchedulerAPI ⇒ 全程 Go 直调 + channelcore/pkg/scheduler/context.go + partition.go —— 放置规则、队列挂载、ask 记账,并把新 allocation 以 RMNewAllocationsEvent 同步回传core/pkg/scheduler/scheduler.go:89 internalSchedule —— 事件驱动 + 100ms 兜底(:96-98);context.go:120 tryReservedAllocate → tryPlaceholderAllocate → tryAllocate(:135-141);partition.go:822 起逐层挑队列/应用/节点,每个 partition 每轮只产出 1 个 allocationsi.proto v1.9.0 = 1edd16cd。AllocationRequest 字段 1 被 reserved "asks":请求与已分配统一用 message Allocation,靠 nodeID 空/非空区分(core/pkg/scheduler/partition.go:1218 if node == nil)。1.5/1.6 时代博客里的 AllocationAsk 已不存在。用户侧唯一动作。Deployment 走 workload webhook,只被打 user-info annotation;被改 schedulerName 的是它创建出来的 Podwebhook admission-webhook.yunikorn.mutate-pods,Operations=[Create,Update],FailurePolicy 默认 Ignoreadmission_controller.go:197 patch = updateSchedulerName(patch) → :370-377 追加 {Op:"add", Path:"/spec/schedulerName", Value: constants.SchedulerName}。FailurePolicy 默认 Ignore (webhook_manager.go:636) ⇒ AC 挂掉时 Pod 会被 default-scheduler 起走,而不是被拒绝。k8shim/pkg/client/apifactory.go:98 podInformer 没有 FieldSelector ⇒ shim 监听集群里全部 Pod。schedulerName != "yunikorn" 的 Pod 走 updateForeignPod(context.go:327) 只记账(si_helper.go:117 CreateAllocationForForeignPod),不进调度。context.go:325 utils.GetApplicationIDFromPod(先卡 schedulerName,utils.go:143)→ :329 updateYuniKornPod → :362 schedulerCache.UpdatePod → :368 ensureAppAndTaskCreated → :379 addApplication → :975 NewApplication。pod.Spec.SchedulingGates 非空时(:355-364)只进 cache,不建 Application/Task。shim/scheduler.go:128 go wait.Until(ss.schedule, GetSchedulingInterval(), stopChan);:171-185 schedule() 逐个 app 调 app.Schedule()(application.go:353-393)—— 每个 tick 每个 app 只走一个 case,也就是只推进一个状态。shim application.go:430 handleSubmitApplicationEvent 组装 &si.ApplicationRequest{New: []*si.AddApplicationRequest{...}};SchedulerAPI 就是同进程的 *RMProxy。core context.go:489 handleRMUpdateApplicationEvent → :526 objects.NewApplication → :527 partition.AddApplication → partition.go:331 getPlacementManager().PlaceApplication(app)AcceptedApplication 在 core/pkg/scheduler/context.go:539 构造,rmproxy.go:110-120 装进 si.ApplicationResponse 并回调;shim 侧 scheduler_callback.go:120 收到、:132 发 NewSimpleApplicationEvent(AcceptApplication)k8shim/pkg/cache/application.go:353-393 Schedule():Accepted 分支(:361-366)只调 postAppAccepted(:482),它按 skipReservationStage(:457) 派 RunApplication 或 TryReserve;scheduleTasks(:397) 只在 Running / Reserving 分支里跑 ⇒ 又要等下一个 tick。task.handle(InitTask)(:407) → task_state.go:325-327 New→Pending → postTaskPending(task.go:338) → SubmitTask → :330-332 Pending→Scheduling。gang 场景 Reserving 只调度 placeholder。task.go:330 SchedulerAPI.UpdateAllocation —— 跑在 dispatcher goroutine 上,不在 schedule() 调用栈里。rmproxy.go:265 → :280 RMUpdateAllocationEvent → core context.go:708 / :720 / :745 → partition.go:1223(:1218 if node == nil 判定这是 ask)scheduler.go:89 internalSchedule:事件驱动 + 100ms 兜底(:96-98);context.go:120 schedule() → tryReservedAllocate → tryPlaceholderAllocate → tryAllocate(:135-141);partition.go:822 起按 队列 → 应用 → 节点 逐层挑,每 partition 每轮只出 1 个 allocationcore objects/application.go:1654 → node.go:484 → :499-508 plugin.Predicates(&si.PredicatesArgs{})返回 core 后 objects/application.go:1659 TryAddAllocation → :1674 newAllocatedAllocationResult —— nodeID 这时才落定ClusterContext context.go:150 notifyRMNewAllocation → :794-801 RMNewAllocationsEvent{Allocations: [alloc.NewSIFromAllocation()]},:803 result := <-c 同步等;rmproxy.go:94-100 组装 si.AllocationResponse{New: ...} → :148 callback.UpdateAllocationscheduler_callback.go:49-77 遍历 response.New:getTask → setAllocationKey → retry.OnError(Backoff{Steps:30, Duration:1s, Cap:30s}) 调 context.AssumePod → TaskAllocated → 后台绑定 → TaskBound。注意 TaskGroupMatch 是 Eventf(regarding, related, eventtype, reason, action, note) 的 action 参数(task.go:302-304),kubectl describe pod 的 Reason 列里永远不会出现它;gang 场景的 reason 是 GangScheduling。v1.9.0 里确实存在 grpc.NewServer()(core/pkg/common/server.go:129、:133 si.RegisterSchedulerServer),但唯一调用方是 core/cmd/simplescheduler/simplescheduler.go:38 这个独立 demo 二进制,默认的 yunikorn-scheduler 部署从不启它 ⇒ 这条链上没有一次网络跳。
一句话:延迟不来自网络(整条链同进程),来自两个独立时钟 —— shim 每 1 秒一个 tick。
Ch.2 · 图解 — Submit Path12
Ch.2 · 它怎么工作 · 图解 · State Rebuild

k8shim 内部:零持久化,把 apiserver 当唯一状态库 重启后靠 informer 全量重放 · 8 步

Informer 层 · 适配层shim 核心 · 全部状态只在内存边界 · yunikorn-core(同进程)Kuberneteskube-apiserver唯一的状态持久层零 CRD无本地持久化APIFactory建并启动 informerClients16 informer 的持有者16 个 Informer · resync=0PodInformer有回调,无 filterNodeInformer有回调,无 filterConfigMapInformer有回调 + filterPriorityClassInformer有回调 + filter其余 12 个 Informer仅 ListerContext事件入口 · UpdatePod 分叉 foreign / YuniKornSchedulerCache · 七张内存 mapnodesMappodsMappcMapassignedPodsassumedPodsorphanedPodspvcRefCountsDispatcher单通道事件总线AsyncRMCallback接收 core 回调api.SchedulerAPI同进程 Go 接口调用 · 不是 gRPCRegisterResourceManagerUpdateAllocationUpdateNodeUpdateApplicationUpdateConfigurationRMProxyyunikorn-core 入口 · 同进程List/WatchLister / 事件同进程调用response.NewKubernetesShim.Run() 启动顺序:dispatcher.Start() → apiFactory.Start()(16 informer + WaitForSync)→ registerShimLayer() → initSchedulerState() → doScheduling()initSchedulerState() → Context.InitializeState():8 步从 informer Lister 全量重放,全程不读任何自有存储1Step 1registerPriorityClassesPriorityClass 全量 List灌进 pcMap,必须最先做2Step 2loadNodes全量读 NodeInformer只登记,不参与调度3Step 3registerPods按 CreationTimestamp 升序跳过已终止 pod4Step 4enableNodes放开为可调度节点filterSchedulableNodes5Step 5AddSchedulingEventHandlers生产代码唯一挂 handler 处只注册 4 组回调6Step 6-8finalizePriorityClassesfinalizeNodes / finalizePods二次 List 对账,补初始化窗口两阶段防超卖:si.NodeInfo_CREATE_DRAIN 注册 → 灌完存量占用 → si.NodeInfo_DRAIN_TO_SCHEDULABLE 放开稳态:schedulerName ≠ yunikorn ⇒ foreign;orphan ⇒ 不发 allocationk8shim 不建 CRD、不落本地存储:进程重启后全部状态从 apiserver 经 informer Lister 全量重放(pod UID 即 AllocationKey,spec.nodeName 即已绑定节点)。resync=0 ⇒ 靠 watch 而非周期性 relist;除 Step6-8 的一次性 finalize 对账外,未发现周期性主动 relist 的路径。NewAPIFactory(apifactory.go)建 16 个 informer;apiFactory.Start() 是 Run() 的第 2 步(scheduler.go:200 → apifactory.go:254-255),随后 Clients.WaitForSync(clients.go:70-99)等同步。⚠ WaitForSync 是无限 for + 1s sleep,未找到超时/退出机制(未穷尽搜索,不宜作结论)。ConfigMapInformer 来自 NewAPIFactory 内的局部变量 namespaceInformerFactory(apifactory.go:95)——限命名空间、只建 ConfigMap informer。clients.go:40-68:KubeClient、SchedulerAPI、InformerFactory、16 个 informer、VolumeBinder。Run 全部 informer 见 clients.go:101-118,HasSynced 见 :70-99。三个数别混:16 = 声明且 Run 的(apifactory.go:40 + clients.go:101-118);7 = addEventHandlers switch 支持的 case(apifactory.go:204-235);4 = 生产代码实际注册的(context.go:114/125/136/146)。StorageInformerHandlers / PVInformerHandlers / PVCInformerHandlers 是无调用者的死分支。ConfigMapInformer:由 NewAPIFactory 内的局部变量 namespaceInformerFactory (apifactory.go:95)建,限命名空间;filterConfigMaps(context.go:514)只放行 yunikorn-configs / yunikorn-defaults 两个 configmap。PriorityClassInformer:注册 PriorityClassInformerHandlers,带 filterPriorityClasses;全量灌进 SchedulerCache 的 pcMap。Context.UpdatePod(context.go:325);AddPod 只是 UpdatePod(nil, obj)(:295-297)。分叉判据:utils.GetApplicationIDFromPod 先判 pod.Spec.SchedulerName != "yunikorn" ⇒ 直接返回 "" 走 foreign 路,与有无 app-id label 无关;取 app-id 的真实顺序是 Label yunikorn.apache.org/app-id → Annotation 同 key → Label applicationId → Label spark-app-selector。Context.lock 是粗粒度互斥,注释明说它「还确保多种事件类型不并发执行」(context.go:74)⇒ Pod/Node/ConfigMap/PriorityClass 事件串行处理。predManager(PredicateManager,context.go:110)复用 K8s predicates;NewSharedLister 在 :107。pkg/cache/external/scheduler_cache.go —— 全部在内存,无持久化。assumedPods 的 value 语义是「该 pod 的 volumes 是否全部 bound」(:48 注释),不是「是否 assumed」:key 存在才表示 assumed。orphanedPods:IsAssignedPod 且未终止、但 nodesMap 里没有 pod.Spec.NodeName 时置入(:336-346,日志 Marking pod as orphan),此时 updatePod 返回 false。另有 3 个派生视图 nodesInfo / nodesInfoPodsWithAffinity / nodesInfoPodsWithReqAntiAffinity 供 predicates 用。dispatcher.Start() 是 Run() 的第一步(scheduler.go:194),源码注释逐字:the dispatcher handles the basic event dispatching, it needs to be started at first。Step2 的 registerNodesInternal 等 NodeAccepted / NodeRejected、以及 core 回调投递的 EventTypeApp / EventTypeTask / EventTypeNode 都依赖它已在跑。AsyncRMCallback.UpdateAllocation(response *si.AllocationResponse)(scheduler_callback.go:49)处理三个 slice:response.New → retry.OnError(backOff Steps:30 / Duration:1s / Cap:30s,:69-73)包裹 context.AssumePod(:78) → dispatcher.Dispatch(:90);response.RejectedAllocations :94-100;response.Released :103-116。6 个方法(另有 Stop)。三条证据:pkg/cmd/shim/main.go:54-57 在 entrypoint.StartAllServicesWithLogger 后把 serviceContext.RMProxy 直接当 api.SchedulerAPI 传入;k8shim/pkg 下 grep google.golang.org/grpc 零命中;core 的 NewNonBlockingGRPCServer 唯一调用者是 core/cmd/simplescheduler/simplescheduler.go:38 这个独立示例二进制。si.proto 的 message 仍在用,但只作进程内 DTO。RegisterResourceManager 的请求体是 si.RegisterResourceManagerRequest{RmID, Version, PolicyGroup, BuildInfo, Config, ExtraConfig}(scheduler.go:148-155),调用点 scheduler.go:162-163。调用点 context.go:1362,实现 :1434-1445:PriorityClassInformer.Lister().List(labels.Everything()) 全量读,逐个 schedulerCache.UpdatePriorityClass(pc)。源码注释说明放第一步是为了后续注册用得上优先级。context.go:1370-1380:loadNodes(:1476) → RegisterNodes → registerNodes 为每个 node 造 si.NodeInfo{NodeID, Action: si.NodeInfo_CREATE_DRAIN, Attributes:{DefaultNodeAttributeHostNameKey / DefaultNodeAttributeRackNameKey …}}(Action @ :1513,实际 key 是 si.io/hostname、si.io/rackname,constants.go:38-39),并等 NodeAccepted / NodeRejected 回执。context.go:1384,实现 :1670-1697:PodInformer.Lister() 全量读,按 CreationTimestamp.Unix() 升序排(:1681-1683,为与上次运行的队列顺序一致),IsPodTerminated 的跳过并置 nil(:1688-1691),其余逐个 ctx.AddPod(pod);已绑定 pod 经 getExistingAllocation(:1737-1765) 还原占用。context.go:1392:enableNodes(filterSchedulableNodes(acceptedNodes)) —— 为每个 node 发 si.NodeInfo{NodeID, Action: si.NodeInfo_DRAIN_TO_SCHEDULABLE, Attributes:{}},一次 SchedulerAPI.UpdateNode(&si.NodeRequest{...})(实现 :1609,Action @ :1617)。context.go:1400,实现 :113-157 —— 生产代码中唯一的 AddEventHandler 调用点,只注册 4 组:ConfigMapInformerHandlers(+filterConfigMaps)、PriorityClassInformerHandlers(+filterPriorityClasses)、NodeInformerHandlers、PodInformerHandlers。全部用 AddEventHandlerWithResyncPeriod(handler, 0)。handler 挂在批量重建之后 ⇒ 才需要 Step6-8 对账。context.go:1409 / :1417 / :1425。因为 handler 是在批量重建之后才挂的,存在一个初始化窗口:窗口内被删的对象不会有 delete 事件。三个 finalize 各自重新 List 一遍建 map、比对并补删(实现 :1447-1472 / :1643-1668 / :1699-1734,日志 :1465 / :1661 / :1725)。先以 si.NodeInfo_CREATE_DRAIN 把节点登记成不可调度,灌完 Step3 的存量 pod 占用后,再用 si.NodeInfo_DRAIN_TO_SCHEDULABLE 放开 —— 防止存量占用还没录入 core 就被超卖。两条 UpdateAllocation 路径:foreign pod → CreateAllocationForForeignPod(si_helper.go:117-141,tags[common.Foreign])→ SchedulerAPI.UpdateAllocation(context.go:420-421);YuniKorn pod → ensureAppAndTaskCreated(context.go:368) → Task 状态机 → Task.updateAllocation(task.go:311) → CreateAllocationForTask(task.go:319) → UpdateAllocation(task.go:330)。门:SchedulerCache.updatePod 返回 false(进 orphanedPods)时,foreign 路直接 return(context.go:428,日志 skipping updating allocation for assigned orphaned pod)、YuniKorn 路不调 ensureAppAndTaskCreated(context.go:362)。
这张图的一句话:k8shim 零持久化、零 CRD —— 重启后靠 InitializeState 的 8 步从 informer Lister 全量重放(pod UID 即 AllocationKey、spec.nodeName 即已绑定节点)。所以「调度器重启」不丢账,但重放期间新 pod 会排队。
Ch.2 · 图解 — State Rebuild13
Ch.2 · 它怎么工作 · Scheduling Cycle

每个调度周期只产出一个 allocation 理解吞吐的唯一钥匙 · 源码级

// core/pkg/scheduler/context.go:120 —— 每个 partition 一个 result
func (cc *ClusterContext) schedule() bool {
  for _, psc := range cc.GetPartitionMapClone() {
    // ① 预留优先
    result := psc.tryReservedAllocate()
    if result == nil {
      // ② placeholder 置换(gang swap)
      result = psc.tryPlaceholderAllocate()
      if result == nil {
        // ③ 常规分配
        result = psc.tryAllocate()   // ← 返回单个 result
      }
    }
    ObserveSchedulingLatency(schedulingStart)
    if result != nil { /* 通知 RM */ activity = true }
  }
  ObserveSchedulingCycle(scheduleCycleStart)
  return activity
}

三条推论

  • ① K8s shim 只支持一个 partition(YUNIKORN-22)⇒ 每周期全集群一个 allocation
  • ② 吞吐 = 1 / 单周期耗时。官方文档独立印证:周期延迟落在 0.001–0.01 秒 ⇒ 100–1000 allocations/s
  • ③ 官方还指出:predicate 评估占了一个周期的绝大部分,是其他部分的 10 倍
做法:因此最该盯的指标是 yunikorn_scheduler_scheduling_cycle_milliseconds。它从 ~2ms 涨到 ~20ms,吞吐就从 ~600/s 掉到 ~50/s。
顺序有讲究:placeholder 置换的优先级高于新的常规分配—— 已凑齐的 gang 应尽快换手,不该让新来的普通 pod 抢走它占好的坑。
Ch.2 · 它怎么工作 — 调度主循环14
Ch.2 · 它怎么工作 · 图解 · Scheduling Cycle

调度主循环:四层深度优先剪枝,每层第一个成功就返回 源码级 · 理解吞吐的唯一钥匙

分区层 · 三顺位严格短路:本轮该 partition 至多 1 个 AllocationResult四层深度优先剪枝:queue → app → ask → node每层都在第一个成功处立刻返回 ⇒ 每 partition 每轮至多 1 个 AllocationResult瓶颈不在排序算法,而在「每次成功重走全树 + 阻塞一次 RM 往返」internalSchedule① 事件驱动 · 100ms 兜底ClusterContext.schedule② 遍历每个 partitiontryReservedAllocate③ 第1顺位 · 兑现预留tryPlaceholderAllocate③ 第2顺位 · 换占位符tryAllocate③ 第3顺位 · 常规调度触发一轮取分区nil ⇒nil ⇒Queue.TryAllocate④ DFS · queue.go:1681IsLeafQueue?sortApplications⑥ leaf 分支 · 排应用sortQueues⑤ parent 分支 · 递归下探leafparentDFS 递归两道 continue 闸门yunikorn-coreyunikorn-k8shimApplication.tryAllocate⑦ 逐 ask 过配额闸门Application.tryNodes⑧ 跳过不可调度节点treeIterator.ForEachNode⑨ B-Tree 快照 · score 升序Node.preAllocateCheck⑩ 纯本地快检 · 零成本AsyncRMCallback.Predicates⑩ 同进程调用 · 非 SI gRPC遍历逐节点plugins.GetResourceManagerCallbackPlugin()newReservedAllocationResult⑪ reservationDelay=2s 后预留PartitionContext.allocate⑪ Reserved ⇒ return nilnotifyRMNewAllocation⑫ result := <-c 阻塞等回执notifyRMAllocationReleased⑫ Replaced ⇒ 换占位符无节点可容纳ReservedAllocated ⇒ result 冒泡回 ClusterContextReplaced跨 cycle:本轮无 allocation ⇒ 下轮由 tryReservedAllocate 优先兑现pkg/scheduler/scheduler.go:89 —— select 三路:<-s.stop 退出;<-s.activityPending 立即触发(cap=1 的 chan bool,scheduler.go:58,由 registerActivity() scheduler.go:218 置位);<-time.After(100 * time.Millisecond) 兜底。不是 1ms 轮询。pkg/scheduler/context.go:120 —— for _, psc := range cc.GetPartitionMapClone();跳过 psc.root.GetMaxResource()==nil(:126) 与 psc.isStopped()(:130);整轮 ObserveSchedulingCycle 计时(:155),单分区 ObserveSchedulingLatency。context.go:135 → partition.go:837;reservationCount==0 直接跳过;内部走 Queue.TryReservedAllocate。context.go:138 → partition.go:855;phAllocationCount==0 跳过;该路径不过 PartitionContext.allocate(partition.go:864-873 直接 return result)。context.go:141 → partition.go:822;从 root 队列开始深度优先下探。三者严格顺序:前一个返回 nil 才试下一个。queue.go:1681。注释原文(queue.go:1676):This is a depth first algorithm: descend into the depth of the queue tree first. leaf 走 sortApplications(:1689),parent 走 sortQueues(:1717),两者互斥。取 headRoom=getHeadRoom()(:1684)、GetPreemptionDelay(:1685)、maxPreemptionsPerQueue=10(:1686/queue.go:48)。queue.go:1682 if sq.IsLeafQueue() → sortApplications(:1689);queue.go:1715 } else { → sortQueues(:1717)。一个 cycle 不可能先后各跑一次 —— 这两条是互斥分支。queue.go:1429 → sorters.go:101。先 filterOnPendingResources(sorters.go:181),再四分支(fair+prio / fair / prio+submitTime / submitTime+prio)。switch 无 default ⇒ Undefined 时完全不排序。withPlaceholdersOnly=true 时只留 HasPlaceholderAllocation() 的 app(queue.go:1435)。queue.go:1454。过滤 child.IsStopped()(:1462) 与 pending<=0(:1466),同时收集 GetFairMaxResource()。排序委托 sortQueue()(sorters.go:30);FifoSortPolicy 且不考虑优先级时完全不排序(sorters.go:38-42),遍历顺序 = GetCopyOfChildren() 的 Go map 随机序。parent 队列 sortType 硬设 FairSortPolicy(queue.go:682-685)。queue.go:1693/1694 canRunApp(queue maxApplications) 与 ugm.GetUserManager().CanRunApp(user/group 限额) 合并判断 ⇒ continue;queue.go:1697/1698 GetBackoffDeadline() 退避未到 ⇒ continue。源码只有这两处 continue。application.go:1030。遍历 sa.sortedRequests —— 顺序由插入维持(sorted_asks.go:29),比较用 Allocation.LessThan(allocation.go:540) = priority 降序 + createTime 升序;全程无 per-cycle ask 排序,也没有对应 metric。逐 ask 短路:unschedulable 超限、NotEnoughUserQuota、NotEnoughQueueQuota 等。application.go:1542。回调内先跳过 !node.IsSchedulable()(:1553) 与 !node.FitInNode()(:1560),再 sa.tryNode(node, ask)(:1564)。循环走完仍无节点时,才在 :1599-1612 判断是否转预留。node_iterator.go:38 —— getTree().Ascend(...)。取 iterator 时 cloneSortedNodes() 克隆整棵 B-Tree 做快照(node_collection.go:177,持写锁,无任何 metric)。nodeRef.Less(:59-71) 先比 nodeScore 升序,同分比 NodeID 字典序;score 由 ScoreNode 增量维护,调度周期内不重排 —— 所以 node_sorting_latency 那个 metric 其实不记录节点排序。node.go:526 —— 纯本地判断:请求资源 > 0、节点未被他人预留(isReservedForAllocation)、availableResource.FitIn。只有过了这一关才会往 shim 发 predicate ⇒ 不是每个节点都跨仓调一次。yunikorn-k8shim/pkg/cache/scheduler_callback.go:196 → Context.IsPodFitNode(k8shim/pkg/cache/context.go:675) → predManager.Predicates(context.go:690)。core 侧入口是 Node.preConditions(core/.../node.go:499,:504 构造 si.PredicatesArgs{AllocationKey, NodeID, Allocate});无 plugin 时一律放行(node.go:520)。application.go:1638。条件(:1599-1612):该 ask 尚未预留(reserved==nil) 且 askAge > reservationDelay(=2 * time.Second, application.go:51);遍历中记录 GetFitInScoreForAvailableResource 最小的节点为候选(:1606-1611);落定前再跑一次 preReserveConditions(predicates allocate=false, :1634)。partition.go:878。ResultType==Reserved 时 :916-919 调 pc.reserve(:971) 后 return nil ⇒ ClusterContext.schedule 拿到 nil:不置 activity、不调用任何 notifyRM*。本轮该 partition 无产出。context.go:794 —— 发 rmevent.RMNewAllocationsEvent 后 :803 result := <-c 阻塞等 shim 回执。主循环在此同步等待,这是「每 partition 每轮至多一个 allocation」的真实成本。ResultType==Replaced 走这条:context.go:148 调用 / :814 实现,带 si.TerminationType_PLACEHOLDER_REPLACED —— 真实 Pod 顶掉占位符。
这张图的一句话:一个 cycle = 「每 partition 至多一个 AllocationResult」的深度优先剪枝,queue→app→ask→node 四层每层都在第一个成功处立刻返回,而且末端还要同步等 shim 回执。⇒ 吞吐瓶颈不在排序算法,在「每次成功分配都要同步等一次回执」。
Ch.2 · 图解 — Scheduling Cycle15
Ch.2 · 它怎么工作 · Queue Model

guaranteed 与 max:两个数字定义整个多租户 90% 的实际价值来自把这棵树设计对

语义(官方原话)

guaranteed(min)max(quota)
作用参与份额计算与分配决策该队列任意时刻所有分配的硬上限
与抢占抢占的锚点:队列不可跌破它与抢占无关
设成 0无保障禁止该队列使用该资源(如 nvidia.com/gpu: 0)
root 队列root 不能设任何资源限制,设了 parsing error。它的 max 自动等于集群大小
实测原文:给 root 设 resources 时 POST /ws/v1/validate-conf 直接返回 {"allowed":false,"reason":"root queue must not have resource limits set"}

一条最容易配错的设计原则

≤ 容量
Σ guaranteed
> 容量
Σ max

guaranteed 之和应 ≤ 集群容量(否则保障是空头承诺); max 之和可以、且通常应该 > 集群容量——这正是「允许借用空闲容量」的表达方式。

反面:如果你把所有队列的 max 加起来正好等于集群容量, 你就退化成了静态切分,丢掉了 YuniKorn 相对「多个专用集群」的主要好处——而那个好处占成本节省的约 70%(第四章)。
做法:调 max 通常安全(只放宽借用上限); 调 guaranteed 会改变抢占行为。优先调 max,谨慎调 guaranteed。
Ch.2 · 它怎么工作 — 队列模型16
Ch.2 · 它怎么工作 · 图解 · Queue Accounting

四个量在队列树上怎么传播 并且:guaranteed 不参与准入 3 层树实例 · 两个 headroom 算例

示例:3 层队列树,数字单位 vcore(内部存毫核 int64)记账机制 · yunikorn-core v1.9.0L1rootL2父 / 叶L3叶队列totalPartitionResource所有节点可分配量之和 = 100root 自己不配额度,否则报:root queue must not have resource limits setrootmax 由节点注册动态给guaranteed—max100allocated64pending18root.prod父队列,只夹紧不存和guaranteed60max80allocated52pending15root.dev叶队列,独立分支guaranteed20max40allocated12pending3root.prod.etlheadroom 0guaranteed40max48allocated48pending9root.prod.bi未用满 guaranteedguaranteed20max60allocated4pending6SetMaxResource↓ max 夹紧↑ allocated / pending↓ 每次现算,不落盘↑ 逐层累加root.prod.etl:headroom = min(48−48, 80−52, 100−64) = 0 —— 卡在自己的 max,与 guaranteed 40 无关root.prod.bi:headroom = min(60−4, 80−52, 100−64) = 28 —— 可长到 32 > guaranteed 20,准入不看 guaranteed橙 ↓ max:仅校验期夹紧、运行期现算 · 主色 ↑ allocated(used)/ pending:实时逐层累加 · 紫 guaranteed:纯本地字段,不入准入① max:自顶向下,只在校验期夹紧一次checkQueueResource :130 拒 child.max > parent.max:133 ComponentWiseMin 夹紧后递归传子 —— 但 setResources 只写本节点⇒ 夹紧值不落盘;并集语义:父未定义的资源类型不受夹紧② used / pending:自底向上,真实字段incPendingResource 先递归父再加自己 ⇒ 每节点 pending = 子树之和TryIncAllocatedResource 逐层过 max 才加 allocatedResourcesortQueues:pending = 0 ⇒ 整棵子树被剪掉,不再下降③ 准入只看 max:headroom 里没有 guaranteedinternalHeadRoom = SubOnlyExisting(maxResource, allocatedResource)再与父队列 ComponentWiseMin 取 min;全函数不读 guaranteedResourceFitInMaxUndef:max 未定义的资源类型视为无限(= 不设限)④ guaranteed 的三条路径(都不管准入)① getFairShare 排序分母(本地值,嵌在 sortQueues 内)② 常规抢占快照 preemption.go:761(+ve = over utilized)③ quota 变更抢占 GetPreemptableResource(1.9.0 新增,−ve 才可抢)yunikorn_queue_resource:state 里没有 headroom 这一项/ws/v1/partition/:partition/queues:maxResource = 本地配置值partition.go:598 updatePartitionResource 把节点 delta 累加进 pc.totalPartitionResource,Prune() 后 :610 pc.root.SetMaxResource(pc.totalPartitionResource)。queue.go:1611-1621 显式拒绝非 root 调用(Warn: Max resources set on a queue that is not the root)。root 的 max 不是配置值,是集群总量:partition.go:610 pc.root.SetMaxResource(pc.totalPartitionResource)。allocated 64 = 52 + 12、pending 18 = 15 + 3,都是子树累加出来的。注意 root 的 allocatedResFits 用 FitIn(不 skipUndef):集群未注册的资源类型在 root 直接被拒(queue.go:1332-1336)。校验期 configvalidator.go:141 sumG.AddTo(childG) 累加子队列 guaranteed(40+20=60 ≤ 60 ✓)、:146 校验 Σchild.guaranteed ≤ parent.max;但这个和不落盘 —— queue.go:591 setResources 全段(591-645)对 children 零命中,只赋值 sq.maxResource / sq.guaranteedResource。dev 的 headroom = min(40−12, 100−64) = 28,只受自己和 root 的 max 约束,与 prod 子树互不影响。internalHeadRoom(queue.go:1505)::1517 SubOnlyExisting(maxResource, allocatedResource) = 48−48 = 0,:1524 再与父 ComponentWiseMin ⇒ min(0, 28, 36) = 0。allocated 48 > guaranteed 40 —— 借用超出 guaranteed 没有任何检查阻止,因为准入只判 headRoom.FitInMaxUndef(application.go:1069)。headroom = min(60−4, 80−52, 100−64) = 28 ⇒ bi 可以长到 32,远超自己的 guaranteed 20。反过来它也不因为 used < guaranteed 就被优待,guaranteed 只影响 getFairShare 的排序分母(resources.go:540)。configvalidator.go:125 checkQueueResource;:130 !parentM.FitInMaxUndef(curM) 拒;:133 curM = ComponentWiseMin(curM, parentM) 后 :137 递归传子。运行期靠 GetMaxResource() 每次逐层现算(queue.go:1532 起,doc comment 说 the missing quantity will be seen as a limit of 0,与 FitInMaxUndef 的「未定义=无限」是两套口径,别混讲)。ComponentWiseMin(resources.go:999-1024) 是并集;交集版是 ComponentWiseMinOnlyExisting(resources.go:1052)。入口 application.go:673(AddAllocationAsk, 637)→ queue.go:969-972 (*Queue).incPendingResource 先 sq.parent.incPendingResource(delta) 再加自己;decPendingResource 用 SubErrorNegative,负值打 Warn「Pending resources went negative」。两阶段可回滚:tryNode(application.go:1645) 先 :1659 node.TryAddAllocation,再 :1660 TryIncAllocatedResource(queue.go:1262 查自己 → :1268 递归查全链 → :1285 才写 allocatedResource),队列侧失败则 :1663 node.RemoveAllocation 回滚。剪枝在 queue.go:1467 StrictlyGreaterThanZero(child.GetPendingResource())。queue.go:1505-1525 internalHeadRoom:sq.maxResource == nil 时(:1511-1513)直接返回 parentHeadRoom。application.go:1069 逐 ask 判 !headRoom.FitInMaxUndef(request.GetAllocatedResource()),不过则尝试抢占,仍不过就 LogAllocationFailure(NotEnoughQueueQuota) + setHeadroomCheckFailed。user/group 配额是并列的第二道门(ugm Headroom, application.go:1055-1064,本图未展开)。排序链:queue.go:1454 sortQueues → sorters.go:30 sortQueue → :69-70 CompUsageRatioSeparately → resources.go:540 getFairShare,传的是 GetGuaranteedResource()(本地原始配置值);父队列默认 FairSortPolicy(queue.go:682-684)。GetActualGuaranteedResource(queue.go:838) 在 v1.9.0 零调用方、连测试都没有,是死代码 —— 所以图上没有「guaranteed 自顶向下取 min」这条箭头。抢占快照里的『有效 guaranteed』规则是 MergeIfNotPresent 继承父级(preemption.go:819),与 min 夹紧相反。Prometheus 侧 state 枚举只有 guaranteed/max/allocated/pending/preempting/maxRunningApps(metrics/queue.go:44-51),headroom 只在 REST 里有。REST 的 maxResource 用 sq.maxResource.DAOMap()(queue.go:924),没调 GetMaxResource(),所以它不是自顶向下夹紧后的有效上限;absUsedCapacity 同样基于本地值,只有 :914 的 HeadRoom 字段反映有效余量。
这张图的一句话:used/pending 自底向上实时累加;max/guaranteed 只存本节点、自顶向下每次现算取 min,从不写回子队列。🔴 而 headroom 公式里完全没有 guaranteed —— 所以「借用到 max」不是一个开关,是 guaranteed 压根不参与准入判定。
Ch.2 · 图解 — Queue Accounting17
Ch.2 · 它怎么工作 · Trap #1

坑一:同一套系统里有两套资源命名 写错不报错、不生效

写在哪CPU 该写什么依据写错的后果
队列配置 resources.guaranteed / .max / limits.maxresources vcore 官方队列配置页全部示例都是 vcore: 10;core 内部常量 CPU = "vcore" 写 cpu ⇒ 被当成「一个名叫 cpu 的自定义资源」⇒ 对真实 CPU 完全不限流
Pod 注解 task-groups 的 minResource cpu 官方 gang 页示例是 "cpu": "100m"(这里是 K8s 资源名,由 shim 翻译) 写 vcore ⇒ 同样不报错、同样不生效
Pod 的 resources.requestscpuK8s 原生规范—
 官方原话(这是唯一的例外说明):"YuniKorn tracks CPU resources internally as the vcore resource type. This maps to the Kubernetes resource type cpu. All other resource types have consistent naming."
单位后缀 k/M/G/T/P/E(10 的幂)与 Ki/Mi/Gi/Ti/Pi/Ei(2 的幂); vcore 可用 m 表示 millicore;memory 默认单位是字节
🔴 1.0 起的行为变更 1.0 之前 memory 按 100 万字节解释、vcore 按 millicore 解释 ⇒ 从 0.x 迁上来的旧配置,数值含义会整体漂移,必须重算
为什么这个坑特别危险:它不报错。队列看起来配好了、API 里能读回来、pod 正常 Running—— 只有当某天一个作业吃掉整个集群时你才会发现那个配额从来没生效过。 ⚠️ 而且不能简化成「一律用 vcore」——那样讲会让听众把 gang 注解写错。必须讲清是分场景的。
Ch.2 · 它怎么工作 — 坑一:两套资源命名18
Ch.2 · 它怎么工作 · Trap #2 · 头号陷阱

坑二:放置规则短路 ⇒ 你的整套配额被静默绕过 🔴 而这就是 v1.9.0 的出厂默认 —— 不是示例,是你什么都不配时的行为

# 官方文档给 tag 规则的示例,一字未改
placementrules:
  - name: tag
    value: namespace
    create: true

# 官方原话:
# "The order that the rules are defined in is the
#  order in which they are executed. If a rule
#  matches the policy will STOP executing the
#  remaining rules."
修法(三道防线全上): ① provided 规则放最前 + create: false; ② root.childtemplate 兜底给动态队列一个上限; ③ 巡检 isManaged==false。

✅ 实测:它做了什么

配好 root.{prod,dev,streaming}, root.dev 的 max_vcore=3000。提交一个 minMember=8 × 500m = 4000m 的 gang, pod 上明确打了 queue: root.dev。预期被配额拦住。实际 8 个 pod 全部 Running。

队列isManagedmax_vcorealloc
root.prodtrue80000
root.devtrue30000 ← 指定的队列,一点没用上
root.streamingtrue40000
root.gang-hardfalseunlimited4000

根因四步:① 规则链只有 tag,它第一个就匹配 ⇒ ② pod 上的 queue label 从未被查看 ⇒ ③ create:true 用 namespace 名自动创建了 root.gang-hard ⇒ ④ 该动态队列 isManaged=false、max 为 unlimited,继承 root ⇒ 等于没有配额。

诚实划界(必须说清,否则是冤枉文档):官方文档对机制的描述完全正确——短路求值、create 语义、动态队列都写了。 问题是它从未说明后果:不会说这让 queue label 失效,也不会说自动创建的队列无配额。而它给的示例恰恰就是这个危险组合。 ⇒ 正确说法是:「文档没写错,但它没告诉你后果。」
Ch.2 · 它怎么工作 — 坑二:放置规则19
Ch.2 · 它怎么工作 · 图解 · Placement Rules

放置规则求值链:出厂默认就会造出无上限队列 头号陷阱的完整机制 · 而且校验器不查它

配置期 · LoadSchedulerConfigFromByteArray → buildRulescheckPlacementRulestag 打头 ⇒ <dynamic> ⇒ 整条不校验,零 warningbuildRulesplacementrules 空 ⇒ 隐式 provided + create:falserecoveryRule永远追加为链上末条(不可配)运行期 · PlaceApplication 单次迭代出厂默认 tag/namespace/create:true ⇒ 每个 namespace 必然匹配 ⇒ 无上限队列静默路径 · 未提供 queues.yaml 时的出厂默认(只有 create:true 能进这里)PlaceApplication按序遍历 · 首个命中即停规则内部(tag 为例)不过 ⇒ 下一条① tag 存在性(tag 独有)② filter ⇒ 不通过=不匹配③ parent rule 递归求值④ create:false ⇒ 须已存在queue == nil ?CheckSubmitAccesswalk-up 祖先 · 仅这一项partition.createQueue复查:名字 / ACL / 祖先非 leafNewDynamicQueueunmanaged · maxResource=nilnil三道检查(queue ≠ nil)IsLeafQueue / CheckSubmitAccess / IsDrainingSetQueuePath成功出口 :215≠ nil无配额 ⇒ 运行期 annotation 补救yunikorn.apache.org/namespace.quota兜底 · 末条仍空(仍在同一次迭代内,:127 早于后置检查)root.@recovery@app forced ⇒ :145 break,跳过后置检查root.default须已存在 · 不会被创建 · 仍过后置检查ErrorRejectedapplication rejected: no placement rule matched非 forced都不成123configvalidator.go:814 checkQueueHierarchyForPlacement —— getLongestStaticPath 一遇到非 fixed 规则就把 staticPath 置为 "<dynamic>"、foundDynamicRule=true(:843-849);随后 if strings.Index(path, RootQueue) != 0 { continue } ⇒ 整条规则链跳过队列存在性与 leaf 校验,errNonExistingQueue / errQueueNotLeaf 都不会触发。调用链 LoadSchedulerConfigFromByteArray → checkPlacementRules(:315) → getLongestPlacementPaths(:806),发生在 buildRules 之前(context.go:181 / :227)。第二陷阱:checkPlacementFilter(:446-450) 用 strings.EqualFold,所以 type: Deny 能过校验,但运行时 filter.go:138 是精确 != filterDeny("deny") ⇒ deny 静默变 allow,两处之间无任何 ToLower 归一化。✅实测已三层确证:四种大小写全过校验;只有精确小写 deny 仍渲染为 deny,Deny/DENY/dEnY 三种在 /placementrules 上全部渲染成 allow;路由结果不同。巡检:/ws/v1/config 保留原文、/placementrules 显示生效语义,两者不一致即中招。placement.go:229-232:placementrules 为空时隐式补 {Name: types.Provided, Create: false}。规则名大小写不敏感(rule.go:139-141 normalise=ToLower);写 recovery 直接报错 recovery rule cannot be part of the config, failing placement rule config(rule.go:118-119)。可写类型 5 个:fixed / user / provided / tag / test(types.Test 在 newRule 的 switch 里是可达分支,只有注释说别在测试外用)。未提供 queues.yaml 时才走 core 的 DefaultSchedulerConfig —— Helm values.yaml:119 yunikornDefaults: {} 且 templates/ 内无 queues.yaml;客户若用 --set-file 或独立 ConfigMap 提供了 queues.yaml,默认配置不生效。placement.go:244 newRules = append(newRules, &recoveryRule{}) —— 无论用户配了什么,recoveryRule 永远是最后一条。单分区规则链看 GET /ws/v1/partition/:partition/placementrules(routes.go:84 → getPartitionRules → handlers.go:883);全量 dump 在 /ws/v1/fullstatedump(routes.go:290)与 /debug/fullstatedump(routes.go:205),不在 /ws/v1/scheduler/ 下。placement.go:113 for _, checkRule := range m.rules;:114 remainingRules--;:118 checkRule.placeApplication —— 返回 err 则 SetQueuePath("") 整体失败(:119-125),不再试下一条;返回 "" 则 continue 下一条(:139-141)。tag_rule.go:80-83 if tagVal == "" { return "", nil } —— tag 规则的第一闸是 tag 存在性,在 filter 之前,这是 tag 独有的顺序:user_rule.go:72 / fixed_rule.go:93 的 filter 才是第一件事,provided_rule.go:80 在 :75 空检查之后。出厂默认用的 tag 名是 namespace(AppTagNamespace),k8shim 一定会填。tag_rule.go:85-91 → filter.allowUser(filter.go:50-73):空 filter 直接返回 filter.allow;否则用户列表/正则先匹,再逐 group,首个命中即返回 filter.allow,都不命中返回 !filter.allow。注意它「不通过」等于「本规则不匹配」,不是拒绝应用 —— 会继续试下一条规则。tag_rule.go:96-102 若 tag 值已是 root. 全限定名则跳过父规则;否则 replaceDot 把 . 换成 _dot_(rule.go:143-146,configvalidator.go:39-41 DOT/DotReplace),再递归父规则(:110-111)。父规则返回空 ⇒ 本规则返回空(:117-119);父队列若已存在且是 leaf ⇒ 报错 parent rule returned a leaf queue。tag_rule.go:143 if !tr.create && queue == nil { return "", nil } —— create 的语义只在这一行:false = 队列必须已存在,否则视为未匹配;true = 跳过存在性检查,直接把不存在的队列名当匹配结果返回(:149)。四条规则同构:tag_rule.go:143 / provided_rule.go:138 / user_rule.go / fixed_rule.go。它本身不创建队列 —— 创建在 partition.createQueue;recovery 路径完全绕过它(partition.go:348 createRecoveryQueue)。placement.go:151 queue := m.queueFn(queueName),:153 在此分岔。queue == nil 只有 create:true 的规则才可能走到 —— create:false 在规则内部就已经视为未匹配了。placement.go:155-159 往上找最近一个已存在的祖先队列;:161-169 只做 CheckSubmitAccess,失败则 queueName="" 后 continue。出厂默认 root 的 submitacl 是 '*',所以这一项也必然通过。此分支没有 IsLeafQueue、没有 IsDraining —— 但这个「少两项」只在 placement.go 内成立,下游 createQueue / addChildQueue / AddApplication 还有 4 层复查。拒绝日志 Submit access denied on queue 是 Debug 级(:162),默认级别看不到。partition.go:353 AddApplication 里 queue == nil 且非恢复队列 ⇒ createQueue(:346-357)。createQueue(:532-568)::535 illegal queue name passed in → :548 CheckSubmitAccess → :551 祖先已是 leaf 则 creation of queue %s failed parent is already a leaf: %s → 逐级 NewDynamicQueue(:560);addChildQueue 还会查父队列 IsDraining(queue.go:1145);建完回到 partition.go:361 再 IsLeafQueue。newDynamicQueueInternal 只设 Name / QueuePath / parent,isManaged=false,maxResource / guaranteedResource / maxRunningApps 全为 nil ⇒ 无上限、无模板配额。运行期确有 Info 日志 dynamic queue added to scheduler(queue.go:224)与 SendNewQueueEvent(:226)—— 「静默」指的是配置期零 warning,不是运行期无记录。placement.go:170-201:IsLeafQueue(:172) → CheckSubmitAccess(:182) → IsDraining(:192),任一失败都 queueName="" 后 continue 下一条规则;全过则 :207 break。三个拒绝分支的日志 Submit access denied on queue / Rule returned parent queue / Cannot place application in draining queue 全是 Debug 级(:162/:173/:193),默认级别下看不到 —— 这反而强化了「静默」。CheckSubmitAccess 自身向上递归(queue.go:876-888)。placement.go:215 app.SetQueuePath(queueName) —— 唯一的成功出口。partition.go:365-378:AddApplication 用 tag namespace.resourcequota / namespace.resourceguaranteed / namespace.resourcemaxapps 给刚建出的动态队列补配额(k8shim 把 annotation yunikorn.apache.org/namespace.quota 等转成这些 tag)。这是运行期的补救,不是唯一出路 —— 配置期的正路是给父队列配 childtemplate(queue.go:1159-1164 → applyTemplate,Debug 日志 applying child template to new leaf queue)。recovery_rule.go:59 if !app.IsCreateForced() { return "", nil };:63 返回 common.RecoveryQueueFull = root.@recovery@(constants.go:29-30)。placement.go:145-149 命中后直接 break,跳过所有后置检查。IsCreateForced 看 tag application.create.force —— k8shim metadata.go:90-93 对任何已被调度的 pod(含 static/mirror、DaemonSet)都置 True,所以这条路在真实集群比想象中常触发。placement.go:127 if remainingRules == 0 && queueName == "" ⇒ common.DefaultPlacementQueue = root.default(constants.go:31),且 :133 要求 queueFn 返回非 nil —— 它不会被创建。因 recoveryRule 必然是末条,remainingRules == 0 就是 recoveryRule 那次迭代,所以 root.default 只在 app 非 forced 时才有机会生效。日志 No rule matched, placing application in default queue 用的 logger 是 log.Config。placement.go:210-213:三个兜底全不成才拒绝应用。真实优先级是 root.@recovery@(forced 时在 :118 就命中并 break)→ root.default(须已存在)→ ErrorRejected;二手资料常把前两个写反。
这张图的一句话:v1.9.0 的出厂默认就是 tag/namespace/create:true + root submitacl '*':每个 namespace 必然匹配、必然造出一个 unmanaged 且 maxResource=nil 的无上限队列;而配置校验器只验证 fixed 规则链,对 tag 规则不验证。 🔴 同一个 '*' 的第二个后果(✅实测):submit ACL 向上求并⇒ 子队列的 submitacl 全是装饰品,除非先收紧 root。
Ch.2 · 图解 — Placement Rules20
Ch.2 · 它怎么工作 · Gang Scheduling

Gang:先用 placeholder 占坑,再换成真实 pod 三个阶段 · 三个注解

① PREPARE
创建 placeholder

按每个 taskGroup 的 minMember 创建等量 pause pod,资源精确等于 minResource

›
② RESERVE
占位

placeholder 是真实 K8s pod,只跑 pause,被 kubelet 真正启动,占住节点上的坑

›
③ SWAP
换手

凑齐 minMember ⇒ 发 RunApplication ⇒ 真实 pod 换进 placeholder 占好的位置

›
✗ TIMEOUT
凑不齐

Hard ⇒ 整个应用失败;Soft(默认) ⇒ 退化成普通逐 pod 调度

三个注解(缺一不可)

注解放在哪
yunikorn.apache.org/task-groups只放应用的第一个 pod(Spark 场景 = driver);若无「第一个」概念则所有 pod 都带同样内容
.../task-group-name每个 pod 都要,声明自己属于哪个组
.../schedulingPolicyParameters与 task-groups 同一个 pod。空格分隔的 k=v
没有集群级开关:官方原话 "There is no cluster-wide configuration needed to enable Gang Scheduling." 调度器看到有效的 taskGroups 就走 gang 路径。

怎么划分 task group

判据(官方):「同资源规格 + 同放置约束」为一组—— 不是按角色分组。如果 executor 分大小两档,那就是两个 task group。

框架分组minMember
Sparkdriver + executor1 + 最小 executor 数
FlinkJobManager + TaskManager1 + 最小并行度
Rayhead + worker1 + 最小 worker 数
MPIlauncher + worker1 + 全部(最典型的 all-or-nothing)
Ch.2 · 它怎么工作 — Gang 机制21
Ch.2 · 它怎么工作 · 图解 · Gang Lifecycle

Placeholder 完整生命周期:占位 → 换手 → 回收 含超时计时器的真实起点

K8skube-apiserverPod 的唯一真相来源shimApplication (shim FSM)影子应用状态机shimPlaceholderManager建删占位 Pod 的服务coreobjects.Application核心应用 + 占位账本originating Pod解析 yunikorn.apache.org/task-groups校验失败 → Event action TaskGroupsError,退化普通调度1AddApplicationRequest(shim 此刻在 Submitted)placeholderAsk = Σ(MinResource×MinMember) · executionTimeoutMilliSeconds2AcceptApplication:Submitted → Accepted3TryReserve:Accepted → Reserving4onReserving() → go func()异步 · 失败不重试即退化5placeholder Podregistry.k8s.io/pause:3.7KubeClient.Create × MinMember(只补差额,幂等)tg-<appID:28>-<taskGroupName:20>-<nonce:10>6经 shim:占位 ask(placeholder=true + taskGroupName)占位 Pod 被 bind ⇒ core addAllocationInternal 记账7initPlaceholderTimer()首个占位记账才起表8Bound 占位 == MinMember9占位齐 ⇒ RunApplication9core 与 shim 各自独立判定 Running —— 无 RPC调用 / 请求回程(core → shim)异步 · 经 shim 中转自驱状态转换(无 RPC)换手四跳握手 —— 任一跳断掉,占位就挂到超时scheduling cycle:预留 → 占位换手 → 普通分配10PLACEHOLDER_REPLACED(只通知删占位)真实 allocation 此刻不下发11删占位 Pod:ForgetPod + ReleaseAppAllocation12回同一枚举 PLACEHOLDER_REPLACEDcore 才 ReplaceAllocation 并 notifyRMNewAllocation 下发真实 allocation13placeholderTimer首个占位落地才起表超时分叉:先分 Case(IsRunning ‖ IsCompleting) && 占位非零Case 1 成立?Case 1 · 与 style 无关只以 TIMEOUT 释放剩余占位应用继续跑,Hard 也不失败core application.go:410-437是Case 2 · 才分 Soft/HardSoft → ResumeApplicationHard → FailApplicationcore application.go:438-491否占位被取消也报 TIMEOUT真实 pod 任一资源维度 > 占位⇒ 取消该占位,type=TIMEOUT不是 PLACEHOLDER_REPLACEDHard ≠ 超时必失败两支共用 clearPlaceholderTimer()placeholderTimeoutInSeconds ×1000 =executionTimeoutMilliSeconds默认 defaultPlaceholderTimeout = 15 minK8s Event:gang 相关 reason 恒为 GangScheduling(action 共 8 项,含 TaskGroupMatch);ApplicationFailed 的 reason=action=ApplicationFailedtask-groups 内 name / minMember / minResource 是文档约定 key(无 json tag,解析大小写不敏感);Go 字段为 Name / MinMember / MinResourcev1.9.0 · core 257fdef7 · k8shim 1a59488dPod 的唯一真相来源:真实 Pod 与 placeholder Pod 都在这里创建/删除12 状态 / 13 事件:New Submitted Accepted Reserving Running Rejected Completing Completed Killing Killed Failing Failed Resuming Expired(k8shim/pkg/cache/application_state.go)k8shim/pkg/cache/placeholder_manager.go:createAppPlaceholders 按 taskGroup 只补差额(幂等,支持恢复)core/pkg/scheduler/objects/application.go:84 type Application struct;占位账本字段 :105-119(placeholderAsk / allocatedPlaceholder / hasPlaceholderAlloc / placeholderData)带 yunikorn.apache.org/task-groups 注解的真实 Pod(originator);另有 app-id / queue / task-group-name / internal.yunikorn.apache.org/placeholder 等 keyGetTaskGroupsFromAnnotation(pod)(k8shim/pkg/cache/utils.go:31),调用点 metadata.go:111/118;DisableGangScheduling=false 才走。注意 name/minMember/minResource 只是文档约定 key —— TaskGroup struct(amprotocol.go:47-57)无任何 json tag,Go 字段为 Name/MinMember/MinResource,解析大小写不敏感handleSubmitApplicationEvent()(k8shim/pkg/cache/application.go:425-455),placeholderAsk 见 :174;还带 gangSchedulingStyle(Soft / Hard),executionTimeoutMilliSeconds = placeholderTimeoutInSeconds × 1000W2 补:Step2 与 TryReserve 之间必经此跳。FSM 边 k8shim/pkg/cache/application_state.go:373-376postAppAccepted()(k8shim/pkg/cache/application.go:482-502);skipReservationStage()(:457)为真则直接 RunApplication,不建占位W3:enter_Reserving 回调(application_state.go:462-464)在 goroutine 里调 createAppPlaceholders(application.go:528-542)。建占位不阻塞 FSM,且失败不重试 —— cleanUp + NewRunApplicationEvent + Event action PlaceholderCreateFailed,整个 gang 退化为普通调度Container Name=pause · ImagePullPolicy=PullIfNotPresent · RestartPolicy=Never · Requests==Limits=MinResource(Guaranteed QoS)· terminationGracePeriodSeconds: 0(placeholder.go:154)· 镜像值 k8shim/pkg/common/constants/constants.go:76,使用点 placeholder.go:131(service.placeholderImage 可覆盖)真正发起 K8s 调用的是 placeholder_manager.go:90 KubeClient.Create(placeholder.pod)(:86 是 MinMember 循环);名字来自 GeneratePlaceholderName,letterBytes = "abcdefghijklmnopqrstuvwxyz0123456789",3+28+1+20+1+10=63 恰好 K8s 名字上限占位 pod 走普通 ask,ask 带 Placeholder=true + TaskGroupName(si_helper.go:81-82);灰虚线表示中间经 shim 中转,不是 apiserver 直连 corecore/pkg/scheduler/objects/application.go:1796 —— resources.IsZero(allocatedPlaceholder) 时置 hasPlaceholderAlloc=true 并调 initPlaceholderTimer()。全仓唯一非测试调用点,三个 no-op 守卫在 :382(须 app 正好在 Accepted 态、execTimeout>0)⇒ 一个占位都起不来的应用,placeholderTimeoutInSeconds 永不触发W1 shim 侧自驱:onReservationStateChange()(k8shim/pkg/cache/application.go:547-583)数每个 taskGroup 的 Bound 态占位 task,全部 MinMember 归零 → NewRunApplicationEvent → FSM 边 Reserving→Running(application_state.go:398-402)W1 core 侧自驱:resources.Equals(allocatedPlaceholder, placeholderAsk) 成立即 HandleApplicationEvent(RunApplication)(core application.go:1804-1805)→ FSM 边 Accepted→Running(core application_state.go:105-107)shim 的 response.Updated switch(scheduler_callback.go:153-165)只有 Completed / Resuming / Failing+Failed 三个 case —— core 进 Running 从不通知 shimW4:core/pkg/scheduler/context.go:135-142 顺序为 tryReservedAllocate(135) → tryPlaceholderAllocate(138) → tryAllocate(141),占位换手是第二位不是第一位;partition 层短路门 if pc.getPhAllocationCount() == 0 { return nil }(partition.go:855-856);匹配成功得 ResultType=Replaced(application.go:1209)。换手不保证同节点(application.go:1305 起遍历 node iterator)core/pkg/scheduler/context.go:148 —— result.ResultType == objects.Replaced 时只发 notifyRMAllocationReleased(…, si.TerminationType_PLACEHOLDER_REPLACED, "replacing allocationKey: "+key)scheduler_callback.go:107-113 遍历 response.Released → ForgetPod + 非 STOPPED_BY_RM 就 dispatch ReleaseAppAllocation;handleReleaseAppAllocationEvent 记 terminationType 后删占位 Pod(k8shim/pkg/cache/application.go:652)占位 task 进 Completed → beforeTaskCompleted → releaseAllocation → CreateReleaseRequestForTask 用同一个枚举回传(si_helper.go:150-168,双向复用);core processAllocationRelease 命中后 swap(core/pkg/scheduler/partition.go:1460;同节点/跨节点两支见 :1539-1545)execTimeout 到期后调 timeoutPlaceholderProcessing()(core/pkg/scheduler/objects/application.go:407-493);defaultPlaceholderTimeout = 15 * time.Minute;事件记录统一用 proto 名 REQUEST_TIMEOUT(102) / APP_RESUMING(211) / ALLOC_REPLACED(503)W6:timeoutPlaceholderProcessing() 是 if/else 而不是 Soft/Hard 二分。Case 1 条件 (IsRunning() || IsCompleting()) && !resources.IsZero(allocatedPlaceholder)(application.go:410-437)Case 2(application.go:438-491)::441 event := ResumeApplication,:442-443 gangSchedulingStyle=Hard 时改为 FailApplication;两支共用 clearPlaceholderTimer()(:492)W5:core application.go:1240-1256 —— delta.HasNegativeValue() ⇒ ph.SetReleased(true) + notifyRMAllocationReleased(…, si.TerminationType_TIMEOUT, "cancel placeholder: resource incompatible")。排障时最易误读为「超时了」
一句话:超时计时器从「第一个占位真正被核心记账」起算 ⇒ 一个占位都起不来的应用永远不会超时。
Ch.2 · 图解 — Gang Lifecycle22
Ch.2 · 它怎么工作 · Measured

✅ 实测:placeholder → 真实 pod 的完整时序 0.5 秒间隔紧密轮询 · 本地 kind 集群

时刻Δ(T0)观测到什么
19:32:00.15T0kubectl apply 发出(minMember=4 × 500m = 2000m,队列 max 4000m 空闲)
19:32:00.52+0.37s4 个真实 pod 创建完毕,全部 Pending
19:32:02.68+2.53s🔵 4 个 placeholder 出现(tg-gang-fit-app-worker-group-*),全部 Pending
19:32:04.04+3.89s第 1 个 placeholder 变 Running
19:32:04.74+4.59s🔴 4 个 placeholder 全部消失,第 1 个真实 pod Running(swap 完成)
19:32:05.44+5.29s2 个真实 pod Running
19:32:06.15+6.00s✅ 4 个真实 pod 全部 Running
6.0 s
提交 → 全部 Running
2.1 s
placeholder 存活时长
~0.15 s
swap 耗时
🔴 一个必须知道的观测陷阱:placeholder 只活 2.1 秒。 我们第一次用 8 秒间隔看 kubectl get pods,完全没看到 placeholder,一度误判为「没有创建 placeholder」。 ⇒ 要看到它,必须用 kubectl get pods -w 或亚秒轮询,或者故意让 gang 装不下。 ⇒ swap 能这么快的原因是 placeholder 的 terminationGracePeriodSeconds: 0——删除时不等优雅退出。
Ch.2 · 它怎么工作 — 实测 swap 时序23
Ch.2 · 它怎么工作 · 图解 · State Machine

Application 状态机:两套 FSM,core 10 态 / k8shim 12 态 6 事件 18 条边 · 唯一终态是 Expired

expireApplication · 72h(terminatedTimeout)rejectApplication声明·不可达resumeApplicationrunApplicationcompleteApplicationrunApplication(自环)runApplication(复活)failApplicationexpireApplication · 72hNew唯一初态Accepted等首个分配Running运行中Completing收尾 30sCompleted正常结束Expired唯一终态Rejected准入被拒Resuminggang 软超时Failing失败中Failed已失败runApplicationrunApplicationcompleteApplicationcompleteApplication30s 或分配清零expireApplication72hfailApplicationREST 上的 :state 不是 FSM 状态名路径段只接受 active / rejected / completedFSM 状态走 ?status=running —— 必须全小写,否则 400进入 Expired ≠ 对象被删还需 cleanupExpiredApps(≤24h)从三张 map 摘除v1.9.0 core 侧恰好 10 态 / 6 事件(事件名小驼峰)/ 18 条声明边 —— 本图全部画出;虚线 New → Resuming 声明存在,实践大概不可达core 没有 Reserving(那属 k8shim 独立的 12 态 FSM),也没有 Starting(si.proto reserved 205 / reserved "APP_STARTING" 已除名)唯一初态。10 这个数字有四处互相独立的证据:applicationState iota 常量块(application_state.go:64-75)、String() 数组字面量(:90)、stateEvents map(:77-88)、Application 上的 Is<State>() 方法(application.go:219…255) —— 全部 = 10。已准入,等第一个分配落地。声明:runApplication 的 Dst=Accepted(application_state.go:100-103,Src = New / Resuming)。enter_Accepted 做 IncQueueApplicationsAccepted / DecQueueApplicationsNew。两个触发点:普通分配落地(application.go:1819,addAllocationInternal 非 placeholder 分支);gang 场景占位全部凑齐 —— resources.Equals(sa.allocatedPlaceholder, sa.placeholderAsk)。声明 :104-107。资源计数器归零后的收尾态(RemoveAllocationAsk 里 resources.IsZero(sa.pending) && resources.IsZero(sa.allocatedResource) && !sa.IsFailing() && !sa.IsCompleting())。completingTimeout = 30s 生产不可配:唯一 setter SetCompletingTimeout 的注释逐字为 // SetCompletingTimeout should be used for testing only.(application.go:2260-2263)。正常结束,但不是终态:enter_Completed(application_state.go:252)setStateTimer(terminatedTimeout = 3*24h, …, ExpireApplication)(application.go:54)⇒ 72h 后进 Expired。唯一终态:全仓 grep Expired.String() 确认它只作 Dst 出现。它没有任何 enter_/leave_ 专属回调;真正把对象摘除的是 partition.go:1131-1148 的 cleanupExpiredApps,从 applications / rejectedApplications / completedApplications 三张 map 删,轮询间隔 DefaultCleanExpiredAppsInterval = 24h(partition_manager.go:32,goroutine :66,循环 :171-183) ⇒ 实际可见期 72h~96h。唯一入口 Application.RejectApplication(rejectedMessage)(application.go:2061-2066,走 HandleApplicationEventWithInfo),实际调用点只有 PartitionContext.AddRejectedApplication。它是唯一不向 shim 发 RMApplicationUpdateEvent 的目标状态(判断在 application.go:286,注释逐字:The only state that does not generate an event is Rejected),但仍经 stateEvents 发 APP_REJECT 进事件流 —— 两个通道别混。唯一触发源是 gang placeholder 超时的软分叉:application.go:441 event := ResumeApplication,紧接 :442-445 if sa.gangSchedulingStyle == Hard { event = FailApplication } + "ResourceReservationTimeout"。默认 defaultPlaceholderTimeout = 15 * time.Minute(application.go:55,包级 var 块,生产不改),可用 K8s annotation 覆盖:placeholderTimeoutInSeconds / gangSchedulingStyle(k8shim constants.go:89 / :91)。注意 core 侧事件叫 resumeApplication,ResumingApplication 是 k8shim 的事件名。三个触发点:gang placeholder 超时且 gangSchedulingStyle == Hard(application.go:442-445,信息串 "ResourceReservationTimeout");partition 被移除时 partitionManager 对任意状态的 app 调 FailApplication("PartitionRemoved")(partition_manager.go:153);以及 shim 侧上报失败。声明 application_state.go:116-119,Src = New / Accepted / Running。Failing → Failed 是单独一条声明(Src 仅 Failing,:120-123)。触发点 application.go:1960-1962:removeAllocationInternal 清完占位后 if sa.IsFailing() { event = FailApplication }。enter_Failed(:257)再 setStateTimer(terminatedTimeout) ⇒ 72h 后进 Expired。handlers.go:66-68 定义 AppStateActive/AppStateRejected/AppStateCompleted(全小写 active/rejected/completed);真正的 FSM 状态走 query 参数 ?status=,且仅在 :state == "active" 时生效(:791-804),比较前双侧都 strings.ToLower ⇒ ?status=Running 会 400。可查的 active 状态只有 6 个(New/Accepted/Running/Completing/Failing/Resuming,:82-88);另外 4 个(Rejected/Completed/Failed/Expired)走 GetRejectedApplications() / GetCompletedApplications() 两张独立 map。Running 自环声明在 application_state.go:105-107(Dst=Running 的 Src 列表含 Running)。同态转移 looplab/fsm 返回 "no transition",被 HandleApplicationEvent 按成功吞掉(application.go:264,官方测试 application_state_test.go:89 钉住);enter_Running 整体被 if event.Src != Running.String() 包住(:201)、leave_Running 被 if event.Dst != Running.String() 包住(:210)⇒ 无论回调是否触发,自环都不改 startTime、不动 metrics。非法事件(如 Running 收到 rejectApplication)返回 InvalidEventError,不被 noTransition 吞掉,会打日志(:92-95)。Accepted --completeApplication--> Completing:声明 application_state.go:108-111 的 Src 第 1 个元素。真实可达 —— application.go:619-620,RemoveAllocationAsk 里 pending/allocated 双零、非 Failing/Completing、无 placeholder 时 Accepted 直接进 Completing ⇒ 收尾不必先经 Running。Completing --runApplication--> Running:图上最反直觉的一条边,同一条 fsm.Events(Dst=Running,:104-107)的 Src 含 Completing(Src 列表在 :106)。触发点 application.go:661,注释逐字:2) all asks and allocation have been removed: state is Completing / Move back to Running。Completing --completeApplication--> Completed(:112-115)不只靠定时器:enter_Completing(application_state.go:239)调 setStateTimer(completingTimeout = 30s, …, CompleteApplication);还有三条同步路径立即触发 —— application.go:1957-1959(placeholder 分支,IsCompleting && stateTimer == nil)、:1982-1984(hasZeroAllocations)、:2049(RemoveAllAllocations)。expireApplication 声明在 application_state.go:128-131,Src = {Completed, Failed, Rejected},Dst = Expired —— 三个「看起来像终态」的状态全部经此边汇入。全部由定时器触发:enter_Rejected(:192)、enter_Completed(:252)、enter_Failed(:261)各自 setStateTimer(terminatedTimeout = 72h)。New --resumeApplication--> Resuming:声明确实存在(:124-127,Src = New / Accepted),但唯一触发源是 placeholder 超时(application.go:441),有 placeholder 时 app 早已离开 New ⇒ 实践中大概不可达,故画虚线。
这张图的一句话:core 侧恰好 10 态、6 事件、18 条边,唯一终态是 Expired —— Rejected/Completed/Failed 都只是「72 小时待清理」。🔴 Reserving 不在 core,它属于 k8shim 那套独立的 12 态 FSM;Starting 则已被删除。
Ch.2 · 图解 — State Machine24
Ch.2 · 它怎么工作 · 图解 · Allocation

Allocation 对象:AllocationAsk 在 v1.9.0 已不存在 三个 bool 表达全部状态

yunikorn-core · objects.Allocation 无 FSM,状态由 3 个 bool 派生yunikorn-k8shim · Task / App 都是 looplab/fsmAllocation 的派生状态(bool 组合,非 FSM)askAge > 2stryReservedAllocateunReserve(多触发点)tryAllocate 直接分配(不经预留)bool 翻转notifyRMNewAllocation恢复:跳过 AllocatedBind 成功KubeClient.BindUpdateReservationplaceholder is boundBound 数 == MinMember只数 Task Bound,不看 podUpdateAllocation(gRPC)Allocationallocated=false待调度请求(俗称 ask)1reservationnode+app 双 map 写入被预留节点移出迭代器2Allocationallocated=true已定 nodeID 与 bindTime3Task: Allocatedshim 收到分配,正在绑postTaskAllocated 起 goroutine4Task: BoundBind API 已返回成功PodBindSuccessful5App: Reserving只调度 placeholderonReservationStateChange 计数6App: Running只调度真实 pod放行真身进 core7released=true占位已交出,等 shim 确认preempted=true与 released 互斥(各返回 error)placeholderUsed=true真身已替换掉占位AddAllocationAskpod event(k8shim)Reason 统一 = GangSchedulingAction = CreatingPlaceholders / PlaceholderAllocated /GangReservationComplete / GangSchedulingFailed / PlaceholderCreateFailed⚠ gang「就位」判据 = 全部 placeholder 的 Task 到达 Bound(KubeClient.Bind 返回成功),从不读 pod.Status.Phase⇒ bind 成功但容器起不来(镜像拉不动 / CSI attach 卡住)时,YuniKorn 依然认为 gang 就位并放行真实 podv1.9.0 无独立的 AllocationAsk 调度对象、也无 AllocationAsk protobuf message(已并入 objects.Allocation;si.proto:271 留有 reserved "allocationAsksToRelease");但 REST DAO 仍有 AllocationAskDAOInfounReserve 多触发点:wait-timeout(60min) / requiredNode 让位 / ask 删除 / 抢占取消 / AllocatedReserved 顺清 · reservationDelay=2s 不可配,但可用环境变量 DISABLE_RESERVATION 整体关闭objects.Allocation(allocation.go:39)。v1.9.0 无独立的 AllocationAsk 调度对象,也无 AllocationAsk protobuf message;ask 只是同一对象的一个阶段。AddAllocationAsk(application.go:637)校验 !IsAllocated() 后插入 sa.requests 与 sa.sortedRequests;唯一调用点 partition.go:1223reservation.go:29 包私有对象、从不 mutate、不用锁;不扣资源。tryNodes(application.go:1600)在 askAge > reservationDelay(2s) 且无节点可放时,按 GetFitInScoreForAvailableResource 选最优候选,过 preReserveConditions 后返回 newReservedAllocationResult(:1638)。双写顺序 node 先(node.go:571→:615,发 si.EventRecord_NODE_RESERVATION)再 app(application.go:895→:898)。被预留节点从默认迭代器消失:acceptUnreserved(node_collection.go:32-34)+ GetNodeIterator 返回 unreservedIterator(:167-168)。Reserved 结果在 partition.go:918 直接 return nil —— 预留状态从不告知 shimtryReservedAllocate(application.go:1402)每个调度轮次第一个跑(context.go:135 顺序 tryReservedAllocate → tryPlaceholderAllocate → tryAllocate)。AllocatedReserved 分支里 pc.unReserve(partition.go:936)严格早于 SetBindTime(time.Now())(:949)与 SetNodeID(:950)⇒ bindTime 是 core 侧时间戳,此刻 shim 还没调 Bind,用它算 bind 延迟不含 apiserver 往返task.go:348 postTaskAllocated 在独立 goroutine 里:bindPodVolumes(:363,失败发 PodVolumesBindFailure :366)→ KubeClient.Bind(task.pod, task.nodeName)(:373,失败发 PodBindFailure :375)→ 仅成功才 NewBound。恢复路径:scheduler_callback.go:84-86 若 IsAssignedPod 则 MarkPreviouslyAllocated → task.go:266 直接 SetState(Bound),跳过本状态postTaskBound(task.go:411)仅当 task.placeholder 时 dispatch NewUpdateApplicationReservationEvent(:417)→ App FSM UpdateReservation: Reserving→Reserving(application_state.go:384-386)。k8shim Task 共 10 态:New Pending Scheduling Allocated Rejected Bound Killing Killed Failed Completed(task_state.go:274-287)onReservationStateChange(application.go:547)用 desireCounts[tg.Name]=tg.MinMember(:554)逐个扣减 for _, t := range app.getTasks(TaskStates().Bound)(:557)—— 数的是 Bound,不是 pod Running;差一个就 return。IsPodRunning 在整个 gang 路径零引用。k8shim App 共 12 态:New Submitted Accepted Reserving Running Rejected Completed Killing Killed Failing Failed Resuming(无 Completing)Reserving→Running 后真实 pod 才被提交调度。core 侧 tryPlaceholderAllocate(application.go:1278)做占位换真身:双向指针 request.SetRelease(ph)(:1274)+ ph.SetRelease(request)(:1276)→ ph.SetReleased(true)(:1278,若已 preempted 则整段回滚 :1281-1296)→ 自行 SetBindTime/SetNodeID(:1298-1300)→ newReplacedAllocationResult;释放走 notifyRMAllocationReleased + si.TerminationType_PLACEHOLDER_REPLACED(context.go:148)allocation.go:72 / SetReleased() :298;由 tryPlaceholderAllocate (application.go:1278)在占位换真身时写入allocation.go:74 / MarkPreempted() :358。SetReleased 见 preempted 报错、MarkPreempted 见 released 报错,代码层强制互斥allocation.go:70。Replaced 结果里真实 Allocation 自行 SetBindTime/SetNodeID(application.go:1298-1300)yunikorn-k8shim/pkg/cache/application.go:557 数的是 TaskStates().Bound;IsPodRunning 唯一使用点 external/scheduler_cache.go:331 只是缓存记账
一句话:AllocationAsk 在 v1.9.0 已不存在 —— 只有一个 Allocation,三个 bool 表达状态。
Ch.2 · 图解 — Allocation25
Ch.2 · 它怎么工作 · Trap #3 · Hard vs Soft

坑三:默认是 Soft,而 Soft 会给你「半个 gang」 ✅ 实测 A/B:只改一个参数

行为HardSoft(默认)
入队时 gang 需求 > 队列 max立即 ApplicationRejected,不建 placeholder相同(该检查与 style 无关)
超时后应用状态Failed,从队列消失Running
超时后pod状态全部 Failed装得下的 Running,其余 Pending
pod 的 .status.reasonResourceReservationTimeout无(走正常调度)
关键 event(实测原文)ApplicationFailedresuming as non-gang application (SOFT)
语义全有或全无,宁可失败尽力而为,允许部分启动
适合Spark / MPI / 分布式训练——凑不齐就没意义的作业可弹性伸缩、能容忍部分副本的负载
🔴 需要真 gang 的作业必须显式写 gangSchedulingStyle=Hard。 默认值 Soft 对「真 gang」场景是错的默认值——它会产生「2 个 Running + 2 个 Pending」: 占着资源、干不了活、还不报错(应用状态是 Running,监控上一切正常)。
实测时序(Hard):T+48s 仍在等 → T+63s 全部 Failed。 设定 60 秒,吻合。超时后队列立刻归还全部资源。
另一个坑:参数名是 placeholderTimeoutInSeconds(有 In)。 键写错会被静默忽略——零日志、零告警,然后套用默认值 15 分钟。第三章有一个真实受害者。
Ch.2 · 它怎么工作 — 坑三:Hard vs Soft26
Ch.2 · 它怎么工作 · Preemption

抢占:七条定律 设计来自 Apache YARN 的经验 · 锚点是 guaranteed

七条定律(官方原文编号)

  1. 抢占策略是强建议,不是保证(DaemonSet 场景会破例)
  2. 抢占不能把受害队列压到 guaranteed 以下
  3. 任务不能抢占同一应用内的任务(目前只做队列间抢占)
  4. 队列不低于 guaranteed ⇒ 不能触发抢占
  5. 队列不高于 guaranteed ⇒ 不能被抢
  6. 只能抢占优先级更低或相等的任务(K8s 只允许更低)
  7. 不能抢占围栏之外的任务(单向围栏)
目标定调(官方):"Preemption is used to get the usage of a queue to at least its guaranteed resource capacity. … Preemption is not the tool to get a queue to its full maximum."
🔴 定律 4 的直接后果: 如果你不设 guaranteed,抢占基本什么都不会做——因为「队列低于 guaranteed」这个前提永远不成立。 这是「抢占配了没反应」的第一大原因。
🔴 定律 2 的反直觉后果: 队列虽然超了 guaranteed,但如果它上面每个 pod 都很大(杀掉任何一个都会跌破 guaranteed), 那它一个 pod 都不会被抢。⇒ pod 粒度越粗,抢占越难生效。
🔴 定律 3 的配置含义: 同队列内高优抢不了低优。想让高优作业压过低优,必须放在不同队列(用 priority.offset 区分), 不是靠同队列内的 PriorityClass。这是很常见的配置错误。
方向别搞反: preemption.policy: fence = 我不能往外抢; disabled = 我不能被抢。 想保护在线服务,用 disabled,不是 fence。
Ch.2 · 它怎么工作 — 抢占七定律27
Ch.2 · 它怎么工作 · 图解 · Preemption

抢占决策链:guaranteed 账本 + 围栏,两把锁串联 每一步都在虚拟账本上先验算

① 入口与三道闸 · core 调度循环② 子过程 checkPreemptionQueueGuarantees · guaranteed 账本③ 选节点 → 送 shim 校验 → 最后一公里PartitionContext.TryAllocate分区开关放行 · YAML preemption: enabledApplication.tryPreemptionheadroom 装不下,或没节点放得下maxPreemptionsPerQueue = 10每队列每轮 10 次预算,先于前置检查Preemptor.CheckPreconditions前置五查 = 3 状态闸 + 2 时间窗findPreemptionFenceRoot定律 7:向上递归定围栏根findEligiblePreemptionVictims围栏内八重筛 · 同队列一律不抢prunePreemptionSnapshots剪掉无 victim 的快照 · 1.9.0 新增isAskQueueUnderGuaranteed定律 4:虚拟移除后能否爬过 guaranteedtryNodes → calculateVictimsByNode两轮筛:victim 队列须超 guaranteedcheckPreemptionPredicates循环后只调 1 次 · 每批 10 并发,满意即早停Context.IsPodFitNodeViaPreemptionk8shim 跑 K8s 谓词 → success / indexcalculateAdditionalVictims补 victim → 查缺口 PreemptionShortfallIncPreemptingResource标记 · 逐级上记 · 事件 · 通知 RM 释放SchedulerKubeClient.Delete裸 DELETE → kube-apiserver,绕过 PDBcore → k8shim1234567891011121314最后一公里:实际驱逐是裸 Pod DELETE,不走 pods/evictionCoreV1().Pods(pod.Namespace).Delete(context.Background(), pod.Name, apis.DeleteOptions{})不是 policy/v1 的 pods/eviction 子资源 ⇒ PodDisruptionBudget 对 YuniKorn 抢占完全无效空 apis.DeleteOptions{} ⇒ 仍走 Pod 自身 terminationGracePeriodSeconds(优雅终止,只是不看 PDB)抢占成功也只 newReservedAllocationResult 预留节点,等 victim 真的 released 才在下一轮分配「七定律」不在源码里:全仓 grep 只命中 Apache License 的 applicable law。它只存在于官方设计文档 design/preemption 的「## The Laws of Preemption」(1.9.0 逐字)。本图沿用该文档的定律编号,但判据一律以源码为准。partition.go:828 root.TryAllocate(..., pc.IsPreemptionEnabled())|开关读 partition.go:169-171 PartitionPreemptionConfig.Enabled / .QuotaPreemptionEnabled(Go 字段路径)|YAML 键全小写:preemption: { enabled: true, quotapreemptionenabled: true } —— quotapreemptionenabled 是一个词、无驼峰;写成 Preemption.Enabled 这类驼峰会被 yaml 静默忽略。两个触发点,差别只在 nodesTried:application.go:1074(headroom 装不下,nodesTried=false)与 :1110(headroom 够但没节点放得下,nodesTried=true)|延迟度量 ObserveTryPreemptionLatency ⚠ 源码缺陷:metric 名是 yunikorn_scheduler_trypreemption_latency_milliseconds,但实测调的是 SinceInSeconds(),Help 也写 in seconds ⇒ 值的单位是秒,照名字做 dashboard 会差 1000 倍。queue.go:1686 每轮把 preemptAttemptsRemaining 置回 maxPreemptionsPerQueue = 10|application.go:1484 判 ==0 直接返回 common.PreemptionMaxAttemptsExhausted|这道闸先于 CheckPreconditions(NewPreemptor 在 :1492,CheckPreconditions 在 :1495),所以它是独立一道门,不是 tryPreemption 的注脚。preemption.go:96/101/106/111/116 共 5 个 return false:!IsAllowPreemptOther() / HasTriggeredPreemption() / GetRequiredNode()!=""(交给 required-node 抢占通道)/ createTime+preemptionDelay(DefaultPreemptionDelay 30s)未到 / GetPreemptCheckTime()+preemptAttemptFrequency(15s)未到|失败事件 common.PreemptionPreconditionsFailed。queue.go:2258-2285 向上递归。三种情况成为围栏根:root 队列 / preemption.policy=fence / shouldFenceByMax(:2271-2276)|max 构成围栏不是 1.9.0 新特性:v1.8.0 queue.go:2134 已有一支严格相等(maxResource == allocatedResource);v1.9.0 是泛化 —— 加 askResource 做投影、改 StrictlyGreaterThanOrEqualsOnlyExisting 按已定义资源型逐型判,即「当前用量 + ask 的投影达到或超过 max 即成围栏」。queue.go:2140-2196 深度优先,八道筛依次:①跳过 ask 自己的队列(:2144) ②DisabledPreemptionPolicy 跳过 ③队列未超 guaranteed 则 delete 快照(定律 5,:2156-2161)④ask 与 victim 资源型 MatchAny ⑤GetRequiredNode()!="" 跳过 ⑥IsReleased 跳过 ⑦IsPreempted 跳过 ⑧fenced || priority ≤ askPriority(:2188)|第①条比文档定律 3 更严:整个 ask 所在队列直接 return ⇒ 同队列不同 application 之间也不能互抢(文档自己承认 intra-queue 抢占尚未实现)。queue.go:2106 调用,实现 :2227-2256。剪掉「无 victim 的叶快照」与「不在 ask 路径、也不在任何 victim 路径上的非叶快照」|这是 v1.9.0 真正新增的三样之一(另两样:SortAllocationsBasedOnAsk / scoreAllocationBasedOnAsk,以及 initWorkingState 从无返回值改为返回撤销数)。checkPreemptionQueueGuarantees preemption.go:223-252:先看 ask 队列 GetRemainingGuaranteedResource() 能否直接装下 ask;否则逐个虚拟移除 PotentialVictims,只要某刻 isAskQueueUnderGuaranteed(:942-951) 为真即通过;全程失败 → common.PreemptionDoesNotGuarantee(:606-609)|⚠ 步 5-7 都嵌在这一步里::224 initQueueSnapshots → :132 FindEligiblePreemptionVictims → queue.go:2079 定围栏根 → :2102 八重筛 → :2106 剪枝。preemption.go:568 tryNodes 是外层循环,:579 对每个节点调 calculateVictimsByNode(:259-391)|:264-267 节点本就够则短路 return -1|第一轮 :284-332 过定律 2 闸 GetPreemptableResource()>=Zero && isVictimQueueOverGuaranteed,按缺口是否变小分 head/tail;第二轮 :340-383 定 index(:372)|节点过滤与排序在 initWorkingState(:137)::203-209 删掉不可调度 / 被他人预留 / FitInNode 失败的节点,:214 sortVictimsForPreemption。preemption.go:437。⚠ 不是每个节点调一次:整个 tryNodes 循环结束后只调一次(:597)|组装 si.PreemptionPredicatesArgs{allocationKey, nodeID, preemptAllocationKeys, startIndex}(proto 小驼峰,si.proto);按 startIndex 升序排 :409-415|batchPreemptionChecks 按 preemptCheckConcurrency=10 切块,每个 check 一个 goroutine(:447),批与批之间串行,bestResult.isSatisfactory 成立即 break(:465-467)。k8shim 侧跑真正的 K8s 调度谓词,回 si.PreemptionPredicatesResponse{success, index}|无 RM plugin 注册时 core 侧会假通过(preemption.go:419-434) ⇒ core 的抢占判定不是自足的安全网|定律 1 只影响排序、不排除 victim:scoreAllocation(:887) 对 IsAllowPreemptSelf()==false 只加 scoreNoPreempt(1<<34),批循环后无条件 return bestResult(:470) ⇒ annotation 里 opt-out 的 Pod 在没有更好解时仍会被抢(这就是 "Preemption policies are strong suggestions, not guarantees" 的机制实现)。补 victim = preemption.go:474-564(调用点 :622):按 compareAllocationLess 排序补充,判据是 ask 队列 remaining guaranteed 是否变化,末尾用 isAskQueueUnderGuaranteed 决定成败|查缺口是另一处 —— preemption.go:663 if p.ask.GetAllocatedResource().StrictlyGreaterThanOnlyExisting(victimsTotalResource) → common.PreemptionShortfall。preemption.go:674 逐个 MarkPreempted(),任一已释放则全部 MarkUnPreempted() 回滚并报 PreemptionVictimsReleased(:672-691)|:694-696 victimQueue.IncPreemptingResource() 递归向上(queue.go:1389-1399)|:707 SendPreemptedBySchedulerEvent(Allocation 层;AskEvents 层的文案函数叫 SendPreemptedByScheduler,无 Event 后缀)|:717 MarkTriggeredPreemption|:720 notifyRMAllocationReleased(finalVictims, si.TerminationType_PREEMPTED_BY_SCHEDULER = 3)|:729 newReservedAllocationResult。链路:scheduler_callback.go:102-112(Released 且 != STOPPED_BY_RM → NewReleaseAppAllocationEvent)→ application.go:643-652 handleReleaseAppAllocationEvent → task.go:183-185 DeleteTaskPod → kubeclient.go:140-141 SchedulerKubeClient.Delete|quota 变更抢占(QuotaPreemptionContext / TryQuotaPreemption,独立后台 goroutine 每秒一次、独立排序与谓词族)共用同一条裸 DELETE 出口。证据:k8shim v1.9.0 对 pkg cmd 做 git grep -icE "eviction|\.Evict\(" 零命中;kubeclient.go:140-141 确为 core/v1 Pod DELETE + 空 apis.DeleteOptions{}(apis 是本文件对 apimachinery meta/v1 的别名,kubeclient.go:28,本仓库不写 metav1)|逻辑上确定,但未做 E2E 实测(造 PDB minAvailable 卡死后触发抢占、观察 Pod 是否仍被删);写进风险章节建议补一次 kind 实测。
这张图的一句话:抢占是「guaranteed 账本 + 围栏」两把锁串起来的 —— 每一步都在虚拟账本上验证「抢完之后 victim 队列不掉到 guaranteed 之下、ask 队列能爬到 guaranteed 之上」。没有 guaranteed,抢占什么都不会做。
Ch.2 · 图解 — Preemption28
Ch.2 · 它怎么工作 · Measured

✅ 实测:抢占真实发生,且精确停在 guaranteed 4 个 pod 被抢 · 完整取证

布置:怎么在「不缺资源」的集群上造出稀缺

难点:集群有 89 core,随便提交都能满足,永远不会触发抢占。 而 root 队列不允许设 resources,所以「给全集群设总闸」这条路堵死。
解法:插一个带 max 的中间父队列。

root
└── tenant          max = 4 vcore  ← 稀缺点
    ├── hi   guar 2, offset +1000, delay 10s
    └── lo   guar 1, offset −1000

先让 lo 提交 8 × 500m = 4000m,正好吃满 tenant:
lo alloc=4000 / guar=1000 ⇒ 超出,可被抢
hi alloc=0 / guar=2000 ⇒ 低于,可触发
⇒ 这正是定律 4 + 5 的教科书式配置。

结果

时刻lohi
T+10s8 Running4 Pending(pending=2000)
T+25s4 Running / 4 Pendingalloc 4000→20004 Runningalloc 0→2000
T+45s ~ T+130s状态稳定,不再变化
🔵 关键观察:hi 拿到恰好 2000m(= 它的 guaranteed)就停了, 没有继续往 max=4000 抢 ⇒ 完美印证「抢占只回到 guaranteed,不冲 max」。
🔴 连带问题:被抢占的 4 个 pod 被删后, ReplicaSet 立刻补了 4 个新 pod,而它们永远 Pending(持续到实验结束)。 ⇒ 抢占在 Deployment 语义下不是「缩容」,是「制造永久 Pending」。
Ch.2 · 它怎么工作 — 抢占实测29
Ch.2 · 它怎么工作 · Observability Gaps

抢占的两个观测缺口 都是实测发现的 · 都影响审计

缺口一 · K8s event 会丢,YuniKorn 事件流不丢

1 / 4
kubectl get events 剩下
4 / 4
/ws/v1/events/batch

4 个 pod 被抢占,kubectl get events 里只剩 1 条 Preempted by … (其余随 pod 删除 / event TTL 消失),而 YuniKorn 的事件 API 里 4 条全在。

做法:抢占审计 / 计费 / 事后复盘必须读 /ws/v1/events/batch,不能依赖 kubectl get events。 事件四要素齐全:被抢的 allocation UUID、受害应用、抢占方的 request UUID + 应用名 + 队列名。

缺口二 · 抢占方不知道自己抢了别人

# 抢占方 pod 的完整 event(实测)
Normal  Scheduling         is queued and waiting…
Normal  Informational      Request '…' does not fit
                           in queue 'root.tenant.hi'
                           ← 中间「我抢占了别人」完全没有记录
Normal  Scheduled          Successfully assigned…
Normal  PodBindSuccessful  is successfully bound…
后果:只有受害者有 Preempted by 事件。 能查「谁杀了我」,查不到「我杀了谁」。排查「这个作业抢了谁」只能从受害方事件反查 (按抢占方的 request UUID 在事件流里搜)。
还有一条相关的:「配额不足在排队」这个事件的级别是 Normal 而不是 Warning ⇒ 只报 Warning 的告警规则会漏报配额不足。
Ch.2 · 它怎么工作 — 观测缺口30
Ch.2 · 它怎么工作 · Trap #4 · 当前 GA 上的活跃 bug

坑四:v1.9.0 的 /ws/v1/metrics 被双重 gzip 默认的 Prometheus 抓取全部失败,且静默

版本gzip.goContent-Encoding 出现次数
v1.7.0不存在— 无中间件,不受影响
v1.8.0不存在— 不受影响
v1.9.0(当前 GA)存在1 只 Set,从不读 ⇒ 无保护
master(→1.10.0)存在7 含穿透保护 ⇒ 已修
因果链:/ws/v1/metrics 由 promhttp.Handler() 提供, 它自己已经 gzip 并设了 Content-Encoding: gzip;1.9.0 的中间件不检查就再压一次, 而 header 仍只宣告一层编码 ⇒ 客户端按一层解压 ⇒ 拿到 gzip 帧不是指标文本。 Prometheus 默认发 Accept-Encoding: gzip ⇒ 指标静默消失、target 掉线。
// master 的修复注释(它自己把失败模式讲清了)
// A handler is allowed to encode the response body
// itself … Compressing again would produce a doubly
// encoded body advertised by a single Content-Encoding,
// which NO CLIENT CAN DECODE. Hand the response over
// untouched instead.
if !d.decided && d.Header().Get("Content-Encoding") != "" {
  d.passThrough()
}

# 缓解 ①:原生 Prometheus
- job_name: yunikorn
  enable_compression: false

# 缓解 ②:prometheus-operator
spec:
  endpoints:
    - port: yunikorn-core
      path: /ws/v1/metrics
      enableCompression: false
影响面:只有这一个端点。 只有它的 handler 预先编码过;/ws/v1/events/stream 被中间件按精确路径排除; 其余路由主动加 --compressed 反而有益(因为 API 没有分页)。
Ch.2 · 它怎么工作 — 坑四:metrics 双 gzip31
Ch.2 · 它怎么工作 · 图解 · The gzip Bug

双重 gzip 的完整成因:两层各压了一次 v1.9.0 活跃 bug · 任何客户端都解不开

① 进程启动期 · 每项只做一次(不在 scrape 路径上)pkg/metrics init()once.Do 注册全部指标prometheus.Register失败只 Warn,不 fatalStartAllServicesWithLogger起采集器与 WebAppnewRouter() httprouter注册 40 条路由http.Server :9080Handler: compressResponse12345进程启动期 ↑ / 每次 scrape ↓② 每次 scrape · 请求进 →Prometheus scrapeAccept-Encoding: gzipcompressResponse/ws/v1/metrics 无豁免deferredGzipResponseWriter缓冲 1400 字节再决定httprouter → loggingHandler路由派发并记耗时getMetrics同步采 runtime 后转交678910③ 响应回程 ←promhttp 在写 body 前就把 Content-Encoding 设到底层 w;dw 没覆写 Header() ⇒ 中间件看不见,又压了第二次promhttp.Handler()第 1 层 gzip · 自己协商switchToGzip第 2 层 gzip · buf ≥ 1400finalize() → gz.Close()封尾,冲上线路Prometheus 解一层得 gzip 流,非文本ServeHTTP(w, r)又压一次14131211线路上的响应体 = gzip(gzip(text))第 2 层 gzip · switchToGzip第 1 层 gzip · promhttpOpenMetrics 文本Content-Encoding: gzip只有一个值 ⇒ 客户端只解一层switchToGzip 用 Set 覆盖成同值唯一规避(v1.9.0 侧无任何压缩开关):Prometheus 别发 Accept-Encodingscrape_configs[].enable_compression: false(默认 true)spec.endpoints[].enableCompression: false(ServiceMonitor,需 Prometheus ≥ v2.49.0)上游修复:master 加 passThrough() —— master only,v1.9.0 未修handler 已设 Content-Encoding 就整段直通(master:gzip.go:67-73 / 97)yunikorn-core/pkg/metrics/init.go:49 · 构造 Metrics{scheduler, queues, event, runtime};Namespace="yunikorn"、SchedulerSubsystem="scheduler"、EventSubsystem="event"、Runtime="runtime"(init.go:27-36 / runtime.go:37)pkg/metrics/scheduler.go:186 循环注册 10 个 Collector;其余注册点 scheduler.go:422 / queue.go:105 / runtime.go:243,注销 prometheus.Unregister (queue.go:123)。失败仅 log.Log(log.Metrics).Warn ⇒ 重复注册会静默丢指标。队列名被编进 subsystem:yunikorn_<队列名>_queue_container(queue.go:81 Subsystem: replaceStr)⇒ 每加一个队列多一个 metric family;yunikorn_queue_app / yunikorn_queue_resource 则用 ConstLabels{queue=...}k8shim/pkg/cmd/shim/main.go:54 → StartAllServicesWithLogger → startAllServicesWithParameters(pkg/entrypoint/entrypoint.go:78,实际代码 99-113)。metricsHistorySize != 0 时建 InternalMetricsHistory + NewInternalMetricsCollector(1 分钟 ticker,metrics_collector.go:43),默认 1440 = 24h × 1min,只存 totalAppsRunning / totalContainersRunningpkg/webservice/webservice.go:44 · 遍历 webRoutes,每条先被 loggingHandler 包裹再 router.Handler(Method, Pattern, handler)。40 = 25 条现役 /ws/v1(Cluster 4 + Scheduler 21)+ 13 条 /debug + 2 条 deprecated 重定向pkg/webservice/webservice.go:69-70 · Addr 硬编码 ":9080",ReadHeaderTimeout 10s,compressResponse 是全局唯一中间件。Helm 的 service.port 只改 Service/containerPort 声明(端口名 http1 / yunikorn-core),改了打不通;values.yaml:128 的 enableWebService gate 的是另一个容器 yunikorn-scheduler-web(http2 / 9889),与 9080 的 metrics 无关Prometheus 默认就发 Accept-Encoding: gzip(scrape_configs 的 enable_compression 默认 true)—— 这是触发缺陷的前提pkg/webservice/gzip.go:134 · 唯一豁免路径是 SSE 的 /ws/v1/events/stream;!clientAcceptsGzip(r)(判据 161-175)则 135-136 直通。压缩级别 gzip.BestSpeed(gzip.go:139)。引入方 YUNIKORN-2249(CHANGELOG:82,标题只说 "queue applications API",实现却落成全局中间件 —— 这正是它意外套上 /ws/v1/metrics 的原因)gzip.go:74-77 · d.buf.Write(b) 后 if d.buf.Len() >= minCompressionSize → switchToGzip()。minCompressionSize = 1400(gzip.go:37;注释里的 1500 只是 Ethernet MTU,v1.9.0 自己的测试注释也写错成 1500)。构造在 gzip.go:149,defer dw.finalize() 在 153。🔴 只覆写 WriteHeader(55) / Write(66),没覆写 Header() ⇒ handler 设的响应头直接落到底层 w,中间件看不见 —— 这是缺陷的结构性根因webservice.go:44-51 建链、53 loggingHandler 记 name/method/uri/duration(log.REST,Debug 级)pkg/webservice/handlers.go:1123 · metrics2.GetRuntimeMetrics().Collect() 在请求线程里同步读 runtime.MemStats(runtime.go:57-60、:71)。getMetrics 不调 writeHeaders(对比 handlers.go:188-197)⇒ /ws/v1/metrics 缺 Access-Control-Allow-Origin 等 4 个头(Content-Type 有,promhttp 用 expfmt.Negotiate 设)handlers.go:1124 · = InstrumentMetricHandler(prometheus.DefaultRegisterer, HandlerFor(prometheus.DefaultGatherer, HandlerOpts{}))(client_golang v1.23.2 promhttp/http.go:96-99);DisableCompression 默认 false(:146),offers {Identity, Gzip, Zstd}(:68-74);先设头后编码:rsp.Header().Set("Content-Encoding", encodingHeader)(:212-214),gz.Reset(rw) 直接包住传入的 writer(:481-484)。每次 scrape 都新建一个 Handler(靠 AlreadyRegisteredError 兜住)gzip.go:91 · Write(66-79)对 Content-Encoding 无任何检查;Set("Content-Encoding","gzip") 把已有值覆盖成同值(头仍是单值)、Add("Vary","Accept-Encoding"),然后 d.gz.Write(d.buf.Bytes()) 把 promhttp 已经 gzip 过的字节再压一次。更坏的变体:客户端发 Accept-Encoding: zstd 时 promhttp 设 Content-Encoding: zstd,这里的 Set 把它改写成 gzip ⇒ 头说 gzip、body 是 gzip(zstd(text))gzip.go:112-117 · defer 在 153 注册;d.useGzip 为真 ⇒ d.gz.Close() 把 gzip(gzip(text)) 冲上线路。若 promhttp 输出不足 1400B,finalize 走 !d.decided 分支原样写出 buffer,反而是正确的 —— 真实调度器 metrics 远超 1400B,所以实际必然踩中客户端按 Content-Encoding: gzip 只解一层,拿到的是二进制 gzip 流而非 OpenMetrics 文本 ⇒ 抓取解析失败。(未实测复现:无 K8s 环境。为什么 1.9.0 没测出来:handlers_test.go:957-964 的 TestMetricsNotEmpty 直接调 promhttp.Handler() 绕过 compressResponse 且不设 Accept-Encoding;5 个 gzip 测试全打 /ws/v1/clusters 或 events/stream)两层各压一次:内层 promhttp(client_golang promhttp/http.go:212-214 先设头再编码)、外层 compressResponse(gzip.go:86 Set 覆盖成同值 + 91 再压)。Content-Encoding 只有一个值 gzip ⇒ 任何客户端都只会解一层YuniKorn v1.9.0 全仓没有压缩开关(grep compression 只命中 gzip.go 的 minCompressionSize;k8shim constants.go:134 的 Compression 是 ConfigMap gzip+base64,无关)。旁路点是 gzip.go:134 的 || !clientAcceptsGzip(r) → 135-136 直通,判据函数 gzip.go:161-175。验证:curl -sH 'Accept-Encoding: gzip' localhost:9080/ws/v1/metrics | gunzip | file -passThrough 与 TestCompressResponseSelfEncodedHandler / -SmallBody / -PreservesStatus 在 v1.9.0 全仓 0 命中,只在 master:pkg/webservice/gzip.go:97 与 master:pkg/webservice/gzip_test.go:95/119/140。master 修复 commit 的注释逐字点名 promhttp("for example promhttp, which performs its own gzip content negotiation")。修复对应的 JIRA 号无法确认(depth-1 shallow clone),故不上图
这张图的一句话:v1.9.0 新加的全局 gzip 中间件不检查 handler 是否已自己压缩,而 /ws/v1/metrics 的 promhttp 会自己 gzip 并设 Content-Encoding —— 结果是「双层 gzip 体 + 单值 Content-Encoding」,任何客户端都解不开。
Ch.2 · 图解 — The gzip Bug32
Ch.2 · 它怎么工作 · 图解 · Hot Reload

ConfigMap 热加载:每一层失败都只记日志、保留旧配置 informer WATCH 推送 · resync=0 · 零轮询

① Kubernetes:写入前 ValidatingWebhook 校验(FailurePolicy=Ignore ⇒ fail-open)kubectl / 用户改 ConfigMapkube-apiserver配置的唯一存储Admission ControllerFailurePolicy=IgnorePOST /ws/v1/validate-confcore validateConf改 ConfigMap1拦 CREATE/UPDATE2POST 校验请求3allowed / reason只认两个名字常量写死,第三个不生效0yunikorn-defaultsindex 0 · helm 创建1yunikorn-configsindex 1 · 用户自建index 1 覆盖 index 0不可达 / 非 2xx / 解析失败 →assuming configmap is valid(放行)唯一真拒绝:Configmap validation failed, aborting② k8shim(scheduler Pod)ConfigMap InformerWATCH,resync=0ContextsetConfigMap(index)SchedulerConfFlattenConfigMaps → 解析handleNonReloadableConfig15 项若变则回退 + WARN分派 index 0/15扁平合并 + 解析6内嵌自调用7解析失败 → Unable to update configmap, ignoring changes(旧配置原样保留)4WATCH 事件(resync=0,无轮询)③ yunikorn-coreClusterContextprocessRMConfigUpdateEventPartitionContextupdatePartitionDetailsGET /ws/v1/config读回规范化配置8RMConfigUpdateEvent + Result chan(同步阻塞)干跑后就地更新9验证读回checksum 相同 → 短路ApplyConf → updateQueues 递归yaml.Marshal 后的对象,非原文配置改了没生效?· 全程 WATCH 推送,无轮询· 每层失败只记日志· 旧配置原样保留· 不崩、不重试、Pod 仍 Running· 查日志 + GET /ws/v1/config 读回值kubectl edit cm yunikorn-configs -n yunikorn(或 yunikorn-defaults)ValidatingWebhookConfiguration: yunikorn-admission-controller-validations;无 NamespaceSelector ⇒ rule 覆盖全集群 configmaps,namespace 过滤在 validateConfigMap 首行做webhook 名 admission-webhook.yunikorn.validate-conf,Operations{Create,Update} / Resources{configmaps}(k8shim/pkg/admission/webhook_manager.go:596,FailurePolicy=Ignore :600)。唯一真拒绝路径:Configmap validation failed, aborting(admission_controller.go:612)core/pkg/webservice/handlers.go:170 validateConf → LoadSchedulerConfigFromByteArray 解析+校验,回 ValidateConfResponse{allowed, reason}(dao/config_info.go:23)。只有 responseData.Allowed == false 才真正拒绝写入const DefaultConfigMapName = "yunikorn-defaults"(k8shim/pkg/common/constants/constants.go:68);helm chart 只渲染这一份,带 annotation "helm.sh/resource-policy": keepconst ConfigMapName = "yunikorn-configs"(k8shim/pkg/common/constants/constants.go:67);不在 helm chart 里,用户自建。两份都缺不报错(GetConfigMap 吞 IsNotFound 返回 nil)FlattenConfigMaps 顺序遍历 []*v1.ConfigMap 并 result[k] = v ⇒ index 1 的同名 key 覆盖 index 0(k8shim/pkg/conf/schedulerconf.go:508)独立的 namespace 级 factory:informers.NewSharedInformerFactoryWithOptions(clientSet, 0, informers.WithNamespace(configs.Namespace))(k8shim/pkg/client/apifactory.go:95);注册 handler 时 resyncPeriod 也传 0 ⇒ 源码里没有任何配置轮询间隔filterConfigMaps(context.go:515)双条件放行(两个名字 + 本 namespace)→ addConfigMaps(:527) / updateConfigMaps(:542) / deleteConfigMaps → triggerReloadConfig(index) → setConfigMap(index)(:657)。0/1 索引在 scheduler 与 admission 两处各自写死,没有共享常量UpdateConfigMaps(k8shim/pkg/conf/schedulerconf.go:170):CreateDefaultConfig 铺默认值 → FlattenConfigMaps 扁平合并 → parseConfig → handleNonReloadableConfig → SetSchedulerConf。队列配置只认 <policyGroup>.yaml(默认 queues.yaml),其余 key 作为 extraConfig 送 coreschedulerconf.go:210-226 共 15 个 checkNonReloadableXxx:CMSvcClusterID / CMSvcPolicyGroup / CMSvcSchedulingInterval / CMSvcVolumeBindTimeout / CMSvcEventChannelCapacity / CMSvcDispatchTimeout / CMKubeQPS / CMKubeBurst / CMSvcDisableGangScheduling / CMSvcNodeInstanceTypeNodeLabelKey / AMFilteringGenerateUniqueAppIds / CMSvcPlaceholderRunAsUser / CMSvcPlaceholderRunAsGroup / CMSvcPlaceholderFSGroup / CMSvcPlaceholderImage。不同则 *new = *old 改回去并打 WARN:ignoring non-reloadable configuration change (restart required to update)core/pkg/scheduler/context.go:205。先 configs.SetConfigMap(ExtraConfig)(:219,在短路之前 ⇒ extra 总会更新)→ LoadSchedulerConfigFromByteArray 解析+Validate+sha256 checksum → :234 if conf.Checksum == oldConf.Checksum 直接返回成功。校验失败只回 Result{Succeeded:false},shim 打 reload configuration failed,调度器不崩updateSchedulerConfig(context.go:370)先 newPartitionContext(p, rmID, nil, true) 干跑校验,通过后才 part.updatePartitionDetails(p)(partition.go:173):UpdateRules → root.ApplyConf → updateQueues(partition.go:229) 递归 → 未访问的子队列 MarkQueueForRemoval()(标记,不是立即删)。队列树就地更新,不重建getClusterConfig(core/pkg/webservice/handlers.go:566)返回 yaml.Marshal(ConfigDAOInfo),默认 application/x-yaml; charset=UTF-8,Accept: application/json 才给 JSON。子队列键是 queues,不是 children —— children 只属 PartitionQueueDAOInfo(dao/queue_info.go:43),服务 /ws/v1/partition/:partition/queues(routes.go:90)。maxapplications / adminacl / submitacl / childtemplate / deadlockdetectionenabled / deadlocktimeoutseconds 是 YAML 默认输出的小写键;JSON 时是 CamelCaseContext 组装 si.UpdateConfigurationRequest{rmID, policyGroup, config, extraConfig}(scheduler-interface/si.proto:415,reserved "configs")→ RMProxy.UpdateConfiguration(core/pkg/scheduler/rmproxy.go:321-339):建 chan *rmevent.Result → HandleEvent → result := <-c,同步阻塞等结果唯一会 Fatal 退出的是进程启动时的 bootstrap(k8shim main.go:45 / :50);热加载失败没有任何 retry,resync=0 也不会有周期性 resync 兜底 ⇒ 恢复只能靠下一次 ConfigMap 变更或重启
一句话:每一层失败都只记日志 + 保留旧配置 ⇒ 「改了没生效」只能查日志与 GET /ws/v1/config。
Ch.2 · 图解 — Hot Reload33
03
On Amazon EKS
在 AWS 上怎么用
AWS 是唯一把 YuniKorn 写进产品文档的公有云。但它是「官方记录、自行运维」——而与 Karpenter 的协同靠的是一个未成文的魔法字符串。
AWS 的官方立场 EKS 版本矩阵 Karpenter 协同 生态集成矩阵
Apache YuniKorn 技术深潜
34
Ch.3 · 在 AWS 上怎么用 · Vendor Position

AWS 是唯一把它写进产品文档的公有云 但是「官方记录、自行运维」

云 / 平台官方推荐的批调度方案官方文档提及 YuniKorn托管组件
AWS EKS / EMR on EKSYuniKorn 与 Volcano 并列,各有一篇官方 tutorial✅ 有专门教程页❌ 非 add-on,仍装社区 Helm chart
阿里云 ACK自研增强 kube-scheduler(内建 Gang + Capacity)⚠️ 仅「计算巢」货架,不在 ACK 组件中心⚠️ 中立货架,非产品团队背书
腾讯云 TKE自研 Extender 系插件❌ 未找到❌
华为云 CCEVolcano(一等公民;xGPU 虚拟化硬依赖 Volcano ≥1.10.5)❌ 未找到❌
火山引擎 VKE自研增强调度器 + Kueue❌ 未找到❌
Google GKEKueue(拓扑感知调度 TAS 直接建在其 CRD 上)❌ site:cloud.google.com yunikorn 返回 0 条❌
Azure AKSKueue(≥4 篇官方文档)❌ 未找到❌
Red Hat OpenShift无支持声明⚠️ 仅 YuniKorn 自己的本地开发指南❌ 无 Operator、无 UBI 镜像
Cloudera CDP / CDEYuniKorn(唯一把它做成商业产品核心的厂商)✅✅ CDE 由 YuniKorn 驱动
AWS 给了什么:EMR on EKS 官方教程(Spark Operator + spark-submit 两条路径)、 AWS Big Data 博客、aws-samples 示例仓库、awslabs/data-on-eks 参考架构(无条件安装 YuniKorn)。
AWS 没给什么:❌ 不是 EKS add-on ❌ 无托管版本 ❌ 无支持 SLA ❌ 从未发布任何 YuniKorn 的性能数字 ❌ 官方教程未覆盖 StartJobRun API 路径。
三阵营看清谁在推: YuniKorn = Cloudera(娘家)+ AWS;Volcano = 华为 + CNCF + Spark 主干内建; Kueue = Google + Microsoft + 字节 + K8s SIG 官方子项目(动能最强)。
Ch.3 · 在 AWS 上怎么用 — AWS 的官方立场35
Ch.3 · 在 AWS 上怎么用 · 图解 · Topology

在 EKS 上装出来到底是什么:2 个 Deployment、2 个 Pod、3 个容器 无 DaemonSet · 硬编码 replicas: 1 · 零 leader election

EKS 托管控制平面(AWS 托管)namespace: yunikornEC2 工作节点 —— kubelet / 业务 Pod 是 K8s 机制,YuniKorn 源码无此逻辑APIkube-apiserver唯一状态源 · AWS 托管集群级 · AC 运行时自建(不在 chart 里)yunikorn-admission-controller-mutationspatch /spec/schedulerName · Ignoreyunikorn-admission-controller-validations/validate-conf · IgnoreK8sdefault-scheduler仍在跑,管非 YK PodIgnore ⇒ 回落failurePolicy: Ignore ×2AC 挂了 → Pod 照样创建成功只是不再被打 schedulerName⇒ 静默滑回 default-scheduler队列 / 配额 / gang 全部失效Helm chart(14 文件 / 10 模板)① pre-install hook 建 SA/Role/Binding weight 0→1→2 —— 权限先于 workload② 建 2 个 Deployment · 2 Pod · 3 容器 0 个 DaemonSet / StatefulSet / Job借用内置 ClusterRole:system:kube-schedulersystem:volume-scheduleryunikorn-admission-controller-service443 → webhook-api 9089yunikorn-admission-controllerDeployment · 1 副本 · hostNetwork4webhook-api 9089yunikorn-servicehttp1 9080 · http2 9889http1 9080 上的 REST(节选)/ws/v1/scheduler/healthcheck/ws/v1/metrics · /ws/v1/config/ws/v1/validate-confyunikorn-schedulerDeployment · replicas: 1(字面量)· 无 leader election9080 / 9889Pod ×1 · 2 容器 · 无任何探针YKyunikorn-scheduler-k8score + shim 同一进程,不走网络5UIyunikorn-scheduler-webPROXY_URL → 127.0.0.1:9080 · LISTEN :9889yunikorn-configs外部创建 · Helm 完全忽略3yunikorn-defaultsHelm 渲染 · policy: keep覆盖admission-controller-secretsAC 运行时自签 CA 并 update7POST /mutate8patch /spec/schedulerName故障域:scheduler 挂掉 ≠ 业务中断⑥ 重启后 InitializeState() 8 步重建状态 —— 已绑定 Pod 按「既成分配」恢复(Step 8: Finalize pods)新 Pod 停在 Pending,运行中 Pod 归 kubelet,零中断;scheduler 无任何探针,不会被 K8s 自动重启EC2kubelet已绑定 Pod 归它管Pod业务 Pod被打 schedulerName写 v1.Binding9拉起容器10唯一状态源。scheduler 的 informer 与 Bind 都走 in-cluster :443(k8shim/pkg/shim/scheduler.go:70;k8shim/pkg/client/kubeclient.go:117-126)AC 用自己的 ClusterRole 在运行时 MutatingWebhookConfigurations().Create()(webhook_manager.go:339/:366;cmd/admissioncontroller/main.go:132 InstallWebhooks)。failurePolicy: Ignore(:615,:636);覆盖 3 apiGroup × 7 资源(:633-634)。范围 = 除 ^kube-system$ 外全部命名空间(am_conf.go:71-72)ValidatingWebhookConfigurations().Create()(webhook_manager.go:266/:293);failurePolicy: Ignore(:580,:600)。逐字 webhook 名:admission-webhook.yunikorn.mutate-pods / admission-webhook.yunikorn.validate-confEKS 自带调度器,YuniKorn 装上后它并没有被停掉:只要 Pod 上没有 schedulerName: yunikorn,就由它调度 —— 队列/配额/gang 全部不生效两个 webhook 的 failurePolicy 都是 Ignore:validating webhook_manager.go:580,600;mutating :615,636。AC 不可用时 apiserver 直接放行,Pod 创建成功但不带 schedulerName: yunikorn,于是安静地由 default-scheduler 调度 —— 没有任何报错,只有队列/配额/gang 失效chart 共 14 个文件,templates/ 下 10 个(9 个 manifest + _helpers.tpl)。RBAC 走 helm.sh/hook: pre-install,pre-upgrade,helm.sh/hook-weight 0→1→2(rbac.yaml:24-25,33-34,74-75;admission-controller-rbac.yaml:25-26,33-34,70-71)。scheduler 借用 system:kube-scheduler 与 system:volume-scheduler(rbac.yaml:99,116);SA 模板无 annotations 字段 ⇒ 要挂 IRSA 必须自己 patch SAadmission-controller-service.yaml:22 name、:31 port: 443、:32 targetPort: webhook-api、:33-36 selector(app=yunikorn, component=yunikorn-admission-controller)。ClusterIP。webhook clientConfig 用 ServiceReference 而非 IP(am_conf.go:67)admission-controller-deployment.yaml:33 副本数 = .Values.admissionController.replicaCount。hostNetwork 默认 true(values.yaml:43)⇒ Pod IP = Node IP,且 :29-32 用 strategy.type: Recreate。🔴 启动顺序:main.go:122 LoadCACertificates → :127 GenerateServerCertificate → :132 InstallWebhooks(注册 webhook)→ 之后才 :92 webhook.Startup 起 9089 HTTPS ⇒ 注册早于监听就绪,这个启动窗口靠 failurePolicy: Ignore 兜底。镜像 apache/yunikorn:admission-1.9.0service.yaml:29 ClusterIP;port 9080 → targetPort http1、port 9889 → targetPort http2(values.yaml:76-79)。selector: app=yunikorn, component=yunikorn-scheduler。REST(routes.go):/ws/v1/metrics /ws/v1/config /ws/v1/validate-conf /ws/v1/partitions /ws/v1/partition/:partition/queues /ws/v1/partition/:partition/nodes /ws/v1/events/stream /ws/v1/scheduler/healthcheck /ws/v1/fullstatedump /ws/v1/stackdeployment.yaml:31 replicas: 1 是字面量,不是 .Values.replicaCount —— 副本数无法通过 values 调整。全仓库 grep leaderelect|leader election|LeaseLock 零命中 ⇒ 单副本是设计约束,不是保守默认值:手动 scale 到 2 会得到两个都在主动调度、彼此不知情的 scheduler(各自 in-memory 队列与节点视图)→ 双重分配 / 超卖scheduler 容器确实没有任何探针(deployment.yaml:82-136 只有 ports/env/resources/securityContext)⇒ 进程僵死不会被 K8s 自动重启;对比 AC 有 startupProbe(:121)+readinessProbe(:128)。v1.9.0 已彻底删除 plugin mode(Makefile:548 只剩 image: sched_image adm_image;YUNIKORN-3210 / YUNIKORN-3273)⇒ 只有 standard mode 可画cmd/shim/main.go:54 entrypoint.StartAllServicesWithLogger()(yunikorn-core 静态链接进 shim 二进制)→ entrypoint.go:82-83 RMProxy + Scheduler、:108-112 REST 硬编码 :9080。启动前先 main.go:43 LoadBootstrapConfigMaps → :48 UpdateConfigMaps。镜像 apache/yunikorn:scheduler-1.9.0web/pkg/cmd/web/main.go:38 PROXY_URL 默认 http://127.0.0.1:9080、LISTEN_ADDRESS 默认 :9889。它是 scheduler Pod 内的 sidecar 容器(deployment.yaml:112-118),不是独立 Deployment,由 enableWebService 控制。镜像 apache/yunikorn:web-1.9.0constants.go:67 ConfigMapName="yunikorn-configs"。chart README:126 原文:yunikorn-configs is entirely ignored by Helm —— 它由外部创建,运行时作为 yunikorn-defaults 的 override。shim main.go:43 LoadBootstrapConfigMaps → :48 UpdateConfigMaps 都在 :54 StartAllServicesWithLogger 之前;AC main.go:56 同理 ⇒ 读配置是最早发生的事constants.go:68 DefaultConfigMapName="yunikorn-defaults"。yunikorn-defaults.yaml:20 name、:27 "helm.sh/resource-policy": keep ⇒ helm uninstall 后该 ConfigMap 残留(未实测 uninstall 行为)admission-controller-secrets.yaml:22 name、:24 type: Opaque —— chart 只建一个空 Secret,没有 data 段。CA 由 AC 进程运行时生成并写回(webhook_manager.go:739 Secrets(namespace).Update;cmd/admissioncontroller/main.go:122 LoadCACertificates)。内含 cacert1.pem / cacert2.pem / cakey1.pem / cakey2.pem,挂到 /run/secrets/webhook⑦ 用户建 Pod → kube-apiserver 按 mutating webhook configuration 调 yunikorn-admission-controller-service:443 → 容器 9089 的 /mutate(cmd/admissioncontroller/main.go:44 mutateURL、:153 mux.HandleFunc(mutateURL, wh.ac.Serve))。⑧ AC 回 JSON Patch op=add path=/spec/schedulerName value="yunikorn"(admission_controller.go:370-377;constants.go:69 SchedulerName)⑥ InitializeState() 是 8 步不是 7 步(context.go:1357-1432):Step 1 priority classes → Step 2 register nodes(初始 disabled)→ Step 3 register pods(按创建顺序;已落在存量节点上的 pod 视为 allocations 而非 asks)→ … → Step 8 finalize pods(context.go:1423-1429 ctx.finalizePods(pods))。⇒ 故障恢复靠重建状态,不是热备🔴 K8s 机制推论,YuniKorn 源码里没有任何 kubelet 代码。shim 一次性写 v1.Binding 后即脱手,不在数据路径上(k8shim/pkg/client/kubeclient.go:117-126)默认范围 = 除 ^kube-system$ 之外的全部命名空间(am_conf.go:71-72;可用 admissionController.filtering.processNamespaces / bypassNamespaces 或 yunikorn.apache.org/namespace.enableYuniKorn 调整)
这张图的一句话:它只是 2 个 Deployment、共 2 个 Pod、3 个容器 —— 没有 DaemonSet。scheduler 是硬编码 replicas: 1 且全仓库零 leader election,所以它不能扩副本;但它挂掉只会让新 pod 堆在 Pending,已写入的绑定不受影响。
Ch.3 · 图解 — Topology36
Ch.3 · 在 AWS 上怎么用 · 图解 · Admission

schedulerName 改写路径:为什么写 default-scheduler 也没用 含唯一会真正拒绝 Pod 的那条分支

① K8s 控制面 —— rules 命中就调用② AC HTTP 入口(TLS)③ AC 内部:mutate() → processPod() 判据链(Pod CREATE)④ 降级支路 —— AC 不可达时 failurePolicy: Ignore 让 Pod 照样入库:安静地错,不是大声地停kubectl / Controller提交 Pod 或工作负载kube-apiserver匹配 7 资源 × {CREATE, UPDATE}admission-webhook.yunikorn.mutate-podsfailurePolicy: Ignore ‧ 无 selector ⇒ 全集群POST /mutate :9089只收 application/jsonServe() 三道前置校验400 / 415 / 4041234TLS 443 → 解码 AdmissionReview → mutate()5mutate() → processPod()CREATE 的 Pod 走这里checkUserInfoAnnotation()无权设 user.info → 拒绝label app=yunikorn ?出口一:自身 Pod 放行shouldProcessNamespace()出口二:唯一 namespace 级豁免updateSchedulerName()无条件写 yunikorn有权非自身TRUE6789改写是无条件的函数签名里没有 pod 参数写 default-scheduler 也白写allowed = falseAC 唯一会拒绝 Pod 的业务路径patch 为空 · 原样放行出口一 app=yunikorn ‧ 出口二 bypassing namespaceadd /spec/schedulerNameadd 覆盖已有值(RFC 6902)无权 ⇒ 拒绝app=yunikornFALSE10shouldLabelNamespace():管 /metadata/labels 与 /metadata/annotations(else 分支写 yunikorn.apache.org/ignore-application),不影响 schedulerNamekube-apiserverAC 不可达 / 超时 10s只记 warning 就入库用户侧无任何错误default-schedulerk8s 默认值,k8shim 无此常量YuniKorn / foreign pod管或不管的分岔口不接管接管11任何创建者:kubectl、Deployment/Job 控制器、Spark Operator 等webhook_manager.go:631-635 operations=[CREATE, UPDATE];apiGroups=["", "apps", "batch"];apiVersions=[v1];resources=[pods, deployments, replicasets, statefulsets, daemonsets, jobs, cronjobs]。AC 内部只有 Pod 走 UPDATE 分支AC 启动时自己把 MutatingWebhookConfiguration yunikorn-admission-controller-mutations 写进 API Server(helm 不发此对象):ignore := v1.Ignore(webhook_manager.go:615)、FailurePolicy: &ignore(:636)、sideEffects: None、admissionReviewVersions: ["v1"]。checkMutatingWebhook:523 会把人工改成 Fail 的配置改回 Ignore。grep NamespaceSelector/ObjectSelector 在 k8shim/pkg/ 零命中 ⇒ 拦截全集群yunikorn-admission-controller-service 443 → targetPort webhook-api → 容器 9089(main.go:42);mux 只注册 /health、/mutate、/validate-conf(main.go:152-154,/mutate 在 :153);TLS 最低 1.2、优先 h2admission_controller.go:637-657 ① body 空或读失败 → 400 "empty or invalid body"(:637-641)② Content-Type != application/json → 415(:645-650)③ urlPath ∉ {/mutate, /validate-conf} → 404 "request is neither mutation nor validation"(:652-657)mutate() admission_controller.go:141:空 namespace 归一为字面量 "default";UPDATE + Pod → processPodUpdate(只拒绝篡改 yunikorn.apache.org/user.info,不改 schedulerName);UPDATE + 其余 6 类资源直接放行;CREATE + 非 Pod → processWorkloadadmission_controller.go:169-175(实现 :349-368),位置在 app=yunikorn 检查之前。提交者不在 accessControl.systemUsers / externalUsers / externalGroups 允许范围内却设置了 yunikorn.apache.org/user.info → allowed=false。这是 Pod CREATE 唯一会被 AC 拒绝的业务路径(另一条是 json.Unmarshal 失败 :162-165)。反之若未设且 bypassAuth=false,AC 会替它补上 user-info patch(:177-184)utils.GetPodLabelValue(&pod, constants.LabelApp) == "yunikorn" → log "ignore yunikorn pod"、allowed=true、patch 为空(admission_controller.go:186-191)。只读 pod.Labels,不看 annotationadmission_controller.go:539 三级判据:① namespace annotation yunikorn.apache.org/namespace.enableYuniKorn 三态 —— 只有字面量 "true" 算 TRUE,"True"/"yes" 等任何其它值算 FALSE(namespace_cache.go:163-175)② admissionController.filtering.processNamespaces ③ admissionController.filtering.bypassNamespaces(默认 ^kube-system$ 来自 am_conf.go:72,不在 helm chart 里 ⇒ 必须改 configmap)updateSchedulerName(patch []common.PatchOperation) —— 签名里连 pod 都没有,物理上不可能读现有 schedulerName;恒 append {Op: add, Path: /spec/schedulerName, Value: constants.SchedulerName},constants.SchedulerName = "yunikorn"(admission_controller.go:370-377)。grep SchedulerName k8shim/pkg/admission/ 只有 :197/:370/:375 三处,零处读取 pod.Spec.SchedulerName坊间说法「Pod 里显式写 schedulerName: default-scheduler 即可绕过 YuniKorn」在 v1.9.0 是错的:updateSchedulerName 不接收 pod,恒发 add /spec/schedulerName=yunikorn,RFC 6902 的 add 会替换已存在的值CREATE 路径由 checkUserInfoAnnotation 拒绝;UPDATE 路径的对应消息是 "user info annotation change is not allowed"(processPodUpdate,admission_controller.go:317-319)两条出口都返回空 patch ⇒ Pod 不带 /spec/schedulerName,落到 k8s 默认 default-scheduler,shim 视为 foreign pod。日志分别是 "ignore yunikorn pod" 与 "bypassing namespace"json.Marshal(patch) → admissionResponseBuilder(uid, true, "", patchBytes),PatchType=JSONPatch(admission_controller.go:117-121, 217)。依据是 RFC 6902 §4.1「add 命中已存在成员时替换其值」+单测 admission_controller_test.go:514/515(no-label namespace 也照改成 yunikorn,且 labels 长度为 0),不是源码里的某一行AC Pod 挂 / Service 无 endpoint / 证书过期 / 超默认 timeoutSeconds 10s。populateMutatingWebhook 未设 timeoutSeconds、matchPolicy、reinvocationPolicy,走 k8s 默认(10s / Equivalent / Never)failurePolicy: Ignore(webhook_manager.go:615,636)⇒ API Server 忽略 webhook 失败,Pod 原样入库,提交者看不到任何报错 —— 风险是「安静地错」,不是「大声地停」Pod 没有拿到 /spec/schedulerName patch,于是取 kube-apiserver 的默认值 default-scheduler。这个值由 k8s 定义,k8shim 里没有对应常量shim 唯一接管闸门:strings.Compare(pod.Spec.SchedulerName, constants.SchedulerName) != 0 → GetApplicationIDFromPod 返回 ""(pkg/common/utils/utils.go:141-145),appID 为空后走 updateForeignPod(context.go:196-201, 325-329, 483-487)—— 不进队列、不受 quota 约束
这张图的一句话:改写是无条件的(那个函数连 pod 都不传参),所以你显式写 default-scheduler 也会被静默覆盖成 yunikorn。而 failurePolicy: Ignore 意味着 AC 挂掉时 pod 照样创建、只是悄悄退回 kube-scheduler —— 是 fail-open,不是全集群瘫痪。
Ch.3 · 图解 — Admission37
Ch.3 · 在 AWS 上怎么用 · 图解 · Identity

身份链路:IAM → K8s group → YuniKorn ACL 五环 · 断一环则组 ACL 全部匹配不上

身份链路 · 五环,断一环则组 ACL 全部匹配不上IAMIAM 身份用户 / 角色 / IRSAEKSEKS 映射aws-auth / access entryAPIAdmissionReviewuserInfo{username,groups}ACAC 注入注解user.info队列 ACL组匹配映射认证注入匹配🔴 最常断在这一环自检:组到底带进来了没有kubectl get pod <pod> -o jsonpath= '{.metadata.annotations.yunikorn\.apache\.org/user\.info}'curl -s :9080/ws/v1/partition/default/usage/groups | jq .组为空 ⇒ 没带进来 ⇒ 组 ACL 全部匹配不上🔴 但在配好这条链之前,你并没有在隔离「ACL 默认拒绝」只在「单队列孤立」看时成立。实际检查沿队列树向上求并 —— 只要沿途任一级放行就放行,而 v1.9.0 出厂默认 root submitacl: '*'。⇒ 开箱净行为是「默认放行」,不是「默认拒绝」落点:先把 IAM→K8s group 映射配对、再收紧 root.submitacl,队列上的组 ACL 才开始有意义 —— 两件事都做完之前,隔离是假的。🔷 链路本身是推论(每一环已由文档/源码确认);「开箱默认放行」是 ✅实测。IAM 用户、角色、IRSA、或 EKS Pod Identity —— 链路的起点。YuniKorn 完全不认识 IAM,它只看最后一环传进来的组名两条等价通路:aws-auth ConfigMap 的 groups,或 EKS access entry 的 kubernetesGroups。🔴 这一环是整条链最常断的地方 —— 没配组映射,后面全白搭apiserver 发给 webhook 的 AdmissionReview 里带 request.userInfoYuniKorn admission controller 把 userInfo 写进 pod 注解 yunikorn.apache.org/user.info。🔵 因 groups 非空 ⇒ 不触发 YuniKorn 自己的组解析队列的 submitacl / limits 的组匹配,用的就是上一环带进来的组两条自检:① pod 注解里的 user.info 有没有 groups ② REST 的 usage/groups 是否非空。任一为空,队列上写的组 ACL 就永远匹配不上,而且没有报错指向这件事✅实测(两轮 A/B):三个子队列写 'deny'/'Deny'/空,root 为 '*' 时三个全 Running;只把 root 换成不存在的用户、其余不动 ⇒ 三个立刻全部 ApplicationRejected。⇒ 要让队列 ACL 真生效,必须先收紧 root.submitacl
一句话:在 EKS 上 submitacl: ' dataeng' 能不能匹配上,取决于你的 IAM→K8s group 映射。🔴 而在这条链配好之前,你以为在做隔离,其实是全放行 —— 出厂默认 root submitacl '*'。
Ch.3 · 图解 — Identity38
Ch.3 · 在 AWS 上怎么用 · Version Matrix

EKS 版本 × YuniKorn 版本:有一个现存缺口 而且它会在每个 EKS 小版本上重演

EKS K8sEKS 支持状态最低 YuniKorn(官方矩阵)结论
1.36标准支持无 —— 没有任何 GA 版本声明支持 1.36🔴 缺口。只能:① 非官方地跑 1.9.0(官方说它已通过 e2e 测试,只是不在矩阵里)② 跑 1.10.0-beta
1.35标准支持1.9.0✅ 完美匹配,跑 1.9.0
1.34标准支持1.8.0✅ 推荐 1.9.0
1.33扩展支持1.8.0🟡 可跑,但没有「精确匹配」的构建
1.32扩展支持1.7.0🟡 1.7.0 精确匹配,但已落后两个小版本、不再收补丁
1.31扩展支持(2026-11 到期)1.6.0🔴 精确匹配的 1.6.3 已 EOL;且 AWS 会自动升级该集群
 YuniKorn 的支持窗口极宽:K8s 1.24 至今未终止支持。所以问题从来不是「太老不支持」,而是「太新还没声明」。
为什么会重演:EKS 大约在上游发布后 ~4 个月跟进一个新 minor; YuniKorn 大约 一年 2 个 minor(实算:近三次间隔 10.4 / 6.2 / 5.8 个月) ⇒ EKS 总会先于 YuniKorn 声明支持某个 K8s 版本。
做法:① 不要用 EKS 的最新 minor 跑 YuniKorn,等矩阵覆盖它; ② 升级顺序:先升 YuniKorn,再升 EKS(它向后兼容窗口宽,反过来会出现空档)。
本地也踩过同一个坑:我们实测时 kind v0.33.0 默认给的是 K8s v1.37.0, 超出支持上限,必须显式 pin kindest/node:v1.33.4。「自动升级把你推到未测试版本上」这个模式在托管 K8s 上同样成立。
Ch.3 · 在 AWS 上怎么用 — 版本矩阵39
Ch.3 · 在 AWS 上怎么用 · Karpenter · 机制真相

整个协同就是一个魔法字符串 我 clone 了 Karpenter 源码复核过

// kubernetes-sigs/karpenter/pkg 下 grep schedulerName
// (排除测试)⇒ 命中数 0。它结构上不认调度器。

// pkg/utils/pod/scheduling.go —— 唯一的门
func IsProvisionable(pod *corev1.Pod) bool {
  return FailedToSchedule(pod) &&
    !IsScheduled(pod) && !IsPreempting(pod) &&
    !IsOwnedByDaemonSet(pod) && !IsOwnedByNode(pod)
}

func FailedToSchedule(pod *corev1.Pod) bool {
  for _, c := range pod.Status.Conditions {
    if c.Type == corev1.PodScheduled &&
       c.Reason == corev1.PodReasonUnschedulable {
      return true   // ← 就这一个字符串
    }
  }
  return false
}

🔵 而 YuniKorn 刻意写两种 Reason

pod 为什么 pendingYuniKorn 写的 ReasonKarpenter 扩容?
队列配额超了不写任何条件🔴 shim 有 SchedulingSkipped 分支,但 v1.9.0 core 走不到❌ 不会连门都没有
集群容量真的不够Unschedulable✅ 会

源码注释原文——意图写得一字不差:
· 配额超了:// we do not trigger the auto-scaling
· 容量不够:// set pod condition to Unschedulable in order to trigger auto-scaling

⇒ 结论要说准:这不是「两个系统互不知情、碰巧能用」, 而是一个未成文但设计正确的隐式契约。「队列限额」与「节点弹性」两套限流器被正确衔接了—— 不会为一个队列本来就不让跑的作业去买节点。
但它仍然脆弱:无 API 定义、双方文档都没写、无跨项目集成测试。 Volcano 就曾把这个 Reason 字符串写错,导致 Karpenter 完全不为它扩容,直到 volcano-sh/volcano#2602 修好。这是发生过的真事。
Ch.3 · 在 AWS 上怎么用 — Karpenter 机制真相40
Ch.3 · 在 AWS 上怎么用 · 图解 · Karpenter

两条路径对照:什么时候扩容,什么时候一台都不加 全场最重要的技术洞察 · 双方源码均已复核

① 集群真的缺资源 ⇒ 写上唯一契约 PodScheduled=False + Reason=Unschedulable ⇒ Karpenter 扩容② 队列/用户配额用满 ⇒ 连 pod 条件都不写 ⇒ Karpenter 的门不匹配 ⇒ 一台机器都不加yunikorn-scheduler 单进程Gang Job Pod带 yunikorn.apache.org/task-groups 注解yunikorn-k8shim为 MinMember 补齐 placeholderyunikorn-core SchedulertryAllocate → 配额闸 → outstanding1提交 ask2进程内回调 FAILED3kube-apiserver唯一的信息交汇点provisioner.trigger.podIsProvisionable → Triggerprovisioner(singleton)1s/10s 批窗 → ScheduleNodeClaim CRkarpenter core 到此为止provider-aws → EC2实例 running ⇒ 开始计费shim registerNodesCREATE_DRAIN → 启用绑定始终由 YuniKorn 做AssumePod;Karpenter 不 bindpause 占住整机等 gang默认 15min 超时才回收45678计费从这里开始91011新节点带 karpenter.sh/unregistered:NoExecute(由 provider 摘除)—— 它只挡 pod 放置(TaintToleration),不挡 shim 注册节点user quota 不足SetSchedulingAttempted 不执行queue headroom 不足FitInMaxUndef = false不进 outstanding 列表getOutstandingRequests 丢弃pod 上无 PodScheduled连 Unschedulable 都没有一台机器都不加FailedToSchedule = false3a3b常见误说「配额超限写 SchedulingSkipped」:shim 确有该分支(context.go:1213),但 v1.9.0 core 全树 SKIPPED 零命中 —— 真实机制是根本不写任何 pod 条件两边没有一行互相认识的代码Karpenter 全仓 schedulerName 命中 0YuniKorn 全仓 karpenter 只在 helmREADME 出现 1 次唯一契约 = pod 的一个 condition✅ EKS 实测(B5 · Karpenter 1.14.1 · 16×m6i.2xlarge · NodePool 无 taint · scripts/21-bench-b5-karpenter.sh)路径 A · 真缺资源(配额充足)conditions=[{reason:"Unschedulable"}] → +1.3s 感知 → +3.8s EC2 已启动NodeClaim 2 · Karpenter 节点 2 · pod 3 Running路径 B · 队列配额受限(root.tiny max=1 vcore)conditions= ← 空。不是 SchedulingSkipped,是什么都没有NodeClaim 0 · Karpenter 节点 0 · pod 3 永久 Pending🔴 shim 的 SKIPPED 分支注释原文 “we do not trigger the auto-scaling”(配额超限时)⇒ 不扩容是**刻意设计**;但 core 从不发 SKIPPED ⇒ 实际是「什么都不写」,而非「写 SchedulingSkipped」。净效果一致,可观测性完全不同。core→shim 是同进程 Go 回调 ResourceManagerCallback.UpdateContainerSchedulingState(scheduler.go:262)—— si.proto 的 4 个 RPC 不含它;绑定始终由 YuniKorn 做,Karpenter 只发 NominatePodEvent。版本:YuniKorn v1.9.0(core 257fdef7 / k8shim 1a59488)× Karpenter 1.14.1(bde0065);EKS 1.33 / us-east-1(账号已隐去)。TryReserve k8shim/pkg/cache/application.go:497 → onReserving :516 → createAppPlaceholders :530;shim 只为每个 task group 的 MinMember 补齐缺的那些 placeholderplaceholder 是真 pod:SchedulerName="yunikorn"(k8shim constants.go:69)、image registry.k8s.io/pause:3.7(constants.go:76)、restartPolicy Never、Requests==Limits==taskGroup.MinResource(placeholder.go:133-135);创建动作在 placeholder_manager.go:90 KubeClient.CreatetryAllocate 先查 userHeadroom(core/pkg/scheduler/objects/application.go:1060-1066);internalInspectOutstandingRequests 独立 goroutine 每秒一轮(scheduler.go:83,112);getOutstandingRequests 入选需 headRoom.FitInMaxUndef && userHeadRoom.FitInMaxUndef && !HasTriggeredScaleUp && requiredNode==common.Empty && !canReplace(application.go:1002)si.proto service Scheduler 的 UpdateAllocation:shim 把 app + placeholder ask 注册进 core,core 才可能 tryAllocateResourceManagerCallback.UpdateContainerSchedulingState(State=si.UpdateContainerSchedulingStateRequest_FAILED, Reason="request is waiting for cluster resources become available"):core/pkg/scheduler/scheduler.go:262,进程内实现 k8shim/pkg/cache/scheduler_callback.go:218-220。si.proto 的 4 个 RPC(RegisterResourceManager / UpdateAllocation / UpdateApplication / UpdateNode)不含它HandleContainerStateUpdate 的 FAILED 分支写 v1.PodCondition{Type: PodScheduled, Status: ConditionFalse, Reason: v1.PodReasonUnschedulable} 并发 Event PodUnschedulable(k8shim/pkg/cache/context.go:1227)。Karpenter 全仓 schedulerName 命中 0,YuniKorn 全仓 karpenter 只在 helm README 出现 1 次 —— 两边没有一行互相认识的代码FailedToSchedule 只认 condition.Type==PodScheduled && condition.Reason==PodReasonUnschedulable(karpenter pkg/utils/pod/scheduling.go:122-124);IsProvisionable 在 scheduling.go:100-106 再叠 !IsScheduled / !IsPreempting / !IsOwnedByDaemonSet / !IsOwnedByNode。PodController 只做 provisioner.Trigger(p.UID)(controller.go:70)+ AckPods + RequeueAfter 10s(:77)—— 它不建任何机器。另一入口 GetProvisionablePods(pkg/utils/node/node.go:167)用于批量拉取第三个 singleton controller,Name()="provisioner"(provisioner.go:111-113):Reconcile(:122) → batcher.Wait(:126)(batch-idle-duration 默认 1s / batch-max-duration 默认 10s,pkg/operator/options/options.go:128,129)→ Schedule(:309) → Create(:413)Provisioner.Create 先查 NodePool Limits.ExceededBy,再 p.kubeClient.Create(ctx, nodeClaim)(provisioner.go:425);metric 名 karpenter_nodeclaims_created_total(labels: reason / nodepool / min_values_relaxed)。kubernetes-sigs/karpenter v1.9.1 全仓无 EC2 代码NodeClaim→EC2 由 karpenter-provider-aws 完成(该仓未 pin、未逐行核)。计费从实例 running 起算 —— 早于 placeholder 落地,浪费窗口比「placeholder 上机才计费」更长新 Node 一出现 shim 就 SchedulerAPI.UpdateNode 报给 core:registerNodes Action=si.NodeInfo_CREATE_DRAIN(k8shim/pkg/cache/context.go:1503,1513)→ enableNodes DRAIN_TO_SCHEDULABLE(:1617)。唯一的门是 context.go:205 if !node.Spec.Unschedulable(cordon,不是 taint)k8shim AssumePod(context.go:807)+ bindPodVolumes(context.go:726)。Karpenter 只发 NominatePodEvent(provisioner.go:462),从不 bind podpause 容器不干活,却按 taskGroup.MinResource 占住 Requests==Limits(k8shim/pkg/cache/placeholder.go:133-135)。超时参数字面值 placeholderTimeoutInSeconds(k8shim constants.go:89,注意 In),core 默认 defaultPlaceholderTimeout = 15 * time.Minute(core/pkg/scheduler/objects/application.go:55);gang 凑不齐时按 gangSchedulingStyle 处理tryAllocate 查 userHeadroom 不通过就 LogAllocationFailure(NotEnoughUserQuota) 并 continue,SetSchedulingAttempted(true) 根本不会执行(core/pkg/scheduler/objects/application.go:1060-1066);常量字面值 "Not enough user quota"getOutstandingRequests 要求 headRoom.FitInMaxUndef && userHeadRoom.FitInMaxUndef(application.go:1002);常量字面值 "Not enough queue quota"if request.IsAllocated() || !request.IsSchedulingAttempted() { continue }(application.go:997)。既然不进列表,就没有任何 UpdateContainerSchedulingState 回调不是写了 SchedulingSkipped,而是 pod 上根本不出现 PodScheduled 这个 condition —— Karpenter 的判据无从命中Karpenter 与 YuniKorn 之间唯一的契约就是那一个 pod 条件:Karpenter 全仓 schedulerName 命中 0,YuniKorn 全仓 karpenter 只在 helm README 出现 1 次Karpenter 与 YuniKorn 之间没有任何互相认识的代码:Karpenter 全仓 schedulerName 命中 0,YuniKorn 全仓 karpenter 只在 helm README 出现 1 次。唯一的契约就是 pod 上的 PodScheduled=False + Reason=Unschedulable 这一个条件t=02:44:12 YuniKorn 写下 PodScheduled=False / reason=Unschedulable、message="request is waiting for cluster resources become available";t=02:44:13.293 Karpenter found provisionable pod(s);t=02:44:15.783 launched nodeclaim m6i.xlarge us-east-1c。⇒ 协同是真的,而且只用 3.8 秒配额受限的 ask 进不到 inspectOutstandingRequests(那里的注释写明"they can fit into the max head room"),所以回调根本不被调用 ⇒ 不写任何条件。shim 里确实有一个 SKIPPED 分支会写 SchedulingSkipped,但 core 全仓只发 FAILED ⇒ 那个分支在 v1.9.0 是死代码
Ch.3 · 图解 — Karpenter41
Ch.3 · 在 AWS 上怎么用 · 图解 · Spark

Spark 作业全路径:YuniKorn 只介入两个点 driver → executor · gang 如何覆盖两侧

spark-submitDriver 内 ExecutorPodsAllocatorkube-apiserver集群 API 与对象存储admission-controlleryunikorn-admission-controlleryunikorn-scheduler (k8shim)+ PlaceholderManager(同进程)yunikorn-core队列排序 / gang 换位创建 driver podSpark Driver Pod | 外部:Spark 上游1patch /spec/schedulerName无条件;标签改写仅当 ns 被 label2Pod ADDED → AddPod / UpdatePod门禁:schedulerName ≠ yunikorn ⇒ GetApplicationIDFromPod 返回空3取 appID/queue → 建 App + Task解析 yunikorn.apache.org/task-groups4UpdateApplicationplaceholderAsk | executionTimeoutMilliSeconds5ApplicationResponse.Accepted6PlaceholderManager 建 pause 占位 Podtg-<appID>-<taskGroupName>-<nonce> × minMember | registry.k8s.io/pause:3.77占位 Pod 回到 informer 再走一遍 3-6UpdateAllocation(placeholder=true) → AssumePod + Bind → postTaskBound8占位齐 → RunApplicationReserving 期间只放 placeholder,driver 也在等9swap → ReplacedTerminationType_PLACEHOLDER_REPLACED10AssumePod(30 步 backoff)→ Bind 真实 PodScheduled / PodBindSuccessful;失败留 AssumePodError11ExecutorPodsAllocator 建 executor podExecutor Pod | 带 task-group-name,回到 3 重走12YuniKorn 只认 PodSpark Driver Pod | Placeholder Pod (tg-*)Executor Pod —— 全靠 Pod informer 认识①②① schedulerName 在这一步生效spark.kubernetes.scheduler.name=yunikorn(driver/executor 专用项可覆盖),或由 AC 无条件 patch不是 yunikorn ⇒ 该 Pod 被当外人,YuniKorn 全程不介入② gang 注解在这一步生效driver pod 上的 yunikorn.apache.org/task-groups(annotation only)只在建 Application 那一刻读一次executor 靠 yunikorn.apache.org/task-group-name 认领占位gang 同时覆盖 driver 与 executordriver 与所有 executor 共享 spark-app-selector⇒ 同一个 Application;Reserving 期间只放 placeholder,driver 也在等;真实 Pod 只能换同名 taskGroup 且 ≤ 占位超时(placeholderTimeoutInSeconds / gangSchedulingStyle):Case 1 已 Running/Completing ⇒ 只用 TerminationType_TIMEOUT 清剩余占位,不看 style;Case 2 ⇒ Hard=失败 / Soft=Resuming外部:Spark 上游(apache/spark v4.0.0),非 YuniKorn 代码。cluster 模式下 spark-submit 直接建 driver pod;走 spark-operator 的 SparkApplication CR 最终也是一份 driver pod —— k8shim 只注册 ConfigMap/PriorityClass/Node/Pod 四个 informer,没有任何 CRD informer。Spark Driver Pod / Placeholder Pod (tg-*) / Executor Pod 都是这里的对象;YuniKorn 只通过 Pod informer 认识它们。可选组件。admission_controller.go:197 无条件 patch /spec/schedulerName;:199 shouldLabelNamespace 才 updateLabels + updatePreemptionInfo,:202 else 走 disableYuniKorn(只加 yunikorn.apache.org/ignore-application 注解,不撤 schedulerName)。注:该注解在 v1.9.0 从未被 shim 读取。对 Pod 的门禁只有 app != yunikorn(:186-191) + shouldProcessNamespace(:193-196)。k8shim/pkg/cache/context.go:295 AddPod → :325 GetApplicationIDFromPod → :368 ensureAppAndTaskCreated → metadata.go:62 getAppMetadata。PlaceholderManager 在同一进程内:pkg/cache/placeholder_manager.go:90。v1.9.0 里 k8shim 与 core 同进程:pkg/cmd/shim/main.go:57 传 serviceContext.RMProxy,走 SI 的 Go 接口调用,不是跨网络 gRPC —— core/pkg/common/server.go 有完整 gRPC server 但生产代码从不调用。--deploy-mode cluster(spark_jobs.sh:40 只能证明 e2e 用 cluster 模式;「spark-submit 直接调 K8s API」的实现在 Spark 上游,不是 YuniKorn 侧证据)updateSchedulerName 打 JSONPatch add /spec/schedulerName = "yunikorn"(admission_controller.go:370,调用点 :197)。装了 AC 就不必自己设 schedulerName。utils.go:143 第一件事就是比 schedulerName;不等于 yunikorn 直接返回空字符串,该 Pod 被当外人,YuniKorn 全程不介入。appID 取值顺序(utils.go:147-171):1 label yunikorn.apache.org/app-id → 2 annotation 同名 → 3 label applicationId → 4 label spark-app-selector。Spark 给 driver 与所有 executor 打同一个 spark-app-selector ⇒ 归入同一个 YuniKorn Application —— 这与 admission controller 无关。task-groups / schedulingPolicyParameters 在 metadata.go:111 解析,只在 driver 建 Application 那一刻读一次。application.go:430 handleSubmitApplicationEvent 发 si.ApplicationRequest{New: []*si.AddApplicationRequest{...}};gang 三个字段在此过界:PlaceholderAsk(:442)、ExecutionTimeoutMilliSeconds、GangSchedulingStyle。scheduler_callback.go:120-135:for _, app := range response.Accepted { dispatcher.Dispatch(NewSimpleApplicationEvent(appID, AcceptApplication)) } —— shim 的 Accepted 状态是 core 回传的,不是本地凭空转的。Accepted → postAppAccepted(application.go:482) → 有 taskGroups 且未 skipReservationStage 则 TryReserve(:497) → Reserving 触发 onReserving → placeholder_manager.go:90 createAppPlaceholders。占位 Pod restartPolicy: Never。占位 Pod 自带 SchedulerName: constants.SchedulerName(placeholder.go:148),过得了步骤 3 的门禁;task.updateAllocation(task.go:311-334) 带 placeholder=true,bind 成功后 postTaskBound(task.go:411-419) 才 Dispatch NewUpdateApplicationReservationEvent —— 步骤 9 的「占位齐」由此而来。Reserving 期间 Application.Schedule() 只放 t.placeholder==true 的 task(application.go:367-372 return t.placeholder),连 driver pod 自己都排在 pause 占位后面等。application.go:583 是 gang 的真正闸门。core/pkg/scheduler/objects/application.go:1301 tryPlaceholderAllocate:真实 Pod 只能换掉同名 taskGroup、且资源不大于自己的占位;context.go:146 判 result.ResultType == objects.Replaced → :148 notify RM。SI 枚举值 4(si.pb.go:48)。scheduler_callback.go:68-78 AssumePod(Steps:30 / Duration:1s / Cap:30s,失败发 AssumePodError:80)→ :88 NewAllocateTaskEvent → postTaskAllocated(task.go:348) → Event(Scheduled)(:356) → bindPodVolumes(:364) → KubeClient.Bind(:373) → Event(PodBindSuccessful)(:380)。这 5 个才是合法 K8s Event reason;gang 那 7 个(TaskGroupMatch 等)reason 一律是 GangScheduling,它们只是 action 字段。外部:Spark 上游 ExecutorPodsAllocator 按 spark.executor.instances 分批建 pod(本地唯一相关依据 spark_jobs.sh:42 --conf spark.executor.instances=$EXEC_COUNT)。executor pod 也继承 schedulerName,并靠 annotation yunikorn.apache.org/task-group-name 认领对应占位。k8shim 只注册 ConfigMap / PriorityClass / Node / Pod 四个 informer(context.go:113-155),没有任何 CRD informer —— 所以 spark-operator 的 SparkApplication CR 与 spark-submit 的介入点完全一致,都从 driver pod 起。core/pkg/scheduler/objects/application.go:407-445 是 if/else 两侧,不是先后顺序::437 Case 1(app 已 Running/Completing 且有已分配占位)只用 TerminationType_TIMEOUT 清剩余占位,完全不看 Hard/Soft;:442 else 才判 style —— Hard ⇒ FailApplication,否则 HandleApplicationEventWithInfo(ResumeApplication, "ResourceReservationTimeout"),shim 的 Resuming 经 ApplicationResponse.Updated 回传,且仅当 shim 当前是 Reserving 才转(scheduler_callback.go:153-160)。
一句话:YuniKorn 只认 Pod —— 只介入两点:schedulerName,与 driver 上的 task-groups 注解。
Ch.3 · 图解 — Spark42
Ch.3 · 在 AWS 上怎么用 · Karpenter · Consolidation

Karpenter 的默认配置会驱逐运行中 gang 的成员 五种保护机制,按强度排序

为什么会发生

# Karpenter 的默认值(kubebuilder 默认)
spec:
  disruption:
    consolidationPolicy: WhenEmptyOrUnderutilized
    consolidateAfter: 0s   # 零宽限期

官方对该策略的定义:"Any node that can be removed or replaced to reduce cost / … willing to accept the pod disruption."
失败模式:Karpenter 驱逐一个 executor → gang 已经 Running、placeholder 已消失 → YuniKorn 把它当普通 ask 重新调度 → 不会重新走 all-or-nothing → 若无 headroom,作业永远卡在 N−1。

选谁下手:官方文档说优先终止 「pod 少的节点」「即将过期的节点」「低优先级 pod 的节点」—— 而「低优先级」看的是 K8s PriorityClass,不是 YuniKorn 队列优先级。 ⚠️ 且「pod 少的节点优先」对一节点一 executor 的 GPU gang 来说,意味着 gang 里每个节点都是首选目标。
#机制强度 / 代价
1NodePool spec.replicas(静态 NodePool)最强:设了它 consolidation 相关字段被忽略。🔴 需 feature gate StaticCapacity=true(Alpha,默认关)
2consolidateAfter: Never强且 GA,一行搞定。但不阻止 Drift 与 Expiration ⇒ 要配 expireAfter: Never
3karpenter.sh/do-not-disrupt中。官方原话「可当成单 pod 的 PDB」。🔴 必须也打在 placeholder 上
4PodDisruptionBudget🔴 对 Karpenter 有效,对 YuniKorn 抢占无效(见下)
5独立 NodePool + taints隔离爆炸半径,代价是容量碎片
🔵 独家:怎么给 placeholder 打注解。 真实 pod 上的注解不会传给 placeholder。必须写进 task group 的 annotations 字段——而这个字段官方文档从未提及(源码里 TaskGroup 有 9 个字段,文档只展示 7 个):
{"name":"exec","minMember":4,"annotations":{"karpenter.sh/do-not-disrupt":"true"}}
Ch.3 · 在 AWS 上怎么用 — consolidation 与保护43
Ch.3 · 在 AWS 上怎么用 · Two Surprises

两个反直觉:PDB 保护不了你,而 CA 在这件事上比 Karpenter 好 都有源码依据

🔴 反直觉一 · PDB 被 YuniKorn 抢占静默绕过

谁在回收 pod走什么 APIPDB 生效?
Karpenter consolidationEviction API(pods/eviction)✅ 生效
YuniKorn 抢占Pods().Delete() —— 裸 DELETE❌ 不生效
// k8shim/pkg/client/kubeclient.go —— 全文件搜 Evict:0 命中
nc.clientSet.CoreV1().Pods(pod.Namespace).
    Delete(context.Background(), pod.Name, apis.DeleteOptions{})

PDB 只由 eviction 子资源的准入检查执行;直接 DELETE 不受 PDB 约束。
⇒ 同一个集群里,两种「回收 pod」的机制对 PDB 的态度完全不同。
⇒ 保护负载不被抢占,唯一有效手段是队列的 preemption.policy: disabled 或 PriorityClass 上的 allow-preemption: "false"。

🔵 反直觉二 · Cluster Autoscaler 在这件事上更好

能力KarpenterCluster Autoscaler
认自定义调度器隐式(靠魔法字符串)✅ 显式开关
--bypassed-scheduler-names=yunikorn
用什么做装箱模拟自己重写的语义✅ 真正的 kube-scheduler framework
(--scheduler-config-file 可配插件)
可观测性—✅ scheduler_unprocessed 标签可证明生效
 推荐配置:--bypassed-scheduler-names=yunikorn --allowed-scheduler-names=default-scheduler,yunikorn
要说准:Karpenter 在速度、实例选型、consolidation 上更强。 但在「认自定义调度器」这一项上,Karpenter 是隐式契约,CA 是显式开关。 ⇒ 选型时应把这一点摆出来,而不是默认「Karpenter 一定更好」。
共同边界:两者都不理解 gang。 可能出现「开了 2 台节点里 1 台成功、另一台容量不足失败」⇒ gang 仍凑不齐,而你已付了 1 台的钱。 这是 gang 在云上的结构性缺口,两家都没解决。
Ch.3 · 在 AWS 上怎么用 — 两个反直觉44
Ch.3 · 在 AWS 上怎么用 · Documentation Defects

两处需要自己核实的地方 都在 AWS 官方材料里 · 都有完整证据链

① EMR on EKS 教程的参数名 (两处都是)

# AWS 官方教程原文(tutorial-yunikorn.html)
yunikorn.apache.org/schedulingPolicyParameters:
  "placeholderTimeoutSeconds=30 gangSchedulingStyle=Hard"
#  ↑ 漏了 In

// k8shim 唯一接受的键(constants.go:83)
const SchedulingPolicyTimeoutParam =
      "placeholderTimeoutInSeconds"
// 全仓搜无 In 的拼写:零命中
你以为实际倍数
超时 30 秒超时 15 分钟30×

为什么静默:解析函数的 switch 只有两个 case、没有 default 分支。 键写错是合法的 k=v,不触发 malformed 告警,但匹配不上任何 case ⇒ timeout 保持初值 0 ⇒ core 套用默认 15 分钟。零日志、零告警、零事件。 叠加同文档里的 Hard:凑不齐的 gang 会占着 placeholder 15 分钟, 而 placeholder 在 Karpenter 下已经把节点开出来并计费了。

② data-on-eks 的 volumeBindTimeout

# awslabs/data-on-eks · helm-values/yunikorn.yaml(main 分支原文)
yunikornDefaults:
  # The default volume bind timeout value of
  # 10 SECONDS may be too short for EBS
  service.volumeBindTimeout: "60s"
项值
注释声称的默认值10 秒
✅ 源码 + 官方文档的实际默认值10 分钟(Default: 10m,官方示例调整方向是调大到 15m)
注释的意图「对 EBS 太短」⇒ 想调大
实际效果10 分钟 → 60 秒,调小了 10 倍

⇒ 做的事与注释的意图正好相反。EKS 上 EBS attach 本就可能慢;把 bind 超时压到 60 秒更容易中止分配, 而对 gang 来说一次 bind 中止意味着整个 gang 重试。
同一份参考架构另外三点:chart 钉在 1.7.0(落后两个小版本);namespace 用 yunikorn-system 而 AWS 自己的 EMR 教程用 yunikorn(两份官方材料不一致); 用 ArgoCD 且 selfHeal: true ⇒ 手改 ConfigMap 会被回滚。

态度:目的不是挑 AWS 的错,而是说明照抄任何参考架构都需要自己核实关键参数。两处都有完整证据链,也都该作为 issue 反馈。 诚实标注:性能后果未在 AWS 实测(无凭证),标为推论;「值缩小 10 倍」与「参数名不被接受」是确定的。
Ch.3 · 在 AWS 上怎么用 — 两处文档缺陷45
Ch.3 · 在 AWS 上怎么用 · Ecosystem

它到底支持哪些大数据组件 官方覆盖 5 类,其余靠通用机制

三档判据(先看这个)

  • ✅ 原生支持 —— 对方有为 YuniKorn 写的代码或官方文档页
  • 🟡 通用机制可用 —— 对方完全不知道 YuniKorn 存在,但它的 CR 暴露了完整 PodSpec,你能塞 schedulerName + label
  • ❌ 不可用 —— 对方 CRD 是手写字段白名单,没有 schedulerName、没有 podTemplate ⇒ 只能靠 admission controller 按 namespace 强行接管
🔵 理解的钥匙:YuniKorn 的设计取向是不引入新 CRD ⇒ 它不需要对方为它写代码,只需要对方肯让你设 schedulerName。 ⇒ 所以支持面的边界不在 YuniKorn 这边,在对方的 CRD 有没有留口子。
对比 Volcano:它有自己的 PodGroup CRD,所以对方必须为它写代码(如 Spark 的 VolcanoFeatureStep)。 门槛更高,但一旦集成就是一等公民。
组件判定关键事实
 官方文档覆盖的全部 5 类(/docs/user_guide/workloads/ 只有 9 页)
Apache Spark✅spark.kubernetes.scheduler.name(Spark 3.3.0 起);有官方专节,但最新 GA(4.2.0)钉的是 1.8.0,1.9.0 只在 master;🔴 只有文档与集成测试,src/main/ 下零生产代码
Kubeflow Spark Operator✅一等公民,有官方 YuniKorn 集成文档页
Ray / KubeRay✅🔵 整个生态里唯一会自动生成 YuniKorn task-groups 的 operator
Apache Flink✅有官方页,经 podTemplate 打注解(⚠️ 该页已陈旧)
TF / MPI(Kubeflow)✅ 页面⚠️ 官方那两页只演示队列路由,零 gang scheduling
 其余全部靠通用机制或不可用
Argo Workflows / Airflow / Tekton / Dagster🟡都有 schedulerName 旋钮。🔴 共同大坑:YuniKorn 的 ACL 看到的是「编排器的 SA」,不是 DAG 所有者 ⇒ 队列 ACL 无法按最终用户区分
Trino / Presto / StarRocks / Doris / ClickHouse / Druid / Pinot🟡/❌🔴 零个查询引擎有 YuniKorn 集成。但它们是长运行服务——队列配额与抢占保护适用,gang 与公平共享不适用
Kubeflow Trainer / LeaderWorkerSet❌🔴 gang API 是 coscheduling|volcano 的封闭联合,没有 YuniKorn。LWS 的 KEP 点了 YuniKorn 的名而代码只支持 Volcano。NVIDIA NeMo 让你用 KAI Scheduler
Ch.3 · 在 AWS 上怎么用 — 生态集成矩阵46
Ch.3 · 生态支持矩阵 · Criteria & Coverage

三档判据,与 34 个组件的分布 先给判据,再给结论;判据比结论更耐用

✅ 原生
7
对方有为 YuniKorn 写的代码,或有官方文档页专讲 YuniKorn
🟡 通用
20
对方不知道 YuniKorn 存在,但暴露了 schedulerName
❌ 不可用
6
CRD 是手写字段白名单 ⇒ 只剩 AC 按 namespace 接管
— 不适用
1
不产生 Pod、也不需要集成点(Iceberg / Hudi / Delta)

「通用」不是降级说法 它有三条确切的通路

  • ① 在 CR 里直接设 —— schedulerName: yunikorn 写进对方暴露的 PodTemplateSpec
  • ② 让 admission controller 按 namespace 接管 —— yunikorn.apache.org/namespace.enableYuniKorn: "true",对 ❌ 档是唯一路
  • ③ 队列与身份靠 label —— yunikorn.apache.org/app-id、…/queue
反面的硬门槛:utils.go:140-143 先比对 SchedulerName != "yunikorn",不匹配直接返回空 appID ⇒ 没设或写错,所有 label 全白打且不报错。
🔵 钥匙:YuniKorn 不引入新 CRD ⇒ 不需要对方写代码,只要对方肯让你设 schedulerName ⇒ 边界不在 YuniKorn 这边,在对方 CRD 有没有留口子。

对照 Volcano:两种取向,两种代价

维度YuniKornVolcano
要不要对方写代码不要(只认 pod annotation)要(须建 PodGroup CR)
一旦集成的待遇永远是「通用旋钮」一等公民

实测同一份 Spark 主干:Volcano 有 98 行生产代码 VolcanoFeatureStep.scala,YuniKorn 侧为 0。

本页要带走的:判定档位说的是「集成深度」,不是「能不能用」——真正决定你拿到哪些能力的是负载形态与对方 CRD 的口子。
Ch.3 · 生态支持矩阵 — 总览与判据47
Ch.3 · 生态支持矩阵 · Batch Engines

计算引擎与作业框架(一)批处理引擎 · Spark 系与 Flink 系 · 4 个

组件判定gang怎么调用(字段路径)关键事实 / 坑
 YuniKorn 的主场,也是全表唯一有官方 gang 配方的一类—— 但「原生」在这四行里的含金量差别极大
Apache Spark
(原生提交)
✅ 原生部分 spark.kubernetes.scheduler.name Spark 3.3.0 起。src/main/** 零命中 ⇒ ✅ 只来自文档专节 + 集成测试
Kubeflow Spark Operator✅ 原生是 spec.batchScheduler · spec.batchSchedulerOptions.queue v2.0.0 引入,gang 全自动。🔴 minResource 零 GPU,手写 task-groups 被覆盖
Apache Flink
(原生模式)
✅ 原生部分 kubernetes.pod-template-file.jobmanager Flink ≥ 1.13。🔴 官方 gang 配方照抄必失败(4096M vs Mi)。🔴 Flink 仓库 0 处 yunikorn ⇒ native 只是(YuniKorn 自己的)文档页,且该页两条外链实测 404
Flink Kubernetes Operator🟡 通用部分 spec.podTemplate.spec.schedulerName 自 1.0.0 即含 3 处 podTemplate。🔴 JM 被替换 ⇒ placeholder 被 GC 且无重建路径
🔴 Spark Operator 的 GPU gang 是个坑,不是小瑕疵:它算出的 minResource 只含 cpu + memory,GPU 零命中 ⇒ placeholder 不申请 GPU、能占住没有 GPU 的节点; 而你手写的 task-groups 会被 operator 无条件覆盖,想补也补不进去。 ⇒ GPU gang 场景建议不要用它的自动模式。
🔵 「原生」要分含金量:Spark 与 Flink 的 ✅ 都只来自 YuniKorn 一侧的文档页—— Flink 那页两条外链实测 404、Flink 全仓 0 命中,对抗复核认为按严格判据实为通用; Flink Operator 判 🟡 的证据同样干脆:Apache JIRA 搜 yunikorn 命中 0,搜 volcano 95。
Ch.3 · 生态支持矩阵 — 批处理引擎48
Ch.3 · 生态支持矩阵 · Distributed Training

计算引擎与作业框架(二)分布式训练与并行计算 · 4 个

组件判定gang怎么调用(字段路径)关键事实 / 坑
 「AI 训练」生态里 YuniKorn 不是一等公民—— 这一页正面回答,并给出唯一的例外
Ray / KubeRay✅ 原生是 batchScheduler.name=yunikorn · ray.io/gang-scheduling-enabled 🔵 全生态唯一自动生成 task-groups 的 operator(268 行生产代码)
MPI Operator✅ 原生部分 spec.mpiReplicaSpecs.<Role>.template.spec.schedulerName 对方仓库 0 处 yunikorn(volcano 177 处)⇒ native 只是文档页
Kubeflow Trainer
(TFJob / PyTorchJob / TrainJob)
🟡 通用部分 spec.<x>ReplicaSpecs.<Role>.template.spec.schedulerName 🔴 PodGroupPolicySource 是封闭联合,写 yunikorn 被 apiserver 静默 prune
Dask(dask-kubernetes)🟡 通用部分 spec.worker.spec.schedulerName · spec.scheduler.spec.schedulerName 2022.9.0 起;task-groups 放 CR 级 annotation 会自动透传到全部 pod
🔴 KubeRay 那个必须先拆掉的坑:worker 的 minReplicas CRD 默认是 0 ⇒ 产出 minMember: 0,被 k8shim 拒掉整份注解 —— 连 head 的 gang 一起丢,只留一条 Warning Event,pod 照样起来、看着像生效了。
另外三条一句话红线:MPI Operator 绝不要传 --gang-scheduling=yunikorn(catch-all, 缺 PodGroup CRD 时 operator 直接起不来);Trainer 的 gang 只能自己手写 pod annotation(队列路由自 v2.0.0、 per-job task-group 注入自 v2.1.0);Dask 的 KubeCluster(image=…, n_workers=…) 没有 scheduler_name 参数 ⇒ 静默回落默认调度器。
Ch.3 · 生态支持矩阵 — 分布式训练与并行计算49
Ch.3 · 生态支持矩阵 · Interactive & Serving

计算引擎与作业框架(三)交互式网关 · 在线推理与多节点服务 · 6 个

组件判定gang怎么调用(字段路径)关键事实 / 坑
 交互式与网关—— 共同特征:提交者不是最终用户,且会话超时会与排队打架
Apache Kyuubi / Livy🟡 通用部分 spark.kubernetes.scheduler.name=yunikorn Kyuubi 任意版本;Livy 需 0.9.0-incubating。🔴 引擎初始化超时默认 180s
JupyterHub (z2jh)
Kubeflow Notebooks
🟡 通用部分 singleuser.extraPodConfig.schedulerName chart 0.9.0 起。🔴 YuniKorn 无任何闲置回收 ⇒ 闲置 notebook 永久占配额
 在线推理与多节点服务—— gang 的卖点只在多节点大模型;单副本推理服务不要开 gang
vLLM on Ray Serve
(RayService)
✅ 原生部分 metadata.labels 三行(gang / app-id / queue) 继承 KubeRay 生产代码。🔴 蓝绿升级两个 RayCluster 同 app-id ⇒ 静默丢弃
KServe / Seldon Core🟡 通用部分 spec.predictor.schedulerName(多节点另设 …workerSpec) 🔴 v0.20.0 默认 Knative 模式硬拒该字段,须加 deploymentMode: Standard
LeaderWorkerSet (LWS)🟡 通用部分 spec.leaderWorkerTemplate.{leader,worker}Template.spec.schedulerName 代码里只认 volcano。🔴 设 schedulerProvider: yunikorn 是硬失败
NVIDIA NeMo / KAI Scheduler🟡 通用部分 jobs.executors[].config.scheduler_name 🔴 多节点分布式 GPU 只走 volcano_job;KAI 是互斥竞品
本页要带走的:共同失效模式不是「设不上」,而是「设上了但被别人接手」—— Knative 的 podspec 白名单、LLMInferenceService 的 label 前缀白名单、LWS 的 provider 白名单、NeMo 的 volcano_job 硬路径, 四种白名单、四种静默方式;上线前必须逐 pod 核验 {.spec.schedulerName}。
Ch.3 · 生态支持矩阵 — 交互式网关与在线推理50
Ch.3 · 生态支持矩阵 · Orchestrators

编排器与流水线 5 个全是 🟡 通用,且共享同一个结构性大坑

组件判定gang怎么调用(字段路径)关键事实 / 坑
 判定一致(🟡 通用 / gang 部分)· 差别全在「哪个字段名会静默失效」
Apache Airflow🟡 通用部分 KubernetesPodOperator(schedulername=…) 参数名全小写、无下划线;写成 scheduler_name 不报错、pod 静默回落
Argo Workflows🟡 通用部分 spec.schedulerName · spec.templates[].schedulerName spec.parallelism < minMember ⇒ 死锁到 placeholder 超时
Tekton Pipelines🟡 通用部分 spec.taskRunTemplate.podTemplate.schedulerName v0.11.0 起。🔴 Affinity Assistant 的 template 没有 SchedulerName(见右下)
Dagster🟡 通用部分 runLauncher.config.k8sRunLauncher.schedulerName 1.0.8 起。step pod 默认不继承 job 级 tag ⇒ 半接管,配额算不准
Prefect🟡 通用部分 work pool base job template 的 spec.template.spec.schedulerName {{ name }} 只对 generateName 有效 ⇒ 拿不到逐 run app-id
🔴 5 个编排器共享的结构性大坑:ACL 看到的是编排器的 ServiceAccount,不是 DAG 所有者。 确证链五跳全在 v1.9.0 源码里:admission_controller.go:169 取 req.UserInfo.Username → 写入 yunikorn.apache.org/user.info → GetUserFromPod 读回 (metadata.go:106 注释原文「user info is retrieved via service account」)→ core 的 CheckSubmitAccess。⇒ 「按用户配额 / 按 DAG owner 分队列」在 YuniKorn 侧物理上不可能。 更糟:默认配置下自己塞 user.info 会被 webhook 拒绝而不是忽略 ⇒ 任务直接失败。 修法是把编排器 SA 加进 accessControl.externalUsers —— 代价是任何能改 DAG 的人都能冒充任意租户,真正的边界必须放在编排器一侧。

Tekton 那条要说准 对抗复核已修正口径

❌ 不要说成「PVC 亲和失效」—— 共置保证本身不失效。
✅ 真实危害:AffinityAssistantTemplate 结构里没有 SchedulerName 字段 ⇒ 用 workspace + PVC 时 AA Pod 走 default-scheduler ⇒ 整条流水线的落点被它钉死,YuniKorn 失去队列与装箱的话语权; 落点不佳时 TaskRun 的硬亲和无法降级,长时间 Pending。
⚠️ 触发条件在真实 CI 默认满足:AA 默认开着。

Ch.3 · 生态支持矩阵 — 编排器与流水线51
Ch.3 · 生态支持矩阵 · Query Engines & OLAP

查询引擎与 OLAP 零个有 YuniKorn 集成 —— 但这不是「不能用」

组件判定gang怎么调用(字段路径)关键事实 / 坑
 双向零集成(两边仓库互相 grep 都是 0 命中)· 差别只在「chart 有没有留口子」
Trino❌ 不可用否 只剩 ns 注解 …/namespace.enableYuniKorn(queue 走 coordinator.labels) 🔴 coordinator: replicas: 1 硬编码 ⇒ 队列 max 卡死 = Trino 整体不可用
PrestoDB❌ 不可用否 coordinator.podAnnotations / worker.podAnnotations 仅 main 分支;🔴 --set schedulerName= 被 helm 静默吞掉、退出码 0
StarRocks🟡 通用部分 spec.starRocksFeSpec.schedulerName(+ BE / CN / FE-Proxy) operator v1.7.0 起。⚠️ Helm chart 漏渲染 fe-proxy 那一处
Apache Doris❌ 不可用部分 CR 里写不了;只有 spec.feSpec.podLabels / annotations schema 逐属性穷举 ⇒ 字段不存在的正面证明。🔴 AC webhook failurePolicy=Ignore
ClickHouse (Altinity)🟡 通用部分 spec.templates.podTemplates[].spec.schedulerName 该字段的 Go 类型就是 core.PodSpec 本体 —— 最干净的一个
Apache Druid🟡 通用部分 面 B 才可用:customTemplateAdapter + pod template 的 spec.schedulerName 三面分开看:常驻 CRD 不可用 / peon Job 可用(26.0.0 起)/ 经典 MM 不适用
Apache Pinot❌ 不可用部分 只剩 AC 接管 + <component>.podAnnotations(实测渲染有效) chart 是手写 PodSpec 白名单,已发布版与 master 全部 0 命中
🔵 这一页的落点(必须原样讲):它们是长运行服务,所以「适用」与「不适用」要分开说。 ✅ 适用:队列 max 配额、guaranteed + 抢占、preemption fence、allow-preemption: "false" 保护。 ❌ 不适用:gang scheduling、查询间公平共享 —— 查询级公平只能由 Trino / Presto 自己的 resource groups 在进程内做。 ⇒ 用不用要看负载形态,不是看组件名。
Ch.3 · 生态支持矩阵 — 查询引擎与 OLAP52
Ch.3 · 生态支持矩阵 · Streaming, Search & Table Formats

流、检索与表格式 长驻有状态服务的三个共性代价 + 一个「不适用」要说清

组件判定gang怎么调用(字段路径)关键事实 / 坑
 流与检索—— 共性:接入 = 一次全量滚动重启;队列打满对它们不是排队,是可用性事件
Apache Kafka (Strimzi)🟡 通用部分 KafkaNodePool.spec.template.pod.schedulerName Strimzi 0.15.0 起、NodePool 路径自 0.36.0。🔴 template.pod 整块替换
Apache Pulsar❌ 不可用部分 只剩 AC 接管;元数据走 .Values.labels + <component>.annotations helm template 出 11176 行,schedulerName 命中 0
Elasticsearch (ECK)
OpenSearch Operator
🟡 通用部分 ECK:spec.nodeSets[].podTemplate.spec.schedulerName(须 …/v1) 判定分裂:ECK 可用;OpenSearch Operator 到 v2.8.0 / main 仍无该字段 ⇒ 不可用
 表格式—— 唯一的「— 不适用」,但它不是「用不上」,是调度问题在另一层已经解决了
Iceberg / Hudi / Delta— 不适用否 本体无字段;维护作业走 spec.batchScheduler: yunikorn(spark-operator ≥ 2.1.0) 不含 Operator / CRD、不产生 Pod ⇒ 无集成点;维护作业 100% 走 Spark 路径
🔴 这一批共有的两条硬约束:① 首次接入必然触发全量滚动重启(schedulerName 进 PodRevision 的 SHA1,无字段级豁免);② gang 只在 day-0 首次创建生效 —— 扩容 / 滚动重启 / 单 pod 重建都不建 placeholder。 OpenSearch 另有致命坑:issue #1364(OPEN)点名「改 schedulerName 的 mutating webhook」会让 bootstrap pod 每 ~2 秒 delete+recreate 死循环 ⇒ 整个集群完全不可用。
🔵 「不适用」≠「用不上」:表格式的调度需求全部落在维护作业上, 而维护作业最适合放低优先级可抢占队列。但要配套:抢占会留 orphan files ⇒ 必须周期性 remove_orphan_files / VACUUM,否则对象存储成本反向上升。 而「作业间互斥」是一致性语义,YuniKorn 不提供 —— 得靠 Airflow / Argo 依赖或表级锁。
Ch.3 · 生态支持矩阵 — 流、检索与表格式53
Ch.3 · 生态支持矩阵 · On AWS

AWS 侧的四条路 一条官方背书、一条是竞品、一条机制互斥、一条要看 NodePool

组件判定gang怎么调用(字段路径)关键事实 / 坑
 4 个 AWS 侧对象 · 判定跨了三档 —— 这一页值得逐条讲透
EMR on EKS✅ 原生是 spec.batchScheduler: yunikorn + spec.batchSchedulerOptions.queue AWS 有 YuniKorn 专属文档页(2023-08-06)+ data-on-eks 52 处命中
SageMaker HyperPod
task governance
🟡 通用部分 HyperPodPyTorchJob.spec.replicaSpecs[].template.spec.schedulerName 它就是 AWS 托管的 Kueue ⇒ 与 YuniKorn 是竞争而非无关
AWS Batch on EKS❌ 不可用否 唯一该做的是排除:admissionController.filtering.bypassNamespaces AWS 原文:Batch 预绑 nodeName ⇒ 任何调度器都不被调用
EKS Auto Mode / Karpenter
Fargate
🟡 通用部分 spec.template.spec.schedulerName + karpenter.sh/do-not-disrupt: "true" Auto Mode 允许自定义调度器(AWS sample 装 chart 1.9.0);Fargate 互斥

① EMR 教程的参数名缺陷

教程两处都写 placeholderTimeoutSeconds=30,漏了 In; k8shim 唯一接受的键是 placeholderTimeoutInSeconds。解析 switch 无 default 分支 ⇒ 连 warn 都不打,timeout 回落 15 分钟(30 倍偏差)。
而同行的 gangSchedulingStyle=Hard 解析正确 ⇒ 真实症状是 placeholder 占着节点 15 分钟然后作业失败。

② HyperPod 走的是另一条路线

官方原文:add-on installs Kueue(v1.6.0-eksbuild.1 → Kueue v0.19.2)。 分层不同:Kueue = admission gate,YuniKorn = 替换 kube-scheduler 的 placement 层。
🔴 add-on 强制独占 Kueue、SageMaker 会覆写你手改的 Kueue 资源; 若在 labels 里手抄了 kueue.x-k8s.io/queue-name, placeholder 被加 gate ⇒ gang 永久死锁。

③ Fargate 为什么是互斥

Fargate 的调度身份就是 spec.schedulerName == fargate-scheduler, 由控制面 mutating webhook 注入。AWS OFFICIAL KB 明说 pod spec 里设了 schedulerName 会让 fargate-scheduler skip the pod ⇒ 一个字段,两个主人,无解。
就算能设价值也≈0:无 GPU、无 Spot、不能挂 EBS。

Ch.3 · 生态支持矩阵 — AWS 侧54
3.5
Measured
真机实测
前面三章的结论,有一部分只有源码依据。这一章把它们搬到真的 EKS 上跑一遍 —— 其中有几条被推翻了,包括我自己刚说过的话。
五个框架跑通 Karpenter 实测闭环 四例静默失败 被推翻的结论
Apache YuniKorn 技术深潜
55
Ch.3.5 · 真机实测 · Why Redo

为什么前面的数字必须在真 EKS 上重测一遍 三个失真源,每一个都会让结论朝「看起来更好」的方向偏

本机 kind + KWOK 的三个失真源
OrbStack 上报整机容量每节点约 4× 超卖 ⇒ 装箱与配额实验全部失真
schedulable 不反映 taint可用容量虚高 25%
KWOK 假节点 predicate 极廉价吞吐数字不可外推到真集群
共同方向:三者都让 YuniKorn 显得更快、更省。没有一个是往坏的方向偏的 —— 这本身就是该警惕的信号。
这一章跑在什么上面
集群yk-eks-lab · EKS 1.33 · us-east-1
节点16 × m6i.2xlarge on-demand(不用 Spot:基准要确定性)
每节点 allocatablecpu 7910m · mem 29.8Gi · pods 58
YuniKorn1.9.0(helm chart 1.9.0)
Karpenter1.14.1 · NodePool yk-default
跑通的框架Spark ×2 通路 · Flink · Ray · Trino
pods 58 这个数很重要:它是 VPC CNI 的 ENI 上限(4 ENI × 15 IP − 2),不是算力限制。压测小 pod 时先撞到的是它。
本章的诚实标准:凡在真 EKS 上跑出来与前面不同的,一律按实测改口并说明原来错在哪;凡没跑的(EMR on EKS、Tier B 九个框架、B2/B4/B7/B8)一律明说没跑,不用「预期如此」代替。
Ch.3.5 · 真机实测 — 为什么重做56
Ch.3.5 · 真机实测 · 图解 · Topology

装完之后集群里到底变成了什么样 数字全部取自实跑集群 —— 注意右下角那 7 个无上限队列

AWS 账号 8357…6093 · us-east-1EKS 1.33EXTENDED_SUPPORT(已脱标准支持)authenticationMode: API_AND_CONFIG_MAPVPC 10.199.0.0/16 · 2 AZ · 单 NAT 网关 nat-0172aeb8… (🔴 清理时最容易漏的持续计费项)us-east-1c公有子网NAT / IGW 出口私有子网全部工作节点在此us-east-1d公有子网NAT / IGW 出口私有子网全部工作节点在此算力:一个托管节点组 + 一个 Karpenter NodePool(两套并存)EC2托管节点组 ng-bench · 16 × m6i.2xlarge每节点 allocatable:cpu 7910m · mem 29.8Gi · pods 58 ⇒ 全集群 928 pod 上限KPKarpenter 1.14.1 NodePool yk-defaultm6i.{large,xlarge,2xlarge} · on-demand · limits.cpu 封顶防失控同一集群,互不知情🔴 AC webhook 默认 processNamespaces 为空 = 全集群接管(bypassNamespaces 默认只有 ^kube-system$)YKns yunikorn2 Deploy · 2 Pod · 3 容器 · 0 DSspark-operator2 podflink-operator1 podkuberay4 podtrino3 podcert-manager3 podns amazon-guardduty —— AWS 安全代理也被接管了kube-system · 38 pod(含 karpenter 本体)队列树实况:18 个队列里 7 个是放置规则**现场造**的,全部无上限11 个我配置的托管队列(isManaged=true)bench · spark · flink · trino · ray · tiny · small · acl-{upper,lower,empty}7 个 autogen 队列(isManaged=false · maxResource 为空 = 无上限)kuberay · spark-operator · flink-operator · cert-manager · amazon-guardduty · yk-test · yk-req落点:这张图上「跑起来了」的东西全都跑起来了 —— 而右下角那 7 个无上限队列说明治理并没有生效。装 YuniKorn 的同一天必须做完两件事:① 收紧 admissionController.filtering.processNamespaces ② 给放置规则链兜底(或让每个作业自带 queue label)。🔴 1.33 的标准支持在 2026-07-29 结束 —— 恰好是 YuniKorn 1.9.0 的 GA 日。而 YuniKorn 1.9.0 的兼容矩阵上限就是 1.33 ⇒ 今天必须在「超出 YuniKorn 矩阵」与「脱离 EKS 标准支持」之间二选一on-demand(基准要确定性,不用 Spot)。🔴 pods=58 是 VPC CNI 的 ENI 上限(4 ENI × 15 IP − 2),不是 CPU 限制 ⇒ 跑小 pod 压测时先撞到的是这个数,不是算力实测(B5 路径 A):YuniKorn 写下 PodScheduled=False/reason=Unschedulable 后 1.3 秒 Karpenter 感知、3.8 秒 EC2 已启动。🔴 但配额受限时 YuniKorn 不写任何条件 ⇒ Karpenter 一台都不加(路径 B:NodeClaim=0)。🔴 测吞吐时必须把 limits.cpu 压到 0 —— 否则集群规模在测量过程中变动yunikorn-scheduler(容器 yunikorn-scheduler-k8s + yunikorn-scheduler-web)与 yunikorn-admission-controller,两者 replicas 都硬编码 1、零 leader election ⇒ 单副本 + 快速重建,不是高可用🔴 这是「webhook 默认全集群」最生动的后果:我从没配置过 GuardDuty,但它的 agent pod 进了 YuniKorn 的队列账本,并现造出 root.amazon-guardduty 这个 maxResource 为空(无上限)的队列。装 YuniKorn 的第一件事应该是收紧 processNamespaces,而不是装完再想出厂放置规则链是 provided(create=false) → tag(namespace, create=true) → recovery。pod 没带 queue label ⇒ 退到 tag 规则,**按 namespace 名现场创建队列**,而现造的队列 maxResource 为空 = 无上限 ⇒ 你精心配的配额,对这些 pod 一个都没管到
Ch.3.5 · 图解 — EKS 拓扑57
Ch.3.5 · 真机实测 · 图解 · Framework Paths

七条提交通路,以及每条在 pod 上真正落地了什么 七行全部 Running、schedulerName 全部是 yunikorn —— 而治理只有四行生效

提交通路怎么配(确切字段)pod 上真正落地了什么YuniKorn 眼里的结果schedappIdqueuegangSpark 原生 spark-submitspark.kubernetes.scheduler.name=yunikorn+ driver/executor 两侧 label 与注解✓✓✓✓每作业一个独立应用四判据全过 · gang 生效Kubeflow Spark OperatorbatchScheduler: yunikornoperator 代你拼全部注解✓✓✓✓每作业一个独立应用driver SucceededFlink Operator(generic)spec.podTemplate.spec.schedulerName+ labels: {queue: root.flink}✓✗autogen✓✗JM + 全部 TM 合成一个应用同 ns 多作业继续合并Ray / KubeRay · 默认装RayCluster 上写 gang-scheduling-enabled与 yunikorn.apache.org/queue —— 都不生效✓✗autogen✗现造队列✗落进现造的 root.kuberay🔴 无上限 · 配额被绕过Ray / KubeRay · 开旋钮helm --set batchScheduler.name=yunikorn(注意 enabled:true 会装成 Volcano)✓✗autogen✓✓queue 与 task-groups 都对了但 appId 仍是 ns 级 autogenTrino · AC 按 ns 接管什么都不配 —— webhook 无条件改写chart 里 schedulerName 命中 0 次✓✗autogen✗现造队列✗整个 namespace 一个应用🔴 队列靠撞名,改名即失效Trino · 注入 label(推荐)--set-string worker.labels.applicationId=…labels 会渲染进 pod template,零 chart 改动✓✓✓~不适用trino-bi 独立应用 3 podsgang 对长驻服务无意义🔴 全部 7 行的 pod 都是 Running,schedulerName 都是 yunikorn ——「跑起来了」这件事完全无法区分上面 4 行和下面 3 行。只有 Spark 天然免疫:它自带每次提交都不同的 spark-app-selector,恰好满足 YuniKorn 的应用识别契约 ——巧合式兼容,不是有意集成。⇒ 除 Spark 之外的每个框架,上线前都必须回答一句:我的 applicationId 从哪来? ✅ 全部 EKS 实测(EKS-RESULTS E11/E12/E14/E19/E23/E24)schedulerName —— 由 AC webhook 无条件注入 ⇒ 任何 chart 都不需要提供这个字段。我原先拿 grep schedulerName==0 当判据,测的是错的东西applicationId —— 缺它 ⇒ 同 namespace 所有 pod 合并成一个应用 yunikorn-<ns>-autogen ⇒ 配额/gang/抢占全按错粒度记账queue —— 缺它 ⇒ 放置规则退到 tag 规则按 namespace **现场创建**队列,而现造的队列 maxResource 为空 = 无上限 ⇒ 配额被绕过task-groups —— 缺它 ⇒ 没有 gang,pod 各自调度。注意 minResource 里 CPU 的键是 cpu,队列配置里是 vcore
Ch.3.5 · 图解 — 框架通路58
Ch.3.5 · 真机实测 · 图解 · Taxonomy

26 个框架,接入通路只有六种形态 而坑是按形态聚集的 —— 知道属于哪一形态,就知道该防什么

接入形态机制属于这一形态的框架🔴 这一形态特有的坑① CRD 显式字段9 个schema 里有 schedulerNamespec…template.spec.schedulerNameKafka/Strimzi · Argo · Dask · MPIJobSet · LWS · Tekton · Volcano · Milvus🔴 层级会随 CRD 版本迁移:Milvus v1alpha1 在spec 顶层,v1beta1 挪进 spec.components⇒ 且开了 strict decoding,写错层级直接被拒② chart 旋钮4 个values 里有 schedulerName / podLabelshelm --set schedulerName=yunikornAirflow · StarRocks · JupyterHub · Trino🔴 **子 chart 不继承父 chart 的 common labels**(4 例:Airflow/Druid/Milvus/Pulsar 的捆绑库)🔴 JupyterHub 自带 kube-scheduler,默认开③ preserve-unknown 逃生舱2 个schema 零显式字段,但该节点不校验podTemplates[] · nodeSets[].podTemplateClickHouse(90 处逃生舱)· ECK(3 处)🔴 写错的字段被**静默丢弃**(schema 不校验)🔴 逃生舱**按路径**,不是全局 ——写在舱外照样被 strict decoding 拒掉④ 只有 annotation4 个无 schedulerName、无 pod label 口子podAnnotations.yunikorn.apache.org/{app-id,queue}Druid · Pinot · Doris · Pulsar🔴 这几个 chart 常**零 resource requests**⇒ vcore/memory 用量恒为 0⇒ 只写 vcore/memory 的配额**永不生效**⑤ conf 透传3 个上游把 spark.kubernetes.* 转发给 Sparkspark.kubernetes.scheduler.name=yunikornSpark 原生 spark-submit · Spark Operator · Kyuubi🔴 Kyuubi 三个陷阱:cluster 模式要对象存储 ·kyuubi 镜像不能当 Spark 镜像 ·client 模式要 headless service⑥ 共存(非接入)1 个两者在时间上根本不重叠Kueue 用 Job suspend/resume,pod 尚不存在Kueue(+ YuniKorn 双层配额)🔵 实测 pod 的 schedulingGates 是**空的** ——对 batch/v1 Job,Kueue 走 Job 级 suspend,不走 Pod 级 gates。两条路别混起来讲落点:**形态只有 6 种,而坑是按形态聚集的** —— 知道一个框架属于哪一形态,就知道该防什么。判据 schedulerName==yunikorn 对这 26 个**几乎没有区分力**(AC webhook 无条件注入它);真正有区分力的是「工作负载能不能进你指定的队列」。✅ 26 个框架全部 EKS 实测 · 唯一来源是 eks-poc/tools/fwrun.py 的 REGISTRY(矩阵由 fwrun.py report 生成)最干净的一类。但「有显式字段」不等于「路径稳定」—— Milvus v1alpha1 的 spec.schedulerName 到 v1beta1 变成 spec.components.schedulerName,而 CRD 开了 strict decoding,写错层级 apiserver 直接报 unknown field。好在它是**大声失败**最大的陷阱是子 chart:Airflow 的 labels 注释明写 “applies to all objects and pods”,但 bitnami postgresql 子 chart 不继承 ⇒ 捆绑的数据库跑在 autogen 无上限队列里,而它往往最吃资源grep schedulerName == 0 会把这两个误判成 unsupported。必须用 CRD schema 递归找出 x-kubernetes-preserve-unknown-fields 节点,并且**只能写在舱内**。代价是写错不报错 ⇒ 必须回到 pod 上核对能接进来完全依赖 YuniKorn 的应用识别优先级链第②级(annotation)。若只记住「用 applicationId label」这一种写法,这 4 个会被误判成接不进去。配额必须额外带 pods 维度这一类自动继承 Spark 那条通路(含 gang)。Spark 还因自带 spark-app-selector 而天然免疫「ns 级 autogen 合并」—— 这是巧合式兼容,不是有意集成流程:Job 以 suspend=true 提交(pod 还不存在)→ Kueue 准入 → 解除 suspend → pod 才被创建 → YuniKorn 调度。⇒ 不冲突的原因比「YuniKorn 尊重 gates」更强:它们压根不同时在场
Ch.3.5 · 图解 — 接入形态分类59
Ch.3.5 · 真机实测 · Overturned

真机跑完之后,我自己错了三处 而且三处是同一个错:把「仓库里有 volcano/kueue 字样」当成「别的调度器进不去」

框架我原来的判定(只有源码依据)EKS 实测
Volcano Job conflict「vc-controller 在 PodGroup 未离开 Pending 前一个 pod 都不建」 genericpod 由 vc-controller 建、YuniKorn 调度、Completed(36s);且不建 PodGroup —— 那正是共存机制
LeaderWorkerSet 「provider 白名单只认 volcano」 3 pod 全 yunikorn、落进预期队列、Running白名单只影响 LWS 自己的 gang 集成,不挡 schedulerName
KServe 「白名单里有 Kueue」暗示 yunikorn 进不去 CRD 里有四处显式 schedulerNamespec.{predictor,transformer,explainer}.schedulerName + predictor.workerSpec
Trino(上一轮已改) unsupported依据是 grep -ci schedulerName == 0 generic那个字段本该由 AC webhook 填;真判据是「能不能往 pod template 注入 label」
四处的共同错法:我把「该项目自己的 gang 集成默认值」当成了「调度器准入白名单」。 而 schedulerName 是一条正交的通路 —— 它由 K8s 本身定义,任何项目都无权拦。 ⇒ 判据必须是「实际提交一个工作负载,回到 pod 上看」,而不是在对方仓库里 grep 竞品名字。
Ch.3.5 · 真机实测 — 被推翻的判定60
Ch.3.5 · 真机实测 · Coexistence

Kueue + YuniKorn 是唯一的双层配额组合 共存确证 —— 但机制和我原来说的不一样,而且更强

我原来的解释(源码依据)
「Kueue 从不写 schedulerName,只改 label / annotation / nodeSelector / schedulingGates;而 YuniKorn v1.9.0 的 shim 尊重 schedulingGates(gated pod 不建 task)」⇒ 所以能共存。
实测把机制否证了
# pod 上的 schedulingGates 是空的 kueue-yk-g4lmf gates= sched=yunikorn kueue-yk-lltxc gates= sched=yunikorn
真实机制:两者时间上根本不重叠
①Job 以 suspend: true 提交🔴 pod 还不存在
②Kueue 准入 —— Workload Admitted=True解除 suspend
③pod 这才被创建 ⇒ YuniKorn 调度落进 root.tierc.kueue,2 pod Succeeded
⇒ 不冲突的原因比「尊重 gates」更强:它们压根不同时在场。schedulingGates 是给裸 Pod / 非 Job 工作负载用的另一条路 —— 两条别混起来讲。
对客口径:Kueue 管 Job 级准入(配额够了才放行),YuniKorn 管 Pod 级调度(放哪台机器 + 队列记账)。层级不同、时间不重叠 ⇒ 可以同时用,而且互补。⚠️ 代价是两套配额要各自维护,写不一致时较紧的那个生效,而没有任何工具会告诉你它们不一致。
Ch.3.5 · 真机实测 — Kueue 共存61
Ch.3.5 · 真机实测 · Karpenter B5

全场最重要那条洞察,现在有实测了 而且它同时纠正了我先前两个版本的说法

观测项路径 A · 真缺资源(配额充足)路径 B · 队列配额受限
队列root.bench(max 160 vcore)root.tiny(max 1 vcore),pod 要 2 核
.status.conditionsreason:"Unschedulable"message: request is waiting for cluster resources become available空不是 SchedulingSkipped,是什么都没有
Karpenter NodeClaim20
新增 EC22 台(m6i.xlarge + m6i.2xlarge)一台都没有
pod 最终状态3 个全 Running3 个永久 Pending
反应速度条件写入 → +1.3s Karpenter 感知 → +3.8s EC2 已启动—
实验设计必须交代的一点:两条路径的 pod 都带 nodeSelector: karpenter.sh/nodepool=yk-default。因为集群有 128 vCPU 富余,不加约束的话 pod 会直接落在现有节点上,根本走不到「需要扩容」这一步。加了之后,「是否扩容」就成了唯一的自由变量。
机制(源码注释原文):inspectOutstandingRequests() 的文档写着 “in order to trigger the auto-scaling”,而它的入选条件是 “they can fit into the max head room” ⇒ 配额受限的 ask 进不到这个函数,回调根本不被调用。
我先前两个说法都要改:① 「写 SchedulingSkipped」—— shim 里确实有这个分支,但 core 全仓只发 FAILED ⇒ 那是死代码。② 「全树 SKIPPED 零命中」—— 对 core 成立,过度概括到了 shim。
对客最准确的一句话:「配额受限不触发扩容」是 YuniKorn 写在注释里的刻意设计(we do not trigger the auto-scaling);但它的实现方式与代码自己的计划不同 —— 计划是写一个带原因的条件,现实是什么都不写。净效果一致,可观测性完全不同。
Ch.3.5 · 真机实测 — Karpenter B562
Ch.3.5 · 真机实测 · Silent Failures

真机上撞出的四例静默失败 它们的共同点:失败和成功长得一模一样

缺陷你会看到什么实际发生了什么
KubeRay 默认装不传播 queuehelm 装 kuberay-operator 不传 values 时 Ray head + worker 全 Running,schedulerName=yunikorn,零报错零 event pod 没拿到 queue label ⇒ 放置规则退到 tag 规则,按 namespace 现场造出 root.kuberay,而现造队列 maxResource 为空 = 无上限 ⇒ 你配的 root.ray 拿到 0 个 pod
Trino 的队列配额数学上不可能生效 把 max 写成多小都拦不住,扩到 13 个 worker 全部 Running chart 默认 resources: {} ⇒ pod 零 requests ⇒ 用量在 vcore/memory 两维上恒为 0,而 max 只写了这两维 ⇒ 两者永不相交。补救:max 必须带 pods 维度
每个成功的 gang 作业都留下假 Warning 作业 exit 0,但 driver pod 上有 Warning: placeholder has been timed out core 在应用正常完成时用 TerminationType_TIMEOUT 释放剩余 placeholder(reason 原文 releasing placeholders on app complete),而 shim 只判类型 ⇒ 无法区分「真超时」与「完成清理」⇒ 会污染按 type=Warning 告警的监控
六个延迟指标的名字都写错了单位 yunikorn_scheduler_scheduling_cycle_milliseconds Observe(SinceInSeconds(start)) ⇒ 值是秒,Help 也写着 in seconds ⇒ 谁按名字写 > 100(想表达 100ms)实际表达的是 100 秒,永远不触发
加上前面章节的四条(cpu vs vcore、放置规则造无配额队列、gang 参数键写错零日志、/ws/v1/metrics 双重 gzip),这个清单已经有八条了 —— 而它们没有一条会让你的部署失败,只会让你的治理悄悄不生效。
Ch.3.5 · 真机实测 — 四例静默失败63
Ch.3.5 · 真机实测 · Application Identity

除 Spark 之外,每个框架上线前都得回答一句:我的 applicationId 从哪来 因为「应用」是配额、gang、抢占、公平的基本单位

出厂默认:整个 namespace 合并成一个应用
# /ws/v1/partition/default/queue/root.flink/applications yunikorn-flink-jobs-autogen Running pods=3 ← JM + 2 TM 合成一个 yunikorn-trino-autogen Running pods=3 ← 整个 ns 一个 yunikorn-kuberay-autogen Running pods=4
同 namespace 再起 5 个 Flink 作业,6 个作业仍是同一个 YuniKorn 应用。这不是显示问题,是记账粒度问题。
那个开关是个两难,不是修复
generateUniqueAppId: false出厂默认3 个 pod → 1 个应用多租户隔离失效
generateUniqueAppId: true3 个 pod → 3 个应用gang 直接失效 —— driver 与 executor 被拆成不同应用,minMember 永远凑不齐
而且它还有可观测性陷阱:开了之后 pod label 是哨兵值 <ns>-uniqueautogen,所有 pod 完全相同,真实应用 ID 只在 scheduler 内存里 ⇒ kubectl get pod -L applicationId 会骗你。
正解既不是 false 也不是 true,而是「每个作业显式打 applicationId」。Spark 之所以是唯一免疫的,是因为它自带每次提交都不同的 spark-app-selector —— 那是它为自己的 executor 发现机制准备的,恰好满足了 YuniKorn 的应用识别契约。这是巧合式兼容,不是有意集成(Spark src/main/ 下零 YuniKorn 生产代码)。
Ch.3.5 · 真机实测 — 应用身份64
04
Decide
怎么决策
这一章会算一笔账,而这笔账可能会劝你别做。这是我们能放在 CFO 面前最可信的一件事。
成本模型 盈亏平衡点 选型对比 迁移剧本
Apache YuniKorn 技术深潜
65
Ch.4 · 怎么决策 · 图解 · Decision Tree

该不该上,以及该选哪一个:四道闸门 四个出口里有三个是「不做 / 做别的」

批处理跑在 K8s 上最小单位是一组 pod?不是单个 pod1规模够吗?香港 ~40 / 美东 ~55 台2主力是分布式训练?还是 Spark 系3需要跨集群配额?一个 shim = 一个集群4不需要 YuniKorn你在「在线服务」那一列否先别做把 ResourceQuota + PriorityClass 用到极致不到线看 KAI / VolcanoTrainer 的 gang API 填不进 YuniKorn训练为主看 MultiKueue / KarmadaYuniKorn 硬编码单 partition需要是够Spark 为主不需要上 YuniKorn按五阶段灰度四个出口里有三个是「不做 / 做别的」—— 这是刻意的。这类项目失败后往往被归咎于技术,而实际原因是规模不匹配。提前把线画出来,是在保护技术选择本身。闸门 ②③④ 的依据见本章后续页判据:我的负载的最小有意义单位,是一个 pod 还是一组 pod?如果是很多互相独立的单 pod 任务,你在「在线服务」那一列盈亏平衡点:TCO = 一次性 89,362 美元摊 36 月 + 每月 3,333 运维 = 5,816/月;毛节省按 23.7% 算 ⇒ 需要每月 24,538 美元的 EC2+EKS 支出Kubeflow Trainer 的 gang API 是 coscheduling|volcano 的封闭联合,字段根本填不进 YuniKorn;NVIDIA NeMo 文档让你用 KAI Schedulerv1.9.0 硬编码单 partition(K8s shim 只支持 default,YUNIKORN-22)⇒ 跨集群配额做不到五阶段:装但不接管 → 单队列单团队 → 队列树+ACL → Gang → 抢占。抢占放最后且独立成一次变更 —— 它是唯一会主动杀 pod 的能力,而 PDB 保护不了它
怎么用这一页:给还没决定的团队,它是四道闸门;给已经上了的团队,它是四个「值不值得继续投入」的检查点 —— 尤其第 ② 道,规模一直没上来时,继续加人做 gang 和抢占是负收益的,停在「队列 + 配额」是一个合理的终点。
Ch.4 · 图解 — Decision Tree66
Ch.4 · 怎么决策 · Cost Model

四个机制,只有两个真值钱 参考单价 m6g.4xlarge us-east-1 = $449.68 / 节点 / 月

#机制占节省份额说明与算例
1池化
用配额替代专用集群
~70% 机制是统计复用,不是调度。三个团队各按自己峰值买 = Σ(mean+z·σ);合池后买 mean_total + z·σ_total,而独立需求下 σ_total = √3·σ_i。
算例:每队 mean 12 / peak 20 ⇒ 3×20 = 60 节点 → 36 + 8√3 ≈ 50 节点。
YuniKorn 在这里的作用只是「提供一个团队信得过的配额,让共享变得可接受」。
2装箱
节点排序 binpacking
~28% 减少碎片 ⇒ Karpenter 更晚才扩容。
🔶 公开材料里唯一的一手量化数字(Halodoc,EMR on EKS,2026-02):节点内存利用率 >90%、CPU ~88%、单节点扩容前可达「96% and above」,"approximately a 10% reduction in EC2 costs"。
保守取 8% 节点数下降:50 → 46 节点。(✅ 我们实测也看到了这个效果:默认 fair 排序用了 46/50 个节点,而 default-scheduler 只用 30/50)
3EKS 控制面合并2% 3 集群 × $0.10/集群·小时 × 730 = $219/月 → $73/月,省 $146/月。这是零头,别拿它当卖点。
4减少失败 / 死锁作业建模为 $0 这是延迟 / SLO 收益,不是成本收益。算例:一个 4 vCPU / 16 GB 的 driver 白等 30 分钟,烧掉的 EMR uplift 是 $0.029。
即使 50 个 driver 同时卡 1 小时也只有 ~$4。放可靠性页,别放 ROI 页。
—Spot 故意不在这个列表里— 它与 YuniKorn 正交(用不用 YuniKorn 都能用 Spot)。把 Spot 的节省算进 YuniKorn 的账是最常见的夸大。
Ch.4 · 怎么决策 — 成本模型67
Ch.4 · 怎么决策 · The Overclaim

最常见的夸大:EMR on EKS 的 uplift 按申请量计费 装箱省不下它一分钱

AWS 定价页原文(us-east-1,2026-09 读)

"Pricing is based on requested vCPU and memory resources for the Task or Pod"
每 vCPU·小时 $0.01012 · 每 GB·小时 $0.00111125

AWS 自己的算例金额
100 vCPU × $0.01012 × 0.5 h$0.506
300 GB × $0.00111125 × 0.5 h$0.1667
uplift 合计$0.6727
🔴 关键推论: YuniKorn 改变的是 pod 落在哪个节点,从不改变 pod 申请多少。
⇒ EMR uplift 这一行在用 YuniKorn 前后是逐位相同的。
⇒ 装箱省下的 EMR uplift 是 $0。
能降低 uplift 的只有两件事: ① 跑得更快(运行时 / SQL 优化)② 申请更少(rightsizing)。
换调度器不在这两条里。
📌 这一条必须主动在 PPT 上说出来。 一个 FinOps 审阅者一定会发现它。
你先说,是专业;被他发现,是可信度归零。
顺带纠正另一个混淆:那些著名的 「5.37 倍更快、成本降 61%」是 EMR Spark 运行时 vs 开源 Spark 的数字 (TPC-DS 派生、3 TB、104 条查询、6 × c5d.9xlarge),与调度器无关。 AWS 从未发布任何 YuniKorn 的性能数字。
✅ 正确口径:EMR 运行时买的是查询速度;YuniKorn 买的是排队、原子性和公平性——第二样你必须自己测。
Ch.4 · 怎么决策 — 最常见的夸大68
Ch.4 · 怎么决策 · Break-even

盈亏平衡点:55 节点(us-east-1)/ 40 节点(香港) 低于这个规模,我的建议是别做

落地成本(按 $4,255 / 工程师·周)

工作项工程师·周金额
试点:1 队列 1 团队非生产,验证 binpacking + 指标3$12,766
生产铺开:3 团队、队列树、放置规则、ACL、配额定量6$25,532
给所有 Spark 作业上 gang(taskGroup、AZ 固定、超时调优)4$17,021
计费链路:日志 → S3 → Athena,关联 CUR split cost5$21,277
runbook、告警、升级自动化、调度器容灾3$12,766
一次性合计21$89,362
稳态运维0.2 FTE$3,333 / 月

TCO = $89,362 / 36 月 + $3,333 = $5,816 / 月
毛节省按 23.7% 计(池化 + 装箱 + 控制面)⇒ 平衡点 = $24,538 / 月的 EC2+EKS 支出 ⇒ us-east-1 约 55 台 m6g.4xlarge;香港 ap-east-1 约 40 台(单价更高,门槛低 27%)。

改造前规模毛节省/月净/月ROI
60 节点($27.2k)$6,446$63111%
120 节点($54.4k)$12,893$7,077122%
300 节点($136k)$32,232$26,416454%
600 节点($272k)$64,464$58,6481008%

必须说出来的一句话

  • 教科书式的「3 个团队各 20 节点」这个例子,过不了盈亏平衡线。一次性投入的简单回收期是 13.9 个月,扣掉稳态运维后,在 $34.6k/月 的账单上只净赚 $631/月。
  • YuniKorn 是一个 >100 节点规模才成立的决定。回收期 3.8 个月(如果你在合并多个专用集群); ~124 个月,也就是永远不回本(如果你本来就把 Karpenter 用得很好)。
Ch.4 · 怎么决策 — 盈亏平衡点69
Ch.4 · 怎么决策 · Comparison

YuniKorn vs Volcano vs Kueue 不要从 feature 列表开始比——先看架构定位

维度YuniKornVolcanoKueue
架构定位替换 kube-scheduler与 kube-scheduler 并存的独立调度器不调度 pod,只做 Job 级准入门控
用户手上写什么注解 + label不引入新 CRD自己的 CRDQueue / PodGroup / VolcanoJob原生 Job + label + 配套 CRD
层级队列 强项任意深度 + guaranteed/max + ACL有 Queue CRD,层级较弱cohort / borrowing,形态不同
真 gang(原子放置) placeholder 占位 PodGroup + minAvailable招牌能力 不做放置 ⇒ 无真 gang
抢占 七条定律,锚点 guaranteed preempt / reclaim 基于优先级
拓扑感知(NUMA / 网络) 无,路线图上也没有 有相关能力 有 TASGKE 的拓扑调度建在其上
多集群 无,且硬编码单集群 volcano-global(alpha) MultiKueue
AI 训练框架原生支持 Kubeflow Trainer 不支持它 Trainer / LWS / MPI 都支持 JobSet / Trainer / RayJob
Spark 生态 强项有官方专节(最新 GA 钉 1.8.0);但只有文档+测试,无生产代码 Spark 主干内建 feature step
治理归属Apache 基金会 TLPCNCFkubernetes-sigsK8s 官方子项目
云厂商背书仅 AWS + Cloudera华为云 CCE 一等公民GKE / AKS / 火山引擎
选型的真正问题不是「哪个 feature 多」,而是「你要的是配额准入还是原子放置」。 Kueue 放行 Job 之后把放置权交回 kube-scheduler ⇒ 它保证的是「这批 pod 的配额够了」, 不是「这批 pod 一定同时落到节点上」。这是三者之间最实质的技术差异。
Ch.4 · 怎么决策 — 三者对比70
Ch.4 · 怎么决策 · YARN Migration

YARN → YuniKorn 概念对照 这是它的护城河,也是最容易配错的地方

YARN(Capacity Scheduler)YuniKorn迁移时的注意点
队列(root.a.b)队列(root.a.b)概念与命名几乎 1:1,这是它的护城河
capacity(百分比)resources.guaranteed(绝对量)🔴 YARN 用百分比会随集群自动伸缩,YuniKorn 用绝对量不会。集群扩容后必须回来改配置,否则保障比例被稀释
maximum-capacityresources.max同上,绝对量
acl_submit_applicationssubmitacl语法不同(「用户列表 空格 组列表」),语义相同
acl_administer_queueadminacl⚠️ YuniKorn 的 adminacl 同时授予 submit 权限
ApplicationMasterSpark driverK8s 上没有 AM 这一层
maximum-applicationsmaxapplications子队列必须 ≤ 父队列
队列内 FIFO / Fair · DRFapplication.sort.policy🔴 跑 gang 的队列必须是 fifo;配成 fair 报 unsupported sort type,而这个报错不提原因。且 properties 会从父队列继承
node label / partition🟡 只能靠 nodeSelector + taint 近似🔴 最大的语义缺口:没有「队列绑定节点组」这个一等公民概念(K8s shim 只支持 1 个 partition)
reservation system(预约未来容量)❌ 无对应物YARN 能预约「明天 2 点给我 100 核」,这里不能
opportunistic containers · Federation❌ 无对应物单集群,见第 1 章的边界页
 🔵 反过来 YuniKorn 有 YARN 没有的:gang scheduling(YARN 靠 AM 自己协调)、 以及与 K8s 原生调度约束(affinity / topologySpread / PVC 拓扑)的天然融合。
Ch.4 · 怎么决策 — YARN 概念对照71
Ch.4 · 怎么决策 · Rollout

迁移剧本:五个阶段 而最直觉的那个方案行不通

🔴 先破除一个错误方案: 「给要迁移的负载加 schedulerName: yunikorn,其余保持 default-scheduler」—— 这行不通。mutating webhook 默认作用于全集群所有工作负载类型, 会把显式写着 default-scheduler 的也改写成 yunikorn,而且不报错。 ⇒ 唯一正确的出口是 namespace 级开关。
阶段 0
装但不接管

embedAdmissionController=false,或 processNamespaces 指向空 ns。判据:能读 config、能抓指标

›
阶段 1
单队列单团队

1 ns + 1 leaf 队列 + binpacking;不开 gang、不开抢占。判据:跑一次超配额实验,确认 pod 停在 Pending 且没有任何 PodScheduled 条件(不要去找 SchedulingSkipped,v1.9.0 不会写)

›
阶段 2
队列树 + ACL

3 团队;provided 规则在前;组 ACL。判据:isManaged==false 巡检为空;组 ACL 真的匹配上了

›
阶段 3
Gang

加 taskGroups,显式 Hard,超时按节点冷启动 p99 取值。判据:placeholder 能正常 swap,无长期 Accepted

›
阶段 4
抢占

设 guaranteed;关键队列设 preemption.policy: disabled。判据:能触发,且无永久 Pending 的 Deployment

✅ 正确的灰度开关(两套,可组合)

# A · admission controller 的 namespace 过滤
#   ✅ 实测:支持逗号分隔正则,亚秒热生效
admissionController.filtering.processNamespaces:
  '^data-eng-dev$,^data-eng-staging$'

# B · namespace 注解(覆盖正则,优先判断)
#   🔵 灰度的最佳抓手:不改全局配置
kubectl annotate ns team-a \
  yunikorn.apache.org/namespace.enableYuniKorn=true
为什么抢占放最后、且独立成一次变更: 它是唯一会主动杀掉正在运行的 pod 的能力,而且 PDB 保护不了它。
可逆性(客户最关心的)——PMC 成员原话: "Since it is a drop-in replacement … Stopping YuniKorn will revert the cluster back to its old state."
但要补两条实测限定:① 已带 schedulerName: yunikorn 的 pod 在卸载后永远不会被调度,回退前必须重建; ② 正在跑的 gang 的 placeholder 命运我们未实测,回退演练要专门验证。
诚实表述:新负载的回退是干净的(摘注解,几秒生效); 已在运行的负载需要重建。
Ch.4 · 怎么决策 — 迁移剧本72
Ch.4 · 怎么决策 · Call to Action

下周就能做的三件事 按「投入从低到高」排序 · 第一件今天就能做完

今天 · 30 分钟
0 成本

先算规模,再谈技术

  • 拉出当前 EC2 + EKS 月度支出
  • 对照盈亏平衡线:香港 ~40 台 / 美东 ~55 台
  • 不到线就先别做,把这页发给决策者
本周 · 1 天
仅本地

在 kind 上跑一遍

  • 17 秒装完,验证配额真的生效
  • 跑一次装不下的 gang,看 ApplicationRejected
  • 记住 pin kindest/node 版本
下周 · 3 工程师·周
需排期

非生产试点

  • 1 namespace + 1 leaf 队列 + binpacking
  • 先不开 gang、不开抢占
  • 把指标接进 Prometheus(记得关压缩)
动作负责人截止验收标准
算出当前规模与盈亏平衡线的差距平台负责人本周三一个数字:距离平衡点还差多少节点
本地 kind 跑通配额与 gang 两个实验SRE本周五能复述「配额撞上」与「gang 被拒」两种 event 原文
过一遍四个坑,确认自己不会踩SRE + 数据平台下周一输出一份「我们的配置里有没有这四个坑」的检查结果
决定做 / 不做,并写下理由平台负责人下周五不做也是一个合格的结论,但要有理由

如果只带走三句话

  • 它解决的问题是真的(资源死锁、配额不能排队),但它是一个 >100 节点规模才成立的决定。
  • 四个坑都是静默的:资源命名、放置规则、gang 参数名、1.9.0 的 metrics gzip。不报错不等于生效。
  • 在 AWS 上它有官方文档背书,但没有托管版本;与 Karpenter 的协同靠一个未成文的字符串——能用,但要知道它为什么能用。
Ch.4 · 怎么决策 — 行动清单73
Appendix · Reference

附录:坑清单速查 每条都有本场对应页码

#坑症状页
1mutating webhook 改写全集群所有工作负载的 schedulerName无法用 schedulerName 灰度;A/B 测出「两边一样」P8 · P72
2放置规则 tag+create:true 在前 ⇒ 造出无配额队列配额完全不生效,pod 全 RunningP19
3队列配置里写 cpu 而非 vcore配额不生效,不报错P18
4schedulingPolicyParameters 键写错 ⇒ 零日志静默忽略超时是 15 分钟而不是你设的值P26 · P45
5v1.9.0 /ws/v1/metrics 双重 gzipPrometheus target 掉线,无指标P31
6抢占走裸 DELETE ⇒ PDB 被绕过PDB 保护不了服务P44
7节点排序默认 fair(摊平)⇒ 云上多开节点实测 46/50 vs 30/50 个节点P67
8gang 队列必须 fifo;fair 报 unsupported sort type报错完全不提原因;properties 会从 root 继承P71
9默认 gangSchedulingStyle=Soft ⇒「半个 gang」应用 Running 但一半 pod Pending,监控看不出P26
10零 placeholder 落地 ⇒ 超时计时器从不启动应用无限期停在 AcceptedP21
11抢占 + Deployment ⇒ 永久 PendingReplicaSet 补的 pod 永远调度不上P29
12抢占方没有 event 记录;K8s event 会丢查不到「我抢了谁」;审计缺记录P30
13Fargate 与 YuniKorn 互斥Fargate pod 永久 Pending—
14placeholder 吃 VPC CNI 的 IP 与 max-pods瞬时需 2× pod 槽位;IP 耗尽表现为 gang 超时—
15kubectl delete cm yunikorn-configs ⇒ 瞬时重置为默认队列树消失,无确认—
完整版见配套《Apache YuniKorn 精通指南》(21 章 + 7 附录,6,400 行):28 条坑清单、25 条 REST 路由全表、Label/Annotation 全表,以及推翻或修正的 7 处流行说法(含 9 处我们自己的更正)。
Appendix — 坑清单速查74
Thank you!
Apache YuniKorn 技术深潜 · v1.9.0
Neo SUN
Solutions Architect Amazon Web Services
带走这三样:
· 配额体系完整性巡检命令(P19)
· 四个静默失效的坑(P74)
· 盈亏平衡线:香港 ~40 台(P69)
配套材料:
· 《精通指南》21 章 + 7 附录
· 可复现实验室(kind + KWOK)
· 2,500 行实测记录(含失败过程)