Pod调度

# 简介
默认情况下，一个Pod在哪个Node节点上运行，是由Scheduler组件采用相应的算法计算出来的，这个过程是不受人工控制的。
在实际使用中，一些情况下我们想控制某些Pod到达某些节点。

kubernetes提供了四类调度方式：
- 自动调度：运行在哪个Node节点上完全由Scheduler经过一系列的算法计算得出
- 定向调度：NodeName、NodeSelector
- 亲和性调度：NodeAffinity、PodAffinity、PodAntiAffinity
- 污点/容忍调度：Taints、Toleration

# 自动调度

运行容器选择Node节点完全由Scheduler经过一系列的算法计算得出选定

# 定向调度

利用在Pod上声明的nodeName或nodeSelector，以此将Pod调度到期望的Node节点上。

> 注意，这里的调度是强制的，这就意味着即使要调度的目标Node不存在，也会向上面进行调度，Pod会运行失败

## NodeName

强制约束，直接跳过Scheduler的调度逻辑，直接将Pod调度到指定名称的节点

创建pod-nodename.yaml
```asp
cat <<EOF> pod-nodename.yaml
apiVersion: v1
kind: Pod
metadata:
  name: pod-nodename
  namespace: dev
spec:
  containers:
    - name: nginx
      image: nginx:1.17.1
  nodeName: node3		#指定调度节点，修改为node1或2可以启动
EOF
```
启动
```asp
kubectl create -f pod-nodename.yaml
```
查看（强行调度到不存在的node3，status为Pending状态）
```asp
kubectl get pod -n dev -o wide
```
```asp
kubectl get pod -n dev -o wide
NAME           READY   STATUS    RESTARTS   AGE   IP       NODE        NOMINATED NODE   READINESS GATES
pod-nodename   0/1     Pending   0          8s    <none>   node3       <none>           <none>
```
删除
```asp
kubectl delete -f pod-nodename.yaml
```

## nodeSelector

将Pod调度到添加了指定标签的Node节点，通过kubernetes的label-selector机制实现
Pod在创建之前由Scheduler使用MatchNodeSelector调度策略进行label匹配，找出目标node，然后将Pod调度到目标节点
该匹配规则是强制约束

给node节点添加标签
```asp
kubectl label node node1 nodeenv=pro
kubectl label node node2 nodeenv=test
```
查看node标签
```asp
kubectl get node --show-labels
```
创建pod-nodename.yaml
```asp
cat <<EOF> pod-nodeselector.yaml
apiVersion: v1
kind: Pod
metadata:
  name: pod-nodeselector
  namespace: dev
spec:
  containers:
    - name: nginx
      image: nginx:1.17.1
  nodeSelector:
    nodeenv: pro		#指定调度到具有nodeenv=pro的Node节点上
EOF
```
启动
```asp
kubectl create -f pod-nodeselector.yaml
```
查看（node1标签是pro所以pod会调度到node1）
```asp
kubectl get -f pod-nodeselector.yaml -o wide
```
```asp
NAME               READY   STATUS    RESTARTS   AGE   IP               NODE    NOMINATED NODE   READINESS GATES
pod-nodeselector   1/1     Running   0          9s    10.244.166.139   node1   <none>           <none>
```
删除
```asp
kubectl delete -f pod-nodeselector.yaml
```
删除标签
```asp
kubectl label node node1 nodeenv-
kubectl label node node2 nodeenv-
```

# 亲和性调度

定向调度如果没有满足条件的Node那么Pod将不会被运行，即使在集群中还有可用的Node列表也不行，这就限制了它的使用场景。
为了解决上述问题引入了亲和性调度（Affinity）。它在nodeSelector的基础之上进行了扩展，可以通过配置的形式，实现优先选择满足条件的Node进行调度，如果没有，也可以调度到不满足条件的节点上，使得调度更加灵活。

**Affinity主要分为三类：**
- nodeAffinity（node亲和性）：以Node为目标，解决Pod可以调度到那些Node的问题
- podAffinity（pod亲和性）：以Pod为目标，解决Pod可以和那些已存在的Pod部署在同一个拓扑域中的问题
- podAntiAffinity（pod反亲和性）：以Pod为目标，解决Pod不能和那些已经存在的Pod部署在同一拓扑域中的问题

