#下面是一个pod亲和性基本配置示例，在调度时，myapp 的 Pod 必须被调度到与 default 命名空间中带有 app: redis 标签的 Pod 所在的同一个节点（Node）上；如果找不到这样的 Redis Pod，myapp 的 Pod 将无法调度（处于 Pending 状态）
[root@k8s-master01 affinity]# cat myapp-affinity.yaml
apiVersion: apps/v1   # API 版本。Deployment 资源属于 apps 组，v1 是当前稳定
kind: Deployment  #资源类型。声明这是一个 Deployment 对象，用于管理无状态应用
metadata:  # 元数据区域，定义该资源的身份信息
  name: myapp  # Deployment 的名称。在同一个 namespace 下必须唯一
  namespace: default  # 所属命名空间。未指定时默认为 default空间
spec:    # 规格定义区域，描述 Deployment 的期望状态
  replicas: 2   # 期望运行的 Pod 副本数量是2
  selector:   # 标签选择器。Deployment 通过它来识别和管理哪些 Pod 
    matchLabels:  # 精确匹配模式。只有标签完全匹配以下键值对的 Pod 才会被纳入管理
      app: myapp   # 匹配条件：Pod 必须带有 app=myapp 标签。
  template:   # Pod 模板。当需要创建新 Pod 时（如扩容、滚动更新），均按此模板生成
    metadata:   # Pod 自身的元数据
      labels:   # 定义Pod的标签。必须包含上面 selector.matchLabels 中定义的所有键值对
        app: myapp  #必须与上面selector.matchLabels对应
    spec:
      # affinity：定义 Pod 的亲和性/反亲和性规则
      affinity:

        # podAffinity：Pod 亲和力
        # 含义：希望当前 Pod 与满足条件的其他 Pod 调度到相同拓扑域
        podAffinity:

          # requiredDuringSchedulingIgnoredDuringExecution：
          # 硬性要求。
          # 调度 Pod 时必须满足下面的规则，否则 Pod 不会被调度。
          # IgnoredDuringExecution 表示：
          # Pod 已经运行后，即使节点 Label 等发生变化，也不会把 Pod 自动迁走。
          requiredDuringSchedulingIgnoredDuringExecution:

            # 一个 PodAffinityTerm，定义“我要靠近谁，以及多近”
            - labelSelector:

                # matchLabels：选择目标 Pod
                # 这里表示寻找具有 app=redis 标签的 Pod
                matchLabels:
                  app: redis

              # namespaces：
              # 指定在哪些 namespace 中寻找上述 Pod。
              # 如果不配置 namespaces，默认只匹配当前 Pod 所在的 namespace。
              namespaces:
                - default

              # topologyKey：拓扑键
              # Scheduler 会读取目标 Pod 所在节点的这个 Label，
              # 然后要求当前 Pod 也进入相同 Label 值的拓扑域。
              #
              # 使用 kubernetes.io/hostname 时：
              # 每个 Node 通常就是一个独立拓扑域，
              # 因此效果就是“和 Redis 放到同一个 Node”。
              topologyKey: kubernetes.io/hostname

      containers:
        - name: myapp
          image: nginx:1.27

          ports:
            - name: http
              containerPort: 80

