节点

1. 切换到对应项目：

   $ oc project <project-name>

2. 运行以下命令：

   $ oc get pods

   例如：

   $ oc get pods -n openshift-console

   输出示例

   NAME                       READY   STATUS    RESTARTS   AGE
   console-698d866b78-bnshf   1/1     Running   2          165m
   console-698d866b78-m87pm   1/1     Running   2          165m

   添加 -o wide 标记来查看 pod IP 地址和 pod 所在的节点。

   $ oc get pods -o wide

   输出示例

   NAME                       READY   STATUS    RESTARTS   AGE    IP            NODE                           NOMINATED NODE
   console-698d866b78-bnshf   1/1     Running   2          166m   10.128.0.24   ip-10-0-152-71.ec2.internal    <none>
   console-698d866b78-m87pm   1/1     Running   2          166m   10.129.0.23   ip-10-0-173-237.ec2.internal   <none>

1. 运行以下命令：

   $ oc adm top pods

   例如：

   $ oc adm top pods -n openshift-console

   输出示例

   NAME                         CPU(cores)   MEMORY(bytes)
   console-7f58c69899-q8c8k     0m           22Mi
   console-7f58c69899-xhbgg     0m           25Mi
   downloads-594fcccf94-bcxk8   3m           18Mi
   downloads-594fcccf94-kv4p6   2m           15Mi

2. 运行以下命令，以查看带有标签的 pod 用量统计：

   $ oc adm top pod --selector=''

   您必须选择过滤所基于的选择器（标签查询）。支持 =、== 和 !=。

流程 (UI)

1. 在 OpenShift Container Platform 控制台中，导航到 Workloads → Pods，或通过您要调查的资源导航到 pod。

   注意

   有些资源（如构建）没有直接查询的 pod。在这种情况下，您可以在资源的 Details 页面中找到 Logs 链接。

2. 从下拉菜单中选择一个项目。
3. 点您要调查的 pod 的名称。
4. 点击 Logs。

1. 编写对象定义 JSON 文件，并使用 kubernetes.io/ingress-bandwidth 和 kubernetes.io/egress-bandwidth 注解指定数据流量速度。例如，将 pod 出口和入口带宽限制为 10M/s：

   受限 Pod 对象定义

   {
       "kind": "Pod",
       "spec": {
           "containers": [
               {
                   "image": "openshift/hello-openshift",
                   "name": "hello-openshift"
               }
           ]
       },
       "apiVersion": "v1",
       "metadata": {
           "name": "iperf-slow",
           "annotations": {
               "kubernetes.io/ingress-bandwidth": "10M",
               "kubernetes.io/egress-bandwidth": "10M"
           }
       }
   }

2. 使用对象定义创建 pod：

   $ oc create -f <file_or_dir_path>

1. 创建 Pod spec 或编辑现有的 pod，使其包含 system-cluster-critical 优先级类：

   spec:
     template:
       metadata:
         name: critical-pod
       priorityClassName: system-cluster-critical 1

   1

   绝不可从节点驱除的 pod 的默认优先级类。

   此外，对于对集群而言很重要但可在必要时移除的 pod，可以指定 system-node-critical。

2. 创建 pod：

   $ oc create -f <file-name>.yaml

1. 在 Topology 视图中，点击节点公开侧面板。

2. 在 Actions 下拉列表中，选择 Add HorizontalPodAutoscaler 来打开 Add HorizontalPodAutoscaler 表单。

   图 2.1. add HorizontalPodAutoscaler

   

3. 在 Add HorizontalPodAutoscaler 表单中，定义名称、最小和最大 pod 限值、CPU 和内存用量，并点 Save。

   注意

   如果缺少 CPU 和内存用量的值，则会显示警告。

1. 在 Topology 视图中，点击节点公开侧面板。
2. 在 Actions 下拉列表中，选择 Edit HorizontalPodAutoscaler 来打开 Edit Horizontal Pod Autoscaler 表单。
3. 在 Edit Horizontal Pod Autoscaler 表单中，编辑最小和最大 pod 限值以及 CPU 和内存用量，然后点 Save。

1. 在 Topology 视图中，点击节点公开侧面板。
2. 在 Actions 下拉列表中，选择 Remove HorizontalPodAutoscaler。
3. 在确认弹出窗口中点击 Remove 删除 HPA。

1. 执行以下之一：

   • 要根据 CPU 使用率百分比来缩放，请为现有对象创建一个 HorizontalPodAutoscaler 对象：

     $ oc autoscale <object_type>/<name> \1
       --min <number> \2
       --max <number> \3
       --cpu-percent=<percent> 4

     1

     指定要自动扩展的对象的类型和名称。对象必须存在，并是一个 Deployment、DeploymentConfig/dc、ReplicaSet/rs、ReplicaSet /rc 或 StatefulSet。

     2

     另外，还可以指定缩减时的最小副本数量。

     3

     指定扩展时的最大副本数量。

     4

     指定所有 pod 的目标平均 CPU 使用率（以请求 CPU 的百分比表示）。如果未指定或为负数，则会使用默认的自动缩放策略。

     例如，以下命令显示了 image-registry Deployment 对象的自动扩展：初始部署需要 3 个 pod。HPA 对象将最小值增加到 5。如果 pod 的 CPU 用量达到 75%，pod 将增加到 7：

     $ oc autoscale deployment/image-registry --min=5 --max=7 --cpu-percent=75

   • 要扩展特定 CPU 值，请为现有对象创建一个类似如下的 YAML 文件：

     1. 创建一个类似以下示例的 YAML 文件：

        apiVersion: autoscaling/v2beta2 1
        kind: HorizontalPodAutoscaler
        metadata:
          name: cpu-autoscale 2
          namespace: default
        spec:
          scaleTargetRef:
            apiVersion: apps/v1 3
            kind: Deployment 4
            name: example 5
          minReplicas: 1 6
          maxReplicas: 10 7
          metrics: 8
          - type: Resource
            resource:
              name: cpu 9
              target:
                type: AverageValue 10
                averageValue: 500m 11

        1

        使用 autoscaling/v2beta2 API。

        2

        指定此 pod 横向自动扩展对象的名称。

        3

        指定要缩放对象的 API 版本。

        • 对于 Deployment，ReplicaSet （Statefulset 对象）使用 apps/v1。
        • 对于 ReplicationController，使用 v1。
        • 对于 DeploymentConfig，使用 apps.openshift.io/v1。

        4

        指定对象的类型。对象必须是 Deployment、DeploymentConfig/dc、ReplicaSet/rs、ReplicationController/rc 或 StatefulSet。

        5

        指定要缩放的对象名称。对象必须存在。

        6

        指定缩减时的最小副本数量。

        7

        指定扩展时的最大副本数量。

        8

        对于内存使用率，使用 metrics 参数。

        9

        为 CPU 使用率指定 cpu 。

        10

        设置为 AverageValue。

        11

        使用目标 CPU 值设置为 averageValue。

     2. 创建 Pod 横向自动扩展：

        $ oc create -f <file-name>.yaml

2. 验证 pod 横向自动扩展是否已创建：

   $ oc get hpa cpu-autoscale

   输出示例

   NAME            REFERENCE            TARGETS         MINPODS   MAXPODS   REPLICAS   AGE
   cpu-autoscale   Deployment/example   173m/500m       1         10        1          20m

