Simple Blog

1
静态供给：
2
管理员手动创建PV → 用户创建PVC → 自动绑定
3

4
动态供给：
5
用户创建PVC（指定StorageClass）→ 自动创建PV → 自动绑定

1
apiVersion: v1
2
kind: Pod
3
metadata:
4
  name: emptydir-demo
5
spec:
6
  containers:
7
  - name: writer
8
    image: busybox
9
    command: ['sh', '-c', 'echo "Hello" > /data/msg.txt; sleep 3600']
10
    volumeMounts:
11
    - name: shared-data
12
      mountPath: /data
13

14
  - name: reader
15
    image: busybox
16
    command: ['sh', '-c', 'while true; do cat /data/msg.txt 2>/dev/null; sleep 5; done']
17
    volumeMounts:
18
    - name: shared-data
19
      mountPath: /data
20

21
  volumes:
22
  - name: shared-data
23
    emptyDir: {}      # 使用磁盘
24
    # emptyDir:
25
    #   medium: Memory  # 使用内存（更快）

1
apiVersion: v1
2
kind: Pod
3
metadata:
4
  name: hostpath-demo
5
spec:
6
  containers:
7
  - name: nginx
8
    image: nginx:1.20
9
    volumeMounts:
10
    - name: host-data
11
      mountPath: /usr/share/nginx/html
12

13
  volumes:
14
  - name: host-data
15
    hostPath:
16
      path: /data/nginx
17
      type: DirectoryOrCreate

1
Available（可用）→ Bound（已绑定）→ Released（已释放）→ Failed（失败）

1
apiVersion: v1
2
kind: PersistentVolume
3
metadata:
4
  name: pv-nfs-001
5
spec:
6
  capacity:
7
    storage: 10Gi
8

9
  accessModes:
10
  - ReadWriteOnce
11

12
  persistentVolumeReclaimPolicy: Retain
13

14
  storageClassName: nfs-storage
15

16
  nfs:
17
    server: 192.168.100.14
18
    path: /data/nfs/pv-001

1
apiVersion: v1
2
kind: PersistentVolumeClaim
3
metadata:
4
  name: mysql-pvc
5
  namespace: default
6
spec:
7
  accessModes:
8
  - ReadWriteOnce
9

10
  resources:
11
    requests:
12
      storage: 10Gi
13

14
  storageClassName: nfs-storage

1
匹配条件（全部满足）：
2
1. accessModes 匹配
3
2. storage大小满足（PV >= PVC）
4
3. storageClassName 匹配
5

6
优先级：
7
1. 大小精确匹配
8
2. 最小满足（PV略大于PVC）

1
apiVersion: v1
2
kind: Pod
3
metadata:
4
  name: mysql-pod
5
spec:
6
  containers:
7
  - name: mysql
8
    image: mysql:8.0
9
    volumeMounts:
10
    - name: mysql-data
11
      mountPath: /var/lib/mysql
12

13
  volumes:
14
  - name: mysql-data
15
    persistentVolumeClaim:
16
      claimName: mysql-pvc

1
apiVersion: storage.k8s.io/v1
2
kind: StorageClass
3
metadata:
4
  name: nfs-storage
5
provisioner: nfs-provisioner
6
parameters:
7
  archiveOnDelete: "false"
8
reclaimPolicy: Delete
9
volumeBindingMode: Immediate

1
apiVersion: storage.k8s.io/v1
2
kind: StorageClass
3
metadata:
4
  name: nfs-storage
5
  annotations:
6
    storageclass.kubernetes.io/is-default-class: "true"
7
provisioner: nfs-provisioner

1
优点：
2
✅ 简单直接，无需额外配置
3
✅ 性能最好（本地磁盘）
4
✅ 零成本
5

6
缺点：
7
❌ 数据绑定节点，Pod漂移会丢失数据
8
❌ 无法多节点共享
9
❌ 安全风险高
10

