Kubernetes (K8S)中深入理解Pods调度

王先森2023-09-152023-09-15

Pods调度

我们部署的 Pod 是通过集群的自动调度策略来选择节点的，默认情况下调度器考虑的是资源足够，并且负载尽量平均，但是有的时候我们需要能够更加细粒度的去控制 Pod 的调度，比如我们希望一些机器学习的应用只跑在有 GPU 的节点上；但是有的时候我们的服务之间交流比较频繁，又希望能够将这服务的 Pod 都调度到同一个的节点上。这就需要使用一些调度方式来控制 Pod 的调度了，主要有两个概念：亲和性和反亲和性，亲和性又分成节点亲和性(nodeAffinity)和 Pod 亲和性(podAffinity)。

定向调度(nodeSelector)

如果要实现定向调度，首先的第一步就是要为Node节点搭上标签（Label），我们知道 label 标签是 kubernetes 中一个非常重要的概念，用户可以非常灵活的利用 label 来管理集群中的资源，比如最常见的 Service 对象通过 label 去匹配 Pod 资源，而 Pod 的调度也可以根据节点的 label 来进行调度。可以使用kubectl label命令：

# 添加label标签
kubectl label nodes <node-name> <label-key>=<label-value>

# 删除label标签
kubectl label nodes <node-name> <label-key>-

我们可以通过下面的命令查看我们的 node 的 label：

1	kubectl get nodes --show-labels

现在我们先给节点 k8s-node2 增加一个domain=boysec.cn的标签，命令如下：

1 2	$ kubectl label nodes k8s-node2 domain=boysec.cn node/k8s-node2 labeled

当节点被打上了相关标签后，在调度的时候就可以使用这些标签了，只需要在 Pod 的 spec 字段中添加 nodeSelector 字段，里面是我们需要被调度的节点的 label 标签，比如，下面的 Pod 我们要强制调度到 k8s-node2 这个节点上去，我们就可以使用 nodeSelector 来表示了

cat > node-selector-demo.yaml << EOF
apiVersion: v1
kind: Pod
metadata:
  labels:
    app: busybox-pod
  name: test-busybox
spec:
  containers:
  - command:
    - sleep
    - "500"
    image: busybox
    imagePullPolicy: Always
    name: test-busybox
  nodeSelector:
    domain: boysec.cn
EOF

通过 describe 命令查看调度结果

$ kubectl describe pods test-busybox 
Name:         test-busybox
Namespace:    default
Priority:     0
Node:         k8s-node2/10.1.1.130
Start Time:   Fri, 15 Sep 2023 16:06:22 +0800
Labels:       app=busybox-pod
Annotations:  <none>
Status:       Running
......
QoS Class:                   BestEffort
Node-Selectors:              domain=boysec.cn
Tolerations:                 node.kubernetes.io/not-ready:NoExecute op=Exists for 300s
                             node.kubernetes.io/unreachable:NoExecute op=Exists for 300s
Events:
  Type    Reason     Age   From               Message
  ----    ------     ----  ----               -------
  Normal  Scheduled  97s   default-scheduler  Successfully assigned default/test-busybox to k8s-node2
  Normal  Pulling    97s   kubelet            Pulling image "busybox"
  Normal  Pulled     79s   kubelet            Successfully pulled image "busybox" in 17.555242061s
  Normal  Created    79s   kubelet            Created container test-busybox
  Normal  Started    79s   kubelet            Started container test-busybox

可以看到 Events 下面的信息，我们的 Pod 通过默认的 default-scheduler 调度器被绑定到了 k8s-node2 节点。不过需要注意的是nodeSelector 属于强制性的，如果我们的目标节点没有可用的资源，我们的 Pod 就会一直处于 Pending 状态。

预定义的标签
除了用户可以自行给Node添加标签，Kubernetes也会给Node预定义一些标签，包括：

kubernetes.io/hostname；
beta.kubernetes.io/os（从1.14版本开始更新为稳定版，到1.18版本删除)；
beta.kubernetes.io/arch（从1.14版本开始更新为稳定版，到1.18版本删除)；
kubernetes.io/os（从1.14版本开始启用)；
kubernetes.io/arch(从1.14版本开始启用)。

亲和性和反亲和性调度