1. 为以下之一创建一个 YAML 文件：

   • 要扩展特定内存值，请为现有对象创建一个类似如下的 HorizontalPodAutoscaler 对象：

     apiVersion: autoscaling/v2beta2 1
     kind: HorizontalPodAutoscaler
     metadata:
       name: hpa-resource-metrics-memory 2
       namespace: default
     spec:
       scaleTargetRef:
         apiVersion: apps/v1 3
         kind: Deployment 4
         name: example 5
       minReplicas: 1 6
       maxReplicas: 10 7
       metrics: 8
       - type: Resource
         resource:
           name: memory 9
           target:
             type: AverageValue 10
             averageValue: 500Mi 11
       behavior: 12
         scaleDown:
           stabilizationWindowSeconds: 300
           policies:
           - type: Pods
             value: 4
             periodSeconds: 60
           - type: Percent
             value: 10
             periodSeconds: 60
           selectPolicy: Max

     1

     使用 autoscaling/v2beta2 API。

     2

     指定此 pod 横向自动扩展对象的名称。

     3

     指定要缩放对象的 API 版本。

     • 对于 Deployment、ReplicaSet 或 Statefulset 对象，请使用 apps/v1。
     • 对于 ReplicationController，使用 v1。
     • 对于 DeploymentConfig，使用 apps.openshift.io/v1。

     4

     指定对象的类型。对象必须是 Deployment、DeploymentConfig、ReplicaSet、ReplicaSet、ReplicationController 或 StatefulSet。

     5

     指定要缩放的对象名称。对象必须存在。

     6

     指定缩减时的最小副本数量。

     7

     指定扩展时的最大副本数量。

     8

     对于内存使用率，使用 metrics 参数。

     9

     为内存使用率指定 memory 。

     10

     将类型设置为 AverageValue。

     11

     指定 averageValue 和一个特定的内存值。

     12

     可选：指定一个扩展策略来控制扩展或缩减率。

   • 要扩展某个百分比，请为现有对象创建一个类似如下的 HorizontalPodAutoscaler 对象：

     apiVersion: autoscaling/v2beta2 1
     kind: HorizontalPodAutoscaler
     metadata:
       name: memory-autoscale 2
       namespace: default
     spec:
       scaleTargetRef:
         apiVersion: apps/v1 3
         kind: Deployment 4
         name: example 5
       minReplicas: 1 6
       maxReplicas: 10 7
       metrics: 8
       - type: Deployment
         resource:
           name: memory 9
           target:
             type: Utilization 10
             averageUtilization: 50 11
       behavior: 12
         scaleUp:
           stabilizationWindowSeconds: 180
           policies:
           - type: Pods
             value: 6
             periodSeconds: 120
           - type: Percent
             value: 10
             periodSeconds: 120
           selectPolicy: Max

     1

     使用 autoscaling/v2beta2 API。

     2

     指定此 pod 横向自动扩展对象的名称。

     3

     指定要缩放对象的 API 版本。

     • 对于 ReplicationController，使用 v1。
     • 对于 DeploymentConfig，使用 apps.openshift.io/v1。
     • 对于 Deployment，ReplicaSet（Statefulset 对象）使用 apps/v1。

     4

     指定对象的类型。对象必须是 Deployment、DeploymentConfig、ReplicaSet、ReplicaSet、ReplicationController 或 StatefulSet。

     5

     指定要缩放的对象名称。对象必须存在。

     6

     指定缩减时的最小副本数量。

     7

     指定扩展时的最大副本数量。

     8

     对于内存使用率，使用 metrics 参数。

     9

     为内存使用率指定 memory 。

     10

     设置 Utilization。

     11

     为所有 pod 指定 averageUtilization 和一个目标平均内存利用率，以请求内存的百分比表示。目标 pod 必须配置内存请求。

     12

     可选：指定一个扩展策略来控制扩展或缩减率。

2. 创建 Pod 横向自动扩展：

   $ oc create -f <file-name>.yaml

   例如：

   $ oc create -f hpa.yaml

   输出示例

   horizontalpodautoscaler.autoscaling/hpa-resource-metrics-memory created

3. 验证 pod 横向自动扩展是否已创建：

   $ oc get hpa hpa-resource-metrics-memory

   输出示例

   NAME                          REFERENCE            TARGETS         MINPODS   MAXPODS   REPLICAS   AGE
   hpa-resource-metrics-memory   Deployment/example   2441216/500Mi   1         10        1          20m

   $ oc describe hpa hpa-resource-metrics-memory

   输出示例

   Name:                        hpa-resource-metrics-memory
   Namespace:                   default
   Labels:                      <none>
   Annotations:                 <none>
   CreationTimestamp:           Wed, 04 Mar 2020 16:31:37 +0530
   Reference:                   Deployment/example
   Metrics:                     ( current / target )
     resource memory on pods:   2441216 / 500Mi
   Min replicas:                1
   Max replicas:                10
   ReplicationController pods:  1 current / 1 desired
   Conditions:
     Type            Status  Reason              Message
     ----            ------  ------              -------
     AbleToScale     True    ReadyForNewScale    recommended size matches current size
     ScalingActive   True    ValidMetricFound    the HPA was able to successfully calculate a replica count from memory resource
     ScalingLimited  False   DesiredWithinRange  the desired count is within the acceptable range
   Events:
     Type     Reason                   Age                 From                       Message
     ----     ------                   ----                ----                       -------
     Normal   SuccessfulRescale        6m34s               horizontal-pod-autoscaler  New size: 1; reason: All metrics below target

流程

1. 在 OpenShift Container Platform Web 控制台中，点击 Operators → OperatorHub。
2. 从可用 Operator 列表中选择 VerticalPodAutoscaler，点 Install。
3. 在 Install Operator 页面中，确保选择了 Operator 推荐的命名空间 选项。这会在 openshift-vertical-pod-autoscaler 命名空间中创建 Operator。如果这个命名空间还没有存在，会自动创建它。
4. 点击 Install。

5. 列出 VPA Operator 组件来验证安装：

   1. 导航到 Workloads → Pods。
   2. 从下拉菜单中选择 openshift-vertical-pod-autoscaler 项目，并验证是否运行了 4 个 pod。
   3. 进入 Workloads → Deployments 以验证运行了四个部署。

6. 可选。使用以下命令在 OpenShift Container Platform CLI 中验证安装：

   $ oc get all -n openshift-vertical-pod-autoscaler

   输出显示 4 个 pod 和 4 个部署：

   输出示例

   NAME                                                    READY   STATUS    RESTARTS   AGE
   pod/vertical-pod-autoscaler-operator-85b4569c47-2gmhc   1/1     Running   0          3m13s
   pod/vpa-admission-plugin-default-67644fc87f-xq7k9       1/1     Running   0          2m56s
   pod/vpa-recommender-default-7c54764b59-8gckt            1/1     Running   0          2m56s
   pod/vpa-updater-default-7f6cc87858-47vw9                1/1     Running   0          2m56s
   
   NAME                  TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)   AGE
   service/vpa-webhook   ClusterIP   172.30.53.206   <none>        443/TCP   2m56s
   
   NAME                                               READY   UP-TO-DATE   AVAILABLE   AGE
   deployment.apps/vertical-pod-autoscaler-operator   1/1     1            1           3m13s
   deployment.apps/vpa-admission-plugin-default       1/1     1            1           2m56s
   deployment.apps/vpa-recommender-default            1/1     1            1           2m56s
   deployment.apps/vpa-updater-default                1/1     1            1           2m56s
   
   NAME                                                          DESIRED   CURRENT   READY   AGE
   replicaset.apps/vertical-pod-autoscaler-operator-85b4569c47   1         1         1       3m13s
   replicaset.apps/vpa-admission-plugin-default-67644fc87f       1         1         1       2m56s
   replicaset.apps/vpa-recommender-default-7c54764b59            1         1         1       2m56s
   replicaset.apps/vpa-updater-default-7f6cc87858                1         1         1       2m56s

1. 切换到您要缩放的工作负载对象所在的项目。

   1. 创建一个 VPA CR YAML 文件：

      apiVersion: autoscaling.k8s.io/v1
      kind: VerticalPodAutoscaler
      metadata:
        name: vpa-recommender
      spec:
        targetRef:
          apiVersion: "apps/v1"
          kind:       Deployment 1
          name:       frontend 2
        updatePolicy:
          updateMode: "Auto" 3
        resourcePolicy: 4
          containerPolicies:
          - containerName: my-opt-sidecar
            mode: "Off"

      1

      指定您需要这个 VPA 管理的工作负载对象类型： Deployment、StatefulSet、Job、DaemonSet、ReplicaSet 或 ReplicationController。

      2

      指定您希望此 VPA 管理的现有工作负载对象的名称。

      3

      指定 VPA 模式：

      • auto 会在与控制器关联的 pod 上自动应用推荐的资源。VPA 会终止现有的 pod，并使用推荐的资源限制和请求创建新 pod。
      • recreate 会在与工作负载对象关联的 pod 上自动应用推荐的资源。VPA 会终止现有的 pod，并使用推荐的资源限制和请求创建新 pod。recreate 模式应该很少使用，只有在需要确保每当资源请求改变时 pod 就需要重启时才使用。
      • Initial 在创建与工作负载对象关联的 pod 时自动应用推荐的资源。VPA 会学习新的资源建议，但不会更新 pod。
      • off 仅为与工作负载对象关联的 pod 生成资源建议。VPA 不会更新 pod，它只会学习新的资源建议，且不会将建议应用到新 pod。

      4

      可选。指定不需要受 VPA 影响的容器，将模式设置为 Off。

   2. 创建 VPA CR:

      $ oc create -f <file-name>.yaml

      在一段短暂的时间后，VPA 会了解与工作负载对象关联的 pod 中容器的资源使用情况。

      您可以使用以下命令查看 VPA 建议：

      $ oc get vpa <vpa-name> --output yaml

      输出显示 CPU 和内存请求的建议，如下所示：

      输出示例

      ...
      status:
      
      ...
      
        recommendation:
          containerRecommendations:
          - containerName: frontend
            lowerBound: 1
              cpu: 25m
              memory: 262144k
            target: 2
              cpu: 25m
              memory: 262144k
            uncappedTarget: 3
              cpu: 25m
              memory: 262144k
            upperBound: 4
              cpu: 262m
              memory: "274357142"
          - containerName: backend
            lowerBound:
              cpu: 12m
              memory: 131072k
            target:
              cpu: 12m
              memory: 131072k
            uncappedTarget:
              cpu: 12m
              memory: 131072k
            upperBound:
              cpu: 476m
              memory: "498558823"
      
      ...

      1

      lowerBound 是最低的推荐资源级别。

      2

      target是推荐的资源级别。

      3

      upperBound 是最高的推荐资源级别。

      4

      uncappedTarget 是最新资源建议。

流程

