【转载】调度插件之PodTopologySpread

油腻中年李大鹅
1,168 阅读17分钟

Pod拓扑分布约束

在 k8s 集群调度中，“亲和性”相关的概念本质上都是控制 Pod 如何被调度——堆叠或是打散。目前 k8s 提供了 podAffinity 以及 podAntiAffinity 两个特性对 Pod 在不同拓扑域的分布进行了一些控制，podAffinity 可以将无数个 Pod 调度到特定的某一个拓扑域，这是堆叠的体现；podAntiAffinity 则可以控制一个拓扑域只存在一个 Pod，这是打散的体现。

但这两种情况都太极端了，在不少场景下都无法达到理想的效果，例如为了实现容灾和高可用，将业务 Pod 尽可能均匀的分布在不同可用区就很难实现。

PodTopologySpread 特性的提出正是为了对 Pod 的调度分布提供更精细的控制，以提高服务可用性以及资源利用率，PodTopologySpread 由 EvenPodsSpread 特性门所控制，在 v1.16 版本第一次发布，并在 v1.18 版本进入 beta 阶段默认启用。再了解这个插件是如何实现之前，我们首先需要搞清楚这个特性是如何使用的。

使用规范

在 Pod 的 Spec 规范中新增了一个 topologySpreadConstraints 字段：

spec:
  topologySpreadConstraints:
  - maxSkew: <integer>
    topologyKey: <string>
    whenUnsatisfiable: <string>
    labelSelector: <object>

由于这个新增的字段是在 Pod spec 层面添加，因此更高层级的控制 (Deployment、DaemonSet、StatefulSet) 也能使用 PodTopologySpread 功能。

topologySpreadConstraints.png

让我们结合上图来理解 topologySpreadConstraints 中各个字段的含义和作用：

  • labelSelector: 用来查找匹配的 Pod，我们能够计算出每个拓扑域中匹配该 label selector 的 Pod 数量，在上图中，假如 label selector 是 app:foo，那么 zone1 的匹配个数为 2， zone2 的匹配个数为 0。
  • topologyKey: 是 Node label 的 key，如果两个 Node 的 label 同时具有该 key 并且 label 值相同，就说它们在同一个拓扑域。在上图中，指定 topologyKey 为 zone， 具有 zone=zone1 标签的 Node 被分在一个拓扑域，具有 zone=zone2 标签的 Node 被分在另一个拓扑域。
  • maxSkew: 描述了 Pod 在不同拓扑域中不均匀分布的最大程度，maxSkew 的取值必须大于 0。每个拓扑域都有一个 skew，计算的公式是: skew[i] = 拓扑域[i]中匹配的 Pod 个数 - min{其他拓扑域中匹配的 Pod 个数}。在上图中，我们新建一个带有 app=foo 标签的 Pod：
    • 如果该 Pod 被调度到 zone1，那么 zone1 中 Node 的 skew 值变为 3，zone2 中 Node 的 skew 值变为 0 (zone1 有 3 个匹配的 Pod，zone2 有 0 个匹配的 Pod )
    • 如果该 Pod 被调度到 zone2，那么 zone1 中 Node 的 skew 值变为 1，zone2 中 Node 的 skew 值变为 0 (zone2 有 1 个匹配的 Pod，拥有全局最小匹配 Pod 数的拓扑域正是 zone2 自己 )
  • whenUnsatisfiable: 描述了如果 Pod 不满足分布约束条件该采取何种策略：
    • DoNotSchedule (默认) 告诉调度器不要调度该 Pod，因此也可以叫作硬策略；
    • ScheduleAnyway 告诉调度器根据每个 Node 的 skew 值打分排序后仍然调度，因此也可以叫作软策略。

单个 TopologySpreadConstraint

假设你拥有一个 4 节点集群，其中标记为 foo:bar 的 3 个 Pod 分别位于 node1、node2 和 node3 中：

20210325153609.png

如果希望新来的 Pod 均匀分布在现有的可用区域，则可以按如下设置其约束：

kind: Pod
apiVersion: v1
metadata:
  name: mypod
  labels:
    foo: bar
spec:
  topologySpreadConstraints:
  - maxSkew: 1
    topologyKey: zone
    whenUnsatisfiable: DoNotSchedule
    labelSelector:
      matchLabels:
        foo: bar
  containers:
  - name: pause
    image: k8s.gcr.io/pause:3.1

topologyKey: zone 意味着均匀分布将只应用于存在标签键值对为 zone: 的节点。 whenUnsatisfiable: DoNotSchedule 告诉调度器如果新的 Pod 不满足约束，则不可调度。如果调度器将新的 Pod 放入 "zoneA"，Pods 分布将变为 [3, 1]，因此实际的偏差为 2 (3 - 1)，这违反了 maxSkew: 1 的约定。此示例中，新 Pod 只能放置在 "zoneB" 上：

