^-^
【go云原生】Kubernetes Pod调度
最近更新：2025-01-07   |   字数总计：2.4k   |   阅读估时：9分钟   |   阅读量：次
  1. Kubernetes Pod调度
    1. 污点与容忍度调度
    2. 节点选择器调度
    3. 亲和性与反亲和性调度
      1. 节点亲和性（pod和node）
      2. pod亲和性和反亲和性（pod与pod）

Kubernetes Pod调度

污点与容忍度调度

1
2
3
4
5
6
7
8
9
10
11
12
13
git clone http://gitlab.0voice.com/golangvip/mock-app.git
# 创建配置文件
kubectl create configmap mock-app-conf --from-file config.yaml=config.yaml
# 创建证书资源
kubectl create secret tls mock-app-crt --cert cert/tls.crt --key cert/tls.key
# 创建docker注册中心登录密钥 
kubectl create secret docker-registry 161dockerauth --docker-server 192.168.239.161:5000 --docker-username lin --docker-password 123456

kubectl apply -f Deployment.yaml
kubectl apply -f Service.yaml

kubectl describe node worker1 # 查看worker1节点的Taints污点，为none
kubectl describe node master # 查看master节点的Taints污点，为node-role.kubernetes.io/control-plane:NoSchedule

  • 污点和容忍度的作用

    1. 污点，是集群节点的一组属性，用于排斥一类特定的pod
    2. 容忍度是应用与pod上的，用来表示pod对带有污点节点的接受程度。
    3. 污点和容忍度相互配合，可以用来避免pod被分配到不合适的节点上。
    4. 每个节点上可以应用一个或多个污点，表示对于那些不能容忍这些污点的Pod，是不会被该节点接受的
    5. pod必须容忍节点的所有污点，才能被节点接受

  • 污点结构与设置

    • 必须包含key和effect两部分，可以不设置value
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      # 结构
      key/value:effect

      #添加污点key=key1,effect=Noschedule
      kubectl taint node k8s-node1 key1:NoSchedule
      #添加污点 key=key1,value=valuel,effect=preferNoschedule 
      kubectl taint node k8s-node1 key1=value1:PreferNoSchedule 
      #添加污点 key=key1,value=valuel,effect=NoExecute
      kubectl taint node k8s-node1 key1=value1:NoExecute 
      #修改已存在的污点
      kubectl taint node k8s-node1 --overwrite keyl=v1:Noschedule 
      #删除污点
      kubectl taint node k8s-node1 key1=v1:NoSchedule- 
      kubectl taint node k8s-node1 key1-

  • effect的值及其作用

    1. Noshedule: 表示除非具有匹配的容忍度，否则新的pod将不会调度到带有污点的节点上。当前正在节点上运行的pod不会被驱逐
    2. PreferNoSchedule: 调度器尽量避免将不能容忍污点的pod调度到节点上，但是不能完全避免
    3. NoExecute: 如果Pod不能容忍这类污点，会马上被驱逐；如果Pod能够容忍这类污点，但是在容忍度定义中没有指定tolerationSeconds，则Pod还会一直在这个节点上运行；如果Pod能够容忍这类污点，而且指定了 toleralionSeconds，则Pod还能在这个节点上继续运行这个指定的时间长度。这段时间过去后，节点生命周期控制器从节点驱除这些Pod。

  • pod容忍度operator值及其含义

    1. Equal：匹配key与value（value可以是空值）都相等的污点，如果指定了effect则effect也必须相等，如果没有指定effect则匹配所有的effect值。
    2. Exists：不能指定value值，匹配key相等的污点，如果指定了effect则effect也必须相等，如果没有指定effect则匹配所有的effect值，如果没有指定key，则容忍任何污点，即使指定了不匹配的effect
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      vim Deployment.yaml
      > spec: 
      >   template:
      >       spec:
      >           toleralion:
      >           - key: key1
      >               operator: Equal
      >               value: v1
      >               effect: NoExecute
      >               toleralionSeconds: 20
      >           - key: key2
      >               operator: Equal
      >               value: v2
      >               effect: Noschedule

  • 利用节点污点进行节点维护

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    # 先将节点的污点都去掉
    kubectl taint node worker1 k1-
    kubectl taint node worker1 k2-
    kubectl apply -f Deployment.yaml # 此时的pod容忍度只设置了k1：v1：NoExecute 20s
    kubectl get pod -o wide # 可以看到节点几乎平均分配到了worker1和worker2上
    # 下面我们要对woker1作维护
    kubectl taint node worker1 k1=v1:NoSchedule # 现有的pod不会被影响
    kubectl taint node worker1 k1=v1:NoExecute # 现有的worker1上的pod 20s之后会被排除
    # 维护结束
    kubectl taint node worker1 k1=v1:NoExecute-
    kubectl taint node worker1 k1=v1:NoSchedule-
    vim Deployment.yaml
    > spec:
    >   replicas: 10 # 使用更改副本数的方式触发调度
    kubectl get pod -o wide # 调度回来了

  • 容忍度规则案例解读

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    # 容忍度规则设置
    tolerations:
    # 第一条
    - key:k1
        operator: "Equal"
        value:v1
        effect: NoExecute
        tolerationseconds: 3600第二条
    # 第二条 
    - key：k2
     operator: "Equal"
     value: v2
     effect: NoExecute
    # 第三条
    - key:k3
     operator: "Equal"
     value: v3
    # 第四条
    - key:k4
     operator: "Equal"
    # 第五条
    - key:k5
      operator: "Exists"
      effect: NoSchedule
    # 第六条
    - key:k6
      operator: "Exists"
    # 第七条
      effect: NoSchedule
      operator Exists 

    # 1. 四配key=k1.value=v1,effect=NoExecute的污点，容忍时长3600s，3600s后，pod将被驱逐
    # 2. 匹配key=k2,value=v2,effect=NoExecute的污点，pod不会被驱逐
    # 3. 匹配key=k3,value=v3的污点
    # 4. 匹配key=k4,value为空的污点
    # 5. 匹配key=k5,effect=NoSchedule的污点
    # 6. 匹配key=k6的污点
    # 7. 匹配任意污点

  • 内置污点

    • 当某种条件为真的时候，节点控制器会自动给节点加上污点，当我们发现有以下污点出现在节点上，就可以根据污点类型进行排查。
    1. node.kubernetes.io/not-ready：节点未准备好。这相当于节点状况Ready的值为“False”
    2. node.kubernetes.io/unreachable：节点控制器访问不到节点.这相当于节点状况Ready的值为Unknown。
    3. node.kubernetes.io/memory-pressure: 节点存在内存压力。
    4. node.kubernetes.io/disk-pressure：节点存在磁盘压力
    5. node.kubernetes.io/pid-pressure：节点的PID压力。
    6. node.kubernetes.io/network-unavailable：节点网络不可用。
    7. node.kubernetes.io/unschedulable：节点不可调度
    8. node.cloudprovider.kubernetes.io/uninitialized：如果kubelet启动时指定了一个外部云平台驱动，它将给当前节点添加一个污点将其标志为不可用。在cloud-controller-manager的一个控制器初始化这个节点后 kubelet将删除这个污点

  • 控制平面使用节点控制器自动创建与节点状况对应的、效果为NoSchedule的污点。调度器在进行调度的时候检查污点，而不会检查节点状态。这确保了节点状况不会直接影响调度。