1. 在 OpenShift Container Platform web 控制台中，点击 Operators → Installed Operators。
2. 切换到 openshift-vertical-pod-autoscaler 项目。
3. 找到 VerticalPodAutoscaler Operator，点 Options 菜单。点击 Uninstall Operator。
4. 在对话框中点 Uninstall。
5. 可选： 要删除与 Operator 关联的所有操作对象，请在对话框中选择 Delete all operand instance for this operator 复选框。
6. 点击 Uninstall。

7. 可选： 使用 OpenShift CLI 删除 VPA 组件：

   1. 删除 VPA 变异 Webhook 配置：

      $ oc delete mutatingwebhookconfigurations/vpa-webhook-config

   2. 列出所有 VPA 自定义资源：

      $ oc get verticalpodautoscalercheckpoints.autoscaling.k8s.io,verticalpodautoscalercontrollers.autoscaling.openshift.io,verticalpodautoscalers.autoscaling.k8s.io -o wide --all-namespaces

      输出示例

      NAMESPACE      NAME                                                                       AGE
      my-project     verticalpodautoscalercheckpoint.autoscaling.k8s.io/vpa-recommender-httpd   5m46s
      
      NAMESPACE                           NAME                                                               AGE
      openshift-vertical-pod-autoscaler   verticalpodautoscalercontroller.autoscaling.openshift.io/default   11m
      
      NAMESPACE      NAME                                                       MODE   CPU   MEM       PROVIDED   AGE
      my-project     verticalpodautoscaler.autoscaling.k8s.io/vpa-recommender   Auto   93m   262144k   True       9m15s

   3. 删除列出的 VPA 自定义资源。例如：

      $ oc delete verticalpodautoscalercheckpoint.autoscaling.k8s.io/vpa-recommender-httpd -n my-project

      $ oc delete verticalpodautoscalercontroller.autoscaling.openshift.io/default -n openshift-vertical-pod-autoscaler

      $ oc delete verticalpodautoscaler.autoscaling.k8s.io/vpa-recommender -n my-project

   4. 列出所有 VPA 自定义资源定义(CRD)：

      $ oc get crd

      输出示例

      NAME                                                              CREATED AT
       ...
      verticalpodautoscalercheckpoints.autoscaling.k8s.io               2022-02-07T14:09:20Z
      verticalpodautoscalercontrollers.autoscaling.openshift.io         2022-02-07T14:09:20Z
      verticalpodautoscalers.autoscaling.k8s.io                         2022-02-07T14:09:20Z
       ...

   5. 删除列出的 VPA CRD：

      $ oc delete crd verticalpodautoscalercheckpoints.autoscaling.k8s.io verticalpodautoscalercontrollers.autoscaling.openshift.io verticalpodautoscalers.autoscaling.k8s.io

      删除 CRD 会删除关联的角色、集群角色和角色绑定。但是，可能存在一些必须手动删除的集群角色。

   6. 列出任何 VPA 集群角色：

      $ oc get clusterrole | grep openshift-vertical-pod-autoscaler

      输出示例

      openshift-vertical-pod-autoscaler-6896f-admin        2022-02-02T15:29:55Z
      openshift-vertical-pod-autoscaler-6896f-edit         2022-02-02T15:29:55Z
      openshift-vertical-pod-autoscaler-6896f-view         2022-02-02T15:29:55Z

   7. 删除列出的 VPA 集群角色。例如：

      $ oc delete clusterrole openshift-vertical-pod-autoscaler-6896f-admin openshift-vertical-pod-autoscaler-6896f-edit openshift-vertical-pod-autoscaler-6896f-view

   8. 删除 VPA Operator：

      $ oc delete operator/vertical-pod-autoscaler.openshift-vertical-pod-autoscaler

1. 创建包含您要保留 secret 的数据的 secret 对象。在以下部分中取消每个 secret 类型所需的特定数据。

   创建不透明 secret 的 YAML 对象示例

   apiVersion: v1
   kind: Secret
   metadata:
     name: test-secret
   type: Opaque 1
   data: 2
     username: dmFsdWUtMQ0K
     password: dmFsdWUtMQ0KDQo=
   stringData: 3
     hostname: myapp.mydomain.com
     secret.properties: |
       property1=valueA
       property2=valueB

   1

   指定 secret 的类型。

   2

   指定编码的字符串和数据。

   3

   指定解码的字符串和数据。

   使用 data 或 stringdata 字段，不能同时使用这两个字段。

2. 更新 pod 的服务帐户以引用 secret：

   使用 secret 的服务帐户的 YAML

   apiVersion: v1
   kind: ServiceAccount
    ...
   secrets:
   - name: test-secret

3. 创建以环境变量或文件（使用 secret 卷）形式消耗 secret 的 pod：

   pod 的 YAML 使用 secret 数据填充卷中的文件

   apiVersion: v1
   kind: Pod
   metadata:
     name: secret-example-pod
   spec:
     containers:
       - name: secret-test-container
         image: busybox
         command: [ "/bin/sh", "-c", "cat /etc/secret-volume/*" ]
         volumeMounts: 1
             - name: secret-volume
               mountPath: /etc/secret-volume 2
               readOnly: true 3
     volumes:
       - name: secret-volume
         secret:
           secretName: test-secret 4
     restartPolicy: Never

   1

   为每个需要 secret 的容器添加 volumeMounts 字段。

   2

   指定您希望显示 secret 的未使用目录名称。secret 数据映射中的每个密钥都将成为 mountPath 下的文件名。

   3

   设置为 true。如果为 true，这指示驱动程序提供只读卷。

   4

   指定 secret 的名称。

   pod 的 YAML 使用 secret 数据填充环境变量

   apiVersion: v1
   kind: Pod
   metadata:
     name: secret-example-pod
   spec:
     containers:
       - name: secret-test-container
         image: busybox
         command: [ "/bin/sh", "-c", "export" ]
         env:
           - name: TEST_SECRET_USERNAME_ENV_VAR
             valueFrom:
               secretKeyRef: 1
                 name: test-secret
                 key: username
     restartPolicy: Never

   1

   指定消耗 secret 密钥的环境变量。

   构建配置的 YAML 使用 secret 数据填充环境变量

   apiVersion: build.openshift.io/v1
   kind: BuildConfig
   metadata:
     name: secret-example-bc
   spec:
     strategy:
       sourceStrategy:
         env:
         - name: TEST_SECRET_USERNAME_ENV_VAR
           valueFrom:
             secretKeyRef: 1
               name: test-secret
               key: username

   1

   指定消耗 secret 密钥的环境变量。

1. 删除 secret：

   $ oc delete secret <secret_name>

2. 清除注解：

   $ oc annotate service <service_name> service.beta.openshift.io/serving-cert-generation-error-

   $ oc annotate service <service_name> service.beta.openshift.io/serving-cert-generation-error-num-

1. 输入以下命令为您要配置的节点类型获取与静态 MachineConfigPool CRD 关联的标签。执行以下步骤之一：

   1. 查看机器配置：

      # oc describe machineconfig <name>

      例如：

      # oc describe machineconfig 00-worker

      输出示例

      Name:         00-worker
      Namespace:
      Labels:       machineconfiguration.openshift.io/role=worker 1

      1

      设备管理器所需标签。

流程

1. 为配置更改创建自定义资源 (CR)。

   设备管理器 CR 配置示例

   apiVersion: machineconfiguration.openshift.io/v1
   kind: KubeletConfig
   metadata:
     name: devicemgr 1
   spec:
     machineConfigPoolSelector:
       matchLabels:
          machineconfiguration.openshift.io: devicemgr 2
     kubeletConfig:
       feature-gates:
         - DevicePlugins=true 3

   1

   为 CR 分配一个名称。

   2

   输入来自机器配置池的标签。

   3

   将 DevicePlugins 设为“true”。

2. 创建设备管理器：

   $ oc create -f devicemgr.yaml

   输出示例

   kubeletconfig.machineconfiguration.openshift.io/devicemgr created

3. 通过确认节点上已创建了 /var/lib/kubelet/device-plugins/kubelet.sock，确保已启用了设备管理器。这是设备管理器 gRPC 服务器在其上侦听新插件注册的 UNIX 域套接字。只有启用了设备管理器，才会在 Kubelet 启动时创建此 sock 文件。

1. 创建一个或多个优先级类：

   1. 指定优先级的名称和值。
   2. （可选）指定优先级类的 globalDefault 字段和描述。

2. 创建 Pod spec 或编辑现有的 pod 以包含优先级类的名称，如下所示：

   带有优先级类名称的 Pod 规格示例

   apiVersion: v1
   kind: Pod
   metadata:
     name: nginx
     labels:
       env: test
   spec:
     containers:
     - name: nginx
       image: nginx
       imagePullPolicy: IfNotPresent
     priorityClassName: high-priority 1

   1

   指定要用于此 pod 的优先级类。

3. 创建 pod：

   $ oc create -f <file-name>.yaml

   您可以将优先级名称直接添加到 pod 配置或 pod 模板中。

流程

