文章导航

1. 调度框架演进
2. 插件总览与流水线
3. ● 六大插件精读
4. NodeResourcesFit
5. NodeAffinity
6. TaintToleration
7. InterPodAffinity
8. PodTopologySpread
9. VolumeBinding
10. 对比总结表
11. 生产踩坑实录
12. FAQ 高频答疑

k8s 源码级精讲（二十六）：调度器内置插件逐个精读

一、调度框架的演进：为什么拆成多个插件

早期 k8s 调度器（v1.14 及之前）是一个 monolithic 大函数，内置几十个 predicate 和 priority 函数，每加一个策略都要改主循环代码。这带来三个根本痛点：

• 改一个策略必须重新编译整个调度器二进制
• 用户的特殊调度需求无法动态扩展
• 所有 predicate 必须串行跑完才能进 priority 阶段，没有短路能力

从 v1.15 起，调度器重构成 Scheduler Framework：将"过滤 / 打分 / 绑定"切成固定扩展点，每个扩展点可挂载多个插件。内置插件是出厂预装，第三方可以 OutOfTree 方式注册自己的插件。

1.1 传统调度器 vs 框架方案对比

维度	传统 monolithic（v1.14 及之前）	Scheduler Framework + 内置插件（v1.15+）
扩展性	改源码 + 重新编译	OutOfTree 注册自定义插件
代码组织	所有 predicate/priority 堆在主文件	每个插件独占一个目录
替换单个策略	无法实现	SchedulerConfiguration 中 disablePlugin 禁用
短路能力	所有 predicate 必须跑完	UnschedulableAndUnresolvable 立刻中断
调试可见性	日志看不到哪个 predicate 失败	每个插件返回 Status 带 reason，describe pod 可看
扩展点数量	硬编码：预选 -> 优选 -> 绑定	14 个扩展点（PreEnqueue ~ Bind）

二、插件总览与调度流水线

2.1 两阶段决策模型

调度器对每个 Pod 的决策分为两个阶段：

┌──────────────────────────────────────────────────────────────┐ │ Filter（硬门槛，行/不行） │ │ │ │ NodeResourcesFit ──► NodeAffinity ──► TaintToleration │ │ │ │ │ │ │ 资源够吗？ 节点 label 匹配？ 容忍污点吗？ │ │ │ │ │ │ │ ▼ ▼ ▼ │ │ 任一插件返回 UnschedulableAndUnresolvable ──► 短路跳过 │ └──────────────────────────────────────────────────────────────┘ ┌──────────────────────────────────────────────────────────────┐ │ Score（软打分，好/更好） │ │ │ │ NodeResourcesFit ──► NodeAffinity ──► TaintToleration │ │ InterPodAffinity ──► PodTopologySpread ──► VolumeBinding │ │ │ │ │ │ │ 资源越闲越分高 亲和匹配越少越分高 卷容量越足越分高 │ │ │ │ ▼ NormalizeScore（归一化到 0-MaxNodeScore） │ │ 所有分数加权求和 ──► 选出分数最高节点 ──► Bind │ └──────────────────────────────────────────────────────────────┘

2.2 插件名称常量（names/names.go, L19-43）

所有内置插件的名字都定义在同一 const 块中，NewInTreeRegistry() 通过这个名字映射到对应的工厂函数：

pkg/scheduler/framework/plugins/names/names.go (L19-43, k8s v1.36.1)

const (
    NodeResourcesFit               = "NodeResourcesFit"
    NodeAffinity                  = "NodeAffinity"
    TaintToleration              = "TaintToleration"
    InterPodAffinity             = "InterPodAffinity"
    PodTopologySpread            = "PodTopologySpread"
    VolumeBinding                = "VolumeBinding"
    NodeResourcesBalancedAllocation = "NodeResourcesBalancedAllocation"
    NodeUnschedulable            = "NodeUnschedulable"
    NodeVolumeLimits             = "NodeVolumeLimits"
    ImageLocality                = "ImageLocality"
    // ... 共 23 个内置插件，完整定义见 names.go L19-43
)

2.3 插件注册表（registry.go, L50-79）

pkg/scheduler/framework/plugins/registry.go (L50-79, k8s v1.36.1)