节点选择器调度

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
vim Deployment.yaml
> spec:
>   template:
>       spec:
>           nodeName: master1
kubectl apply -f Deployment.yaml 
kubectl get pod -o wide # 我们可以发现节点名称优先级是高于容忍度和污点的

kubectl label nodes worker1 disktype=ssd
kubectl label nodes worker2 disktype=machinery
vim Deployment.yaml
> spec:
>   template:
>       spec:
>           nodeSelector: # 可以包含多个，但是多个必须都匹配
>               disktype: ssd
kubectl apply -f Deployment.yaml 
kubectl get pod -o wide

亲和性与反亲和性调度

节点亲和性（pod和node）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
apiVersion: v1
kind: Pod
metadata:
  name: with-node-affinity
spec:
  affinity: # 亲和性定义
     nodeAffinity: # 我们定义的pod和node之间的亲和性
       requiredDuringSchedulinggnoredDuringExecution: # 必须设置
        nodeselectorTerms: # 节点选择条件
           - matchExpressions: # 表达式匹配条件
                - key: topology.kubernetes.io/zone # 匹配的节点label
                    operator: In # 需要是下面value中的一个
                    values:
                    - antarctica-eastl
                    - antarctica-westl
       preferredDuringSchedulinggnoredDuringExecution: # 偏好设置
       - weight: 1 # 权重，1~100
         preference: # 首选项 ， 下面两个都要符合，如果没有将会处于pending状态
           matchExpressions:  # 按表达式
            - key: another-node-label-key
              operator: In
              values:
              - another-node-label-value
           matchFields: # 按字段
           - key: metadata.name
                operator: In
                values:
                - worker2
  containers:
  - name: with-node-affinity
    image: registry.k8s.io/pause: 2.0
  • operator
    1. In：标签值存在于提供的字符串集中
    2. Notln：标签值不包含在提供的字符串集中
    3. Exists：对象上存在具有此键的标签
    4. DoesNotExist：对象上不存在具有此键的标签
    5. Gt：提供的值将被解析为整数，并且该整数小于通过解析此选择算符命名的标签的值所得到的整数
    6. Lt：提供的值将被解析为整数，并且该整数大于通过解析此选择算符命名的标签的值所得到的整数
    7. Gt和Lt操作符不能与非整数值一起使用。如果给定的值未解析为整数，则该Pod将无法被调度
    8. Gt和Lt不适用于podAffinity，只能与nodeAffinity一起使用