1. 通过使用机器集或直接编辑节点，为节点添加标签：

   • 在创建节点时，使用 MachineSet 对象向由机器集管理的节点添加标签：

     1. 运行以下命令，将标签添加到 MachineSet 对象中：

        $ oc patch MachineSet <name> --type='json' -p='[{"op":"add","path":"/spec/template/spec/metadata/labels", "value":{"<key>"="<value>","<key>"="<value>"}}]'  -n openshift-machine-api

        例如：

        $ oc patch MachineSet abc612-msrtw-worker-us-east-1c  --type='json' -p='[{"op":"add","path":"/spec/template/spec/metadata/labels", "value":{"type":"user-node","region":"east"}}]'  -n openshift-machine-api

        提示

        您还可以应用以下 YAML 将标签添加到机器集中：

        apiVersion: machine.openshift.io/v1beta1
        kind: MachineSet
        metadata:
          name: <machineset>
          namespace: openshift-machine-api
        spec:
          template:
            spec:
              metadata:
                labels:
                  region: "east"
                  type: "user-node"

     2. 使用 oc edit 命令验证标签是否已添加到 MachineSet 对象中：

        例如：

        $ oc edit MachineSet abc612-msrtw-worker-us-east-1c -n openshift-machine-api

        MachineSet 对象示例

        apiVersion: machine.openshift.io/v1beta1
        kind: MachineSet
        
        ....
        
        spec:
        ...
          template:
            metadata:
        ...
            spec:
              metadata:
                labels:
                  region: east
                  type: user-node
        ....

   • 直接向节点添加标签：

     1. 为节点编辑 Node 对象：

        $ oc label nodes <name> <key>=<value>

        例如，若要为以下节点添加标签：

        $ oc label nodes ip-10-0-142-25.ec2.internal type=user-node region=east

        提示

        您还可以应用以下 YAML 将标签添加到节点：

        kind: Node
        apiVersion: v1
        metadata:
          name: <node_name>
          labels:
            type: "user-node"
            region: "east"

     2. 验证标签是否已添加到节点：

        $ oc get nodes -l type=user-node,region=east

        输出示例

        NAME                          STATUS   ROLES    AGE   VERSION
        ip-10-0-142-25.ec2.internal   Ready    worker   17m   v1.18.3+002a51f

2. 将匹配的节点选择器添加到 pod：

   • 要将节点选择器添加到现有和未来的 pod，请向 pod 的控制对象添加节点选择器：

     带有标签的 ReplicaSet 对象示例

     kind: ReplicaSet
     
     ....
     
     spec:
     
     ....
     
       template:
         metadata:
           creationTimestamp: null
           labels:
             ingresscontroller.operator.openshift.io/deployment-ingresscontroller: default
             pod-template-hash: 66d5cf9464
         spec:
           nodeSelector:
             kubernetes.io/os: linux
             node-role.kubernetes.io/worker: ''
             type: user-node 1

     1

     添加节点选择器。

   • 要将节点选择器添加到一个特定的新 pod，直接将选择器添加到 Pod 对象中：

     使用节点选择器的 Pod 对象示例

     apiVersion: v1
     kind: Pod
     
     ....
     
     spec:
       nodeSelector:
         region: east
         type: user-node

     注意

     您不能直接将节点选择器添加到现有调度的 pod 中。

1. 使用所需的 predicates 和 priorities，创建一个名为 policy.cfg 的 JSON 文件。

   调度程序 JSON 文件示例

   {
   "kind" : "Policy",
   "apiVersion" : "v1",
   "predicates" : [ 1
           {"name" : "MaxGCEPDVolumeCount"},
           {"name" : "GeneralPredicates"},
           {"name" : "MaxAzureDiskVolumeCount"},
           {"name" : "MaxCSIVolumeCountPred"},
           {"name" : "CheckVolumeBinding"},
           {"name" : "MaxEBSVolumeCount"},
           {"name" : "MatchInterPodAffinity"},
           {"name" : "CheckNodeUnschedulable"},
           {"name" : "NoDiskConflict"},
           {"name" : "NoVolumeZoneConflict"},
           {"name" : "PodToleratesNodeTaints"}
           ],
   "priorities" : [ 2
           {"name" : "LeastRequestedPriority", "weight" : 1},
           {"name" : "BalancedResourceAllocation", "weight" : 1},
           {"name" : "ServiceSpreadingPriority", "weight" : 1},
           {"name" : "NodePreferAvoidPodsPriority", "weight" : 1},
           {"name" : "NodeAffinityPriority", "weight" : 1},
           {"name" : "TaintTolerationPriority", "weight" : 1},
           {"name" : "ImageLocalityPriority", "weight" : 1},
           {"name" : "SelectorSpreadPriority", "weight" : 1},
           {"name" : "InterPodAffinityPriority", "weight" : 1},
           {"name" : "EqualPriority", "weight" : 1}
           ]
   }

   1

   根据需要添加 predicates。

   2

   根据需要添加 priorities。

2. 根据调度程序 JSON 文件创建配置映射：

   $ oc create configmap -n openshift-config --from-file=policy.cfg <configmap-name> 1

   1

   输入配置映射的名称。

   例如：

   $ oc create configmap -n openshift-config --from-file=policy.cfg scheduler-policy

   输出示例

   configmap/scheduler-policy created

   提示

   您还可以应用以下 YAML 来创建配置映射：

   kind: ConfigMap
   apiVersion: v1
   metadata:
     name: scheduler-policy
     namespace: openshift-config
   data: 1
     policy.cfg: |
       {
       "kind": "Policy",
       "apiVersion": "v1",
       "predicates": [
           {
               "name": "RequireRegion",
               "argument": {
                   "labelPreference":
                       {"label": "region"},
                       {"presence": true}
               }
            }
         ],
       "priorities": [
           {
               "name":"ZonePreferred",
               "weight" : 1,
               "argument": {
                   "labelPreference":
                       {"label": "zone"},
                       {"presence": true}
                  }
              }
          ]
       }

   1

   带有 predicates 和 priorities 的 JSON 格式的 policy.cfg 文件。

3. 编辑调度程序 Operator 自定义资源以添加配置映射：

   $ oc patch Scheduler cluster --type='merge' -p '{"spec":{"policy":{"name":"<configmap-name>"}}}' --type=merge 1

   1

   指定配置映射的名称。

   例如：

   $ oc patch Scheduler cluster --type='merge' -p '{"spec":{"policy":{"name":"scheduler-policy"}}}' --type=merge

   提示

   您还可以应用以下 YAML 来添加配置映射：

   apiVersion: config.openshift.io/v1
   kind: Scheduler
   metadata:
     name: cluster
   spec:
     mastersSchedulable: false
     policy:
       name: scheduler-policy 1

   1

   添加调度程序策略配置映射的名称。

   在修改了 Scheduler 配置资源后，等待 openshift-kube-apiserver pod 重新部署。这可能需要几分钟。只有重新部署 pod 后，新的调度程序才会生效。

4. 通过查看 openshift-kube-scheduler 命名空间中调度程序 pod 的日志，来验证已配置调度程序策略。以下命令检查由调度程序注册的 predicates 和 priorities：

   $ oc logs <scheduler-pod> | grep predicates

   例如：

   $ oc logs openshift-kube-scheduler-ip-10-0-141-29.ec2.internal | grep predicates

   输出示例

   Creating scheduler with fit predicates 'map[MaxGCEPDVolumeCount:{} MaxAzureDiskVolumeCount:{} CheckNodeUnschedulable:{} NoDiskConflict:{} NoVolumeZoneConflict:{} GeneralPredicates:{} MaxCSIVolumeCountPred:{} CheckVolumeBinding:{} MaxEBSVolumeCount:{} MatchInterPodAffinity:{} PodToleratesNodeTaints:{}]' and priority functions 'map[InterPodAffinityPriority:{} LeastRequestedPriority:{} ServiceSpreadingPriority:{} ImageLocalityPriority:{} SelectorSpreadPriority:{} EqualPriority:{} BalancedResourceAllocation:{} NodePreferAvoidPodsPriority:{} NodeAffinityPriority:{} TaintTolerationPriority:{}]'

流程

1. 编辑 Scheduler 对象：

   $ oc edit scheduler cluster

2. 指定在 spec.profile 字段中使用的配置集：

   apiVersion: config.openshift.io/v1
   kind: Scheduler
   metadata:
     ...
     name: cluster
     resourceVersion: "601"
     selfLink: /apis/config.openshift.io/v1/schedulers/cluster
     uid: b351d6d0-d06f-4a99-a26b-87af62e79f59
   spec:
     mastersSchedulable: false
     policy:
       name: ""
     profile: HighNodeUtilization 1

   1

   设置为 LowNodeUtilization、HighNodeUtilization 或 NoScoring。

3. 保存文件以使改变生效。

流程

1. 创建在 Pod spec 中带有特定标签的 pod:

   $ cat team4.yaml
   apiVersion: v1
   kind: Pod
   metadata:
     name: security-s1
     labels:
       security: S1
   spec:
     containers:
     - name: security-s1
       image: docker.io/ocpqe/hello-pod