affinity:    # 定义亲和性和反亲和性规则
  podAffinity:   # Pod 亲和力：希望当前 Pod 靠近某类 Pod

    requiredDuringSchedulingIgnoredDuringExecution:
      # required：硬性要求，调度时必须满足
      # DuringScheduling：Pod 调度阶段检查
      # IgnoredDuringExecution：Pod 运行后，即使条件变化，也不会自动迁移

      - labelSelector:
          # labelSelector：定义“我要靠近哪些 Pod”

          matchExpressions:
            # matchExpressions：使用表达式匹配 Pod 标签
            # 相比 matchLabels，可以使用 In、NotIn、Exists 等条件

            - key: security
              # key：要匹配的 Pod Label 的 key
              # 例如目标 Pod 上需要存在：
              # security=S1

              operator: In
              # operator：匹配运算符
              # In 表示标签值必须属于 values 列表中的某个值

              values:
                - S1
              # values：允许匹配的标签值
              # 当前配置相当于：
              # security 的值必须是 S1

        topologyKey: topology.kubernetes.io/zone
        # topologyKey：定义什么叫“靠近”
        # 这里按 zone 划分拓扑域
        #
        # 例如：
        # node01 topology.kubernetes.io/zone=zone-a
        # node02 topology.kubernetes.io/zone=zone-a
        # node03 topology.kubernetes.io/zone=zone-b
        #
        # 如果 security=S1 的 Pod 在 node01，
        # 那么当前 Pod 可以调度到 node01 或 node02，
        # 因为它们都属于 zone-a

        namespaces:
          - default
        # namespaces：在哪些 namespace 中寻找符合 labelSelector 的目标 Pod
        # 这里表示只查找 default namespace
        #
        # 如果不写 namespaces，
        # 默认只查找当前 Pod 所在的 namespace

matchExpressions:
  - key: security
    operator: In
    values:
      - S1    
它等价于：
matchLabels:
  security: S1

matchExpressions:
  - key: security
    operator: In
    values:
      - S1
      - S2
# 表示：security=S1 或者 security=S2
# 而 matchLabels 就不方便直接表达这种“多个值任选其一”的条件。      

matchExpressions:
  - key: gpu
    operator: Exists

affinity:   # 定义亲和性和反亲和性规则
  podAffinity: # Pod 亲和性规则，定义当前 Pod 希望与哪些其他 Pod 靠近
    
    # preferredDuringSchedulingIgnoredDuringExecution: 
    # 软性偏好规则。
    # Scheduler 会尽量满足此规则，但如果无法满足（例如没有符合条件的 Pod 或资源不足），
    # Pod 仍然会被调度到其他节点，不会导致 Pod 处于 Pending 状态。
    preferredDuringSchedulingIgnoredDuringExecution: 
      - weight: 100 # 权重值（1-100）。
                    # 当有多个偏好规则时，权重越高，Scheduler 越优先满足该规则。
                    # 这里设为 100 表示最高优先级偏好。
        
        podAffinityTerm: # 定义具体的亲和性匹配条件
          labelSelector: # 标签选择器，用于筛选目标 Pod
            matchExpressions: # 基于表达式的匹配模式，比 matchLabels 更灵活
              - key: security # 目标 Pod 的标签键名
                operator: In # 操作符，表示“包含在以下值中”
                values: # 对应的标签值列表
                  - S2 # 寻找标签为 security=S2 的 Pod
          topologyKey: topology.kubernetes.io/zone # 拓扑键，表示希望当前 Pod 与目标 Pod 位于相同的“可用区（Zone）”
          namespaces: # 指定在哪些命名空间中寻找目标 Pod
            - default # 仅在 default 命名空间中查找带有 security=S2 标签的 Pod

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx
  namespace: default

spec:
  replicas: 3

  selector:
    matchLabels:
      app: nginx

  template:
    metadata:
      labels:
        app: nginx   # 当前 Pod 的标签，反亲和规则会通过这个标签识别同类 Pod

    spec:
      affinity:   # 定义亲和性和反亲和性规则

        podAntiAffinity:   # Pod 反亲和：避免当前 Pod 与指定 Pod 位于同一拓扑域

          requiredDuringSchedulingIgnoredDuringExecution:
            # required：硬性反亲和
            # 调度时必须满足，否则 Pod 会保持 Pending
            # IgnoredDuringExecution：Pod 运行后规则发生变化，不会自动驱逐已有 Pod

            - labelSelector:
                # labelSelector：选择“需要避开的 Pod”

                matchLabels:
                  app: nginx
                  # 匹配 app=nginx 的 Pod
                  # 即当前 nginx Pod 要避开其他 nginx Pod

              namespaces:
                - default
                # 在哪些 namespace 中查找目标 Pod
                # 这里表示只检查 default 命名空间
                # 如果不配置，默认也是当前 Pod 所在 namespace

              topologyKey: kubernetes.io/hostname
              # topologyKey：定义“不能处于同一个什么范围”
              # kubernetes.io/hostname 表示以 Node 为拓扑域
              # 即 nginx Pod 不能和其他 nginx Pod 在同一个 Node