11
适用场景：
12
- 开发测试
13
- 单节点集群
14
- DaemonSet日志收集

1
优点：
2
✅ 支持RWX多节点读写
3
✅ 配置简单
4
✅ 成本低
5

6
缺点：
7
❌ 性能一般（网络IO）
8
❌ 单点故障风险（NFS Server挂了全挂）
9
❌ 不适合高并发
10

11
适用场景：
12
- 开发环境
13
- 小规模生产（非核心业务）
14
- 共享配置文件

1
优点：
2
✅ 高可用（数据多副本）
3
✅ 可扩展（横向扩展）
4
✅ 性能好
5
✅ 支持RWX
6

7
缺点：
8
❌ 部署复杂
9
❌ 需要专业运维
10
❌ 资源消耗大（至少3节点）
11

12
适用场景：
13
- 企业级生产环境
14
- 大规模集群
15
- 对数据可靠性要求高

1
优点：
2
✅ 高可用（云厂商保障）
3
✅ 易用（云平台集成）
4
✅ 性能可选（SSD/HDD）
5
✅ 快照备份方便
6

7
缺点：
8
❌ 只支持RWO
9
❌ 成本较高
10
❌ 绑定云厂商
11

12
适用场景：
13
- 云环境生产
14
- 数据库存储
15
- 单实例应用

1
优点：
2
✅ 无限容量
3
✅ 高可用
4
✅ 成本低（按量付费）
5

6
缺点：
7
❌ 不支持POSIX文件系统
8
❌ 只适合读多写少场景
9

10
适用场景：
11
- 静态资源（图片、视频）
12
- 备份归档
13
- 大数据存储

1
1. 能用云存储就用云存储（省心）
2
2. 自建存储需要专业运维团队
3
3. 数据库等核心应用使用高可用存储
4
4. 定期备份，备份，备份！

1
apiVersion: v1
2
kind: Pod
3
metadata:
4
  name: nginx-hostpath
5
  labels:
6
    app: nginx
7
spec:
8
  # 指定调度到node1（hostPath绑定节点）
9
  nodeSelector:
10
    kubernetes.io/hostname: k8s-node1
11

12
  containers:
13
  - name: nginx
14
    image: nginx:1.20
15
    ports:
16
    - containerPort: 80
17
    volumeMounts:
18
    - name: html-data
19
      mountPath: /usr/share/nginx/html
20

21
  volumes:
22
  - name: html-data
23
    hostPath:
24
      path: /data/nginx-html
25
      type: Directory
26
---
27
apiVersion: v1
28
kind: Service
29
metadata:
30
  name: nginx-hostpath
31
spec:
32
  selector:
33
    app: nginx
34
  ports:
35
  - port: 80
36
    nodePort: 30090
37
  type: NodePort

1
# RBAC权限
2
apiVersion: v1
3
kind: ServiceAccount
4
metadata:
5
  name: nfs-provisioner
6
  namespace: kube-system
7
---
8
apiVersion: rbac.authorization.k8s.io/v1
9
kind: ClusterRole
10
metadata:
11
  name: nfs-provisioner
12
rules:
13
- apiGroups: [""]
14
  resources: ["persistentvolumes"]
15
  verbs: ["get", "list", "watch", "create", "delete"]
16
- apiGroups: [""]
17
  resources: ["persistentvolumeclaims"]
18
  verbs: ["get", "list", "watch", "update"]
19
- apiGroups: ["storage.k8s.io"]
20
  resources: ["storageclasses"]
21
  verbs: ["get", "list", "watch"]
22
- apiGroups: [""]
23
  resources: ["events"]
24
  verbs: ["create", "update", "patch"]
25
---
26
apiVersion: rbac.authorization.k8s.io/v1
27
kind: ClusterRoleBinding
28
metadata:
29
  name: nfs-provisioner
30
roleRef:
31
  apiGroup: rbac.authorization.k8s.io
32
  kind: ClusterRole
33
  name: nfs-provisioner