kubernetes 调度器的调度流程，默认的调度器在使用的时候，经过了 predicates 和 priorities 两个阶段，但是在实际的生产环境中，往往我们需要根据自己的一些实际需求来控制 Pod 的调度，这就需要用到 nodeAffinity(节点亲和性)、podAffinity(pod 亲和性) 以及 podAntiAffinity(pod 反亲和性)。

亲和性/反亲和性调度策略比较如下：

调度策略	匹配标签	操作	拓扑域	调度目标
nodeAffinity	主机	In、NotIn、Gt、Lt、Exists、DoesNotExist	否	指定主机
podAffinity	POD	In、NotIn、Gt、Lt、Exists、DoesNotExist	是	Pod与指定Pod在同一拓扑域
podAntiAffinity	POD	In、NotIn、Gt、Lt、Exists、DoesNotExist	是	Pod与指定Pod不在同一拓扑域

亲和性调度可以分成软策略和硬策略两种方式:

软策略就是如果现在没有满足调度要求的节点的话，Pod 就会忽略这条规则，继续完成调度过程，说白了就是满足条件最好了，没有的话也无所谓
硬策略就比较强硬了，如果没有满足条件的节点的话，就不断重试直到满足条件为止，简单说就是你必须满足我的要求，不然就不干了

对于亲和性和反亲和性都有这两种规则可以设置： preferredDuringSchedulingIgnoredDuringExecution 和requiredDuringSchedulingIgnoredDuringExecution，前面的就是软策略，后面的就是硬策略。多个优先级规则还可以设置权重(weight)值，以定义执行的先后顺序。

节点亲和性

节点亲和性（nodeAffinity）主要是用来控制 Pod 要部署在哪些节点上，以及不能部署在哪些节点上的，它可以进行一些简单的逻辑组合了，不只是简单的相等匹配。

我们用一个 Deployment 来管理5个 Pod 副本，现在我们来控制下这些 Pod 的调度，如下例子：

cat > node-affinity-demo.yaml <<EOF
apiVersion: apps/v1
kind: Deployment
metadata:
  name: node-affinity
  labels:
    app: node-affinity
spec:
  replicas: 5
  selector:
    matchLabels:
      app: node-affinity
  template:
    metadata:
      labels:
        app: node-affinity
    spec:
      containers:
      - name: nginx
        image: nginx:alpine
        ports:
        - containerPort: 80
          name: nginxweb
      affinity:                                            # 亲和性
        nodeAffinity:                                      # node亲和性
          requiredDuringSchedulingIgnoredDuringExecution:  # 硬策略限制
            nodeSelectorTerms:
            - matchExpressions:
              - key: kubernetes.io/hostname                # 标签键名
                operator: NotIn                            #键值运算关系 ，NotIn:label的值不在某个列表中。 表示不是k8s-node1节点就可运行
                values:
                - k8s-node1
          preferredDuringSchedulingIgnoredDuringExecution:  # 软策略限制
          - weight: 1                                       # 权重
            preference:
              matchExpressions:
              - key: domain
                operator: In
                values:
                - boysec.cn
EOF

这个 Pod 首先是要求不能运行在 k8s-node1这个节点上，如果有个节点满足 domain=boysec.cn 的话就优先调度到这个节点上。

$ kubectl get pods -l app=node-affinity -o wide
NAME                             READY   STATUS    RESTARTS   AGE     IP             NODE        NOMINATED NODE   READINESS GATES
node-affinity-8549dfd56b-677h6   1/1     Running   0          2m31s   172.16.130.4   k8s-node2   <none>           <none>
node-affinity-8549dfd56b-82ztk   1/1     Running   0          2m31s   172.16.130.8   k8s-node2   <none>           <none>
node-affinity-8549dfd56b-h9rsw   1/1     Running   0          2m31s   172.16.130.3   k8s-node2   <none>           <none>
node-affinity-8549dfd56b-wkw4x   1/1     Running   0          2m31s   172.16.130.7   k8s-node2   <none>           <none>
node-affinity-8549dfd56b-x47lv   1/1     Running   0          2m31s   172.16.130.5   k8s-node2   <none>           <none>

