在CSDN学Golang云原生Kubernetes Pod调度

一，NodeSelector定向调度

在 Kubernetes 中，可以使用 NodeSelector 字段来指定 Pod 调度到哪些节点上运行。NodeSelector 是一个键值对的 map，其中键是节点的标签名，值是标签值。具体步骤如下：

1. 在节点上添加标签

首先需要在节点上添加相应的标签，例如：

kubectl label nodes node1 app=example-app

1. 编写 Pod 的 YAML 文件

在编写 Pod 的 YAML 文件时，需要添加 nodeSelector 字段来指定 Pod 要调度到哪些节点上运行。

1.  
   apiVersion: v1
2.  
   kind: Pod
3.  
   metadata:
4.  
   name: example-pod
5.  
   spec:
6.  
   containers:
7.  
   - name: example-container
8.  
   image: your_image_name
9.  
   nodeSelector:
10.  
    app: example-app # 指定要调度到带有 app=example-app 标签的节点上运行

1. 使用 kubectl apply 命令部署 Pod

kubectl apply -f your_pod_yaml_file.yaml

1. 查看 Pod 是否部署成功

kubectl get pods example-pod -o wide # -o wide 可以查看分配给该 pod 的节点名称和 IP 地址等信息。

二，Node亲和性调度NodeAffinity

在 Kubernetes 中，可以使用 NodeAffinity 字段来指定 Pod 的亲和性调度规则，NodeAffinity 是一个结构体，其中包含两个属性：

• requiredDuringSchedulingIgnoredDuringExecution: 在调度阶段必须满足的亲和性规则。
• preferredDuringSchedulingIgnoredDuringExecution: 优先级较低的亲和性规则。

下面是一个使用 golang NodeAffinity 进行亲和性调度的例子：

1.  
   import (
2.  
   "k8s.io/api/core/v1"
3.  
   )
4.  
    
5.  
   // 创建 PodSpec 对象
6.  
   podSpec := &v1.PodSpec{
7.  
   ...
8.  
   Affinity: &v1.Affinity{
9.  
   NodeAffinity: &v1.NodeAffinity{
10.  
    RequiredDuringSchedulingIgnoredDuringExecution: &v1.NodeSelector{ // 必须满足以下标签要求
11.  
    NodeSelectorTerms: []v1.NodeSelectorTerm{
12.  
    {
13.  
    MatchExpressions: []v1.NodeSelectorRequirement{
14.  
    {
15.  
    Key: "zone",
16.  
    Operator: v1.NodeSelectorOpIn,
17.  
    Values: []string{"cn-east-01", "cn-east-02"},
18.  
    },
19.  
    },
20.  
    },
21.  
    },
22.  
    },
23.  
    PreferredDuringSchedulingIgnoredDuringExecution: nil, // 暂不需要优先级较低的亲和性规则
24.  
    },
25.  
    },
26.  
    }
27.  
     
28.  
    // 创建 Pod 对象
29.  
    pod := &v1.Pod{
30.  
    ...
31.  
    Spec: *podSpec,
32.  
    }

在上述代码中，我们通过定义 RequiredDuringSchedulingIgnoredDuringExecution 属性，并设置 NodeSelectorTerms 和 MatchExpressions 来指定 Pod 调度到哪些节点上运行。这里我们要求节点的 zone 标签的值必须是 cn-east-01 或者 cn-east-02。

需要注意的是，如果指定了多个亲和性规则，则每个规则都必须满足才能将 Pod 调度到对应的节点上。

除了使用 golang 代码进行调度之外，也可以在 Pod 的 YAML 文件中添加相应的 NodeAffinity 字段来指定 Pod 的亲和性调度规则。

三，Pod亲和度与互斥调度PodAffinity

在 Kubernetes 中，Pod 的亲和度与互斥调度可以通过 PodAffinity 和 PodAntiAffinity 字段进行设置。其中，PodAffinity 用于指定必须共存的 Pod，而 PodAntiAffinity 用于指定不得共存的 Pod。

这两个字段都包含了一个 requiredDuringSchedulingIgnoredDuringExecution 属性和一个 preferredDuringSchedulingIgnoredDuringExecution 属性：

• requiredDuringSchedulingIgnoredDuringExecution: 在调度阶段必须满足的规则。
• preferredDuringSchedulingIgnoredDuringExecution: 优先级较低的规则。

下面是一个使用 golang 进行 Pod 亲和度与互斥调度的例子：

1.  
   import (
2.  
   "k8s.io/api/core/v1"
3.  
   )
4.  
    
5.  
   // 创建 PodSpec 对象