34
subjects:
35
- kind: ServiceAccount
36
  name: nfs-provisioner
37
  namespace: kube-system
38
---
39
# Deployment
40
apiVersion: apps/v1
41
kind: Deployment
42
metadata:
43
  name: nfs-provisioner
44
  namespace: kube-system
45
spec:
46
  replicas: 1
47
  selector:
48
    matchLabels:
49
      app: nfs-provisioner
50
  template:
51
    metadata:
52
      labels:
53
        app: nfs-provisioner
54
    spec:
55
      serviceAccountName: nfs-provisioner
56
      containers:
57
      - name: nfs-provisioner
58
        image: registry.cn-hangzhou.aliyuncs.com/open-ali/nfs-client-provisioner:latest
59
        volumeMounts:
60
        - name: nfs-client-root
61
          mountPath: /persistentvolumes
62
        env:
63
        - name: PROVISIONER_NAME
64
          value: nfs-provisioner        # Provisioner名称
65
        - name: NFS_SERVER
66
          value: 192.168.100.14         # NFS服务器地址
67
        - name: NFS_PATH
68
          value: /data/nfs-storage      # NFS共享路径
69
      volumes:
70
      - name: nfs-client-root
71
        nfs:
72
          server: 192.168.100.14
73
          path: /data/nfs-storage
74
---
75
# StorageClass
76
apiVersion: storage.k8s.io/v1
77
kind: StorageClass
78
metadata:
79
  name: nfs-storage
80
  annotations:
81
    storageclass.kubernetes.io/is-default-class: "true"  # 设为默认
82
provisioner: nfs-provisioner
83
parameters:
84
  archiveOnDelete: "false"    # 删除PVC时不归档数据
85
reclaimPolicy: Delete
86
volumeBindingMode: Immediate

1
apiVersion: v1
2
kind: PersistentVolumeClaim
3
metadata:
4
  name: test-pvc
5
spec:
6
  accessModes:
7
  - ReadWriteMany
8
  resources:
9
    requests:
10
      storage: 1Gi
11
  storageClassName: nfs-storage

1
apiVersion: v1
2
kind: Pod
3
metadata:
4
  name: test-nfs-pod
5
spec:
6
  containers:
7
  - name: app
8
    image: nginx:1.20
9
    volumeMounts:
10
    - name: data
11
      mountPath: /usr/share/nginx/html
12
  volumes:
13
  - name: data
14
    persistentVolumeClaim:
15
      claimName: test-pvc

1
apiVersion: v1
2
kind: Service
3
metadata:
4
  name: mysql-headless
5
spec:
6
  clusterIP: None  # Headless Service
7
  selector:
8
    app: mysql
9
  ports:
10
  - port: 3306
11
---
12
apiVersion: apps/v1
13
kind: StatefulSet
14
metadata:
15
  name: mysql
16
spec:
17
  serviceName: mysql-headless
18
  replicas: 3
19
  selector:
20
    matchLabels:
21
      app: mysql
22
  template:
23
    metadata:
24
      labels:
25
        app: mysql
26
    spec:
27
      containers:
28
      - name: mysql
29
        image: mysql:8.0
30
        ports:
31
        - containerPort: 3306
32
        env:
33
        - name: MYSQL_ROOT_PASSWORD
34
          value: "MyPass123"
35
        volumeMounts:
36
        - name: data
37
          mountPath: /var/lib/mysql
38

39
  # VolumeClaimTemplate（每个Pod独立PVC）
40
  volumeClaimTemplates:
41
  - metadata:
42
      name: data
43
    spec:
44
      accessModes: ["ReadWriteOnce"]
45
      storageClassName: nfs-storage
46
      resources:
47
        requests:
48
          storage: 5Gi

1
想象一个物流调度中心：
2

3
Pod = 货物（需要运送到某个仓库）
4
Node = 仓库（存放货物的地方）
5
Scheduler = 调度员（决定货物放到哪个仓库）
6