> 关于亲和性和反亲和性的使用场景的说明：
亲和性：如果两个应用频繁交互，那么就有必要利用亲和性让两个应用尽可能的靠近，这样可以较少因网络通信而带来的性能损耗。
反亲和性：当应用采用多副本部署的时候，那么就有必要利用反亲和性让各个应用实例打散分布在各个Node上，这样可以提高服务的高可用性。

## nodeAffinity

以Node为目标，解决Pod可以调度到那些Node的问题

> 如果同时定义了nodeSelector和nodeAffinity，那么必须两个条件都满足，Pod才能运行在指定的Node上。
如果nodeAffinity指定了多个nodeSelectorTerms，那么只需要其中一个能够匹配成功即可。
如果一个nodeSelectorTerms中有多个matchExpressions，则一个节点必须满足所有的才能匹配成功。
如果一个Pod所在的Node在Pod运行期间其标签发生了改变，不再符合该Pod的nodeAffinity的要求，则系统将忽略此变化。

使用说明
```asp
pod.spec.affinity.nodeAffinity
  requiredDuringSchedulingIgnoredDuringExecution  Node节点必须满足指定的所有规则才可以，相当于硬限制
    nodeSelectorTerms    节点选择列表
      matchFields        按节点字段列出的节点选择器要求列表
      matchExpressions   按节点标签列出的节点选择器要求列表(推荐)
        key              键
        values           值
        operator         关系符 支持Exists, DoesNotExist, In, NotIn, Gt, Lt
  preferredDuringSchedulingIgnoredDuringExecution 优先调度到满足指定的规则的Node，相当于软限制 (倾向)
    preference           一个节点选择器项，与相应的权重相关联
      matchFields        按节点字段列出的节点选择器要求列表
      matchExpressions   按节点标签列出的节点选择器要求列表(推荐)
        key              键
        values           值
        operator         关系符 支持In, NotIn, Exists, DoesNotExist, Gt, Lt
    weight               倾向权重，在范围1-100。
```

关系符的使用说明
```asp
- matchExpressions:
	- key: nodeenv # 匹配存在标签的key为nodeenv的节点
	  operator: Exists   
	- key: nodeenv # 匹配标签的key为nodeenv,且value是"xxx"或"yyy"的节点
	  operator: In    
      values: ["xxx","yyy"]
    - key: nodeenv # 匹配标签的key为nodeenv,且value大于"xxx"的节点
      operator: Gt   
      values: "xxx"
```

### 硬限制

Node节点必须满足指定的所有规则才可以，不满足运行失败

创建node标签
```asp
kubectl label node node1 nodeenv=pro
kubectl label node node2 nodeenv=test
```
创建pod-nodeaffinity-required.yaml
```asp
cat <<EOF> pod-nodeaffinity-required.yaml
apiVersion: v1
kind: Pod
metadata:
  name: pod-nodeaffinity-required
  namespace: dev
spec:
  containers:
  - name: nginx
    image: nginx:1.17.1
  affinity:                        #亲和性配置
    nodeAffinity:                  #node亲和性配置
      requiredDuringSchedulingIgnoredDuringExecution: #硬限制
        nodeSelectorTerms:
        - matchExpressions:        #匹配env的值在["xxx","yyy"]中的标签
          - key: nodeenv
            operator: In
            values: ["xxx","yyy"]  #修改xxx或yyy为pro或test条件将满足
EOF
```
启动
```asp
kubectl create -f pod-nodeaffinity-required.yaml
```
查看（没有node拥有xxx或yyy的标签，不满足调度条件，硬限制的status状态为Pending）
```asp
kubectl get -f pod-nodeaffinity-required.yaml -o wide
```
```asp
NAME                        READY   STATUS    RESTARTS   AGE   IP       NODE     NOMINATED NODE   READINESS GATES
pod-nodeaffinity-required   0/1     Pending   0          27s   <none>   <none>   <none>           <none>
```
查看日志
```asp
kubectl describe -f pod-nodeaffinity-required.yaml
```
删除
```asp
kubectl delete -f pod-nodeaffinity-required.yaml
```
删除node标签
```asp
kubectl label node node1 nodeenv-
kubectl label node node2 nodeenv-
```