20210325153809.png

或者：

20210325153830.png

你可以调整 Pod 约束以满足各种要求：

  • 将 maxSkew 更改为更大的值，比如 "2"，这样新的 Pod 也可以放在 "zoneA" 上。
  • 将 topologyKey 更改为 "node"，以便将 Pod 均匀分布在节点上而不是区域中。 在上面的例子中，如果 maxSkew 保持为 "1"，那么传入的 Pod 只能放在 "node4" 上。
  • 将 whenUnsatisfiable: DoNotSchedule 更改为 whenUnsatisfiable: ScheduleAnyway， 以确保新的 Pod 可以被调度。

多个 TopologySpreadConstraint

下面的例子建立在前面例子的基础上来对多个 Pod 拓扑分布约束进行说明。假设你拥有一个 4 节点集群，其中 3 个标记为 foo:bar 的 Pod 分别位于 node1、node2 和 node3 上：

20210325153609.png

可以使用 2 个 TopologySpreadConstraint 来控制 Pod 在 区域和节点两个维度上的分布：

# two-constraints.yaml
kind: Pod
apiVersion: v1
metadata:
  name: mypod
  labels:
    foo: bar
spec:
  topologySpreadConstraints:
  - maxSkew: 1
    topologyKey: zone
    whenUnsatisfiable: DoNotSchedule
    labelSelector:
      matchLabels:
        foo: bar
  - maxSkew: 1
    topologyKey: node
    whenUnsatisfiable: DoNotSchedule
    labelSelector:
      matchLabels:
        foo: bar
  containers:
  - name: pause
    image: k8s.gcr.io/pause:3.1

在这种情况下，为了匹配第一个约束，新的 Pod 只能放置在 "zoneB" 中；而在第二个约束中， 新的 Pod 只能放置在 "node4" 上，最后两个约束的结果加在一起，唯一可行的选择是放置 在 "node4" 上。

多个约束之间可能存在冲突，假设有一个跨越 2 个区域的 3 节点集群：

20210325154257.png

如果对集群应用 two-constraints.yaml，会发现 "mypod" 处于Pending状态，这是因为为了满足第一个约束，"mypod" 只能放在 "zoneB" 中，而第二个约束要求 "mypod" 只能放在 "node2" 上，Pod 调度无法满足这两种约束，所以就冲突了。

为了克服这种情况，你可以增加 maxSkew 或修改其中一个约束，让其使用 whenUnsatisfiable: ScheduleAnyway。

集群默认约束

除了为单个 Pod 设置拓扑分布约束，也可以为集群设置默认的拓扑分布约束，默认拓扑分布约束在且仅在以下条件满足 时才会应用到 Pod 上：

  • Pod 没有在其 .spec.topologySpreadConstraints 设置任何约束；
  • Pod 隶属于某个服务、副本控制器、ReplicaSet 或 StatefulSet。

你可以在 调度方案（Schedulingg Profile）中将默认约束作为 PodTopologySpread 插件参数的一部分来进行设置。 约束的设置采用和前面 Pod 中的规范一致，只是 labelSelector 必须为空。配置的示例可能看起来像下面这个样子：

apiVersion: kubescheduler.config.k8s.io/v1beta1
kind: KubeSchedulerConfiguration

profiles:
  - pluginConfig:
      - name: PodTopologySpread
        args:
          defaultConstraints:
            - maxSkew: 1
              topologyKey: topology.kubernetes.io/zone
              whenUnsatisfiable: ScheduleAnyway
          defaultingType: List

预选

前面了解了如何使用Pod拓扑分布约束，接下来就可以看看调度器中对应的插件是如何实现的了。

PreFilter

首先也是去查看这个插件的 PreFilter 函数的实现：

// pkg/scheduler/framework/plugins/podtopologyspread/filtering.go

// PreFilter invoked at the prefilter extension point.
// 在PreFilter扩展点调用PreFilter。
func (pl *PodTopologySpread) PreFilter(ctx context.Context, cycleState *framework.CycleState, pod *v1.Pod) (*framework.PreFilterResult, *framework.Status) {
	s, err := pl.calPreFilterState(ctx, pod)
	if err != nil {
		return nil, framework.AsStatus(err)
	}
	cycleState.Write(preFilterStateKey, s)
	return nil, nil
}

这里最核心的就是 calPreFilterState 函数，该函数用来计算描述如何在拓扑域上传递 Pod 的 preFilterState 状态数据，在了解该函数如何实现之前，我们需要先弄明白 preFilterState 的定义：