7
调度员需要考虑：
8
- 仓库剩余空间（节点资源）
9
- 货物特殊要求（需要冷藏？易碎？）
10
- 距离和效率（网络延迟、亲和性）
11
- 仓库限制（某些仓库不收危险品）

1
为什么调度如此重要？
2

3
1. 资源利用率
4
   - 合理分配Pod，避免某些节点过载
5
   - 提高集群整体资源使用效率
6

7
2. 高可用性
8
   - 将Pod分散到不同节点/机房
9
   - 避免单点故障
10

11
3. 性能优化
12
   - 将相关Pod调度到一起（减少网络延迟）
13
   - 将Pod调度到合适的硬件（GPU、SSD）
14

15
4. 合规要求
16
   - 某些数据必须存储在特定区域
17
   - 敏感服务只能运行在特定节点

1
┌─────────────────────────────────────────────────────────────┐
2
│  用户创建Pod：kubectl apply -f pod.yaml                      │
3
└─────────────────────────────────────────────────────────────┘
4
                              ↓
5
┌─────────────────────────────────────────────────────────────┐
6
│  API Server接收请求                                          │
7
│  - Pod状态：Pending                                         │
8
│  - nodeName：空（未分配节点）                                │
9
└─────────────────────────────────────────────────────────────┘
10
                              ↓
11
┌─────────────────────────────────────────────────────────────┐
12
│  Scheduler监听到新Pod                                        │
13
│  开始调度流程                                                │
14
└─────────────────────────────────────────────────────────────┘
15
                              ↓
16
┌─────────────────────────────────────────────────────────────┐
17
│  预选阶段（Filtering）                                       │
18
│                                                             │
19
│  检查每个节点是否满足Pod的硬性要求：                          │
20
│  ✓ 资源充足？（CPU、内存）                                   │
21
│  ✓ 端口可用？                                               │
22
│  ✓ 节点选择器匹配？（nodeSelector）                          │
23
│  ✓ 节点亲和性满足？（nodeAffinity required）                 │
24
│  ✓ 污点能容忍？（Tolerations）                              │
25
│  ✓ 其他约束满足？                                           │
26
│                                                             │
27
│  结果：从10个节点中筛选出5个候选节点                          │
28
└─────────────────────────────────────────────────────────────┘
29
                              ↓
30
┌─────────────────────────────────────────────────────────────┐
31
│  优选阶段（Scoring）                                         │
32
│                                                             │
33
│  对候选节点打分（0-100分）：                                  │
34
│  - 资源均衡度（LeastRequestedPriority）                      │
35
│  - 节点亲和性偏好（NodeAffinityPriority）                    │
36
│  - Pod亲和性偏好（InterPodAffinityPriority）                 │
37
│  - 镜像已存在（ImageLocalityPriority）                       │
38
│  - ...                                                      │
39
│                                                             │
40
│  Node1: 85分 | Node2: 92分 | Node3: 78分 | ...               │
41
└─────────────────────────────────────────────────────────────┘
42
                              ↓
43
┌─────────────────────────────────────────────────────────────┐
44
│  选择最高分节点：Node2（92分）                                │
45
│  绑定Pod到Node2                                              │
46
└─────────────────────────────────────────────────────────────┘
47
                              ↓
48
┌─────────────────────────────────────────────────────────────┐
49
│  Node2上的Kubelet                                           │
50
│  - 监听到分配给自己的Pod                                     │
51
│  - 拉取镜像                                                 │
52
│  - 创建容器                                                 │
53
│  - Pod状态：Running                                         │
54
└─────────────────────────────────────────────────────────────┘