2. 在创建其他 pod 时，按如下所示编辑 Pod 规格：

   1. 使用 podAffinity 小节配置 requiredDuringSchedulingIgnoredDuringExecution 参数或 preferredDuringSchedulingIgnoredDuringExecution 参数：

   2. 指定必须满足的键和值。如果您希望新 pod 与另一个 pod 一起调度，请使用与第一个 pod 上标签相同的 key 和 value 参数。

          podAffinity:
            requiredDuringSchedulingIgnoredDuringExecution:
            - labelSelector:
                matchExpressions:
                - key: security
                  operator: In
                  values:
                  - S1
              topologyKey: failure-domain.beta.kubernetes.io/zone

   3. 指定一个 operator。运算符可以是 In、NotIn、Exists 或 DoesNotExist。例如，使用运算符 In 来要求节点上存在该标签。
   4. 指定 topologyKey，这是一个预填充的 Kubernetes 标签，供系统用于表示这样的拓扑域。

3. 创建 pod。

   $ oc create -f <pod-spec>.yaml

流程

1. 创建在 Pod spec 中带有特定标签的 pod:

   $ cat team4.yaml
   apiVersion: v1
   kind: Pod
   metadata:
     name: security-s2
     labels:
       security: S2
   spec:
     containers:
     - name: security-s2
       image: docker.io/ocpqe/hello-pod

2. 在创建其他 pod 时，编辑 Pod spec 来设置以下参数：

3. 使用 podAntiAffinity 小节配置 requiredDuringSchedulingIgnoredDuringExecution 参数或 preferredDuringSchedulingIgnoredDuringExecution 参数：

   1. 为节点指定一个 1 到 100 的权重。优先选择权重最高的节点。

   2. 指定必须满足的键和值。如果您希望新 pod 不与另一个 pod 一起调度，请使用与第一个 pod 上标签相同的 key 和 value 参数。

          podAntiAffinity:
            preferredDuringSchedulingIgnoredDuringExecution:
            - weight: 100
              podAffinityTerm:
                labelSelector:
                  matchExpressions:
                  - key: security
                    operator: In
                    values:
                    - S2
                topologyKey: kubernetes.io/hostname

   3. 为偏好规则指定一个 1 到 100 的权重。
   4. 指定一个 operator。运算符可以是 In、NotIn、Exists 或 DoesNotExist。例如，使用运算符 In 来要求节点上存在该标签。
4. 指定 topologyKey，这是一个预填充的 Kubernetes 标签，供系统用于表示这样的拓扑域。

5. 创建 pod。

   $ oc create -f <pod-spec>.yaml

1. 使用 oc label node 命令给节点添加标签：

   $ oc label node node1 e2e-az-name=e2e-az1

   提示

   您还可以应用以下 YAML 来添加标签：

   kind: Node
   apiVersion: v1
   metadata:
     name: <node_name>
     labels:
       e2e-az-name: e2e-az1

2. 在 Pod spec 中，使用 nodeAffinity 小节来配置 requiredDuringSchedulingIgnoredDuringExecution 参数：

   1. 指定必须满足的键和值。如果希望新 pod 调度到您编辑的节点上，请使用与节点中标签相同的 key 和 value 参数。

   2. 指定一个 operator。运算符可以是 In、NotIn、Exists 或 DoesNotExist、Lt 或 Gt。例如，使用运算符 In 来要求节点上存在该标签：

      输出示例

      spec:
        affinity:
          nodeAffinity:
            requiredDuringSchedulingIgnoredDuringExecution:
              nodeSelectorTerms:
              - matchExpressions:
                - key: e2e-az-name
                  operator: In
                  values:
                  - e2e-az1
                  - e2e-az2

3. 创建 pod：

   $ oc create -f e2e-az2.yaml

1. 使用 oc label node 命令给节点添加标签：

   $ oc label node node1 e2e-az-name=e2e-az3

2. 在 Pod spec 中，使用 nodeAffinity 小节来配置 preferredDuringSchedulingIgnoredDuringExecution 参数：

   1. 为节点指定一个权重，值为 1 到 100 的数字。优先选择权重最高的节点。

   2. 指定必须满足的键和值。如果希望新 pod 调度到您编辑的节点上，请使用与节点中标签相同的 key 和 value 参数：

      spec:
        affinity:
          nodeAffinity:
            preferredDuringSchedulingIgnoredDuringExecution:
            - weight: 1
              preference:
                matchExpressions:
                - key: e2e-az-name
                  operator: In
                  values:
                  - e2e-az3

   3. 指定一个 operator。运算符可以是 In、NotIn、Exists 或 DoesNotExist、Lt 或 Gt。例如，使用运算符 In 来要求节点上存在该标签：

3. 创建 pod。

   $ oc create -f e2e-az3.yaml

流程

1. 通过编辑 Pod spec 使其包含 tolerations 小节来向 pod 添加容限：

   使用 Equal 运算符的 pod 配置文件示例

   spec:
     tolerations:
     - key: "key1" 1
       value: "value1"
       operator: "Equal"
       effect: "NoExecute"
       tolerationSeconds: 3600 2

   1

   容限参数，如 Taint 和 toleration 组件表中所述。

   2

   tolerationSeconds 参数指定 pod 在被驱除前可以保持与节点绑定的时长。

   例如：

   使用 Exists 运算符的 pod 配置文件示例

   spec:
      tolerations:
       - key: "key1"
         operator: "Exists" 1
         effect: "NoExecute"
         tolerationSeconds: 3600

   1

   Exists 运算符不会接受一个 value。

   本例在 node1 上放置一个键为 key1 且值为 value1 的污点，污点效果是 NoExecute。

2. 通过以下命令，使用 Taint 和 toleration 组件表中描述的参数为节点添加污点：

   $ oc adm taint nodes <node_name> <key>=<value>:<effect>

   例如：

   $ oc adm taint nodes node1 key1=value1:NoExecute

   此命令在 node1 上放置一个键为 key1，值为 value1 的污点，其效果是 NoExecute。

   注意

   如果为 control plane 节点（也称为 master 节点）添加了一个 NoSchedule 污点，则节点必须具有 node-role.kubernetes.io/master=:NoSchedule 污点，该污点会被默认添加。

   例如：

   apiVersion: v1
   kind: Node
   metadata:
     annotations:
       machine.openshift.io/machine: openshift-machine-api/ci-ln-62s7gtb-f76d1-v8jxv-master-0
       machineconfiguration.openshift.io/currentConfig: rendered-master-cdc1ab7da414629332cc4c3926e6e59c
   ...
   spec:
     taints:
     - effect: NoSchedule
       key: node-role.kubernetes.io/master
   ...

   pod 上的容限与节点上的污点匹配。具有任一容限的 pod 可以调度到 node1 上。

1. 从节点移除污点：

   $ oc adm taint nodes <node-name> <key>-

   例如：

   $ oc adm taint nodes ip-10-0-132-248.ec2.internal key1-

   输出示例

   node/ip-10-0-132-248.ec2.internal untainted

2. 要从 pod 移除某一容限，请编辑 Pod 规格来移除该容限：

   spec:
     tolerations:
     - key: "key2"
       operator: "Exists"
       effect: "NoExecute"
       tolerationSeconds: 3600

流程

1. 通过使用机器集或直接编辑节点，为节点添加标签：

   • 在创建节点时，使用 MachineSet 对象向由机器集管理的节点添加标签：

     1. 运行以下命令，将标签添加到 MachineSet 对象中：

        $ oc patch MachineSet <name> --type='json' -p='[{"op":"add","path":"/spec/template/spec/metadata/labels", "value":{"<key>"="<value>","<key>"="<value>"}}]'  -n openshift-machine-api

        例如：

        $ oc patch MachineSet abc612-msrtw-worker-us-east-1c  --type='json' -p='[{"op":"add","path":"/spec/template/spec/metadata/labels", "value":{"type":"user-node","region":"east"}}]'  -n openshift-machine-api

        提示

        您还可以应用以下 YAML 将标签添加到机器集中：

        apiVersion: machine.openshift.io/v1beta1
        kind: MachineSet
        metadata:
          name: <machineset>
          namespace: openshift-machine-api
        spec:
          template:
            spec:
              metadata:
                labels:
                  region: "east"
                  type: "user-node"

     2. 使用 oc edit 命令验证标签是否已添加到 MachineSet 对象中：

        例如：

        $ oc edit MachineSet abc612-msrtw-worker-us-east-1c -n openshift-machine-api

        MachineSet 对象示例

        apiVersion: machine.openshift.io/v1beta1
        kind: MachineSet
        
        ....
        
        spec:
        ...
          template:
            metadata:
        ...
            spec:
              metadata:
                labels:
                  region: east
                  type: user-node
        ....

   • 直接向节点添加标签：

     1. 为节点编辑 Node 对象：

        $ oc label nodes <name> <key>=<value>

        例如，若要为以下节点添加标签：

        $ oc label nodes ip-10-0-142-25.ec2.internal type=user-node region=east

        提示

        您还可以应用以下 YAML 将标签添加到节点：

        kind: Node
        apiVersion: v1
        metadata:
          name: <node_name>
          labels:
            type: "user-node"
            region: "east"

     2. 验证标签是否已添加到节点：

        $ oc get nodes -l type=user-node,region=east

        输出示例

        NAME                          STATUS   ROLES    AGE   VERSION
        ip-10-0-142-25.ec2.internal   Ready    worker   17m   v1.18.3+002a51f