// pkg/scheduler/framework/plugins/podtopologyspread/common.go

type topologyPair struct {
	key   string
	value string
}

// topologySpreadConstraint is an internal version for v1.TopologySpreadConstraint
// and where the selector is parsed.
// Fields are exported for comparison during testing.
// topologySpreadConstraint是v1.TopologySpreadConstraint的内部版本，用于解析选择器。
// 将字段导出以供测试时进行比较。
type topologySpreadConstraint struct {
	MaxSkew     int32
	TopologyKey string
	Selector    labels.Selector
	MinDomains  int32
}


// pkg/scheduler/framework/plugins/podtopologyspread/filtering.go

const preFilterStateKey = "PreFilter" + Name

// CAVEAT: the reason that `[2]criticalPath` can work is based on the implementation of current
// preemption algorithm, in particular the following 2 facts:
// Fact 1: we only preempt pods on the same node, instead of pods on multiple nodes.
// Fact 2: each node is evaluated on a separate copy of the preFilterState during its preemption cycle.
// If we plan to turn to a more complex algorithm like "arbitrary pods on multiple nodes", this
// structure needs to be revisited.
// Fields are exported for comparison during testing.

// 警告：“[2]criticalPath”之所以能够工作，是基于当前抢占算法的实现，尤其是以下两个事实：
// 事实1：我们只抢占同一节点上的Pod，而不是多个节点上的Pod。
// 事实2：在抢占周期中，每个节点在preFilterState的单独副本上进行评估。
// 如果我们计划转向更复杂的算法，例如 “多个节点上的任意pod”，则需要重新审视这种结构。
// 测试时导出字段进行比较。
type criticalPaths [2]struct {
	// TopologyValue denotes the topology value mapping to topology key.
	// TopologyValue表示映射到拓扑键的拓扑值。
	TopologyValue string
	// MatchNum denotes the number of matching pods.
	// MatchNum表示匹配的pod数量。
	MatchNum int
}

preFukterState中定义了3个属性，在PreFilter处进行计算，在Filter中使用：

  • Constraints 用来保存定义的所有拓扑分布约束信息
  • TpKeyToCriticalPaths 是一个 map，以定义的拓扑 Key 为 Key，值是一个 criticalPaths 指针，criticalPaths 的定义不太好理解，是一个两个长度的结构体数组，结构体里面保存的是定义的拓扑对应的 Value 值以及该拓扑下匹配的 Pod 数量，而且需要注意的是这个数组的第一个元素中匹配数量是最小的（其实这里定义一个结构体就可以，只是为了保证获取到的是最小的匹配数量，就定义了两个，第二个是用来临时比较用的，真正有用的是第一个结构体）
  • TpPairToMatchNum 同样是一个 map，对应的 Key 是 topologyPair，这个类型其实就是一个拓扑对，Values 值就是这个拓扑对下匹配的 Pod 数

接下来我们分析calPreFilterState函数的实现：

// pkg/scheduler/framework/plugins/podtopologyspread/filtering.go