1
┌─────────────────────────────────────────────────────────────┐
2
│                    K8s调度策略全景图                         │
3
├─────────────────────────────────────────────────────────────┤
4
│                                                             │
5
│  【硬性约束】必须满足，否则Pod无法调度                        │
6
│  ┌─────────────────────────────────────────────────────┐   │
7
│  │ • nodeSelector          - 节点标签选择器              │   │
8
│  │ • nodeName              - 指定节点名称                │   │
9
│  │ • nodeAffinity.required - 节点亲和性（硬性）          │   │
10
│  │ • podAffinity.required  - Pod亲和性（硬性）           │   │
11
│  │ • Taints & Tolerations  - 污点与容忍                  │   │
12
│  │ • 资源请求              - CPU/内存必须满足            │   │
13
│  └─────────────────────────────────────────────────────┘   │
14
│                                                             │
15
│  【软性偏好】尽量满足，不满足也能调度                         │
16
│  ┌─────────────────────────────────────────────────────┐   │
17
│  │ • nodeAffinity.preferred  - 节点亲和性（软性）        │   │
18
│  │ • podAffinity.preferred   - Pod亲和性（软性）         │   │
19
│  │ • podAntiAffinity         - Pod反亲和性               │   │
20
│  └─────────────────────────────────────────────────────┘   │
21
│                                                             │
22
│  【优先级调度】资源不足时的抢占机制                           │
23
│  ┌─────────────────────────────────────────────────────┐   │
24
│  │ • PriorityClass          - Pod优先级                  │   │
25
│  │ • Preemption             - 抢占低优先级Pod            │   │
26
│  └─────────────────────────────────────────────────────┘   │
27
│                                                             │
28
└─────────────────────────────────────────────────────────────┘

1
调度决策顺序（从高到低）：
2

3
1. nodeName（最高优先级）
4
   ↓ 直接指定节点，绕过Scheduler
5
2. Taints & Tolerations
6
   ↓ 节点排斥机制
7
3. nodeSelector / nodeAffinity.required
8
   ↓ 硬性节点选择
9
4. podAffinity/podAntiAffinity.required
10
   ↓ 硬性Pod亲和/反亲和
11
5. nodeAffinity.preferred
12
   ↓ 软性节点偏好
13
6. podAffinity/podAntiAffinity.preferred
14
   ↓ 软性Pod亲和/反亲和
15
7. 资源均衡、镜像本地化等其他因素

1
场景1：将Pod调度到SSD节点
2
  节点标签：disk-type=ssd
3
  Pod配置：nodeSelector: disk-type: ssd
4

5
场景2：将Pod调度到GPU节点
6
  节点标签：gpu=nvidia
7
  Pod配置：nodeSelector: gpu: nvidia
8

9
场景3：将Pod调度到特定机房
10
  节点标签：zone=beijing
11
  Pod配置：nodeSelector: zone: beijing

1
apiVersion: v1
2
kind: Pod
3
metadata:
4
  name: nginx-ssd
5
spec:
6
  nodeSelector:           # 节点选择器
7
    disk-type: ssd        # 只调度到标签为disk-type=ssd的节点
8
  containers:
9
  - name: nginx
10
    image: nginx:1.20

1
✗ 只支持精确匹配（key=value）
2
✗ 不支持"或"逻辑（disk-type=ssd 或 disk-type=nvme）
3
✗ 不支持"非"逻辑（不要disk-type=hdd）
4
✗ 不支持软性偏好（尽量选择，但不强制）
5

6
解决方案：使用nodeAffinity（节点亲和性）

1
requiredDuringScheduling  = 调度时必须满足
2
preferred DuringScheduling = 调度时尽量满足
3
IgnoredDuringExecution   = 运行时忽略（Pod已运行后，即使条件不满足也不驱逐）

1
apiVersion: v1
2
kind: Pod
3
metadata:
4
  name: nginx-affinity-required
5
spec:
6
  affinity:
7
    nodeAffinity:
8
      requiredDuringSchedulingIgnoredDuringExecution:  # 硬性要求
9
        nodeSelectorTerms:
10
        - matchExpressions:
11
          - key: disk-type
12
            operator: In
13
            values:
14
            - ssd
15
            - nvme          # disk-type=ssd 或 disk-type=nvme