6.  
   podSpec := &v1.PodSpec{
7.  
   ...
8.  
   Affinity: &v1.Affinity{
9.  
   PodAffinity: &v1.PodAffinity{ // 设置必须共存规则
10.  
    RequiredDuringSchedulingIgnoredDuringExecution: []v1.PodAffinityTerm{
11.  
    {
12.  
    LabelSelector: &metav1.LabelSelector{
13.  
    MatchLabels: map[string]string{"app": "nginx"},
14.  
    },
15.  
    Namespaces: []string{"default"},
16.  
    TopologyKey: "kubernetes.io/hostname",
17.  
    },
18.  
    },
19.  
    PreferredDuringSchedulingIgnoredDuringExecution: nil, // 暂不需要优先级较低的规则
20.  
    },
21.  
    PodAntiAffinity: &v1.PodAntiAffinity{ // 设置不得共存规则
22.  
    RequiredDuringSchedulingIgnoredDuringExecution: []v1.PodAffinityTerm{
23.  
    {
24.  
    LabelSelector: &metav1.LabelSelector{
25.  
    MatchLabels: map[string]string{"app": "nginx"},
26.  
    },
27.  
    Namespaces: []string{"default"},
28.  
    TopologyKey: "kubernetes.io/hostname",
29.  
    },
30.  
    },
31.  
    PreferredDuringSchedulingIgnoredDuringExecution: nil, // 暂不需要优先级较低的规则
32.  
    },
33.  
    },
34.  
    }
35.  
     
36.  
    // 创建 Pod 对象
37.  
    pod := &v1.Pod{
38.  
    ...
39.  
    Spec: *podSpec,
40.  
    }

在上述代码中，我们通过定义 PodAffinity 和 PodAntiAffinity 属性，并设置 requiredDuringSchedulingIgnoredDuringExecution 字段和相应的规则，来指定 Pod 的亲和度与互斥调度。这里我们要求必须共存的 Pod 必须是标签为 app=nginx 的 Pod，而不得共存的 Pod 也必须是标签为 app=nginx 的 Pod。

需要注意的是，在设置亲和度与互斥调度时，可以通过多种方式指定匹配规则，如使用 label selector、namespace 等。在实际使用中，请根据实际情况进行选择。

四，pod Taints 和Tolerations

在Kubernetes集群中，Taints和Tolerations是用于控制Pod是否可以被调度到某个Node上的机制。

• Taints：Taints是标记Node的一种方式，通过将一个或多个Taints添加到Node上，可以限制哪些Pod能够调度到该节点。例如，如果您希望禁止在生产环境中运行的应用程序部署到具有特定硬件或软件配置的节点上，则可以使用Taint来实现这一点。
• Tolerations：Tolerations是告诉Kubernetes哪些Pod可以调度到具有特定Taints的Node上的一种方法。如果您想要将特定应用程序部署到具有某些硬件或软件配置的节点上，则必须使用Tolerations来实现这一点。

例如，假设我们有三个节点：node1、node2和node3。我们希望防止任何Pod被调度到node1上，并且只允许具有“gpu=true”标签的Pod在node2和node3上进行调度。我们可以执行以下操作：

1. 在 node1 上添加 taint

kubectl taint nodes node1 key=value:NoSchedule

1. 在具有 toleration 的 Pod 上声明 toleration

1.  
   apiVersion: v1
2.  
   kind: Pod
3.  
   metadata:
4.  
   name: gpu-pod
5.  
   spec:
6.  
   containers:
7.  
   - name: gpu-container
8.  
   image: gpu-image:v1.0
9.  
   tolerations:
10.  
    - key: "gpu"
11.  
    operator: "Equal"
12.  
    value: "true"
13.  
    effect: "NoSchedule"

这样，只有具有“gpu=true”标签的Pod才能被调度到node2和node3上。而在node1上添加了taint，因此不会有任何Pod被调度到该节点上。

五，pod Priority 优先级调度

在 Kubernetes 集群中，Pod 被分配给 Node 运行。而 Pod 之间的优先级是由 Kubernetes 的调度器（Scheduler）来控制的。Pod 的优先级越高，则它被分配到节点上的机会就越大。

为了设置 Pod 的优先级，可以使用 PriorityClass 对象。PriorityClass 是一个资源对象，用于定义 Pod 的优先级和访问策略。

下面是一个示例 PriorityClass：

1.  
   apiVersion: scheduling.k8s.io/v1
2.  
   kind: PriorityClass
3.  
   metadata:
4.  
   name: high-priority
5.  
   value: 1000000
6.  
   globalDefault: false
7.  
   description: "This priority class should be used for important pods only."

在这个示例中，我们创建了一个名为 high-priority 的 PriorityClass，并将其值设置为 1000000。这意味着当一个 Pod 使用此 PriorityClass 来定义它的优先级时，它将比其他具有较低值的 PriorityClass 更容易被分配到节点上运行。

要使用这个 PriorityClass，请在 Pod 定义文件中添加如下字段：

1.  
   apiVersion: v1
2.  
   kind: Pod
3.  
   metadata:
4.  
   name: my-pod
5.  
   spec:
6.  
   priorityClassName: high-priority
7.  
   containers:
8.  
   - name: my-container
9.  
   image: nginx

注意，在设置完 priorityClassName 字段后，请确保所有相关的 Node 上都安装了 kube-scheduler 组件，并且该组件已经启动。这样才能使调度器根据定义的优先级来调度 Pod 的运行。

这篇好文章是转载于：学新通技术网