// calPreFilterState computes preFilterState describing how pods are spread on topologies.
// calPreFilterState计算描述POD如何在拓扑上分布的preFilterState。
func (pl *PodTopologySpread) calPreFilterState(ctx context.Context, pod *v1.Pod) (*preFilterState, error) {
	// 获取所有节点信息
	allNodes, err := pl.sharedLister.NodeInfos().List()
	if err != nil {
		return nil, fmt.Errorf("listing NodeInfos: %w", err)
	}
	var constraints []topologySpreadConstraint
	if len(pod.Spec.TopologySpreadConstraints) > 0 {
		// We have feature gating in APIServer to strip the spec
		// so don't need to re-check feature gate, just check length of Constraints.
		// 我们在APIServer中有功能门来剥离规范，所以不需要重新检查功能门，只需检查约束的长度。
		// 如果 Pod 中配置了 TopologySpreadConstraints,转换成这里的 topologySpreadConstraint 对象
		constraints, err = filterTopologySpreadConstraints(pod.Spec.TopologySpreadConstraints, v1.DoNotSchedule, pl.enableMinDomainsInPodTopologySpread)
		if err != nil {
			return nil, fmt.Errorf("obtaining pod's hard topology spread constraints: %w", err)
		}
	} else {
		// 获取默认的拓扑分布约束
		constraints, err = pl.buildDefaultConstraints(pod, v1.DoNotSchedule)
		if err != nil {
			return nil, fmt.Errorf("setting default hard topology spread constraints: %w", err)
		}
	}
	// 没有约束，直接返回
	if len(constraints) == 0 {
		return &preFilterState{}, nil
	}

	// 初始化 preFilterState 状态
	s := preFilterState{
		Constraints:          constraints,
		TpKeyToCriticalPaths: make(map[string]*criticalPaths, len(constraints)),
		TpPairToMatchNum:     make(map[topologyPair]int, sizeHeuristic(len(allNodes), constraints)),
	}

	requiredSchedulingTerm := nodeaffinity.GetRequiredNodeAffinity(pod)
	tpCountsByNode := make([]map[topologyPair]int, len(allNodes))
	processNode := func(i int) {
		nodeInfo := allNodes[i]
		node := nodeInfo.Node()
		if node == nil {
			klog.ErrorS(nil, "Node not found")
			return
		}
		// In accordance to design, if NodeAffinity or NodeSelector is defined,
		// spreading is applied to nodes that pass those filters.
		// Ignore parsing errors for backwards compatibility.
		// 根据设计，如果定义了NodeAffinity或NodeSelector，则扩展应用于通过这些过滤器的节点。
		// 忽略分析错误以实现向后兼容性。
		match, _ := requiredSchedulingTerm.Match(node)
		if !match {
			return
		}
		// Ensure current node's labels contains all topologyKeys in 'Constraints'.
		// 确保当前节点的标签包含‘Constraints’中的所有topologyKey。
		if !nodeLabelsMatchSpreadConstraints(node.Labels, constraints) {
			return
		}

		// 根据约束初始化拓扑树
		tpCounts := make(map[topologyPair]int, len(constraints))
		for _, c := range constraints {
			pair := topologyPair{key: c.TopologyKey, value: node.Labels[c.TopologyKey]}
			// 计算约束的拓扑域中匹配的 pod 数
			count := countPodsMatchSelector(nodeInfo.Pods, c.Selector, pod.Namespace)
			tpCounts[pair] = count
		}
		tpCountsByNode[i] = tpCounts
	}
	pl.parallelizer.Until(ctx, len(allNodes), processNode)

	for _, tpCounts := range tpCountsByNode {
		for tp, count := range tpCounts {
			s.TpPairToMatchNum[tp] += count
		}
	}
	if pl.enableMinDomainsInPodTopologySpread {
		s.TpKeyToDomainsNum = make(map[string]int, len(constraints))
		for tp := range s.TpPairToMatchNum {
			s.TpKeyToDomainsNum[tp.key]++
		}
	}

	// calculate min match for each topology pair
	// 计算每个拓扑对的最小匹配
	for i := 0; i < len(constraints); i++ {
		key := constraints[i].TopologyKey
		s.TpKeyToCriticalPaths[key] = newCriticalPaths()
	}
	for pair, num := range s.TpPairToMatchNum {
		s.TpKeyToCriticalPaths[pair.key].update(pair.value, num)
	}

	return &s, nil
}

// update 函数就是用来保证 criticalpPaths 中的第一个元素是最小的 Pod 匹配数
func (p *criticalPaths) update(tpVal string, num int) {
	// first verify if `tpVal` exists or not
	i := -1
	if tpVal == p[0].TopologyValue {
		i = 0
	} else if tpVal == p[1].TopologyValue {
		i = 1
	}

	if i >= 0 {
		// `tpVal` exists
		p[i].MatchNum = num
		if p[0].MatchNum > p[1].MatchNum {
			// swap paths[0] and paths[1]
			p[0], p[1] = p[1], p[0]
		}
	} else {
		// `tpVal` doesn't exist
		if num < p[0].MatchNum {
			// update paths[1] with paths[0]
			p[1] = p[0]
			// update paths[0]
			p[0].TopologyValue, p[0].MatchNum = tpVal, num
		} else if num < p[1].MatchNum {
			// update paths[1]
			p[1].TopologyValue, p[1].MatchNum = tpVal, num
		}
	}
}

首先判断Pod中是否定义了TopopogySpreadConstraint,如果定义了就回去转换成preFilterState中的COnstraints,如果没有定义需要查看是否为调度器配置了默认的拓扑分布约束，如果都没有就直接返回。

然后循环所有的节点，先根据NodeAffinity或者NodeSelector进行过滤，然后根据约束中定义的topologyKeys过滤节点。

接着计算每个节点下的拓扑对匹配的Pod数量，存入TpPairToMatchNum中，最后就是要把所有的约束中匹配的Pod数量最小(或稍大)的放入TpkeyToCrutucakPaths中保存起来。整个 preFilterState 保存下来传递到后续的插件中使用，比如在 filter 扩展点中同样也注册了这个插件，所以我们可以来查看下在 filter 中是如何实现的。