func NewInTreeRegistry() runtime.Registry {
    fts := plfeature.NewSchedulerFeaturesFromGates(feature.DefaultFeatureGate)
    registry := runtime.Registry{
        nodeaffinity.Name:        runtime.FactoryAdapter(fts, nodeaffinity.New),
        noderesources.Name:       runtime.FactoryAdapter(fts, noderesources.NewFit),
        tainttoleration.Name:     runtime.FactoryAdapter(fts, tainttoleration.New),
        podtopologyspread.Name:   runtime.FactoryAdapter(fts, podtopologyspread.New),
        volumebinding.Name:       runtime.FactoryAdapter(fts, volumebinding.New),
        interpodaffinity.Name:    runtime.FactoryAdapter(fts, interpodaffinity.New),
        // ... 共 25 个插件，完整注册见 registry.go L50-79
    }
    return registry
}

三、六大插件逐个精读

下面按调度流水线上的实际触发顺序，逐一拆解六个核心插件。每个插件统一六段式：核心职责 -> 设计目的 -> 源码精读 -> YAML 示例 -> 生产踩坑 -> FAQ。

3.1 NodeResourcesFit

源码精读

pkg/scheduler/framework/plugins/noderesources/fit.go (k8s v1.36.1)

// Fit struct 定义（L92-105）
type Fit struct {
    ignoredResources    sets.Set[string]
    ignoredResourceGroups sets.Set[string]
    enableInPlacePodVerticalScaling bool
    enableSidecarContainers        bool
    enableSchedulingQueueHint       bool
    enablePodLevelResources         bool
    enableDRAExtendedResource       bool
    handle                         fwk.Handle
    *resourceAllocationScorer       // 复用打分计算器
    placementScorer  *resourceAllocationScorer
}

// Filter 方法（L612-648）
// 核心逻辑：累加 pod 所有容器的 requests，对比 nodeInfo.Allocatable
// 任意资源不足 → 返回 Unschedulable 或 UnschedulableAndUnresolvable
func (f *Fit) Filter(ctx context.Context, cycleState fwk.CycleState,
    pod *v1.Pod, nodeInfo fwk.NodeInfo) *fwk.Status {
    s, err := getPreFilterState(cycleState)
    insufficientResources := fitsRequest(s, nodeInfo, ...)
    if len(insufficientResources) != 0 {
        statusCode := fwk.Unschedulable
        for _, ir := range insufficientResources {
            if ir.Unresolvable {
                statusCode = fwk.UnschedulableAndUnresolvable
            }
        }
        return fwk.NewStatus(statusCode, failureReasons...)
    }
    return nil
}

// Score 方法（L767-786）- LeastAllocated 默认策略
// 公式: score = (capacity - requested) * MaxNodeScore / capacity
// 越闲 → 分子越大 → 分越高
func (f *Fit) Score(ctx context.Context, state fwk.CycleState,
    pod *v1.Pod, nodeInfo fwk.NodeInfo) (int64, *fwk.Status) {
    s, err := getPreScoreState(state)
    return f.score(ctx, pod, nodeInfo, s.podRequests, s.draPreScoreState)
}

// EventsToRegister（L368-398）
// 关键事件：Pod 删除/缩容、节点 Add/UpdateNodeAllocatable/UpdateNodeTaint/UpdateNodeLabel
// 配合 enableSchedulingQueueHint 时，只注册 Add | UpdateNodeAllocatable 减少无效重试

YAML 配置示例

# 触发 NodeResourcesFit 的 Pod（k8s v1.36.1）
apiVersion: v1
kind: Pod
metadata:
  name: resource-demo
spec:
  containers:
  - name: nginx
    image: nginx:1.25
    resources:
      requests:
        cpu: "2000m"
        memory: "512Mi"
      limits:
        cpu: "4000m"
        memory: "1Gi"

3.2 NodeAffinity

pkg/scheduler/framework/plugins/nodeaffinity/node_affinity.go (k8s v1.36.1)

// NodeAffinity struct（L38-44）
type NodeAffinity struct {
    handle                fwk.Handle
    addedNodeSelector    *nodeaffinity.NodeSelector   // 配置级追加的选择器
    addedPrefSchedTerms *nodeaffinity.PreferredSchedulingTerms
    enableSchedulingQueueHint bool
}