从结果可以看出有5个 Pod 被部署到了 k8s-node2 节点上，但是可以看到并没有一个 Pod 被部署到 k8s-node1 这个节点上，因为我们的硬策略就是不允许部署到该节点上，而 k8s-node2 是软策略，所以会尽量满足。这里的匹配逻辑是 label 标签的值在某个列表中，现在 Kubernetes 提供的操作符有下面的几种：

In：label 的值在某个列表中
NotIn：label 的值不在某个列表中
Gt：label 的值大于某个值
Lt：label 的值小于某个值
Exists：某个 label 存在
DoesNotExist：某个 label 不存在

但是需要注意的是如果 nodeSelectorTerms 下面有多个选项的话，满足任何一个条件就可以了；如果 matchExpressions有多个选项的话，则必须同时满足这些条件才能正常调度 Pod。

Pod 亲和性

Pod 亲和性（podAffinity）主要解决 Pod 可以和哪些 Pod 部署在同一个拓扑域中的问题（其中拓扑域用主机标签实现，可以是单个主机，也可以是多个主机组成的 cluster、zone 等等），而 Pod 反亲和性主要是解决 Pod 不能和哪些 Pod 部署在同一个拓扑域中的问题，它们都是处理的 Pod 与 Pod 之间的关系，比如一个 Pod 在一个节点上了，那么我这个也得在这个节点，或者你这个 Pod 在节点上了，那么我就不想和你待在同一个节点上。

由于我们这里只有一个集群，并没有区域或者机房的概念，所以我们这里直接使用主机名来作为拓扑域，把 Pod 创建在同一个主机上面。

同样，还是针对上面的资源对象，我们来测试下 Pod 的亲和性：

cat > pod-affinity-demo.yaml <<EOF
apiVersion: apps/v1
kind: Deployment
metadata:
  name: pod-affinity
  labels:
    app: pod-affinity
spec:
  replicas: 3
  selector:
    matchLabels:
      app: pod-affinity
  template:
    metadata:
      labels:
        app: pod-affinity
    spec:
      containers:
      - name: nginx
        image: nginx:alpine
        ports:
        - containerPort: 80
          name: nginxweb
      affinity:
        podAffinity:                                       # 想让两个pod运行在同一个node上
          requiredDuringSchedulingIgnoredDuringExecution:  # 硬策略
          - labelSelector:                                 # 标签选择
              matchExpressions:
              - key: app                                   # 当有Pods标签app存busybox-pod在时就选择
                operator: In
                values:
                - busybox-pod
            topologyKey: kubernetes.io/hostname
EOF

上面这个例子中的 Pod 需要调度到某个指定的节点上，并且该节点上运行了一个带有 app=busybox-pod 标签的 Pod。我们可以查看有标签 app=busybox-pod 的 pod 列表：

1
2
3

$  kubectl get pods -l app=busybox-pod -o wide
NAME           READY   STATUS    RESTARTS   AGE     IP             NODE        NOMINATED NODE   READINESS GATES
test-busybox   1/1     Running   0          2m50s   172.16.130.3   k8s-node2   <none>           <none>

我们看到这个 Pod 运行在了 k8s-node2 的节点上面，所以按照上面的亲和性来说，上面我们部署的3个 Pod 副本也应该运行在 node2 节点上：

$ kubectl get pods -o wide -l app=pod-affinity
NAME                            READY   STATUS    RESTARTS   AGE    IP             NODE        NOMINATED NODE   READINESS GATES
pod-affinity-7d657d6bfb-fwvr5   1/1     Running   0          106s   172.16.130.4   k8s-node2   <none>           <none>
pod-affinity-7d657d6bfb-r7c7q   1/1     Running   0          104s   172.16.130.7   k8s-node2   <none>           <none>
pod-affinity-7d657d6bfb-zbzwz   1/1     Running   0          105s   172.16.130.5   k8s-node2   <none>           <none>

如果我们把上面的 test-busybox 和 pod-affinity 这个 Deployment 都删除，然后重新创建 pod-affinity 这个资源，就会发现不能正常调度了。

$ kubectl delete -f node-selector-demo.yaml
$ kubectl delete -f pod-affinity-demo.yaml 
$ kubectl apply -f pod-affinity-demo.yaml 
$ kubectl get pods -l app=pod-affinity
NAME                            READY   STATUS    RESTARTS   AGE
pod-affinity-7d657d6bfb-bzm78   0/1     Pending   0          20s
pod-affinity-7d657d6bfb-mcxf9   0/1     Pending   0          20s
pod-affinity-7d657d6bfb-rlx9v   0/1     Pending   0          20s