Filter

在 preFilter 阶段将 Pod 拓扑分布约束的相关信息存入到了 CycleState 中，下面在 filter 阶段中就可以来直接使用这些数据了：

// pkg/scheduler/framework/plugins/podtopologyspread/filtering.go

// Filter invoked at the filter extension point.
// 在Filter扩展点调用Filter
func (pl *PodTopologySpread) Filter(ctx context.Context, cycleState *framework.CycleState, pod *v1.Pod, nodeInfo *framework.NodeInfo) *framework.Status {
    node := nodeInfo.Node()
    if node == nil {
        return framework.AsStatus(fmt.Errorf("node not found"))
    }

    // 获取 preFilterState
    s, err := getPreFilterState(cycleState)
    if err != nil {
        return framework.AsStatus(err)
    }

    // However, "empty" preFilterState is legit which tolerates every toSchedule Pod.
    // 但是，“空” 预过滤状态是合法的，它可以容忍每个toSchedule Pod。
    if len(s.Constraints) == 0 {
        return nil
    }

    podLabelSet := labels.Set(pod.Labels)
    // 循环pod设置的约束
    for _, c := range s.Constraints {
        tpKey := c.TopologyKey
        // 检查当前节点是否有对应的拓扑key
        tpVal, ok := node.Labels[c.TopologyKey]
        if !ok {
            klog.V(5).InfoS("Node doesn't have required label", "node", klog.KObj(node), "label", tpKey)
            return framework.NewStatus(framework.UnschedulableAndUnresolvable, ErrReasonNodeLabelNotMatch)
        }

        selfMatchNum := 0
        if c.Selector.Matches(podLabelSet) {
            selfMatchNum = 1
        }

        pair := topologyPair{key: tpKey, value: tpVal}

        // judging criteria:
        // 'existing matching num' + 'if self-match (1 or 0)' - 'global minimum' <= 'maxSkew'
        minMatchNum, err := s.minMatchNum(tpKey, c.MinDomains, pl.enableMinDomainsInPodTopologySpread)
        if err != nil {
            klog.ErrorS(err, "Internal error occurred while retrieving value precalculated in PreFilter", "topologyKey", tpKey, "paths", s.TpKeyToCriticalPaths)
            continue
        }

        matchNum := 0
		// 获取当前节点所在的拓扑域匹配的Pod数量
        if tpCount, ok := s.TpPairToMatchNum[pair]; ok {
            matchNum = tpCount
        }
		
		// 如果匹配的pod数量 + 1 或者0 - 最小匹配数量 > MaxSkew
		// 则证明不满足约束条件
        skew := matchNum + selfMatchNum - minMatchNum
        if skew > int(c.MaxSkew) {
            klog.V(5).InfoS("Node failed spreadConstraint: matchNum + selfMatchNum - minMatchNum > maxSkew", "node", klog.KObj(node), "topologyKey", tpKey, "matchNum", matchNum, "selfMatchNum", selfMatchNum, "minMatchNum", minMatchNum, "maxSkew", c.MaxSkew)
            return framework.NewStatus(framework.Unschedulable, ErrReasonConstraintsNotMatch)
        }
    }

    return nil
}

首先通过 CycleState 获取 preFilterState ，如果没有配置约束或者拓扑对匹配数量为0这直接返回了。

然后循环定义的拓扑约束，先检查当前节点是否有对应的 TopologyKey，没有就返回错误，然后判断拓扑对的分布程度是否大于 MaxSkew，判断方式为拓扑中匹配的 Pod 数量 + 1/0(如果 Pod 本身也匹配则为1) - 最小的 Pod 匹配数量 > MaxSkew ，这个也是前面我们在关于 Pod 拓扑分布约束中的 maxSkew 的含义描述的意思。

优选

PreScore 与 Score

同样首先需要调用PreScore函数进行打分钱的一些准备，把打分的数据存储起来：

// pkg/scheduler/framework/plugins/podtopologyspread/scoring.go

// preScoreState computed at PreScore and used at Score.
// Fields are exported for comparison during testing.
// preScoreState在PreScore上计算，在Score上使用
// 将字段导出以供测试时进行比较。
type preScoreState struct {
	// 定义的约束
	Constraints []topologySpreadConstraint
	// IgnoredNodes is a set of node names which miss some Constraints[*].topologyKey.
	// IgnoredNodes 是一组 miss 掉 Constraints[*].topologyKey 的节点名称
	IgnoredNodes sets.String
	// TopologyPairToPodCounts is keyed with topologyPair, and valued with the number of matching pods.
	// TopologyPairToPodCounts 以 topologyPair 为键，以匹配的 Pod 数量为值
	TopologyPairToPodCounts map[topologyPair]*int64
	// TopologyNormalizingWeight is the weight we give to the counts per topology.
	// This allows the pod counts of smaller topologies to not be watered down by
	// bigger ones.
	// TopologyNormalizingWeight 是我们给每个拓扑的计数的权重
	// 这使得较小的拓扑的 Pod 数不会被较大的稀释
	TopologyNormalizingWeight []float64
}

