《蹲坑学K8S》之26-3:nodeAffinity

NodeAffinity就是节点亲和性，相对应的是 Anti-Affinity，就是反亲和性，这种方法比上面的nodeSelector更加灵活，它可以进行一些简单的逻辑组合了，不只是简单的相等匹配。

1、Affinity相对于nodeSelector机制的优点：

（1）表达的语法：支持In,NotIn,Exists,DoesNotExist,Gt,Lt．

（2）支持soft(preference)和hard(requirement),hard表示pod sheduler到某个node上，则必须满足亲和性设置。soft表示scheduler的时候，无法满足节点的时候，会选择非nodeSelector匹配的节点。

（3）nodeAffinity的基础上添加多个nodeSelectorTerms字段，调度的时候Node只需要nodeSelectorTerms中的某一个符合条件就符合nodeAffinity的规则．在nodeSelectorTerms中添加matchExpressions，需要可以调度的Node是满足matchExpressions中表示的所有规则。

2、节点Node 亲和性支持两种形式：

（1）requiredDuringSchedulingIgnoredDuringExecution 必须满足策略，如果不满足则不进行调度。

（2）preferredDuringSchedulingIgnoredDuringExecution 倾向满足策略，不满足的情况下会调度的不符合条件的Node上。

其中IgnoreDuringExecution表示在Pod运行期间Node的标签发生变化，导致亲和性策略不能满足，则继续运行当前的Pod。

可以将这个分作两段来看：

前半段requiredDuringScheduling表示下面定义的规则必须强制满足（require）。

后半段IgnoredDuringExecution表示不会影响已经在节点上运行的Pod，目前Kubernetes提供的规则都是以IgnoredDuringExecution结尾的，因为当前的节点亲缘性规则只会影响正在被调度的pod，最终，kubernetes也会支持RequiredDuringExecution，即去除节点上的某个标签，那些需要节点包含该标签的pod将会被剔除。

requiredDuringSchedulingRequiredDuringExecution 必须满足策略，如果不满足则不进行调度。

preferredDuringSchedulingRequiredDuringExecution 倾向满足策略，不满足的情况下会调度的不符合条件的Node上。

其中RequiredDuringExecution表示运行的pod所在Node节点不再满足条件，kubernetes会把pod从Node节点中删除，重新选择符合策略要求的Node节点。这个属性暂时还不支持。

[root@k8s-master-1 ~]# kubectl label nodes k8s-node-1 yiihu.cn/foo=foo

[root@k8s-master-1 ~]# kubectl get nodes k8s-node-1 --show-labels

硬策略应用

[root@k8s-master-1 ~]# vim test-nodeaffinity.yaml
添加：
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx
spec:
  selector:
    matchLabels:
      role: frontend
  replicas: 2
  template:
    metadata:
      labels:
        role: frontend
    spec:
      affinity:                                                                                       ##亲和性
        nodeAffinity:                                                                            ##node亲和性
          requiredDuringSchedulingIgnoredDuringExecution:            ##硬策略
            nodeSelectorTerms:                                                             ##节点选择器
            - matchExpressions:
              - key: yiihu.cn/foo
                operator: In
                values:
                - foo
      containers:
      - name: nginx
        image: nginx:1.16
        ports:
        - name: http
          containerPort: 80

软策略应用

[root@k8s-master-1 ~]# vim test-nodeaffinity.yaml
添加：
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx
spec:
  selector:
    matchLabels:
      role: frontend
  replicas: 2
  template:
    metadata:
      labels:
        role: frontend
    spec:
      affinity:
        nodeAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:                  ##软策略
          - weight: 1                                                                                     ##权重
            preference:
              matchExpressions:
              - key: yiihu.cn/foo
                operator: In
                values:
                - foo
          - weight: 100                                                                                  ##权重
            preference:
              matchExpressions:
              - key: yiihu.cn/foo
                operator: NotIn
                values:
                - foo
 
      containers:
      - name: nginx
        image: nginx:1.16
        ports:
        - name: http
          containerPort: 80

注解：

In: label的值在某个列表中

NotIn：label的值不在某个列表

Exists：某个label存在

DoesNotExist：某个label不存在

Gt：label的值大于某个值（字符串比较）

Lt：label的值小于某个值（字符串比较）

如果nodeAffinity中nodeSelector有多个选项，节点满足任何一个条件即可；如果matchExpressions有多个选项，则节点必须同时满足这些选项才能运行pod 。

需要说明的是并没有nodeAntiAffinity（节点反亲和），因为NotIn和DoesNotExist可以提供相同的功能。

案例：

[root@k8s-master-1 ~]# vim test-nodeaffinity.yaml
添加：
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx
spec:
  selector:
    matchLabels:
      role: frontend
  replicas: 2
  template:
    metadata:
      labels:
        role: frontend
    spec:
      affinity:                                                                                              ##亲和性
        nodeAffinity:                                                                                   ##node亲和性
          requiredDuringSchedulingIgnoredDuringExecution:                   ##硬策略
            nodeSelectorTerms:                                                                    ##节点选择器
            - matchExpressions:
              - key: kubernetes.io/hostname
                operator: In
                values:
                - k8s-node-1
                - k8s-node-2
          preferredDuringSchedulingIgnoredDuringExecution:                  ##软策略
          - weight: 1
            preference:
              matchExpressions:
              - key: yiihu.cn/foo
                operator: In
                values:
                - foo
      containers:
      - name: nginx
        image: nginx:1.16
        ports:
        - name: http
          containerPort: 80

由此可见：pod同时定义了requiredDuringSchedulingIgnoredDuringExecution和preferredDuringSchedulingIgnoredDuringExecution两种nodeAffinity：

第一个策略：Pod运行在特定k8s-node-1和k8s-node-2节点上。

第二个策略：Node节点上最好有对应的yiihu.cn/foo=foo标签。

总结：NodeAffinity： node节点亲和性

硬限制：必须满足指定的规则才可以调度pod到node上

软限制：优先满足指定规则，调度器会尝试调度pod到node上， 但不强求。