可以看到都处于 Pending 状态了，这是因为现在没有一个节点上面拥有 app=busybox-pod 这个标签的 Pod，而上面我们的调度使用的是硬策略，所以就没办法进行调度了，大家可以去尝试下重新将 test-busybox 这个 Pod 调度到其他节点上，观察下上面的3个副本会不会也被调度到对应的节点上去。

我们这个地方使用的是 kubernetes.io/hostname 这个拓扑域，意思就是我们当前调度的 Pod 要和目标的 Pod 处于同一个主机上面，因为要处于同一个拓扑域下面，为了说明这个问题，我们把拓扑域改成 beta.kubernetes.io/os，同样的我们当前调度的 Pod 要和目标的 Pod 处于同一个拓扑域中，目标的 Pod 是拥有 beta.kubernetes.io/os=linux 的标签，而我们这里所有节点都有这样的标签，这也就意味着我们所有节点都在同一个拓扑域中，所以我们这里的 Pod 可以被调度到任何一个节点，重新运行上面的 app=busybox-pod 的 Pod，然后再更新下我们这里的资源对象：

$ kubectl apply -f node-selector-demo.yaml 
$  kubectl get pods -l app=pod-affinity -o wide
NAME                            READY   STATUS    RESTARTS   AGE     IP             NODE        NOMINATED NODE   READINESS GATES
pod-affinity-7d657d6bfb-bzm78   1/1     Running   0          3m40s   172.16.130.4   k8s-node1   <none>           <none>
pod-affinity-7d657d6bfb-mcxf9   1/1     Running   0          3m40s   172.16.130.5   k8s-node2   <none>           <none>
pod-affinity-7d657d6bfb-rlx9v   1/1     Running   0          3m40s   172.16.130.7   k8s-node2   <none>           <none>

Pod 反亲和性

Pod 反亲和性（podAntiAffinity）则是反着来的，比如一个节点上运行了某个 Pod，那么我们的模板 Pod 则不希望被调度到这个节点上面去了。我们把上面的 podAffinity 直接改成 podAntiAffinity

cat > pod-antiaffinity-demo.yaml <<EOF
apiVersion: apps/v1
kind: Deployment
metadata:
  name: pod-antiaffinity
  labels:
    app: pod-antiaffinity
spec:
  replicas: 3
  selector:
    matchLabels:
      app: pod-antiaffinity
  template:
    metadata:
      labels:
        app: pod-antiaffinity
    spec:
      containers:
      - name: nginx
        image: nginx:alpine
        ports:
        - containerPort: 80
          name: nginxweb
      affinity:
        podAntiAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:  # 硬策略
          - labelSelector:
              matchExpressions:
              - key: app
                operator: In
                values:
                - busybox-pod
            topologyKey: kubernetes.io/hostname
EOF

这里的意思就是如果一个节点上面有一个 app=busybox-pod 这样的 Pod 的话，那么我们的 Pod 就别调度到这个节点上面来，上面我们把app=busybox-pod 这个 Pod 固定到了 node2 这个节点上面的，所以正常来说我们这里的 Pod 不会出现在该节点上：

```

可以看到没有被调度到 k8s-node2 节点上，这就是使用的 Pod 反亲和性。

# 污点与容忍

## 污点介绍

对于 `nodeAffinity` 无论是硬策略还是软策略方式，都是调度 Pod 到预期节点上，而污点（Taints）恰好与之相反，如果一个节点标记为 Taints ，除非 Pod 也被标识为可以容忍污点节点，否则该 Taints 节点不会被调度 Pod。

> 污点（taints）: 打上了污点的node就不会承载新pod的调度
>
> 容忍（toleration）: 设置了有容忍的pod，仍能调度到有污点的node上

**污点的4种类型：**

1. `NoSchedule` ：表示K8S不会把pod调度到有该污点的节点上，但不影响该节点已存在的pod
2. `PreferNoschedule`: 表示K8S尽量不调度pod到有该污点的节点上
3. `NoExecute` : 表示K8S不会把pod调度到有这个污点的节点上，同时还会把有这个污点的节点上已经存在的pod全部驱逐
4. `Cordon`： 表示不会调度新的pod，并且不会强制驱逐已有的pod

**添加污点：**

```shell
$ kubectl taint nodes k8s-node1 key=value:NoSchedule
$ kubectl taint nodes k8s-node2 key=value:NoExecute

