1
func CreateBuilder(builder *Builder) (taskId string, err error) {
2

3
  volumes, volumeMounts := getBuilderVolumeAndMount(builder.Name, builder.NFSs)
4

5
  var replicas int32 = 1
6

7
  tolers, nodeMatches := buildDedicatedBuilder(builder)
8

9
  ...
10

11
  annotations, err := getBuilderAnnotations(builder.Name)
12
  if err != nil {
13
    return "", err
14
  }
15

16
  ...
17

18
  go task.DoCreateBuilder(
19
    taskId,
20
    &kubeclient.Deployment{
21
      Name:        builder.Name,
22
      Labels:      labels,
23
      MatchLabels: matchlabels,
24
      Replicas:    &replicas,
25
      Pod: kubeclient.Pod{
26
        Labels:      labels,
27
        Annotations: annotations,
28
        Volumes:     volumes,
29
        Containers: []kubeclient.Container{
30
          {
31
            Image:        builder.Image,
32
            Resources:    *resources,
33
            Env:          getEnvs(builder.Env),
34
            Command:      builder.Command,
35
            VolumeMounts: volumeMounts,
36
          },
37
        },
38
        NodeMatches:     nodeMatches,
39
        Tolerations:     tolers,
40
        PullImageSecret: pullImageSecret,
41
      },
42
    },
43
  )
44

45
  return taskId, nil
46
}
47

48

49
// buildDedicatedBuilder 获取污点和节点亲和度配置
50
func buildDedicatedBuilder(builder *Builder) ([]corev1.Toleration, []kubeclient.NodeMatch) {
51
    // 优先读取专机配置
52
    ...
53
    // 读取具有特殊配置的机器
54
    ...
55
    // 如果配置中配置了节点选择器则使用节点选择器
56
    ...
57
    return nil, nil
58
}
59

60
// getBuilderAnnotations 获取构建机注释配置
61
func getBuilderAnnotations(builderName string) (map[string]string, error) {
62
  ...
63
  // 获取节点记录，用来把构建机分配到已有的节点
64
  ...
65
  // 获取RealResource记录
66
  ...
67
  return result, nil
68
}

1
func CreateDeployment(dep *Deployment) error {
2
  ...
3
  // 将 NodeMatches 转为 nodeAffinity
4
  var affinity *corev1.Affinity
5
  if len(dep.Pod.NodeMatches) > 0 {
6
    var matches []corev1.NodeSelectorRequirement
7
    for _, mat := range dep.Pod.NodeMatches {
8
      matches = append(matches, corev1.NodeSelectorRequirement{
9
        Key:      mat.Key,
10
        Operator: mat.Operator,
11
        Values:   mat.Values,
12
      })
13
    }
14
    affinity = &corev1.Affinity{
15
      NodeAffinity: &corev1.NodeAffinity{
16
        RequiredDuringSchedulingIgnoredDuringExecution: &corev1.NodeSelector{
17
          NodeSelectorTerms: []corev1.NodeSelectorTerm{
18
            {
19
              MatchExpressions: matches,
20
            },
21
          },
22
        },
23
      },
24
    }
25
  }
26
  ...
27
  return nil
28
}

1
apiVersion: v1
2
kind: Pod
3
metadata:
4
  annotations:
5
    bkci.dispatch.kubenetes/builder-history-nodes: '["10.x.x.1","10.x.x.2","10.x.x.3"]'
6
  labels:
7
    bkci.dispatch.kubenetes/core: build1753761077695-ivcpmoxg
8
    bkci.dispatch.kubenetes/watch-task: t-1753785688231121886-iInjpMUr-builder-start
9
  name: build1753761077695-ivcpmoxg-c9d8fc6c9-mqhkk
10
  ...

1
package bkdevopsschedulerplugin
2

3
import (
4
    "context"
5
    "encoding/json"
6
    "k8s.io/api/core/v1"
7
    "k8s.io/kubernetes/pkg/scheduler/framework"
8
)
9

10
const nodesAnnotation = "bkci.dispatch.kubenetes/builder-history-nodes"
11
const readResourceAnnotation = "bkci.dispatch.kubenetes/builder-real-resources"
12

13
type realResourceUsage struct {
14
    Cpu    string `json:"cpu"`
15
    Memory string `json:"memory"`
16
}
17

18
func (s *SchedulerPlugin) Score(_ context.Context, _ *framework.CycleState, pod *v1.Pod, nodeName string) (int64, *framework.Status) {
19
    // 读取历史节点信息
20
    var nodeHis []string
21
    if nodesS, ok := pod.ObjectMeta.Annotations[nodesAnnotation]; ok {
22
        _ = json.Unmarshal([]byte(nodesS), &nodeHis)
23
    }
24

25
    // 读取资源信息
26
    var realResources []realResourceUsage
27
    if realS, ok := pod.ObjectMeta.Annotations[readResourceAnnotation]; ok {
28
        _ = json.Unmarshal([]byte(realS), &realResources)
29
    }
30

31
    // 计算历史节点分数
32
    nodeScore := calculateNodeHisScore(nodeHis, nodeName)
33

34
    // 计算资源分数
35
    // ...省略资源分数计算逻辑...
36
    realResourceScore := ... // 通过 realResources 和节点资源情况计算
37

38
    // 返回总分
39
    return nodeScore + realResourceScore, nil
40
}
41

42
var nodeHisScores = map[int]int64{0: 30, 1: 20, 2: 10}
43

44
// calculateNodeHisScore 计算历史节点分数，将3个历史节点从最近到最远依次打分 30 - 10分
45
func calculateNodeHisScore(nodeHis []string, nodeName string) int64 {
46
  if len(nodeHis) == 0 {
47
    return framework.MinNodeScore
48
  }
49

50
  for index, name := range nodeHis {
51
    if name != nodeName {
52
      continue
53
    }
54

55
    score := framework.MinNodeScore
56
    if indexS, ok := nodeHisScores[index]; ok {
57
      score = indexS
58
    }
59

60
    return score
61
  }
62

63
  return framework.MinNodeScore
64
}