### 软限制

优先调度到满足指定的规则的Node，不满足随机指定node运行

创建pod-nodeaffinity-preferred.yaml

```asp
cat <<EOF> pod-nodeaffinity-preferred.yaml
apiVersion: v1
kind: Pod
metadata:
  name: pod-nodeaffinity-preferred
  namespace: dev
spec:
  containers:
    - name: nginx
      image: nginx:1.17.1
  affinity:                       #亲和性配置
    nodeAffinity:                 #node亲和性配置
      preferredDuringSchedulingIgnoredDuringExecution: #软限制
      - weight: 1
        preference:
          matchExpressions:       #匹配env的值在["xxx","yyy"]中的标签
          - key: nodeenv
            operator: In
            values: ["xxx","yyy"]
EOF
```
启动
```asp
kubectl create -f pod-nodeaffinity-preferred.yaml
```
查看（node节点没有xxx或yyy标签，不满足调度条件，但软限制会自动分配到其他node）
```asp
kubectl get -f pod-nodeaffinity-preferred.yaml -o wide
```
```asp
NAME                         READY   STATUS    RESTARTS   AGE   IP               NODE    NOMINATED NODE   READINESS GATES
pod-nodeaffinity-preferred   1/1     Running   0          99s   10.244.166.141   node1   <none>           <none>
```
查看日志
```asp
kubectl describe -f pod-nodeaffinity-preferred.yaml
```
删除
```asp
kubectl delete -f pod-nodeaffinity-preferred.yaml
```

## podAffinity

以运行的Pod为目标，实现让新创建的Pod和参照的Pod在一个区域的功能。

使用说明
```asp
pod.spec.affinity.podAffinity
  requiredDuringSchedulingIgnoredDuringExecution  硬限制
    namespaces          指定参照pod的namespace
    topologyKey         指定调度作用域
    labelSelector       标签选择器
      matchExpressions  按节点标签列出的节点选择器要求列表(推荐)
        key             键
        values          值
        operator        关系符 支持In, NotIn, Exists, DoesNotExist.
      matchLabels       指多个matchExpressions映射的内容
  preferredDuringSchedulingIgnoredDuringExecution 软限制
    podAffinityTerm     选项
      namespaces
      topologyKey
      labelSelector
         matchExpressions
        key             键
        values          值
            operator
         matchLabels
    weight              倾向权重，在范围1-1
```
> topologyKey用于指定调度的作用域，例如:
如果指定为kubernetes.io/hostname，那就是以Node节点为区分范围。
如果指定为beta.kubernetes.io/os，则以Node节点的操作系统类型来区分。

### 硬限制

匹配调试满足运行，不满足运行失败