2. 将匹配的节点选择器添加到 pod：

   • 要将节点选择器添加到现有和未来的 pod，请向 pod 的控制对象添加节点选择器：

     带有标签的 ReplicaSet 对象示例

     kind: ReplicaSet
     
     ....
     
     spec:
     
     ....
     
       template:
         metadata:
           creationTimestamp: null
           labels:
             ingresscontroller.operator.openshift.io/deployment-ingresscontroller: default
             pod-template-hash: 66d5cf9464
         spec:
           nodeSelector:
             kubernetes.io/os: linux
             node-role.kubernetes.io/worker: ''
             type: user-node 1

     1

     添加节点选择器。

   • 要将节点选择器添加到一个特定的新 pod，直接将选择器添加到 Pod 对象中：

     使用节点选择器的 Pod 对象示例

     apiVersion: v1
     kind: Pod
     
     ....
     
     spec:
       nodeSelector:
         region: east
         type: user-node

     注意

     您不能直接将节点选择器添加到现有调度的 pod 中。

1. 编辑调度程序 Operator CR 以添加默认的集群范围节点选择器：

   $ oc edit scheduler cluster

   使用节点选择器的调度程序 Operator CR 示例

   apiVersion: config.openshift.io/v1
   kind: Scheduler
   metadata:
     name: cluster
   ...
   
   spec:
     defaultNodeSelector: type=user-node,region=east 1
     mastersSchedulable: false
     policy:
       name: ""

   1

   使用适当的 <key>:<value> 对添加节点选择器。

   完成此更改后，请等待重新部署 openshift-kube-apiserver 项目中的 pod。这可能需要几分钟。只有重新部署 pod 后，默认的集群范围节点选择器才会生效。

2. 通过使用机器集或直接编辑节点，为节点添加标签：

   • 在创建节点时，使用机器集向由机器集管理的节点添加标签：

     1. 运行以下命令，将标签添加到 MachineSet 对象中：

        $ oc patch MachineSet <name> --type='json' -p='[{"op":"add","path":"/spec/template/spec/metadata/labels", "value":{"<key>"="<value>","<key>"="<value>"}}]'  -n openshift-machine-api 1

        1

        为每个标识添加 <key>/<value> 对。

        例如：

        $ oc patch MachineSet ci-ln-l8nry52-f76d1-hl7m7-worker-c --type='json' -p='[{"op":"add","path":"/spec/template/spec/metadata/labels", "value":{"type":"user-node","region":"east"}}]'  -n openshift-machine-api

        提示

        您还可以应用以下 YAML 将标签添加到机器集中：

        apiVersion: machine.openshift.io/v1beta1
        kind: MachineSet
        metadata:
          name: <machineset>
          namespace: openshift-machine-api
        spec:
          template:
            spec:
              metadata:
                labels:
                  region: "east"
                  type: "user-node"

     2. 使用 oc edit 命令验证标签是否已添加到 MachineSet 对象中：

        例如：

        $ oc edit MachineSet abc612-msrtw-worker-us-east-1c -n openshift-machine-api

        MachineSet 对象示例

        apiVersion: machine.openshift.io/v1beta1
        kind: MachineSet
          ...
        spec:
          ...
          template:
            metadata:
          ...
            spec:
              metadata:
                labels:
                  region: east
                  type: user-node
          ...

     3. 通过缩减至 0 并扩展节点来重新部署与该机器集关联的节点：

        例如：

        $ oc scale --replicas=0 MachineSet ci-ln-l8nry52-f76d1-hl7m7-worker-c -n openshift-machine-api

        $ oc scale --replicas=1 MachineSet ci-ln-l8nry52-f76d1-hl7m7-worker-c -n openshift-machine-api

     4. 使用 oc edit 命令验证标签是否已添加到 MachineSet 对象中：

        例如：

        $ oc edit MachineSet ci-ln-l8nry52-f76d1-hl7m7-worker-c -n openshift-machine-api

     5. 通过缩减至 0 并扩展节点来重新部署与该机器集关联的节点：

        例如：

        $ oc scale --replicas=0 MachineSet ci-ln-l8nry52-f76d1-hl7m7-worker-c -n openshift-machine-api

        $ oc scale --replicas=1 MachineSet ci-ln-l8nry52-f76d1-hl7m7-worker-c -n openshift-machine-api

     6. 当节点就绪并可用时，使用 oc get 命令验证该标签是否已添加到节点：

        $ oc get nodes -l <key>=<value>

        例如：

        $ oc get nodes -l type=user-node

        输出示例

        NAME                                       STATUS   ROLES    AGE   VERSION
        ci-ln-l8nry52-f76d1-hl7m7-worker-c-vmqzp   Ready    worker   61s   v1.18.3+002a51f

   • 直接向节点添加标签：

     1. 为节点编辑 Node 对象：

        $ oc label nodes <name> <key>=<value>

        例如，若要为以下节点添加标签：

        $ oc label nodes ci-ln-l8nry52-f76d1-hl7m7-worker-b-tgq49 type=user-node region=east

        提示

        您还可以应用以下 YAML 将标签添加到节点：

        kind: Node
        apiVersion: v1
        metadata:
          name: <node_name>
          labels:
            type: "user-node"
            region: "east"

     2. 使用 oc get 命令验证标签是否已添加到节点：

        $ oc get nodes -l <key>=<value>,<key>=<value>

        例如：

        $ oc get nodes -l type=user-node,region=east

        输出示例

        NAME                                       STATUS   ROLES    AGE   VERSION
        ci-ln-l8nry52-f76d1-hl7m7-worker-b-tgq49   Ready    worker   17m   v1.18.3+002a51f

1. 创建命名空间或编辑现有命名空间，以添加 openshift.io/node-selector 参数：

   $ oc edit namespace <name>

   输出示例

   apiVersion: v1
   kind: Namespace
   metadata:
     annotations:
       openshift.io/node-selector: "type=user-node,region=east" 1
       openshift.io/description: ""
       openshift.io/display-name: ""
       openshift.io/requester: kube:admin
       openshift.io/sa.scc.mcs: s0:c30,c5
       openshift.io/sa.scc.supplemental-groups: 1000880000/10000
       openshift.io/sa.scc.uid-range: 1000880000/10000
     creationTimestamp: "2021-05-10T12:35:04Z"
     labels:
       kubernetes.io/metadata.name: demo
     name: demo
     resourceVersion: "145537"
     uid: 3f8786e3-1fcb-42e3-a0e3-e2ac54d15001
   spec:
     finalizers:
     - kubernetes

   1

   使用适当的 <key>:<value> 对添加 openshift.io/node-selector。

2. 通过使用机器集或直接编辑节点，为节点添加标签：

   • 在创建节点时，使用 MachineSet 对象向由机器集管理的节点添加标签：

     1. 运行以下命令，将标签添加到 MachineSet 对象中：

        $ oc patch MachineSet <name> --type='json' -p='[{"op":"add","path":"/spec/template/spec/metadata/labels", "value":{"<key>"="<value>","<key>"="<value>"}}]'  -n openshift-machine-api

        例如：

        $ oc patch MachineSet ci-ln-l8nry52-f76d1-hl7m7-worker-c --type='json' -p='[{"op":"add","path":"/spec/template/spec/metadata/labels", "value":{"type":"user-node","region":"east"}}]'  -n openshift-machine-api

        提示

        您还可以应用以下 YAML 将标签添加到机器集中：

        apiVersion: machine.openshift.io/v1beta1
        kind: MachineSet
        metadata:
          name: <machineset>
          namespace: openshift-machine-api
        spec:
          template:
            spec:
              metadata:
                labels:
                  region: "east"
                  type: "user-node"

     2. 使用 oc edit 命令验证标签是否已添加到 MachineSet 对象中：

        例如：

        $ oc edit MachineSet ci-ln-l8nry52-f76d1-hl7m7-worker-c -n openshift-machine-api

        输出示例

        apiVersion: machine.openshift.io/v1beta1
        kind: MachineSet
        metadata:
        ...
        spec:
        ...
          template:
            metadata:
        ...
            spec:
              metadata:
                labels:
                  region: east
                  type: user-node

     3. 重新部署与该机器集关联的节点：

        例如：

        $ oc scale --replicas=0 MachineSet ci-ln-l8nry52-f76d1-hl7m7-worker-c -n openshift-machine-api

        $ oc scale --replicas=1 MachineSet ci-ln-l8nry52-f76d1-hl7m7-worker-c -n openshift-machine-api

     4. 当节点就绪并可用时，使用 oc get 命令验证该标签是否已添加到节点：

        $ oc get nodes -l <key>=<value>

        例如：

        $ oc get nodes -l type=user-node,region=east

        输出示例

        NAME                                       STATUS   ROLES    AGE   VERSION
        ci-ln-l8nry52-f76d1-hl7m7-worker-c-vmqzp   Ready    worker   61s   v1.18.3+002a51f

   • 直接向节点添加标签：

     1. 编辑 Node 对象以添加标签：

        $ oc label <resource> <name> <key>=<value>

        例如，若要为以下节点添加标签：

        $ oc label nodes ci-ln-l8nry52-f76d1-hl7m7-worker-c-tgq49 type=user-node region=east

        提示

        您还可以应用以下 YAML 将标签添加到节点：

        kind: Node
        apiVersion: v1
        metadata:
          name: <node_name>
          labels:
            type: "user-node"
            region: "east"

     2. 使用 oc get 命令验证标签是否已添加到 Node 对象中：

        $ oc get nodes -l <key>=<value>

        例如：

        $ oc get nodes -l type=user-node,region=east

        输出示例

        NAME                                       STATUS   ROLES    AGE   VERSION
        ci-ln-l8nry52-f76d1-hl7m7-worker-b-tgq49   Ready    worker   17m   v1.18.3+002a51f