affinity:
  podAntiAffinity:

    preferredDuringSchedulingIgnoredDuringExecution:
      # preferred：软性规则
      # 尽量满足，无法满足时仍然可以调度

      - weight: 100
        # 权重范围 1~100
        # 数值越大，Scheduler 越倾向满足这条规则

        podAffinityTerm:
          # 注意：
          # Pod 软亲和和 Pod 软反亲和这里都使用 podAffinityTerm

          labelSelector:
            matchLabels:
              app: nginx
              # 希望避开的 Pod

          namespaces:
            - default

          topologyKey: kubernetes.io/hostname
          # 尽量不要和 app=nginx 的 Pod 位于同一个节点

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
  namespace: default
spec:
  replicas: 2   # 创建 2 个 Pod 副本
  selector:
    matchLabels:
      app: myapp   # Deployment 通过该标签管理 Pod
  template:
    metadata:
      labels:
        app: myapp
    spec:
      affinity:  # affinity：定义亲和性/反亲和性调度规则

        # nodeAffinity：节点亲和力
        # 根据 Node 的 Label 决定 Pod 应该调度到哪些节点
        nodeAffinity:
          # ============================
          # 1. 节点硬亲和
          # ============================
          requiredDuringSchedulingIgnoredDuringExecution:
            # required：必须满足
            # DuringScheduling：Pod 调度时检查
            # IgnoredDuringExecution：
            # Pod 已经运行后，即使节点 Label 发生变化，
            # Kubernetes 也不会因此自动驱逐这个 Pod

            nodeSelectorTerms:
              # nodeSelectorTerms：定义节点筛选条件
              # 这里可以配置一个或多个 NodeSelectorTerm

              - matchExpressions:  # matchExpressions：通过表达式匹配 Node Label
                  - key: disk
                    # key：节点 Label 的 key
                    # 例如节点上：
                    # disk=ssd

                    operator: In
                    # operator：匹配运算符
                    # In 表示 Label 的值必须位于 values 列表中

                    values:  # values：允许的 Label 值
                      - ssd   # 表示 Pod 必须调度到 disk=ssd 的节点
          # ============================
          # 2. 节点软亲和
          # ============================
          preferredDuringSchedulingIgnoredDuringExecution:
            # preferred：优先满足，但不是强制要求
            # 如果找不到满足条件的节点，Pod 仍然可以调度

            - weight: 100
              # weight：这条软亲和规则的权重
              # 范围：1~100
              # 数值越大，Scheduler 越倾向选择满足该条件的节点

              preference:
                # preference：定义具体的节点偏好条件
                # 注意：Node 软亲和这里使用 preference

                matchExpressions:
                  # 通过 Node Label 表达式匹配节点
                  - key: gpu
                    # Node Label 的 key
                    operator: In
                    # gpu 的值必须位于 values 中
                    values:
                      - A100
                    # 优先选择 gpu=A100 的节点
      containers:
        - name: myapp
          image: nginx:1.27

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app  #定义的pod标签时app=myapp
    spec:
      affinity:
        podAntiAffinity:
          # 硬性反亲和：必须满足，否则 Pod 会一直 Pending
          requiredDuringSchedulingIgnoredDuringExecution:
          - labelSelector:
              matchLabels:
                app: my-app   # 不要和自己有相同标签的pod部署到一起
            topologyKey: kubernetes.io/hostname  # 关键！按节点 hostname 排斥
            namespaces:
              - default    # 不要和默认命名空间的pod部署到一起
      containers:
      - name: app
        image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/nginx:latest