// initPreScoreState iterates "filteredNodes" to filter out the nodes which
// don't have required topologyKey(s), and initialize:
// 1) s.TopologyPairToPodCounts: keyed with both eligible topology pair and node names.
// 2) s.IgnoredNodes: the set of nodes that shouldn't be scored.
// 3) s.TopologyNormalizingWeight: The weight to be given to each constraint based on the number of values in a topology.
// initPreScoreState 迭代 "filteredNodes" 来过滤掉没有设置 topologyKey 的节点，并进行初始化：
// 1) s.TopologyPairToPodCounts: 以符合条件的拓扑对和节点名称为键
// 2) s.IgnoredNodes: 不应得分的节点集合
// 3) s.TopologyNormalizingWeight: 根据拓扑结构中的数值数量给予每个约束的权重
func (pl *PodTopologySpread) initPreScoreState(s *preScoreState, pod *v1.Pod, filteredNodes []*v1.Node, requireAllTopologies bool) error {
	var err error
	// 将 Pod 或默认定义的约束转换到 Constraints 中
	if len(pod.Spec.TopologySpreadConstraints) > 0 {
		s.Constraints, err = filterTopologySpreadConstraints(pod.Spec.TopologySpreadConstraints, v1.ScheduleAnyway, pl.enableMinDomainsInPodTopologySpread)
		if err != nil {
			return fmt.Errorf("obtaining pod's soft topology spread constraints: %w", err)
		}
	} else {
		s.Constraints, err = pl.buildDefaultConstraints(pod, v1.ScheduleAnyway)
		if err != nil {
			return fmt.Errorf("setting default soft topology spread constraints: %w", err)
		}
	}
	if len(s.Constraints) == 0 {
		return nil
	}
	topoSize := make([]int, len(s.Constraints))
	// 循环过滤节点得到的所有节点
	for _, node := range filteredNodes {
		if requireAllTopologies && !nodeLabelsMatchSpreadConstraints(node.Labels, s.Constraints) {
			// Nodes which don't have all required topologyKeys present are ignored
			// when scoring later.
			// 后面打分时，没有全部所需 topologyKeys 的节点会被忽略
			s.IgnoredNodes.Insert(node.Name)
			continue
		}
		// 循环约束条件
		for i, constraint := range s.Constraints {
			// per-node counts are calculated during Score.
			// 每个节点的计数在计分时计算
			if constraint.TopologyKey == v1.LabelHostname {
				continue
			}
			
			// 拓扑对初始化
			pair := topologyPair{key: constraint.TopologyKey, value: node.Labels[constraint.TopologyKey]}
			if s.TopologyPairToPodCounts[pair] == nil {
				s.TopologyPairToPodCounts[pair] = new(int64)
				topoSize[i]++
			}
		}
	}

	s.TopologyNormalizingWeight = make([]float64, len(s.Constraints))
	for i, c := range s.Constraints {
		sz := topoSize[i] // 拓扑约束数量
		if c.TopologyKey == v1.LabelHostname {
			// 如果 TopologyKey 是 Hostname 标签
			sz = len(filteredNodes) - len(s.IgnoredNodes)
		}
		// 计算拓扑约束的权重
		s.TopologyNormalizingWeight[i] = topologyNormalizingWeight(sz)
	}
	return nil
}


// topologyNormalizingWeight calculates the weight for the topology, based on
// the number of values that exist for a topology.
// Since <size> is at least 1 (all nodes that passed the Filters are in the
// same topology), and k8s supports 5k nodes, the result is in the interval
// <1.09, 8.52>.
//
// Note: <size> could also be zero when no nodes have the required topologies,
// however we don't care about topology weight in this case as we return a 0
// score for all nodes.

// topologyNormalizingWeight 根据拓扑存在的值的数量，计算拓扑的权重。
// 由于<size>至少为1（所有通过 Filters 的节点都在同一个拓扑结构中）
// 而k8s支持5k个节点，所以结果在区间<1.09，8.52>。
//
// 注意：当没有节点具有所需的拓扑结构时，<size> 也可以为0
// 然而在这种情况下，我们并不关心拓扑结构的权重
// 因为我们对所有节点都返回0分。
func topologyNormalizingWeight(size int) float64 {
	return math.Log(float64(size + 2))
}