创建参照pod（一个具有pro标签的pod）
```asp
cat <<EOF> pod-podaffinity-target.yaml
apiVersion: v1
kind: Pod
metadata:
  name: pod-podaffinity-target
  namespace: dev
  labels:
    podenv: pro     #设置pod标签
spec:
  containers:
  - name: nginx
    image: nginx:1.17.1
EOF
```
启动
```asp
kubectl create -f pod-podaffinity-target.yaml
```
查看（具有pro标签的参照pod运行在node1）
```asp
kubectl get -f pod-podaffinity-target.yaml -o wide --show-labels
```
```asp
NAME                     READY   STATUS    RESTARTS   AGE   IP               NODE    NOMINATED NODE   READINESS GATES   LABELS
pod-podaffinity-target   1/1     Running   0          46m   10.244.166.140   node1   <none>           <none>            podenv=pro
```
创建pod-podaffinity-requred.yaml
```asp
cat <<EOF> pod-podaffinity-requred.yaml
apiVersion: v1
kind: Pod
metadata:
  name: pod-podaffinity-requred
  namespace: dev
spec:
  containers:
    - name: nginx
      image: nginx:1.17.1
  affinity:                         #亲和性配置
    podAffinity:                    #设置Pod亲和性
      requiredDuringSchedulingIgnoredDuringExecution: #硬限制
      - labelSelector:
           matchExpressions:        #该Pod必须和拥有标签podenv=xxx或者podenv=yyy的Pod在同一个Node
           - key: podenv
             operator: In
             values: ["xxx","yyy"]  #修改xxx或者yyy为pro条件将满足
        topologyKey: kubernetes.io/hostname
EOF
```
启动
```asp
kubectl create -f pod-podaffinity-requred.yaml
```
查看（没有找到符合条件的pod所以status状态为Pending）
```asp
kubectl get -f pod-podaffinity-requred.yaml -o wide --show-labels
```
```asp
NAME                      READY   STATUS    RESTARTS   AGE
pod-podaffinity-requred   0/1     Pending   0          6s
```
查看日志
```asp
kubectl describe -f pod-podaffinity-requred.yaml
```
删除
```asp
kubectl delete -f pod-podaffinity-requred.yaml
```
删除参照pod
```asp
kubectl delete -f pod-podaffinity-target.yaml
```

## podAntiAffinity

"反亲和性"让新Pod和参照Pod不在一个区域

创建参照pod（一个具test标签的pod）
```asp
cat <<EOF> pod-podaffinity-target.yaml
apiVersion: v1
kind: Pod
metadata:
  name: pod-podaffinity-target
  namespace: dev
  labels:
    podenv: test     #设置标签
spec:
  containers:
  - name: nginx
    image: nginx:1.17.1
EOF
```
启动
```asp
kubectl create -f pod-podaffinity-target.yaml
```
查看（具有test标签的参照pod运行在node2）
```asp
kubectl get -f pod-podaffinity-target.yaml -o wide --show-labels
```
```asp
NAME                     READY   STATUS    RESTARTS   AGE   IP              NODE    NOMINATED NODE   READINESS GATES   LABELS
pod-podaffinity-target   1/1     Running   0          18s   10.244.104.42   node2   <none>           <none>            podenv=test
```

创建pod-podantiaffinity-requred.yaml
```asp
cat <<EOF> pod-podantiaffinity-requred.yaml
apiVersion: v1
kind: Pod
metadata:
  name: pod-podantiaffinity-requred
  namespace: dev
spec:
  containers:
    - name: nginx
      image: nginx:1.17.1
  affinity:                   #亲和性配置
    podAntiAffinity:          #Pod反亲和性
      requiredDuringSchedulingIgnoredDuringExecution: #硬限制
      - labelSelector:
          matchExpressions:  #匹配podenv的值在["test"]中的标签
          - key: podenv
            operator: In
            values: ["test"]
        topologyKey: kubernetes.io/hostname
EOF
```
启动
```asp
kubectl create -f pod-podantiaffinity-requred.yaml
```
查看（具有test标签的参照pod运行在node2，反亲和性规则生效新pod运行在node1）
```asp
kubectl get -f pod-podantiaffinity-requred.yaml -o wide
```
```asp
NAME                          READY   STATUS    RESTARTS   AGE   IP               NODE    NOMINATED NODE   READINESS GATES
pod-podantiaffinity-requred   1/1     Running   0          3s    10.244.166.153   node1   <none>           <none>
```
查看日志
```asp
kubectl describe -f pod-podantiaffinity-requred.yaml
```
删除
```asp
kubectl delete -f pod-podantiaffinity-requred.yaml
```
删除参照pod
```asp
kubectl delete -f pod-podaffinity-target.yaml
```
# 污点/容忍调度

## 污点（Taints）

亲和性和反亲和性调度都是站在Pod的角度上，污点可以站在Node的角度上，通过在Node上添加污点属性，来决定Pod调度。
Node被设置了污点之后就和Pod之间存在了一种相斥的关系，进而拒绝Pod调度进来，甚至可以将已经存在的Pod驱逐出去。