16
          - key: zone
17
            operator: In
18
            values:
19
            - beijing       # 同时 zone=beijing
20
  containers:
21
  - name: nginx
22
    image: nginx:1.20

1
apiVersion: v1
2
kind: Pod
3
metadata:
4
  name: nginx-affinity-preferred
5
spec:
6
  affinity:
7
    nodeAffinity:
8
      preferredDuringSchedulingIgnoredDuringExecution:  # 软性偏好
9
      - weight: 80          # 权重1-100，越高越优先
10
        preference:
11
          matchExpressions:
12
          - key: disk-type
13
            operator: In
14
            values:
15
            - ssd
16
      - weight: 20          # 权重较低
17
        preference:
18
          matchExpressions:
19
          - key: zone
20
            operator: In
21
            values:
22
            - beijing
23
  containers:
24
  - name: nginx
25
    image: nginx:1.20

1
apiVersion: v1
2
kind: Pod
3
metadata:
4
  name: nginx-affinity-combo
5
spec:
6
  affinity:
7
    nodeAffinity:
8
      # 硬性要求：必须在beijing或shanghai
9
      requiredDuringSchedulingIgnoredDuringExecution:
10
        nodeSelectorTerms:
11
        - matchExpressions:
12
          - key: zone
13
            operator: In
14
            values:
15
            - beijing
16
            - shanghai
17
      # 软性偏好：尽量选择SSD节点
18
      preferredDuringSchedulingIgnoredDuringExecution:
19
      - weight: 100
20
        preference:
21
          matchExpressions:
22
          - key: disk-type
23
            operator: In
24
            values:
25
            - ssd
26
  containers:
27
  - name: nginx
28
    image: nginx:1.20

1
apiVersion: v1
2
kind: Pod
3
metadata:
4
  name: nginx-specific-node
5
spec:
6
  nodeName: k8s-node1      # 直接指定节点名称
7
  containers:
8
  - name: nginx
9
    image: nginx:1.20

1
✗ 绕过Scheduler，不检查资源是否充足
2
✗ 绕过Taints检查，可能调度到不应该去的节点
3
✗ 节点不存在或不可用时，Pod一直Pending
4
✗ 不推荐在生产环境使用
5

6
适用场景：
7
✓ 调试和测试
8
✓ DaemonSet（每个节点运行一个Pod）
9
✓ 静态Pod

1
想象一个公寓楼的租房场景：
2

3
节点（Node） = 公寓房间
4
污点（Taint） = 房间的"缺点标签"（如：靠马路吵、没有电梯、只租给程序员）
5
Pod          = 租客
6
容忍（Toleration） = 租客能接受的"缺点"
7

8
场景1：房间标签"靠马路=吵:NoSchedule"
9
  → 普通租客不愿意住（Pod不会调度）
10
  → 能忍受噪音的租客可以住（Pod配置了对应Toleration）
11

12
场景2：Master节点的污点"node-role.kubernetes.io/control-plane:NoSchedule"
13
  → 普通Pod不会调度到Master
14
  → 系统组件（如CoreDNS）配置了容忍，可以运行在Master上

1
┌─────────────────────────────────────────────────────────────┐
2
│  节点有污点 + Pod没有对应容忍 = Pod不会调度到该节点           │
3
│  节点有污点 + Pod有对应容忍   = Pod可以调度到该节点           │
4
│  节点没有污点               = Pod可以调度到该节点            │
5
└─────────────────────────────────────────────────────────────┘
6

7
示例：
8
┌─────────────┐                    ┌─────────────┐
9
│   Node1     │                    │   Node2     │
10
│  无污点     │                    │ Taint: gpu  │
11
└─────────────┘                    └─────────────┘
12
      ↑                                  ↑
13
      │ ✓ 可以调度                        │ ✗ 不能调度
14
      │                                  │
15
┌─────────────┐                    ┌─────────────┐
16
│   Pod A     │                    │   Pod A     │
17
│  无容忍     │                    │  无容忍     │
18
└─────────────┘                    └─────────────┘
19