取消污点：

1 2	$ kubectl taint nodes k8s-node1 key:NoSchedule- $ kubectl taint nodes k8s-node2 key:NoExecute-

kubeadm 搭建的集群默认就给 k8s-master 节点添加了一个污点标记，所以我们看到我们平时的 Pod 都没有被调度到 master 上去

$ kubectl get nodes
NAME          STATUS                     ROLES    AGE   VERSION
k8s-master1   Ready,SchedulingDisabled   <none>   56d   v1.23.6
k8s-node1     Ready                      <none>   56d   v1.23.6
k8s-node2     Ready                      <none>   56d   v1.23.6
$ kubectl describe nodes k8s-master1
Name:               k8s-master1
Roles:              master
Labels:             beta.kubernetes.io/arch=amd64
                    beta.kubernetes.io/os=linux
                    kubernetes.io/arch=amd64
                    kubernetes.io/hostname=k8s-master1
                    kubernetes.io/os=linux
                    node-role.kubernetes.io/master=
......
Taints:             node-role.kubernetes.io/master:NoSchedule
Unschedulable:      false
......

可以使用上面的命令查看 k8s-master 节点的信息，其中有一条关于 Taints 的信息：node-role.kubernetes.io/master:NoSchedule，就表示master 节点打了一个污点的标记，其中影响的参数是 NoSchedule，表示 Pod 不会被调度到标记为 taints 的节点。

取消\添加k8s-master的污点，查看污点都已经取消了

# 取消
kubectl uncordon k8s-master1 
# 添加
kubectl cordon k8s-master1

容忍介绍

容忍类型：

toleration：
定义pod的容忍度（可以接受哪些类型的污点），而后可以调度到这种污点类型的node
operator：
如果operator是Exists,那么容忍度不需要value而是直接匹配污点类型
如果operator是Equal,那么需要指定value并且value的值需要等于node污点的key

测试容忍案例

在 k8s-node2节点打NoSchedule污点

1	$ kubectl taint nodes k8s-node2 test=k8s-node2:NoSchedule

上面的命名将 k8s-node2 节点标记为了污点，影响策略是 NoSchedule，只会影响新的 Pod 调度，如果仍然希望某个 Pod 调度到 taint 节点上，则必须在 Spec 中做出 Toleration 定义，才能调度到该节点，比如现在我们想要将一个 Pod 调度到 master 节点：

cat > taint-demo.yaml <<EOF
apiVersion: apps/v1
kind: Deployment
metadata:
  name: taint
  labels:
    app: taint
spec:
  replicas: 3
  selector:
    matchLabels:
      app: taint
  template:
    metadata:
      labels:
        app: taint
    spec:
      containers:
      - name: nginx
        image: nginx:alpine
        ports:
        - name: http
          containerPort: 80
      tolerations:                                    # 污点容忍
      - key: "node.kubernetes.io/unschedulable"         # 污点的key是node-role.kubernetes.io/master 
        operator: "Exists"                            # 容忍所有含污点的node
        effect: "NoSchedule"
EOF

然后创建上面的资源，查看结果：

$ kubectl get pods -l app=taint -o wide
NAME                     READY   STATUS    RESTARTS   AGE   IP             NODE          NOMINATED NODE   READINESS GATES
taint-554bf45c8f-5tn8c   1/1     Running   0          3s    172.16.120.4   k8s-node1     <none>           <none>
taint-554bf45c8f-jk7td   1/1     Running   0          3s    172.16.120.5   k8s-node1     <none>           <none>
taint-554bf45c8f-vnb9p   1/1     Running   0          3s    172.16.100.7   k8s-master1   <none>           <none>

我们可以看到有一个 Pod 副本被调度到了 master 节点，这就是容忍的使用方法。

总结：对于 tolerations 属性的写法，其中的 key、value、effect 与 Node 的 Taint 设置需保持一致，还有以下几点说明：