pod亲和性和反亲和性（pod与pod）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
apiVersion: v1
kind: Pod
metadata: 
  name: with-pod-affinity
spec:
  affinity:
    podAffinity: # pod亲和性
       requiredDuringSchedulinggnoredDuringExecution: # 必须配置
       - labelselector:
            matchExpressions: 
            - key: security # pod标签
              operator: In
              values:
              - S1
          topologykey: topology.kubernetes.io/zone # k8s集群的节点分区定义
    podAntiAffinity: # pod反亲和性
      preferredDuringSchedulinggnoredDuringExecution: # 偏好配置
      - weight: 100
         podAffinityTerm:
             labelselector:
              matchExpressions:
              - key: security
                operator: In
                values:
                - S2
              topologykey: topology.kubernetes.io/zone
   containers:
   - name:with-pod-affinity
   image: registry.k8s.io/pause: 2.0
  • 亲和性规则规定，只有节点属于特定的区域且该区域中的其他Pod已打上security=S1标签时，调度器才可以将示例Pod调度到此节点上。例如，如果我们有一个具有指定区域（称之为“ZoneV）的集群，此区域由带有topology.kubernetes.io/zone=V标签的节点组成，那么只要Zonev内已经至少有一个Pod打了security=S1标签，调度器就可以将此Pod调度到ZoneV内的任何节点。相反，如果ZoneV中没有带有security=S1标签的Pod，则调度器不会将示例Pod调度给该区域中的任何节点
  • 反亲和性规则规定，如果节点属于特定的区域且该区域中的其他Pod已打上security=S2标签则调度器应尝试避免将Pod调度到此节点上。例如，如果我们有一个具有指定区域（我们称之为ZoneR）的集群，此区域由带有topology.kubernetes.io/zone=R标签的节点组成，只要ZoneR内已经至少有一个Pod打了security=S2标签，调度器应避免将Pod分配给ZoneR内的任何节点。相反，如果ZoneR中没有带有security=S2标签的Pod，则反亲和性规则不会影响将Pod调度到Zone
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    # 为节点进行分区操作
    kubectl label nodes worker1 region=A
    kubectl label nodes worker2 region=B
    # 亲和性设置
    vim Deployment.yaml
    spec:
       replicas: 10
       selector:
        matchLabels：
          app:mockapp
       template: 
         metadata:
            Labels:
                app: mockapp
         spec:
           affinity:
            podAffinity:
              requiredDuringschedulingIgnoredDuringExecution:
                LabelSelector:
                   matchLabels
                    app: mockapp
                topologykey: region # 以分区为最终决定
           restartPolicy: Always
           imagePulisecrets:
              name: 16ldockerauth

    kubectl apply -f Deployment.yaml
  • 亲和性和反亲和性不要应用于大规模的集群，因为涉及到计算，可能会影响性能
2025-01-07 该篇文章被 Cleofwine 归为分类: Go云原生

上一篇：【go云原生】k8s有状态应用程序的部署 下一篇：【go云原生】Ceph文件系统与K8s
© 2023-2026 Cleofwine / Email / GitHub / 浙ICP备2024136127号
🌙赠我弯弯一枚月，也赠予我晚星⭐ 本站由Hexo驱动｜使用Hexo-theme-A4主题