// Filter（L216-239）- 硬条件匹配
func (pl *NodeAffinity) Filter(ctx context.Context, state fwk.CycleState,
    pod *v1.Pod, nodeInfo fwk.NodeInfo) *fwk.Status {
    node := nodeInfo.Node()
    // 配置级追加的选择器优先判断
    if pl.addedNodeSelector != nil && !pl.addedNodeSelector.Match(node) {
        return fwk.NewStatus(fwk.UnschedulableAndUnresolvable, errReasonEnforced)
    }
    // requiredDuringSchedulingIgnoredDuringExecution 硬匹配
    match, _ := s.requiredNodeSelectorAndAffinity.Match(node)
    if !match {
        return fwk.NewStatus(fwk.UnschedulableAndUnresolvable, ErrReasonPod)
    }
    return nil
}

// Score（L269-297）- 软偏好打分
func (pl *NodeAffinity) Score(ctx context.Context, state fwk.CycleState,
    pod *v1.Pod, nodeInfo fwk.NodeInfo) (int64, *fwk.Status) {
    node := nodeInfo.Node()
    var count int64
    // 累加匹配的 preferred terms 权重
    if pl.addedPrefSchedTerms != nil {
        count += pl.addedPrefSchedTerms.Score(node)
    }
    if s.preferredNodeAffinity != nil {
        count += s.preferredNodeAffinity.Score(node)
    }
    return count, nil
}

# 触发 NodeAffinity 的 Pod（k8s v1.36.1）
# 必须调度到 node-type=general 或 compute 节点
apiVersion: v1
kind: Pod
metadata:
  name: affinity-demo
spec:
  nodeSelector:
    az: cn-east-1
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchExpressions:
          - key: node-type
            operator: In
            values: [general, compute]
      preferredDuringSchedulingIgnoredDuringExecution:
      - weight: 100
        preference:
          matchExpressions:
          - key: az
            operator: In
            values: [cn-east-1]

3.3 TaintToleration

pkg/scheduler/framework/plugins/tainttoleration/taint_toleration.go (k8s v1.36.1)

// TaintToleration struct（L34-39）
type TaintToleration struct {
    handle                                    fwk.Handle
    enableSchedulingQueueHint                bool
    enableTaintTolerationComparisonOperators bool  // 支持 Exists 操作符
}

// ErrReasonNotMatch（L47-54）
const (
    Name = names.TaintToleration
    ErrReasonNotMatch = "node(s) had taints that the pod didn't tolerate"
)

// Filter（L118-132）
// 核心：调用 FindMatchingUntoleratedTaint 找无法容忍的污点
// NoSchedule/NoExecute 污点无匹配 → UnschedulableAndUnresolvable
func (pl *TaintToleration) Filter(ctx context.Context, state fwk.CycleState,
    pod *v1.Pod, nodeInfo fwk.NodeInfo) *fwk.Status {
    logger := klog.FromContext(ctx)
    node := nodeInfo.Node()
    taint, isUntolerated := v1helper.FindMatchingUntoleratedTaint(
        logger, node.Spec.Taints, pod.Spec.Tolerations,
        helper.DoNotScheduleTaintsFilterFunc(),
        pl.enableTaintTolerationComparisonOperators)
    if !isUntolerated {
        return nil
    }
    return fwk.NewStatus(fwk.UnschedulableAndUnresolvable,
        "node(s) had untolerated taint(s)")
}

// Score（L194-207）
// 无法容忍的 PreferNoSchedule 污点越多 → 分越低（越不想去）
func (pl *TaintToleration) Score(ctx context.Context, state fwk.CycleState,
    pod *v1.Pod, nodeInfo fwk.NodeInfo) (int64, *fwk.Status) {
    logger := klog.FromContext(ctx)
    node := nodeInfo.Node()
    s, err := getPreScoreState(state)
    score := int64(pl.countIntolerableTaintsPreferNoSchedule(
        logger, node.Spec.Taints, s.tolerationsPreferNoSchedule))
    return score, nil
}

# 触发 TaintToleration 的 Pod（k8s v1.36.1）
apiVersion: v1
kind: Pod
metadata:
  name: taint-demo
spec:
  tolerations:
  - key: "dedicated"
    operator: "Equal"
    value: "true"
    effect: "NoSchedule"
  # 关键业务：对 not-ready/unreachable 延迟 5 分钟驱逐
  - key: "node.kubernetes.io/not-ready"
    operator: "Exists"
    effect: "NoExecute"
    tolerationSeconds: 300
  - key: "node.kubernetes.io/unreachable"
    operator: "Exists"
    effect: "NoExecute"
    tolerationSeconds: 300