// PreScore builds and writes cycle state used by Score and NormalizeScore.
// PreScore 构建写入 CycleState 用于后面的 Score 和 NormalizeScore 使用
func (pl *PodTopologySpread) PreScore(
    ctx context.Context,
    cycleState *framework.CycleState,
    pod *v1.Pod,
    filteredNodes []*v1.Node,
) *framework.Status {
    // 获取所有节点
    allNodes, err := pl.sharedLister.NodeInfos().List()
    if err != nil {
        return framework.AsStatus(fmt.Errorf("getting all nodes: %w", err))
    }

    // 过滤后的节点或者当前没有节点，表示没有节点用于打分
    if len(filteredNodes) == 0 || len(allNodes) == 0 {
        // No nodes to score.
        return nil
    }

    // 初始化 preScoreState 状态
    state := &preScoreState{
        IgnoredNodes:            sets.NewString(),
        TopologyPairToPodCounts: make(map[topologyPair]*int64),
    }
    // Only require that nodes have all the topology labels if using
    // non-system-default spreading rules. This allows nodes that don't have a
    // zone label to still have hostname spreading.
    //如果使用非系统默认扩展规则，则仅要求节点具有所有拓扑标签。这允许没有区域标签的节点仍然具有主机名扩展。
    requireAllTopologies := len(pod.Spec.TopologySpreadConstraints) > 0 || !pl.systemDefaulted
    err = pl.initPreScoreState(state, pod, filteredNodes, requireAllTopologies)
    if err != nil {
        return framework.AsStatus(fmt.Errorf("calculating preScoreState: %w", err))
    }

    // return if incoming pod doesn't have soft topology spread Constraints.
    if len(state.Constraints) == 0 {
        cycleState.Write(preScoreStateKey, state)
        return nil
    }

    // Ignore parsing errors for backwards compatibility.
    // 为了向后兼容，忽略解析错误
    requiredNodeAffinity := nodeaffinity.GetRequiredNodeAffinity(pod)
    processAllNode := func(i int) {
        nodeInfo := allNodes[i]
        node := nodeInfo.Node()
        if node == nil {
            return
        }
        // (1) `node` should satisfy incoming pod's NodeSelector/NodeAffinity
        // (2) All topologyKeys need to be present in `node`
        // (1) `node`应满足传入 pod 的 NodeSelector/NodeAffinity
        // (2) 所有的 topologyKeys 都需要存在于`node`中。
        match, _ := requiredNodeAffinity.Match(node)
        if !match || (requireAllTopologies && !nodeLabelsMatchSpreadConstraints(node.Labels, state.Constraints)) {
            return
        }

        for _, c := range state.Constraints {
			// 拓扑树
            pair := topologyPair{key: c.TopologyKey, value: node.Labels[c.TopologyKey]}
            // If current topology pair is not associated with any candidate node,
            // continue to avoid unnecessary calculation.
            // Per-node counts are also skipped, as they are done during Score.
            // 如果当前拓扑对没有与任何候选节点相关联，则继续避免不必要的计算
            // 每个节点的计算也被跳过，因为它们是在 Score 期间进行的
            tpCount := state.TopologyPairToPodCounts[pair]
            if tpCount == nil {
                continue
            }
            // 计算节点上匹配的所有 pod 数量
            count := countPodsMatchSelector(nodeInfo.Pods, c.Selector, pod.Namespace)
            atomic.AddInt64(tpCount, int64(count))
        }
    }
    pl.parallelizer.Until(ctx, len(allNodes), processAllNode)

    cycleState.Write(preScoreStateKey, state)
    return nil
}

上面的处理逻辑整体比较简单，最重要的是计算每个拓扑约束的权重，这样才方便后面打分的时候计算分数，存入到 CycleState 后就可以了来查看具体的 Score 函数的实现了：

// pkg/scheduler/framework/plugins/podtopologyspread/scoring.go