流程

1. 创建 Pod spec 并指定 pod 拓扑分散约束：

   pod-spec.yaml 文件示例

   apiVersion: v1
   kind: Pod
   metadata:
     name: my-pod
     labels:
       foo: bar
   spec:
     topologySpreadConstraints:
     - maxSkew: 1 1
       topologyKey: topology.kubernetes.io/zone 2
       whenUnsatisfiable: DoNotSchedule 3
       labelSelector: 4
         matchLabels:
           foo: bar 5
     containers:
     - image: "docker.io/ocpqe/hello-pod"
       name: hello-pod

   1

   两个拓扑域间的 pod 数量的最大差别。默认为 1，您不能指定 0 值。

   2

   节点标签的密钥。具有此键和相同值的节点被视为在同一拓扑中。

   3

   如果不满足分布式约束，如何处理 pod。默认为 DoNotSchedule，它会告诉调度程序不要调度 pod。设置为 ScheduleAnyway，它仍然会调度 pod，但调度程序会优先考虑 skew 的根据情况以使集群不要出现不平衡的情况。

   4

   匹配此标签选择器的 Pod 在分发时被计算并识别为组，以满足约束要求。确保指定标签选择器，否则就无法匹配 pod。

   5

   如果您希望以后正确计数此 Pod 规格，请确保此 Pod spec 也会设置其标签选择器来匹配这个标签选择器。

2. 创建 pod：

   $ oc create -f pod-spec.yaml

流程

1. 创建包含包含调度程序配置文件的配置映射的文件：

   Example scheduler-config-map.yaml

   apiVersion: v1
   kind: ConfigMap
   metadata:
     name: scheduler-config
     namespace: kube-system 1
   data:
     scheduler-config.yaml: | 2
       apiVersion: kubescheduler.config.k8s.io/v1beta2
       kind: KubeSchedulerConfiguration
       profiles:
         - schedulerName: custom-scheduler 3
       leaderElection:
         leaderElect: false

   1

   此流程使用 kube-system 命名空间，但您可以使用自己选择的命名空间。

   2

   当此流程稍后定义 Deployment 资源时，您可以使用 --config 参数将此文件传递给调度程序命令。

   3

   为自定义调度程序定义调度程序配置集。在 Pod 配置中定义 schedulerName 时使用此调度程序名称。

2. 创建配置映射：

   $ oc create -f scheduler-config-map.yaml

3. 创建一个包含自定义调度程序部署资源的文件：

   custom-scheduler.yaml 文件示例

   apiVersion: v1
   kind: ServiceAccount
   metadata:
     name: custom-scheduler
     namespace: kube-system 1
   ---
   apiVersion: rbac.authorization.k8s.io/v1
   kind: ClusterRoleBinding
   metadata:
     name: custom-scheduler-as-kube-scheduler
   subjects:
   - kind: ServiceAccount
     name: custom-scheduler
     namespace: kube-system 2
   roleRef:
     kind: ClusterRole
     name: system:kube-scheduler
     apiGroup: rbac.authorization.k8s.io
   ---
   apiVersion: rbac.authorization.k8s.io/v1
   kind: ClusterRoleBinding
   metadata:
     name: custom-scheduler-as-volume-scheduler
   subjects:
   - kind: ServiceAccount
     name: custom-scheduler
     namespace: kube-system 3
   roleRef:
     kind: ClusterRole
     name: system:volume-scheduler
     apiGroup: rbac.authorization.k8s.io
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     labels:
       component: scheduler
       tier: control-plane
     name: custom-scheduler
     namespace: kube-system 4
   spec:
     selector:
       matchLabels:
         component: scheduler
         tier: control-plane
     replicas: 1
     template:
       metadata:
         labels:
           component: scheduler
           tier: control-plane
           version: second
       spec:
         serviceAccountName: custom-scheduler
         containers:
         - command:
           - /usr/local/bin/kube-scheduler
           - --config=/etc/config/scheduler-config.yaml 5
           image: "<namespace>/<image_name>:<tag>" 6
           livenessProbe:
             httpGet:
               path: /healthz
               port: 10259
               scheme: HTTPS
             initialDelaySeconds: 15
           name: kube-second-scheduler
           readinessProbe:
             httpGet:
               path: /healthz
               port: 10259
               scheme: HTTPS
           resources:
             requests:
               cpu: '0.1'
           securityContext:
             privileged: false
           volumeMounts:
           - name: config-volume
             mountPath: /etc/config
         hostNetwork: false
         hostPID: false
         volumes:
           - name: config-volume
             configMap:
               name: scheduler-config

   1 2 3 4

   此流程使用 kube-system 命名空间，但您可以使用自己选择的命名空间。

   5

   自定义调度程序的命令可能需要不同的参数。

   6

   指定您为自定义调度程序创建的容器镜像。

4. 在集群中创建部署资源：

   $ oc create -f custom-scheduler.yaml

流程

1. 如果您的集群使用基于角色的访问控制 (RBAC)，将自定义调度程序名称添加到 system:kube-scheduler 集群角色。

   1. 编辑 system:kube-scheduler 集群角色：

      $ oc edit clusterrole system:kube-scheduler

   2. 将自定义调度程序的名称添加到 leases 和 endpoints 的 resourceNames 列表中：

      apiVersion: rbac.authorization.k8s.io/v1
      kind: ClusterRole
      metadata:
        annotations:
          rbac.authorization.kubernetes.io/autoupdate: "true"
        creationTimestamp: "2021-07-07T10:19:14Z"
        labels:
          kubernetes.io/bootstrapping: rbac-defaults
        name: system:kube-scheduler
        resourceVersion: "125"
        uid: 53896c70-b332-420a-b2a4-f72c822313f2
      rules:
      ...
      - apiGroups:
        - coordination.k8s.io
        resources:
        - leases
        verbs:
        - create
      - apiGroups:
        - coordination.k8s.io
        resourceNames:
        - kube-scheduler
        - custom-scheduler 1
        resources:
        - leases
        verbs:
        - get
        - update
      - apiGroups:
        - ""
        resources:
        - endpoints
        verbs:
        - create
      - apiGroups:
        - ""
        resourceNames:
        - kube-scheduler
        - custom-scheduler 2
        resources:
        - endpoints
        verbs:
        - get
        - update
      ...

      1 2

      本例使用 custom-scheduler 作为自定义调度程序名称。

2. 创建 Pod 配置并在 schedulerName 参数中指定自定义调度程序的名称：

   custom-scheduler-example.yaml 文件示例

   apiVersion: v1
   kind: Pod
   metadata:
     name: custom-scheduler-example
     labels:
       name: custom-scheduler-example
   spec:
     schedulerName: custom-scheduler 1
     containers:
     - name: pod-with-second-annotation-container
       image: docker.io/ocpqe/hello-pod

   1

   要使用的自定义调度程序的名称，本例中为 custom-scheduler。如果没有提供调度程序名称，pod 会自动使用默认调度程序来调度。

3. 创建 pod：

   $ oc create -f custom-scheduler-example.yaml

验证

1. 输入以下命令检查 pod 是否已创建：

   $ oc get pod custom-scheduler-example

   custom-scheduler-example pod 在输出中列出：

   NAME                       READY     STATUS    RESTARTS   AGE
   custom-scheduler-example   1/1       Running   0          4m

2. 输入以下命令检查自定义调度程序是否已调度 pod：

   $ oc describe pod custom-scheduler-example

   调度程序 custom-scheduler 如以下截断的输出所示：

   Events:
     Type    Reason          Age        From                                               Message
     ----    ------          ----       ----                                               -------
     Normal  Scheduled       <unknown>  custom-scheduler                                   Successfully assigned default/custom-scheduler-example to <node_name>

流程

1. 登陆到 OpenShift Container Platform Web 控制台。

2. 为 Kube Descheduler Operator 创建所需的命名空间。

   1. 进行 Administration → Namespaces，点 Create Namespace。
   2. 在 Name 字段中输入 openshift-kube-descheduler-operator，在 Labels 字段中输入 openshift.io/cluster-monitoring=true 来启用 descheduler 指标，然后点击 Create。

3. 安装 Kube Descheduler Operator。

   1. 进入 Operators → OperatorHub。
   2. 在过滤框中输入 Kube Descheduler Operator。
   3. 选择 Kube Descheduler Operator 并点 Install。
   4. 在 Install Operator 页面中，选择 A specific namespace on the cluster。从下拉菜单中选择 openshift-kube-descheduler-operator 。
   5. 将 Update Channel 和 Approval Strategy 的值调整为所需的值。
   6. 点击 Install。