3.4 InterPodAffinity

pkg/scheduler/framework/plugins/interpodaffinity/ (k8s v1.36.1)

// InterPodAffinity struct（plugin.go L46-53）
type InterPodAffinity struct {
    parallelizer              fwk.Parallelizer
    args                     config.InterPodAffinityArgs
    sharedLister             fwk.SharedLister    // 访问所有 Pod / Node
    nsLister                 listersv1.NamespaceLister
    enableSchedulingQueueHint bool
}

// Filter（filtering.go L410-432）
// 三层判断：Pod 亲和 -> Pod 反亲和 -> 已有 Pod 反亲和
// 任一层不满足 → 返回 Unschedulable 或 UnschedulableAndUnresolvable
func (pl *InterPodAffinity) Filter(ctx context.Context, cycleState fwk.CycleState,
    pod *v1.Pod, nodeInfo fwk.NodeInfo) *fwk.Status {
    state, err := getPreFilterState(cycleState)
    if !satisfyPodAffinity(state, nodeInfo) {
        return fwk.NewStatus(fwk.UnschedulableAndUnresolvable, ErrReasonAffinityRulesNotMatch)
    }
    if !satisfyPodAntiAffinity(state, nodeInfo) {
        return fwk.NewStatus(fwk.Unschedulable, ErrReasonAntiAffinityRulesNotMatch)
    }
    if !satisfyExistingPodsAntiAffinity(state, nodeInfo) {
        return fwk.NewStatus(fwk.Unschedulable, ErrReasonExistingAntiAffinityRulesNotMatch)
    }
    return nil
}

// Score（scoring.go L236-255）
// 统计节点拓扑域内匹配的 Pod 数，越少分越高（反亲和）或越高（亲和）
func (pl *InterPodAffinity) Score(ctx context.Context, cycleState fwk.CycleState,
    pod *v1.Pod, nodeInfo fwk.NodeInfo) (int64, *fwk.Status) {
    node := nodeInfo.Node()
    s, err := getPreScoreState(cycleState)
    var score int64
    for tpKey, tpValues := range s.topologyScore {
        if v, exist := node.Labels[tpKey]; exist {
            score += tpValues[v]
        }
    }
    return score, nil
}

# 触发 InterPodAffinity 的 Pod（k8s v1.36.1）
# web 和 redis 必须分布在不同 zone（反亲和）
apiVersion: v1
kind: Pod
metadata:
  name: web-pod
spec:
  affinity:
    podAntiAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
      - labelSelector:
          matchLabels:
            app: redis-cache
        topologyKey: topology.kubernetes.io/zone
    podAffinity:
      preferredDuringSchedulingIgnoredDuringExecution:
      - weight: 100
        podAffinityTerm:
          labelSelector:
            matchLabels:
              app: web-frontend
          topologyKey: topology.kubernetes.io/zone

3.5 PodTopologySpread

pkg/scheduler/framework/plugins/podtopologyspread/plugin.go (k8s v1.36.1)

// PodTopologySpread struct（L59-73）
type PodTopologySpread struct {
    systemDefaulted         bool   // 是否为 system 自动注入的约束
    defaultConstraints    []v1.TopologySpreadConstraint
    sharedLister          fwk.SharedLister
    services              corelisters.ServiceLister
    replicaSets           appslisters.ReplicaSetLister
    statefulSets          appslisters.StatefulSetLister
    enableMatchLabelKeysInPodTopologySpread bool
    enableSchedulingQueueHint                 bool
    enableTaintTolerationComparisonOperators  bool
}

// Filter：skew = count(匹配Pod) - min(所有拓扑域匹配数)
// 超过 maxSkew → UnschedulableAndUnresolvable

// Score：
//   scoreForCount(cnt, maxSkew, tpWeight) = cnt * tpWeight + (maxSkew - 1)
//   匹配 Pod 越少 → skew 越小 → 分越高