**污点的格式：key=value:effect，key和value是污点的标签，effect描述污点的作用，支持如下三个选项：**
- PreferNoSchedule：尽量避免把Pod调度到具有该污点的Node上，除非没有其他节点可以调度。
- NoSchedule：不会把Pod调度到具有该污点的Node上，但是不会影响当前Node上已经存在的Pod。
- NoExecute：不会把Pod调度到具有该污点的Node上，同时也会将Node上已经存在的Pod驱逐。

![](/media/202406/2024-06-25_162239_7471940.3932476879182709.png)

**因为master节点设置了默认污点（NoSchedule），所以pod不会调度到master上来，查看masrer的污点信息**
```asp
kubectl describe node master | grep Taints
```
```asp
Taints:             node-role.kubernetes.io/master:NoSchedule
```

### PreferNoSchedule

规避将Pod调度到具有该污点的Node，除非没有其他节点可以调度。

设置污点至node1
```asp
kubectl taint node node1 tag=done:PreferNoSchedule
```
查看污点
```asp
kubectl describe node node1 | grep Taints
```
创建pod
```asp
kubectl run nginx --image=nginx:1.17.1 -n dev
```
查看pod（当前只有一个node1节点，没有其他节点可以调度，PreferNoSchedule最终允许调度到node1）
```asp
kubectl get pod -n dev -o wide
```
```asp
NAME                    READY   STATUS    RESTARTS   AGE    IP               NODE    NOMINATED NODE   READINESS GATES
nginx-95bc49849-9wcrs   1/1     Running   0          4m5s   10.244.166.129   node1   <none>           <none>
```
取消污点
```asp
kubectl taint node node1 tag:PreferNoSchedule-
```

### NoSchedule

Pod不会调度到具有该污点的Node上，并且不会影响当前Node上已经存在的Pod

设置污点
```asp
kubectl taint node node1 tag=done:NoSchedule
```
查看污点
```asp
kubectl describe node node1 | grep Taints
```
查看刚才创建的pod（nginx的pod依然在运行，NoSchedule不会驱离之前的pod）
```asp
kubectl get pod -n dev -o wide
```
```asp
NAME                    READY   STATUS    RESTARTS   AGE    IP               NODE    NOMINATED NODE   READINESS GATES
nginx-95bc49849-9wcrs   1/1     Running   0          4m5s   10.244.166.129   node1   <none>           <none>
```
再次创建一个pod
```asp
kubectl run nginx-1 --image=nginx:1.17.1 -n dev
```
查看（（nginx-1的pod处于Pending状态，NoSchedule不允许调度到node1）
```asp
kubectl get pod -n dev -o wide
```
```asp
NAME                       READY   STATUS    RESTARTS   AGE   IP               NODE     NOMINATED NODE   READINESS GATES
nginx-1-6688b79b69-nwgvk   0/1     Pending   0          44s   <none>           <none>   <none>           <none>
nginx-95bc49849-9wcrs      1/1     Running   0          11m   10.244.166.129   node1    <none>           <none>
```
删除污点
```asp
kubectl taint node node1 tag:NoSchedule-
```
### NoExecute

Pod不会调度到具有该污点的Node上，并且当前区域不满足条件的pod将会被驱离