4. 创建 descheduler 实例。

   1. 在 Operators → Installed Operators 页面中，点 Kube Descheduler Operator。
   2. 选择 Kube Descheduler 标签页并点 Create KubeDescheduler。

   3. 根据需要编辑设置。

      1. 展开 Profiles 部分，以选择要启用的一个或多个配置文件。AffinityAndTaints 配置集默认启用。单击 Add Profile 以选择其他配置文件。
      2. 可选： 使用 Descheduling Interval Seconds 字段更改 descheduler 运行间隔的秒数。默认值为 3600 秒。
   4. 点击 Create。

流程

1. 编辑 KubeDescheduler 对象：

   $ oc edit kubedeschedulers.operator.openshift.io cluster -n openshift-kube-descheduler-operator

2. 在 spec.profiles 部分指定一个或多个配置集。

   apiVersion: operator.openshift.io/v1
   kind: KubeDescheduler
   metadata:
     name: cluster
     namespace: openshift-kube-descheduler-operator
   spec:
     deschedulingIntervalSeconds: 3600
     logLevel: Normal
     managementState: Managed
     operatorLogLevel: Normal
     profiles:
     - AffinityAndTaints       1
     - TopologyAndDuplicates   2
     - LifecycleAndUtilization 3

   1

   启用 AffinityAndTaints 配置集，它会驱除违反了 pod 间的反关联性、节点关联性和节点污点的 pod。

   2

   启用 TopologyAndDuplicates 配置集，它会驱除 pod，以便在节点间平均分配类似的 pod 或相同拓扑域的 pod。

   3

   启用 LifecycleAndUtilization 配置集，用于驱除长时间运行的 pod，并平衡节点之间的资源使用量。

   您可以启用多个配置集 ; 指定配置集的顺序并不重要。

3. 保存文件以使改变生效。

流程

1. 编辑 KubeDescheduler 对象：

   $ oc edit kubedeschedulers.operator.openshift.io cluster -n openshift-kube-descheduler-operator

2. 将 deschedulingIntervalSeconds 字段更新为所需的值：

   apiVersion: operator.openshift.io/v1
   kind: KubeDescheduler
   metadata:
     name: cluster
     namespace: openshift-kube-descheduler-operator
   spec:
     deschedulingIntervalSeconds: 3600 1
   ...

   1

   设置 descheduler 运行间隔的秒数。如果设为 0，则 descheduler 会运行一次并退出。

3. 保存文件以使改变生效。

流程

1. 登陆到 OpenShift Container Platform Web 控制台。

2. 删除 descheduler 实例。

   1. 在 Operators → Installed Operators 页面中，点 Kube Descheduler Operator。
   2. 选择 Kube Descheduler 选项卡。
   3. 点 集群 条目旁的 Options 菜单 并选择 Delete KubeDescheduler。
   4. 在确认对话框中，点 Delete。

3. 卸载 Kube Descheduler Operator。

   1. 导航到 Operators → Installed Operators，
   2. 点 Kube Descheduler Operator 条目 旁边的 Options 菜单，然后选择 Uninstall Operator。
   3. 在确认对话框中，点 Uninstall。

4. 删除 openshift-kube-descheduler-operator 命名空间。

   1. 导航至 Administration → Namespaces。
   2. 在过滤器框中输入 openshift-kube-descheduler-operator。
   3. 点 openshift-kube-descheduler-operator 条目旁的 Options 菜单 ，然后选择 Delete Namespace。
   4. 在确认对话框中，输入 openshift-kube-descheduler-operator 并点 Delete。

5. 删除 KubeDescheduler CRD。

   1. 进入 Administration → Custom Resource Definitions。
   2. 在过滤器框中输入 KubeDescheduler。
   3. 点 KubeDescheduler 条目旁的 Options 菜单 ，然后选择 Delete CustomResourceDefinition。
   4. 在确认对话框中，点 Delete。

1. 定义守护进程集 yaml 文件：

   apiVersion: apps/v1
   kind: DaemonSet
   metadata:
     name: hello-daemonset
   spec:
     selector:
         matchLabels:
           name: hello-daemonset 1
     template:
       metadata:
         labels:
           name: hello-daemonset 2
       spec:
         nodeSelector: 3
           role: worker
         containers:
         - image: openshift/hello-openshift
           imagePullPolicy: Always
           name: registry
           ports:
           - containerPort: 80
             protocol: TCP
           resources: {}
           terminationMessagePath: /dev/termination-log
         serviceAccount: default
         terminationGracePeriodSeconds: 10

   1

   决定哪些 pod 属于守护进程集的标签选择器。

   2

   pod 模板的标签选择器。必须与上述标签选择器匹配。

   3

   决定应该在哪些节点上部署 pod 副本的节点选择器。节点上必须存在匹配的标签。

2. 创建守护进程集对象：

   $ oc create -f daemonset.yaml

3. 验证 pod 是否已创建好，并且每个节点都有 pod 副本：

   1. 查找 daemonset pod：

      $ oc get pods

      输出示例

      hello-daemonset-cx6md   1/1       Running   0          2m
      hello-daemonset-e3md9   1/1       Running   0          2m

   2. 查看 pod 以验证 pod 已放置到节点上：

      $ oc describe pod/hello-daemonset-cx6md|grep Node

      输出示例

      Node:        openshift-node01.hostname.com/10.14.20.134

      $ oc describe pod/hello-daemonset-e3md9|grep Node

      输出示例

      Node:        openshift-node02.hostname.com/10.14.20.137

1. 创建一个类似以下示例的 YAML 文件：

   apiVersion: batch/v1
   kind: Job
   metadata:
     name: pi
   spec:
     parallelism: 1    1
     completions: 1    2
     activeDeadlineSeconds: 1800 3
     backoffLimit: 6   4
     template:         5
       metadata:
         name: pi
       spec:
         containers:
         - name: pi
           image: perl
           command: ["perl",  "-Mbignum=bpi", "-wle", "print bpi(2000)"]
         restartPolicy: OnFailure    6

   1

   可选：指定一个作业应并行运行多少个 pod 副本；默认与 1。

   • 对于非并行作业，请保留未设置。当取消设置时，默认为 1。

   2

   可选：指定标记作业完成需要成功完成多少个 pod。

   • 对于非并行作业，请保留未设置。当取消设置时，默认为 1。
   • 对于具有固定完成计数的并行作业，请指定完成数。
   • 对于带有工作队列的并行作业，请保留 unset。当取消设置默认为 parallelism 值。

   3

   可选：指定作业可以运行的最长持续时间。

   4

   可选：指定作业的重试次数。此字段默认值为 6。

   5

   指定控制器创建的 Pod 模板。

   6

   指定 pod 的重启策略。

   • Never不要重启作业。
   • OnFailure。仅在失败时重启该任务。

   • Always。总是重启该任务。

     如需了解 OpenShift Container Platform 如何使用与失败容器相关的重启策略，请参阅 Kubernetes 文档中的示例状态。

2. 创建作业：

   $ oc create -f <file-name>.yaml

1. 创建一个类似以下示例的 YAML 文件：

   apiVersion: batch/v1
   kind: CronJob
   metadata:
     name: pi
   spec:
     schedule: "*/1 * * * *"  1
     concurrencyPolicy: "Replace" 2
     startingDeadlineSeconds: 200 3
     suspend: true            4
     successfulJobsHistoryLimit: 3 5
     failedJobsHistoryLimit: 1     6
     jobTemplate:             7
       spec:
         template:
           metadata:
             labels:          8
               parent: "cronjobpi"
           spec:
             containers:
             - name: pi
               image: perl
               command: ["perl",  "-Mbignum=bpi", "-wle", "print bpi(2000)"]
             restartPolicy: OnFailure 9

   1

   以 cron 格式指定的作业调度计划。在本例中，作业将每分钟运行一次。

   2

   可选的并发策略，指定如何对待 Cron Job 中的并发作业。只能指定以下并发策略之一。若未指定，默认为允许并发执行。

   • Allow，允许 Cron Job 并发运行。
   • Forbid，禁止并发运行。如果上一运行尚未结束，则跳过下一运行。
   • Replace，取消当前运行的作业并替换为新作业。

   3

   可选期限（秒为单位），如果作业因任何原因而错过预定时间，则在此期限内启动作业。错过的作业执行计为失败的作业。若不指定，则没有期限。

   4

   可选标志，允许挂起 Cron Job。若设为 true，则会挂起所有后续执行。

   5

   要保留的成功完成作业数（默认为 3）。

   6

   要保留的失败完成作业数（默认为 1）。

   7

   作业模板。类似于作业示例。

   8

   为此 Cron Job 生成的作业设置一个标签。

   9

   pod 的重启策略。这不适用于作业控制器。

   注意

   .spec.successfulJobsHistoryLimit 和 .spec.failedJobsHistoryLimit 字段是可选的，用于指定应保留的已完成作业和已失败作业的数量。默认情况下，分别设置为 3 和 1。如果将限制设定为 0，则对应种类的作业完成后不予保留。

2. 创建 cron job：

   $ oc create -f <file-name>.yaml