# PodTopologySpread skew 计算示例 假设 3 个 zone，各有 Pod 数： zone-a: 5 个 Pod ← skew = 5 - 2 = 3 ← 超过 maxSkew zone-b: 2 个 Pod ← skew = 2 - 2 = 0 ← OK zone-c: 2 个 Pod ← skew = 2 - 2 = 0 ← OK 若 maxSkew = 2： → zone-a 超过 maxSkew，新 Pod 无法调度到 zone-a → 只能调度到 zone-b 或 zone-c 若 whenUnsatisfiable = ScheduleAnyway： → 允许调度到 zone-a，但记录拓扑违规

# 触发 PodTopologySpread 的 Pod（k8s v1.36.1）
# 让 demo-app 副本均匀分布在 zone 级别，maxSkew=1
apiVersion: v1
kind: Pod
metadata:
  name: topology-spread-demo
spec:
  topologySpreadConstraints:
  - maxSkew: 1
    topologyKey: topology.kubernetes.io/zone
    whenUnsatisfiable: DoNotSchedule  # 硬约束
    labelSelector:
      matchLabels:
        app: demo-app
  - maxSkew: 2
    topologyKey: topology.kubernetes.io/hostname
    whenUnsatisfiable: ScheduleAnyway  # 软约束
    labelSelector:
      matchLabels:
        app: demo-app

3.6 VolumeBinding（跨四阶段）

pkg/scheduler/framework/plugins/volumebinding/ (k8s v1.36.1)

// VolumeBinding struct（volume_binding.go L70-79）
type VolumeBinding struct {
    Binder      SchedulerVolumeBinder  // 核心绑定器接口
    PVCLister   corelisters.PersistentVolumeClaimLister
    classLister storagelisters.StorageClassLister
    scorer      volumeCapacityScorer   // 容量打分器（alpha）
    fts         feature.Features
}

// SchedulerVolumeBinder 接口（binder.go L153-196）
type SchedulerVolumeBinder interface {
    // 获取 Pod 所有 PVC（已绑定 / 延迟绑定 / 立即绑定）
    GetPodVolumeClaims(pod *v1.Pod) (*PodVolumeClaims, error)
    // 查找匹配的 PV，检查节点亲和/容量/拓扑
    FindPodVolumes(pod, node) (*PodVolumes, ConflictReasons, error)
    // PreFilter 阶段：假设能绑，提前写入 AssumeCache
    AssumePodVolumes(assumedPod, nodeName, volumes) (allFullyBound bool, err error)
    // 绑定失败时回退
    RevertAssumedPodVolumes(volumes)
    // PreBind 阶段：提交真实绑定到 etcd
    BindPodVolumes(ctx, assumedPod, volumes) error
}

// Filter（volume_binding.go L409-453）
// 调用 FindPodVolumes 检查 PV 节点亲和/容量/拓扑匹配
// 匹配失败 → UnschedulableAndUnresolvable（无任何节点可满足）
func (pl *VolumeBinding) Filter(ctx context.Context, cs fwk.CycleState,
    pod *v1.Pod, nodeInfo fwk.NodeInfo) *fwk.Status {
    logger := klog.FromContext(ctx)
    node := nodeInfo.Node()
    podVolumes, reasons, err := pl.Binder.FindPodVolumes(
        logger, pod, state.podVolumeClaims, node)
    if len(reasons) > 0 {
        status := fwk.NewStatus(fwk.UnschedulableAndUnresolvable)
        for _, reason := range reasons {
            status.AppendReason(string(reason))
        }
        return status
    }
    state.Lock()
    state.podVolumesByNode[node.Name] = podVolumes
    state.Unlock()
    return nil
}

// Score（volume_binding.go L470-523）
// 节点指定 StorageClass 剩余容量越多 → 分越高
// 需要 --feature-gates=StorageCapacityScoring=true（alpha）
func (pl *VolumeBinding) Score(...) (int64, *fwk.Status) {
    if pl.scorer == nil { return 0, nil }
    // 按 StorageClass 分组，计算剩余容量
    // broken linear function：剩余越多分越高
    return pl.scorer(classResources), nil
}

# 触发 VolumeBinding 的 Pod（k8s v1.36.1）
apiVersion: v1
kind: Pod
metadata:
  name: volume-demo
spec:
  containers:
  - name: app
    image: nginx
    volumeMounts:
    - name: data
      mountPath: /usr/share/nginx/html
  volumes:
  - name: data
    persistentVolumeClaim:
      claimName: my-pvc