// Score invoked at the Score extension point.
// The "score" returned in this function is the matching number of pods on the `nodeName`,
// it is normalized later.
// 在 Score 扩展点调用
// 该函数返回的Score为`nodeName`匹配的实例个数，稍后会进行归一化处理。
func (pl *PodTopologySpread) Score(ctx context.Context, cycleState *framework.CycleState, pod *v1.Pod, nodeName string) (int64, *framework.Status) {
	nodeInfo, err := pl.sharedLister.NodeInfos().Get(nodeName)
	if err != nil {
		return 0, framework.AsStatus(fmt.Errorf("getting node %q from Snapshot: %w", nodeName, err))
	}

	node := nodeInfo.Node()
	s, err := getPreScoreState(cycleState)
	if err != nil {
		return 0, framework.AsStatus(err)
	}

	// Return if the node is not qualified.
	// 如果节点不合格则返回
	if s.IgnoredNodes.Has(node.Name) {
		return 0, nil
	}

	// For each present <pair>, current node gets a credit of <matchSum>.
	// And we sum up <matchSum> and return it as this node's score.
	// 没出现一个 <pair>, 当前节点就会得到一个 <matchSum> 的分数
	// 而我们将<matchSum>相加，作为这个节点的分数返回
	var score float64
	for i, c := range s.Constraints {
		if tpVal, ok := node.Labels[c.TopologyKey]; ok {
			var cnt int64
			if c.TopologyKey == v1.LabelHostname {
				// 如果 TopologyKey 是 Hostname 则 cnt 为节点上匹配约束的 selector 的 Pod 数量
				cnt = int64(countPodsMatchSelector(nodeInfo.Pods, c.Selector, pod.Namespace))
			} else {
				// 拓扑对下匹配的Pod数量
				pair := topologyPair{key: c.TopologyKey, value: tpVal}
				cnt = *s.TopologyPairToPodCounts[pair]
			}
            // 计算当前节点所得分数
			score += scoreForCount(cnt, c.MaxSkew, s.TopologyNormalizingWeight[i])
		}
	}
	return int64(math.Round(score)), nil
}

// scoreForCount calculates the score based on number of matching pods in a
// topology domain, the constraint's maxSkew and the topology weight.
// `maxSkew-1` is added to the score so that differences between topology
// domains get watered down, controlling the tolerance of the score to skews.
// scoreForCount 根据拓扑域中匹配的豆荚数量、约束的maxSkew和拓扑权重计算得分。
// `maxSkew-1`加到分数中，这样拓扑域之间的差异就会被淡化，控制分数对偏斜的容忍度。
func scoreForCount(cnt int64, maxSkew int32, tpWeight float64) float64 {
	return float64(cnt)*tpWeight + float64(maxSkew-1)

在 Score 阶段就是为当前的节点去计算一个分数，这个分数就是通过拓扑对下匹配的 Pod 数量和对应权重的结果得到的一个分数，另外在计算分数的时候还加上了 maxSkew-1，这样可以淡化拓扑域之间的差异。

NormalizeScore

当所有节点的分数计算完成后，还需要调用NormalizeScore扩展插件：

// pkg/scheduler/framework/plugins/podtopologyspread/scoring.go

// NormalizeScore invoked after scoring all nodes.
// NormalizeScore 在对所有节点打分过后调用
func (pl *PodTopologySpread) NormalizeScore(ctx context.Context, cycleState *framework.CycleState, pod *v1.Pod, scores framework.NodeScoreList) *framework.Status {
	s, err := getPreScoreState(cycleState)
	if err != nil {
		return framework.AsStatus(err)
	}
	if s == nil {
		return nil
	}

	// Calculate <minScore> and <maxScore>
    // 计算 <minScore> 和 <maxScore>
	var minScore int64 = math.MaxInt64
	var maxScore int64
	for i, score := range scores {
		// it's mandatory to check if <score.Name> is present in m.IgnoredNodes
		if s.IgnoredNodes.Has(score.Name) {
			scores[i].Score = invalidScore
			continue
		}
		if score.Score < minScore {
			minScore = score.Score
		}
		if score.Score > maxScore {
			maxScore = score.Score
		}
	}

	for i := range scores {
		if scores[i].Score == invalidScore {
			scores[i].Score = 0
			continue
		}
        // 如果 maxScore 为0，指定当前节点的分数为 MaxNodeScore
		if maxScore == 0 {
			scores[i].Score = framework.MaxNodeScore
			continue
		}
        // 计算当前节点的分数
		s := scores[i].Score
		scores[i].Score = framework.MaxNodeScore * (maxScore + minScore - s) / maxScore
	}
	return nil
}

NormalizeScore 扩展是在 Score 扩展执行完成后，为每个 ScorePlugin 并行运行 NormalizeScore 方法，然后并为每个 ScorePlugin 应用评分默认权重，然后总结所有插件调用过后的分数，最后选择一个分数最高的节点。

到这里我们就完成了对 PodTopologySpread 的实现分析，我们利用该特性可以实现对 Pod 更加细粒度的控制，我们可以把 Pod 分布到不同的拓扑域，从而实现高可用性，这也有助于工作负载的滚动更新和平稳地扩展副本。

avatar
文章
阅读
粉丝