[root@k8s-master01 20-affinity]# cat my-app.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app  #定义的pod标签时app=myapp
    spec:
      affinity:
        podAntiAffinity:
          # pod软亲和性，尽量满足，不强制要求必须满足
          preferredDuringSchedulingIgnoredDuringExecution:
              - weight: 100
                podAffinityTerm:
                    labelSelector:
                        matchExpressions:
                            - key: app
                              operator: In
                              values:
                                - my-app
                    topologyKey: kubernetes.io/hostname  # 关键！按节点 hostname 排斥
                    namespaces:
                      - default    # 不要和默认命名空间的pod部署到一起
      containers:
      - name: app
        image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/nginx:latest

[root@k8s-master01 20-affinity]# cat diff-zone.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  replicas: 2
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app  #定义的pod标签时app=myapp
    spec:
      affinity:
        podAntiAffinity:
          # 硬性反亲和：必须满足，否则 Pod 会一直 Pending
          requiredDuringSchedulingIgnoredDuringExecution:
            - labelSelector:
                matchExpressions:
                  - key: app
                    operator: In
                    values:
                      - my-app
              topologyKey: zone  #按照zone来划分拓扑域
              namespaces:
                - default
      containers:
      - name: app
        image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/nginx:latest

[root@k8s-master01 20-affinity]# cat my-app.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  replicas: 2
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app  #定义的pod标签时app=myapp
    spec:
      affinity:
        podAffinity:
          # 硬性反亲和：必须满足，否则 Pod 会一直 Pending
          requiredDuringSchedulingIgnoredDuringExecution:
            - labelSelector:
                matchExpressions:
                  - key: app
                    operator: In
                    values:
                      - redis-cache
              topologyKey: zone
              namespaces:
                - default    # 不要和默认命名空间的pod部署到一起
      containers:
      - name: app
        image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/nginx:latest

[root@k8s-master01 20-affinity]# cat disktype.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  replicas: 2
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app  #定义的pod标签时app=myapp
    spec:
      affinity:
        nodeAffinity:
          # 硬性反亲和：必须满足，否则 Pod 会一直 Pending
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
              - matchExpressions:
                  - key: disktpye
                    operator: In
                    values:  #满足任意一个即可
                      - ssd  
                      - nvme
      containers:
      - name: app
        image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/nginx:latest

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  replicas: 1
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app  #定义的pod标签时app=myapp
    spec:
      affinity:
        nodeAffinity:
          # 硬性反亲和：必须满足，否则 Pod 会一直 Pending
          preferredDuringSchedulingIgnoredDuringExecution:
            - weight: 50
              preference:
                matchExpressions:
                  - key: disktype
                    operator: In
                    values:
                      - ssd
            - weight: 90
              preference:
                matchExpressions:
                  - key: disktype
                    operator: In
                    values:
                      - nvem
      containers:
      - name: app
        image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/nginx:latest

vim performance.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app  #定义的pod标签时app=myapp
    spec:
      affinity:
        nodeAffinity:
          # 软亲和性，尽量满足
          preferredDuringSchedulingIgnoredDuringExecution:
            - weight: 100
              preference:
                matchExpressions:
                  - key: performance
                    operator: NotIn
                    values:
                      - low
      containers:
      - name: app
        image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/nginx:latest

[root@k8s-master01 20-affinity]# vim spread.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  replicas: 8
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app  #定义的pod标签时app=myapp
    spec:
      affinity:
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
            - matchExpressions:
              - key: region
                operator: In
                values:
                - beijing

      topologySpreadConstraints:
      - maxSkew: 1
        topologyKey: zone
        whenUnsatisfiable: DoNotSchedule
        labelSelector:
          matchLabels:
            app: my-app

      containers:
      - name: app
        image: registry.cn-beijing.aliyuncs.com/k8s-liujunwei/nginx:latest
# 注意：topologySpreadConstraints和affinity可以分开单独使用