---
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: fast-ssd
provisioner: pd.csi.storage.gke.io
parameters:
  type: pd-ssd
volumeBindingMode: WaitForFirstConsumer  # 关键：延迟绑定
allowVolumeExpansion: true

四、插件对比总结表

插件	Filter 职责	Score 职责	跨越阶段	核心数据结构
NodeResourcesFit	CPU/内存/GPU/临时存储是否足够	LeastAllocated 最闲优先（默认）	Filter / Score	resourceAllocationScorer
NodeAffinity	nodeSelector + nodeAffinity required 硬匹配	preferred 软偏好打分	Filter / Score	nodeaffinity.NodeSelector
TaintToleration	NoSchedule/NoExecute 污点容忍判断	PreferNoSchedule 污点越多分越低	Filter / Score	Toleration[] vs NodeSpec.Taints[]
InterPodAffinity	硬亲和/反亲和拓扑域匹配	软亲和/反亲和加权打分	Filter / Score	WeightedPodAffinityTerm[]
PodTopologySpread	拓扑域 skew 是否超过 maxSkew	匹配 Pod 数越少分越高	Filter / Score	TopologySpreadConstraint[]
VolumeBinding	PV 节点亲和/容量/拓扑匹配	StorageClass 剩余容量打分（alpha）	PreFilter / Filter / Reserve / PreBind	SchedulerVolumeBinder

五、生产踩坑实录

坑一：NodeResourcesFit 漏算了 Pod 级 resources（生产高危）

根因：v1.26 之前 NodeResourcesFit 读取的是 container[].resources.limits 计算资源；v1.26 起改为读取 container[].resources.requests。如果 Pod 只写了 limits 没写 requests，v1.26+ 的行为与之前不一致。

排查命令：

# 查看节点真实 Allocatable
kubectl describe node <node-name> | grep -A5 "Allocated resources"

# 查看 Pod 实际 requests/limits
kubectl get pod <pod-name> -o jsonpath='{.spec.containers[*].resources}'

# 开启调度器详细日志
kubectl get pod <pod-name> -n kube-system -o jsonpath='{.spec.nodeName}' 2>/dev/null || echo "未调度"

修复：

containers:
- name: gpu-worker
  resources:
    requests:
      nvidia.com/gpu: "1"   # v1.26+ 必须显式声明
    limits:
      nvidia.com/gpu: "1"

坑二：NodeAffinity required 条件与节点 label 同步延迟

根因：调度器通过 node informer 同步节点 label。如果 Pod 提交后、调度前 label 刚更新但 informer 还未同步完成，调度器看到的是旧数据。Filter 阶段匹配失败。

修复：使用 preferredDuringSchedulingIgnoredDuringExecution 替代硬匹配，或确保 Pod 提交前 label 已存在。

坑三：InterPodAffinity 硬亲和导致死锁

根因：requiredDuringSchedulingIgnoredDuringExecution 的硬亲和在 Filter 阶段强制要求拓扑域内已有匹配 Pod。初始部署时双方 Pod 互相依赖，出现"鸡生蛋蛋生鸡"的死锁。

修复：将 required 改为 preferred，降低初始部署阶段的耦合度。

坑四：PodTopologySpread 隐式注入 defaultConstraints

根因：v1.27+ 中，当 Pod 不声明约束且 SchedulerConfiguration 的 defaultingType = SystemDefaulting 时，PodTopologySpread 自动注入 hostname skew=3 和 zone skew=5 两个 system-defaulted 约束。

修复：显式声明自己的约束覆盖默认行为，或在 SchedulerConfiguration 中把 defaultingType 设为 CustomDefaulting 并清空 defaultConstraints。

坑五：VolumeBinding AssumeCache 导致的调度死循环

根因：VolumeBinding 在 PreFilter 阶段假设 PVC 能绑定。如果 StorageClass 是 WaitForFirstConsumer，真正绑定要等 Pod 调度到节点后才触发。假设期间节点信息变化（污点/label 更新），AssumeCache 里的假设失效，导致调度循环。

修复：确保 Pod 的 nodeSelector 或亲和性先选定候选节点，再让 PVC 在该节点附近绑定。

六、FAQ 高频答疑（分类版）

6.1 基础概念（5 题）

6.2 源码原理（8 题）

6.3 生产实践（9 题）

---