20
┌─────────────┐                    ┌─────────────┐
21
│   Node1     │                    │   Node2     │
22
│  无污点     │                    │ Taint: gpu  │
23
└─────────────┘                    └─────────────┘
24
      ↑                                  ↑
25
      │ ✓ 可以调度                        │ ✓ 可以调度
26
      │                                  │
27
┌─────────────┐                    ┌─────────────┐
28
│   Pod B     │                    │   Pod B     │
29
│ Toleration: │                    │ Toleration: │
30
│   gpu       │                    │   gpu       │
31
└─────────────┘                    └─────────────┘

1
NoSchedule（不调度）：
2
┌──────────────────────────────────────────────┐
3
│ 效果：新Pod不会调度到该节点                    │
4
│ 已有Pod：不受影响，继续运行                    │
5
│                                              │
6
│ 使用场景：                                    │
7
│ - Master节点（不运行业务Pod）                 │
8
│ - 专用节点（GPU节点只给特定应用）             │
9
└──────────────────────────────────────────────┘
10

11
PreferNoSchedule（尽量不调度）：
12
┌──────────────────────────────────────────────┐
13
│ 效果：尽量不调度，但如果没有其他节点可以调度    │
14
│ 已有Pod：不受影响，继续运行                    │
15
│                                              │
16
│ 使用场景：                                    │
17
│ - 资源紧张的节点（希望新Pod去其他节点）        │
18
│ - 维护预备节点（准备下线，但不紧急）           │
19
└──────────────────────────────────────────────┘
20

21
NoExecute（不调度+驱逐）：
22
┌──────────────────────────────────────────────┐
23
│ 效果：新Pod不调度 + 驱逐已有Pod                │
24
│ 已有Pod：被驱逐！（除非有容忍）                │
25
│                                              │
26
│ 使用场景：                                    │
27
│ - 节点维护（需要清空节点）                    │
28
│ - 节点故障（自动添加，触发Pod迁移）           │
29
│ - 节点隔离（安全原因需要清空）                │
30
└──────────────────────────────────────────────┘

1
tolerations:
2
- key: "key"              # 污点的key
3
  operator: "Equal"       # 操作符：Equal或Exists
4
  value: "value"          # 污点的value（Exists时不需要）
5
  effect: "NoSchedule"    # 污点的effect（可选，不填则匹配所有effect）
6
  tolerationSeconds: 3600 # 容忍时间（仅NoExecute有效）

1
apiVersion: v1
2
kind: Pod
3
metadata:
4
  name: nginx-toleration
5
spec:
6
  tolerations:
7
  - key: "gpu"
8
    operator: "Equal"
9
    value: "nvidia"
10
    effect: "NoSchedule"
11
  containers:
12
  - name: nginx
13
    image: nginx:1.20

1
apiVersion: v1
2
kind: Pod
3
metadata:
4
  name: nginx-toleration-exists
5
spec:
6
  tolerations:
7
  - key: "gpu"
8
    operator: "Exists"      # 只要有gpu这个key就容忍
9
    effect: "NoSchedule"
10
  containers:
11
  - name: nginx
12
    image: nginx:1.20

1
apiVersion: v1
2
kind: Pod
3
metadata:
4
  name: nginx-tolerate-all
5
spec:
6
  tolerations:
7
  - operator: "Exists"      # 容忍所有污点（危险！）
8
  containers:
9
  - name: nginx
10
    image: nginx:1.20

1
apiVersion: v1
2
kind: Pod
3
metadata:
4
  name: nginx-toleration-seconds
5
spec:
6
  tolerations:
7
  - key: "maintenance"
8
    operator: "Equal"
9
    value: "true"
10
    effect: "NoExecute"
11
    tolerationSeconds: 3600   # 容忍3600秒后被驱逐
12
  containers:
13
  - name: nginx
14
    image: nginx:1.20