设置污点
```asp
kubectl taint node node1 tag=done:NoExecute
```
查看污点
```asp
kubectl describe node node1 | grep Taints
```
查看刚才创建的2个pod（NoExecute驱离了所有pod）
```asp
kubectl get pod -n dev -o wide
```
```asp
NAME                       READY   STATUS    RESTARTS   AGE   IP       NODE     NOMINATED NODE   READINESS GATES
nginx-1-6688b79b69-dhs5g   0/1     Pending   0          25s   <none>   <none>   <none>           <none>
nginx-95bc49849-hflzn      0/1     Pending   0          25s   <none>   <none>   <none>           <none>
```
再次创建一个pod
```asp
kubectl run nginx-2 --image=nginx:1.17.1 -n dev
```
查看（NoExecute不允许调度任何pod）
```asp
kubectl get pod -n dev -o wide
```
```asp
NAME                       READY   STATUS    RESTARTS   AGE    IP       NODE     NOMINATED NODE   READINESS GATES
nginx-1-6688b79b69-dhs5g   0/1     Pending   0          2m4s   <none>   <none>   <none>           <none>
nginx-2-5d75cc6c67-mmv2w   0/1     Pending   0          3s     <none>   <none>   <none>           <none>
nginx-95bc49849-hflzn      0/1     Pending   0          2m4s   <none>   <none>   <none>           <none>
```
删除污点
```asp
kubectl taint node node1 tag:NoExecute-
```
查看（删除node1的污点后所有pod都会自动调度到node1运行）
```asp
kubectl get pod -n dev -o wide
```
```asp
NAME                       READY   STATUS    RESTARTS   AGE     IP               NODE    NOMINATED NODE   READINESS GATES
nginx-1-6688b79b69-dhs5g   1/1     Running   0          3m22s   10.244.166.145   node1   <none>           <none>
nginx-2-5d75cc6c67-mmv2w   1/1     Running   0          81s     10.244.166.148   node1   <none>           <none>
nginx-95bc49849-hflzn      1/1     Running   0          3m22s   10.244.166.149   node1   <none>           <none>
```
删除pod
```asp
kubectl delete deployment -n dev nginx
kubectl delete deployment -n dev nginx-1
kubectl delete deployment -n dev nginx-2
```

## 容忍（Toleration）

污点就是拒绝，容忍就是忽略，Node通过污点拒绝Pod调度上去，Pod通过容忍忽略拒绝。

![](/media/202406/2024-06-25_170621_7665070.16457820253308897.png)

容忍的详细配置
> kubectl explain pod.spec.tolerations
......
FIELDS:
  key       # 对应着要容忍的污点的键，空意味着匹配所有的键
  value     # 对应着要容忍的污点的值
  operator  # key-value的运算符，支持Equal和Exists（默认）
  effect    # 对应污点的effect，空意味着匹配所有影响
  tolerationSeconds   # 容忍时间, 当effect为NoExecute时生效，表示pod在Node上的停留时间

给node1设置NoExecute污点拒绝所有pod调度
```asp
kubectl taint node node1 tag=done:NoExecute
```
查看污点
```asp
kubectl describe node node1 | grep Taints
```
创建pod
```asp
kubectl run nginx --image=nginx:1.17.1 -n dev
```
查看pod（当前只有一个node1节点，没有其他节点可以调度，PreferNoSchedule最终允许调度到node1）
```asp
kubectl get pod -n dev -o wide
```
```asp
NAME                    READY   STATUS    RESTARTS   AGE   IP       NODE     NOMINATED NODE   READINESS GATES
nginx-95bc49849-kkgf4   0/1     Pending   0          11s   <none>   <none>   <none>           <none>
```
设置容忍 pod-toleration.yaml
```asp
cat <<EOF> pod-toleration.yaml
apiVersion: v1
kind: Pod
metadata:
  name: nginx-toleration
  namespace: dev
spec:
  containers:
  - name: nginx
    image: nginx:1.17.1
  tolerations:          #容忍
  - key: "tag"          #要容忍的污点的key
    operator: Equal     #操作符(=)
    value: "done"       #要容忍的污点的value(tag=done:NoExecute)
    effect: NoExecute   #添加容忍的规则，这里必须和标记的污点规则相同
EOF
```
启动
```asp
kubectl create -f pod-toleration.yaml
```
查看（新创建的nginx-toleration设置了针对NoExecute的容忍所以成功运行到node1）
```asp
kubectl get pod -n dev -o wide
```
```asp
NAME                    READY   STATUS    RESTARTS   AGE    IP               NODE     NOMINATED NODE   READINESS GATES
nginx-95bc49849-kkgf4   0/1     Pending   0          3m3s   <none>           <none>   <none>           <none>
nginx-toleration        1/1     Running   0          2s     10.244.166.150   node1    <none>           <none>
```
删除污点
```asp
kubectl taint node node1 tag:NoExecute-
```
删除pod
```asp
kubectl delete -f pod-toleration.yaml
```