节点

1. 切换到对应项目：

   $ oc project <project-name>

2. 运行以下命令：

   $ oc get pods

   例如：

   $ oc get pods

   输出示例

   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=''

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

   例如：

   $ oc adm top pod --selector='name=my-pod'

流程 (UI)

1. 在 Red Hat OpenShift Service on AWS 控制台中，进入 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. 通过创建类似如下的 YAML 文件，定义 pod spec 使其包含优先级类的名称：

   apiVersion: v1
   kind: Pod
   metadata:
     name: nginx
     labels:
       env: test
   spec:
     containers:
     - name: nginx
       image: nginx
       imagePullPolicy: IfNotPresent
     priorityClassName: system-cluster-critical 1

   1

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

2. 创建 pod：

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

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

流程

1. 在 Red Hat OpenShift Service on AWS web 控制台中，点 Operators → OperatorHub。
2. 从可用的 Operator 列表中选择 Custom Metrics Autoscaler，然后点 Install。
3. 在 Install Operator 页面中，确保为 Installation Mode 选择了 A specific namespace on the cluster 选项。
4. 对于 Installed Namespace，点 Select a namespace。

5. 点 Select Project:

   • 如果存在 keda 命名空间，请从列表中选择 keda。

   • 如果 keda 命名空间不存在：

     1. 选择 Create Project 以打开 Create Project 窗口。
     2. 在 Name 字段中输入 keda。
     3. 在 Display Name 字段中输入描述性名称，如 keda。
     4. 可选：在 Display Name 字段中，为命名空间添加描述。
     5. 点 Create。
6. 点 Install。

7. 列出自定义 Metrics Autoscaler Operator 组件来验证安装：

   1. 导航到 Workloads → Pods。
   2. 从下拉菜单中选择 keda 项目，并验证 custom-metrics-autoscaler-operator autoscaler pod 是否正在运行。
   3. 进入到 Workloads → Deployments 以验证 custom-metrics-autoscaler-operator 部署是否正在运行。

8. 可选：使用以下命令在 OpenShift CLI 中验证安装：

   $ oc get all -n keda

   输出结果类似如下：

   输出示例

   NAME                                                      READY   STATUS    RESTARTS   AGE
   pod/custom-metrics-autoscaler-operator-5fd8d9ffd8-xt4xp   1/1     Running   0          18m
   
   NAME                                                 READY   UP-TO-DATE   AVAILABLE   AGE
   deployment.apps/custom-metrics-autoscaler-operator   1/1     1            1           18m
   
   NAME                                                            DESIRED   CURRENT   READY   AGE
   replicaset.apps/custom-metrics-autoscaler-operator-5fd8d9ffd8   1         1         1       18m

9. 安装 KedaController 自定义资源，该资源创建所需的 CRD：

   1. 在 Red Hat OpenShift Service on AWS web 控制台中，点 Operators → Installed Operators。
   2. 点 Custom Metrics Autoscaler。
   3. 在 Operator Details 页面中，点 KedaController 选项卡。

   4. 在 KedaController 选项卡中，点 Create KedaController 并编辑文件。

      kind: KedaController
      apiVersion: keda.sh/v1alpha1
      metadata:
        name: keda
        namespace: keda
      spec:
        watchNamespace: '' 1
        operator:
          logLevel: info 2
          logEncoder: console 3
          caConfigMaps: 4
          - thanos-cert
          - kafka-cert
        metricsServer:
          logLevel: '0' 5
          auditConfig: 6
            logFormat: "json"
            logOutputVolumeClaim: "persistentVolumeClaimName"
            policy:
              rules:
              - level: Metadata
              omitStages: ["RequestReceived"]
              omitManagedFields: false
            lifetime:
              maxAge: "2"
              maxBackup: "1"
              maxSize: "50"
        serviceAccount: {}

      1

      指定自定义 Metrics Autoscaler Operator 应该在其中扩展应用程序的单个命名空间。将它留空，或将其留空，以便在所有命名空间中扩展应用程序。此字段应具有命名空间或为空。默认值为空。

      2

      指定自定义 Metrics Autoscaler Operator 日志消息的详细程度。允许的值有 debug、info 和error。默认为 info。

      3

      指定 Custom Metrics Autoscaler Operator 日志消息的日志记录格式。允许的值是 console 或 json。默认为 console。

      4

      可选：使用 CA 证书指定一个或多个配置映射，自定义 Metrics Autoscaler Operator 可以使用它们安全地连接到启用了 TLS 的指标源。

      5

      指定自定义 Metrics Autoscaler Metrics 服务器的日志记录级别。允许的值是 0（用于 info）和 4（用于 debug ）。默认值为 0。

      6

      激活自定义 Metrics Autoscaler Operator 的审计日志记录，并指定要使用的审计策略，如"配置审计日志记录"部分中所述。

   5. 点 Create 创建 KEDA 控制器。

流程

1. 创建 TriggerAuthentication 或 ClusterTriggerAuthentication 对象。

   1. 创建定义对象的 YAML 文件：

      使用 secret 的触发器验证示例

      kind: TriggerAuthentication
      apiVersion: keda.sh/v1alpha1
      metadata:
        name: prom-triggerauthentication
        namespace: my-namespace
      spec:
        secretTargetRef:
        - parameter: user-name
          name: my-secret
          key: USER_NAME
        - parameter: password
          name: my-secret
          key: USER_PASSWORD

   2. 创建 TriggerAuthentication 对象：

      $ oc create -f <filename>.yaml

2. 创建或编辑使用触发器身份验证的 ScaledObject YAML 文件：

   1. 运行以下命令，创建定义对象的 YAML 文件：

      使用触发器身份验证的扩展对象示例

      apiVersion: keda.sh/v1alpha1
      kind: ScaledObject
      metadata:
        name: scaledobject
        namespace: my-namespace
      spec:
        scaleTargetRef:
          name: example-deployment
        maxReplicaCount: 100
        minReplicaCount: 0
        pollingInterval: 30
        triggers:
        - type: prometheus
          metadata:
            serverAddress: https://thanos-querier.openshift-monitoring.svc.cluster.local:9092
            namespace: kedatest # replace <NAMESPACE>
            metricName: http_requests_total
            threshold: '5'
            query: sum(rate(http_requests_total{job="test-app"}[1m]))
            authModes: "basic"
          authenticationRef:
            name: prom-triggerauthentication 1
            kind: TriggerAuthentication 2

      1

      指定触发器身份验证对象的名称。

      2

      指定 TriggerAuthentication。TriggerAuthentication 是默认值。

      使用集群触发器身份验证的扩展对象示例

      apiVersion: keda.sh/v1alpha1
      kind: ScaledObject
      metadata:
        name: scaledobject
        namespace: my-namespace
      spec:
        scaleTargetRef:
          name: example-deployment
        maxReplicaCount: 100
        minReplicaCount: 0
        pollingInterval: 30
        triggers:
        - type: prometheus
          metadata:
            serverAddress: https://thanos-querier.openshift-monitoring.svc.cluster.local:9092
            namespace: kedatest # replace <NAMESPACE>
            metricName: http_requests_total
            threshold: '5'
            query: sum(rate(http_requests_total{job="test-app"}[1m]))
            authModes: "basic"
          authenticationRef:
            name: prom-cluster-triggerauthentication 1
            kind: ClusterTriggerAuthentication 2

      1

      指定触发器身份验证对象的名称。

      2

      指定 ClusterTriggerAuthentication。

   2. 运行以下命令来创建扩展的对象：

      $ oc apply -f <filename>

流程

1. 使用以下命令编辑工作负载的 ScaledObject CR：

   $ oc edit ScaledObject scaledobject

2. 使用任何值添加 autoscaling.keda.sh/paused-replicas 注解：

   apiVersion: keda.sh/v1alpha1
   kind: ScaledObject
   metadata:
     annotations:
       autoscaling.keda.sh/paused-replicas: "4" 1
     creationTimestamp: "2023-02-08T14:41:01Z"
     generation: 1
     name: scaledobject
     namespace: my-project
     resourceVersion: '65729'
     uid: f5aec682-acdf-4232-a783-58b5b82f5dd0

   1

   指定自定义 Metrics Autoscaler Operator 将副本扩展到指定的值，并停止自动扩展。

流程

1. 使用以下命令编辑工作负载的 ScaledObject CR：

   $ oc edit ScaledObject scaledobject

2. 删除 autoscaling.keda.sh/paused-replicas 注解。

   apiVersion: keda.sh/v1alpha1
   kind: ScaledObject
   metadata:
     annotations:
       autoscaling.keda.sh/paused-replicas: "4" 1
     creationTimestamp: "2023-02-08T14:41:01Z"
     generation: 1
     name: scaledobject
     namespace: my-project
     resourceVersion: '65729'
     uid: f5aec682-acdf-4232-a783-58b5b82f5dd0

   1

   删除此注解以重启暂停的自定义指标自动扩展。

流程

1. 编辑 KedaController 自定义资源以添加 auditConfig 小节：

   kind: KedaController
   apiVersion: keda.sh/v1alpha1
   metadata:
     name: keda
     namespace: keda
   spec:
   # ...
     metricsServer:
   # ...
       auditConfig:
         logFormat: "json" 1
         logOutputVolumeClaim: "pvc-audit-log" 2
         policy:
           rules: 3
           - level: Metadata
           omitStages: "RequestReceived" 4
           omitManagedFields: false 5
         lifetime: 6
           maxAge: "2"
           maxBackup: "1"
           maxSize: "50"

   1

   指定审计日志的输出格式，可以是 legacy 或 json。

   2

   指定用于存储日志数据的现有持久性卷声明。所有来自 API 服务器的请求都会记录到此持久性卷声明。如果将此字段留空，日志数据将发送到 stdout。

   3

   指定应记录哪些事件及其应包含哪些数据：

   • None ：不记录事件。
   • Metadata ：仅记录请求的元数据，如用户、时间戳等。不要记录请求文本和响应文本。这是默认值。
   • Request ：仅记录元数据和请求文本，而不记录响应文本。这个选项不适用于非资源请求。
   • RequestResponse ：日志事件元数据、请求文本和响应文本。这个选项不适用于非资源请求。

   4

   指定没有创建事件的阶段。

   5

   指定是否省略请求的 managed 字段，并从写入 API 审计日志的响应正文，可以是 true 来省略字段，或 false 包含字段。

   6

   指定审计日志的大小和生命周期。

   • MaxAge ：根据文件名中编码的时间戳，保留审计日志文件的最大天数。
   • maxBackup ：要保留的审计日志文件的最大数量。设置为 0 以保留所有审计日志文件。
   • maxsize ：在轮转审计日志文件前以 MB 为单位的最大大小。

验证

1. 直接查看审计日志文件：

   1. 获取 keda-metrics-apiserver the pod 的名称：

      oc get pod -n keda

      输出示例

      NAME                                                  READY   STATUS    RESTARTS   AGE
      custom-metrics-autoscaler-operator-5cb44cd75d-9v4lv   1/1     Running   0          8m20s
      keda-metrics-apiserver-65c7cc44fd-rrl4r               1/1     Running   0          2m55s
      keda-operator-776cbb6768-zpj5b                        1/1     Running   0          2m55s

   2. 使用类似如下的命令查看日志数据：

      $ oc logs keda-metrics-apiserver-<hash>|grep -i metadata 1

      1

      可选： 您可以使用 grep 命令指定要显示的日志级别： Metadata、Request、RequestResponse。

      例如：

      $ oc logs keda-metrics-apiserver-65c7cc44fd-rrl4r|grep -i metadata

      输出示例

       ...
      {"kind":"Event","apiVersion":"audit.k8s.io/v1","level":"Metadata","auditID":"4c81d41b-3dab-4675-90ce-20b87ce24013","stage":"ResponseComplete","requestURI":"/healthz","verb":"get","user":{"username":"system:anonymous","groups":["system:unauthenticated"]},"sourceIPs":["10.131.0.1"],"userAgent":"kube-probe/1.28","responseStatus":{"metadata":{},"code":200},"requestReceivedTimestamp":"2023-02-16T13:00:03.554567Z","stageTimestamp":"2023-02-16T13:00:03.555032Z","annotations":{"authorization.k8s.io/decision":"allow","authorization.k8s.io/reason":""}}
       ...

2. 另外，您可以查看特定的日志：

   1. 使用类似如下的命令登录到 keda-metrics-apiserver the pod:

      $ oc rsh pod/keda-metrics-apiserver-<hash> -n keda

      例如：

      $ oc rsh pod/keda-metrics-apiserver-65c7cc44fd-rrl4r -n keda

   2. 进入 /var/audit-policy/ 目录：

      sh-4.4$ cd /var/audit-policy/

   3. 列出可用的日志：

      sh-4.4$ ls

      输出示例

      log-2023.02.17-14:50  policy.yaml

   4. 根据需要查看日志：

      sh-4.4$ cat <log_name>/<pvc_name>|grep -i <log_level> 1

      1

      可选： 您可以使用 grep 命令指定要显示的日志级别： Metadata、Request、RequestResponse。

      例如：

      sh-4.4$ cat log-2023.02.17-14:50/pvc-audit-log|grep -i Request

      输出示例

       ...
      {"kind":"Event","apiVersion":"audit.k8s.io/v1","level":"Request","auditID":"63e7f68c-04ec-4f4d-8749-bf1656572a41","stage":"ResponseComplete","requestURI":"/openapi/v2","verb":"get","user":{"username":"system:aggregator","groups":["system:authenticated"]},"sourceIPs":["10.128.0.1"],"responseStatus":{"metadata":{},"code":304},"requestReceivedTimestamp":"2023-02-17T13:12:55.035478Z","stageTimestamp":"2023-02-17T13:12:55.038346Z","annotations":{"authorization.k8s.io/decision":"allow","authorization.k8s.io/reason":"RBAC: allowed by ClusterRoleBinding \"system:discovery\" of ClusterRole \"system:discovery\" to Group \"system:authenticated\""}}
       ...

流程

1. 进入存储 must-gather 数据的目录。

2. 执行以下之一：

   • 要只获取自定义 Metrics Autoscaler Operator must-gather 数据，请使用以下命令：

     $ oc adm must-gather --image="$(oc get packagemanifests openshift-custom-metrics-autoscaler-operator \
     -n openshift-marketplace \
     -o jsonpath='{.status.channels[?(@.name=="stable")].currentCSVDesc.annotations.containerImage}')"

     must-gather 命令的自定义镜像直接从 Operator 软件包清单中拉取，以便它可用于提供 Custom Metric Autoscaler Operator 的任何集群。

   • 除了 Custom Metric Autoscaler Operator 信息外，要收集默认的 must-gather 数据：

     1. 使用以下命令获取自定义 Metrics Autoscaler Operator 镜像并将其设置为环境变量：

        $ IMAGE="$(oc get packagemanifests openshift-custom-metrics-autoscaler-operator \
          -n openshift-marketplace \
          -o jsonpath='{.status.channels[?(@.name=="stable")].currentCSVDesc.annotations.containerImage}')"

     2. 使用带有自定义 Metrics Autoscaler Operator 镜像的 oc adm must-gather ：

        $ oc adm must-gather --image-stream=openshift/must-gather --image=${IMAGE}

   例 3.1. Custom Metric Autoscaler 的 must-gather 输出示例

   └── keda
       ├── apps
       │   ├── daemonsets.yaml
       │   ├── deployments.yaml
       │   ├── replicasets.yaml
       │   └── statefulsets.yaml
       ├── apps.openshift.io
       │   └── deploymentconfigs.yaml
       ├── autoscaling
       │   └── horizontalpodautoscalers.yaml
       ├── batch
       │   ├── cronjobs.yaml
       │   └── jobs.yaml
       ├── build.openshift.io
       │   ├── buildconfigs.yaml
       │   └── builds.yaml
       ├── core
       │   ├── configmaps.yaml
       │   ├── endpoints.yaml
       │   ├── events.yaml
       │   ├── persistentvolumeclaims.yaml
       │   ├── pods.yaml
       │   ├── replicationcontrollers.yaml
       │   ├── secrets.yaml
       │   └── services.yaml
       ├── discovery.k8s.io
       │   └── endpointslices.yaml
       ├── image.openshift.io
       │   └── imagestreams.yaml
       ├── k8s.ovn.org
       │   ├── egressfirewalls.yaml
       │   └── egressqoses.yaml
       ├── keda.sh
       │   ├── kedacontrollers
       │   │   └── keda.yaml
       │   ├── scaledobjects
       │   │   └── example-scaledobject.yaml
       │   └── triggerauthentications
       │       └── example-triggerauthentication.yaml
       ├── monitoring.coreos.com
       │   └── servicemonitors.yaml
       ├── networking.k8s.io
       │   └── networkpolicies.yaml
       ├── keda.yaml
       ├── pods
       │   ├── custom-metrics-autoscaler-operator-58bd9f458-ptgwx
       │   │   ├── custom-metrics-autoscaler-operator
       │   │   │   └── custom-metrics-autoscaler-operator
       │   │   │       └── logs
       │   │   │           ├── current.log
       │   │   │           ├── previous.insecure.log
       │   │   │           └── previous.log
       │   │   └── custom-metrics-autoscaler-operator-58bd9f458-ptgwx.yaml
       │   ├── custom-metrics-autoscaler-operator-58bd9f458-thbsh
       │   │   └── custom-metrics-autoscaler-operator
       │   │       └── custom-metrics-autoscaler-operator
       │   │           └── logs
       │   ├── keda-metrics-apiserver-65c7cc44fd-6wq4g
       │   │   ├── keda-metrics-apiserver
       │   │   │   └── keda-metrics-apiserver
       │   │   │       └── logs
       │   │   │           ├── current.log
       │   │   │           ├── previous.insecure.log
       │   │   │           └── previous.log
       │   │   └── keda-metrics-apiserver-65c7cc44fd-6wq4g.yaml
       │   └── keda-operator-776cbb6768-fb6m5
       │       ├── keda-operator
       │       │   └── keda-operator
       │       │       └── logs
       │       │           ├── current.log
       │       │           ├── previous.insecure.log
       │       │           └── previous.log
       │       └── keda-operator-776cbb6768-fb6m5.yaml
       ├── policy
       │   └── poddisruptionbudgets.yaml
       └── route.openshift.io
           └── routes.yaml

3. 从工作目录中创建的 must-gather 目录创建一个压缩文件。例如，在使用 Linux 操作系统的计算机上运行以下命令：

   $ tar cvaf must-gather.tar.gz must-gather.local.5421342344627712289/ 1

   1

   将 must-gather-local.5421342344627712289/ 替换为实际目录名称。

4. 在红帽客户门户中为您的问题单附上压缩文件。

流程

1. 在 Red Hat OpenShift Service on AWS web 控制台中选择 Administrator 视角。
2. 选择 Observe → Metrics。
3. 要创建自定义查询，请将 PromQL 查询添加到 Expression 字段中。
4. 要添加多个查询，选择 Add Query。

流程

1. 创建一个类似如下的 YAML 文件：只有名称 <2>, 对象名称 <4>, 和对象类型 <5> 是必需的。

   缩放对象示例

   apiVersion: keda.sh/v1alpha1
   kind: ScaledObject
   metadata:
     annotations:
       autoscaling.keda.sh/paused-replicas: "0" 1
     name: scaledobject 2
     namespace: my-namespace
   spec:
     scaleTargetRef:
       apiVersion: apps/v1 3
       name: example-deployment 4
       kind: Deployment 5
       envSourceContainerName: .spec.template.spec.containers[0] 6
     cooldownPeriod:  200 7
     maxReplicaCount: 100 8
     minReplicaCount: 0 9
     metricsServer: 10
       auditConfig:
         logFormat: "json"
         logOutputVolumeClaim: "persistentVolumeClaimName"
         policy:
           rules:
           - level: Metadata
           omitStages: "RequestReceived"
           omitManagedFields: false
         lifetime:
           maxAge: "2"
           maxBackup: "1"
           maxSize: "50"
     fallback: 11
       failureThreshold: 3
       replicas: 6
     pollingInterval: 30 12
     advanced:
       restoreToOriginalReplicaCount: false 13
       horizontalPodAutoscalerConfig:
         name: keda-hpa-scale-down 14
         behavior: 15
           scaleDown:
             stabilizationWindowSeconds: 300
             policies:
             - type: Percent
               value: 100
               periodSeconds: 15
     triggers:
     - type: prometheus 16
       metadata:
         serverAddress: https://thanos-querier.openshift-monitoring.svc.cluster.local:9092
         namespace: kedatest
         metricName: http_requests_total
         threshold: '5'
         query: sum(rate(http_requests_total{job="test-app"}[1m]))
         authModes: basic
       authenticationRef: 17
         name: prom-triggerauthentication
         kind: TriggerAuthentication

   1

   可选：指定自定义 Metrics Autoscaler Operator 将副本扩展到指定的值和停止自动扩展，如 "Pausing the custom metrics autoscaler for a workload" 部分所述。

   2

   指定此自定义指标自动扩展的名称。

   3

   可选：指定目标资源的 API 版本。默认为 apps/v1。

   4

   指定要缩放的对象名称。

   5

   指定 kind 为 Deployment, StatefulSet 或 CustomResource。

   6

   可选：指定目标资源中的容器的名称，其中的自定义自动扩展器获取包含 secret 的环境变量等。默认为 .spec.template.spec.containers[0]。

   7

   可选。指定一个在最后的触发器报告后等待的时间（以秒为单位），在经过这个时间后才会将部署缩减为 0（如果 minReplicaCount 设置为 0）。默认值为 300。

   8

   可选：指定扩展时的最大副本数量。默认值为 100。

   9

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

   10

   可选：指定审计日志的参数。如"配置审计日志记录"部分中所述。

   11

   可选：指定在扩展程序无法从源中获取由 failureThreshold 参数定义的次数时回退到的副本数。有关回退行为的更多信息，请参阅 KEDA 文档。

   12

   可选：指定检查每个触发器的时间间隔（以秒为单位）。默认值为 30。

   13

   可选：指定是否在删除扩展对象后将目标资源扩展为原始副本数。默认为 false，这会在删除扩展对象时保留副本数。

   14

   可选：指定 pod 横向自动扩展的名称。默认为 keda-hpa-{scaled-object-name}。

   15

   可选：指定一个扩展策略来控制用来扩展或缩减 pod 的速度，如"扩展策略"部分中所述。

   16

   指定用作扩展基础的触发器，如"识别自定义指标自动扩展触发器"部分中所述。本例使用 Red Hat OpenShift Service on AWS 监控。

   17

   可选：指定触发器身份验证或集群触发器身份验证。如需更多信息，请参阅附加资源部分中的 了解自定义指标自动扩展触发器身份验证。

   • 输入 TriggerAuthentication 来使用触发器身份验证。这是默认值。
   • 输入 ClusterTriggerAuthentication 来使用集群触发器身份验证。

2. 运行以下命令来创建自定义指标自动扩展：

   $ oc create -f <filename>.yaml

流程

1. 在 Red Hat OpenShift Service on AWS web 控制台中，点 Operators → Installed Operators。
2. 切换到 keda 项目。

3. 删除 KedaController 自定义资源。

   1. 找到 CustomMetricsAutoscaler Operator 并点 KedaController 选项卡。
   2. 找到自定义资源，然后点 Delete KedaController。
   3. 点 Uninstall。

4. 删除自定义 Metrics Autoscaler Operator:

   1. 点 Operators → Installed Operators。
   2. 找到 CustomMetricsAutoscaler Operator 并点 Options 菜单 并选择 Uninstall Operator。
   3. 点 Uninstall。

5. 可选： 使用 OpenShift CLI 删除自定义指标自动扩展组件：

   1. 删除自定义指标自动扩展 CRD：

      • clustertriggerauthentications.keda.sh
      • kedacontrollers.keda.sh
      • scaledjobs.keda.sh
      • scaledobjects.keda.sh
      • triggerauthentications.keda.sh

      $ oc delete crd clustertriggerauthentications.keda.sh kedacontrollers.keda.sh scaledjobs.keda.sh scaledobjects.keda.sh triggerauthentications.keda.sh

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

   2. 列出任何自定义指标自动扩展集群角色：

      $ oc get clusterrole | grep keda.sh

   3. 删除列出的自定义指标自动扩展集群角色。例如：

      $ oc delete clusterrole.keda.sh-v1alpha1-admin

   4. 列出任何自定义指标自动扩展集群角色绑定：

      $ oc get clusterrolebinding | grep keda.sh

   5. 删除列出的自定义指标自动扩展集群角色绑定。例如：

      $ oc delete clusterrolebinding.keda.sh-v1alpha1-admin

6. 删除自定义指标自动扩展项目：

   $ oc delete project keda

7. 删除 Cluster Metric Autoscaler Operator：

   $ oc delete operator/openshift-custom-metrics-autoscaler-operator.keda

流程

1. 创建 pod 规格中具有特定标签的 pod：

   1. 使用以下内容创建 YAML 文件：

      apiVersion: v1
      kind: Pod
      metadata:
        name: security-s1
        labels:
          security: S1
      spec:
        securityContext:
          runAsNonRoot: true
          seccompProfile:
            type: RuntimeDefault
        containers:
        - name: security-s1
          image: docker.io/ocpqe/hello-pod
          securityContext:
            runAsNonRoot: true
            seccompProfile:
              type: RuntimeDefault

   2. 创建 pod。

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

2. 在创建其他 pod 时，配置以下参数以添加关联性：

   1. 使用以下内容创建 YAML 文件：

      apiVersion: v1
      kind: Pod
      metadata:
        name: security-s1-east
      # ...
      spec:
        affinity: 1
          podAffinity:
            requiredDuringSchedulingIgnoredDuringExecution: 2
            - labelSelector:
                matchExpressions:
                - key: security 3
                  values:
                  - S1
                  operator: In 4
              topologyKey: topology.kubernetes.io/zone 5
      # ...

      1

      添加 pod 关联性。

      2

      配置 requiredDuringSchedulingIgnoredDuringExecution 参数或 preferredDuringSchedulingIgnoredDuringExecution 参数。

      3

      指定必须满足的 key 和 values。如果您希望新 pod 与其他 pod 一起调度，请使用与第一个 pod 上标签相同的 key 和 values 参数。

      4

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

      5

      指定 topologyKey，这是一个预填充的 Kubernetes 标签，供系统用于表示这样的拓扑域。

   2. 创建 pod。

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

流程

1. 创建 pod 规格中具有特定标签的 pod：

   1. 使用以下内容创建 YAML 文件：

      apiVersion: v1
      kind: Pod
      metadata:
        name: security-s1
        labels:
          security: S1
      spec:
        securityContext:
          runAsNonRoot: true
          seccompProfile:
            type: RuntimeDefault
        containers:
        - name: security-s1
          image: docker.io/ocpqe/hello-pod
          securityContext:
            allowPrivilegeEscalation: false
            capabilities:
              drop: [ALL]

   2. 创建 pod。

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

2. 在创建其他 pod 时，配置以下参数：

   1. 使用以下内容创建 YAML 文件：

      apiVersion: v1
      kind: Pod
      metadata:
        name: security-s2-east
      # ...
      spec:
      # ...
        affinity: 1
          podAntiAffinity:
            preferredDuringSchedulingIgnoredDuringExecution: 2
            - weight: 100 3
              podAffinityTerm:
                labelSelector:
                  matchExpressions:
                  - key: security 4
                    values:
                    - S1
                    operator: In 5
                topologyKey: kubernetes.io/hostname 6
      # ...

      1

      添加 pod 反关联性。

      2

      配置 requiredDuringSchedulingIgnoredDuringExecution 参数或 preferredDuringSchedulingIgnoredDuringExecution 参数。

      3

      对于一个首选的规则，为节点指定一个 1-100 的权重。优先选择权重最高的节点。

      4

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

      5

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

      6

      指定 topologyKey，它是一个预先填充的 Kubernetes 标签，用于表示这样的拓扑域。

   2. 创建 pod。

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

1. 创建 pod 规格中具有特定标签的 pod：

   1. 使用以下内容创建 YAML 文件：

      注意

      您不能直接将关联性添加到调度的 pod 中。

      输出示例

      apiVersion: v1
      kind: Pod
      metadata:
        name: s1
      spec:
        affinity: 1
          nodeAffinity:
            requiredDuringSchedulingIgnoredDuringExecution: 2
              nodeSelectorTerms:
              - matchExpressions:
                - key: e2e-az-name 3
                  values:
                  - e2e-az1
                  - e2e-az2
                  operator: In 4
      #...

      1

      添加 pod 关联性。

      2

      配置 requiredDuringSchedulingIgnoredDuringExecution 参数。

      3

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

      4

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

   2. 创建 pod：

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

1. 创建具有特定标签的 pod：

   1. 使用以下内容创建 YAML 文件：

      注意

      您不能直接将关联性添加到调度的 pod 中。

      apiVersion: v1
      kind: Pod
      metadata:
        name: s1
      spec:
        affinity: 1
          nodeAffinity:
            preferredDuringSchedulingIgnoredDuringExecution: 2
            - weight: 3
              preference:
                matchExpressions:
                - key: e2e-az-name 4
                  values:
                  - e2e-az3
                  operator: In 5
      #...

      1

      添加 pod 关联性。

      2

      配置 preferredDuringSchedulingIgnoredDuringExecution 参数。

      3

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

      4

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

      5

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

   2. 创建 pod。

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

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。总是重启该任务。

     如需有关 Red Hat OpenShift Service on AWS 如何使用与失败容器相关的重启策略，请参阅 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

流程

1. 在执行 pod 驱除前，标记不可调度的节点。

   1. 将节点标记为不可调度：

      $ oc adm cordon <node1>

      输出示例

      node/<node1> cordoned

   2. 检查节点状态为 Ready,SchedulingDisabled:

      $ oc get node <node1>

      输出示例

      NAME        STATUS                     ROLES     AGE       VERSION
      <node1>     Ready,SchedulingDisabled   worker    1d        v1.30.3

2. 使用以下方法之一驱除 pod:

   • 在一个或多个节点上驱除所有或选定的 pod：

     $ oc adm drain <node1> <node2> [--pod-selector=<pod_selector>]

   • 使用 --force 选项强制删除裸机 pod。设为 true 时，即使存在不由复制控制器、副本集、作业、守护进程设置或有状态设置管理的 pod，也会继续执行删除：

     $ oc adm drain <node1> <node2> --force=true

   • 使用 --grace-period 以秒为单位设置一个期限，以便每个 pod 能够安全地终止。如果为负，则使用 pod 中指定的默认值：

     $ oc adm drain <node1> <node2> --grace-period=-1

   • 忽略由守护进程集管理的 pod，将 --ignore-daemonsets 标记设为 true：

     $ oc adm drain <node1> <node2> --ignore-daemonsets=true

   • 使用 --timeout 标记来设置在放弃前要等待的时长。值为 0 时设定无限时长：

     $ oc adm drain <node1> <node2> --timeout=5s

   • 即使存在使用 emptyDir 卷的 pod，将 --delete-emptydir-data 标志设为 true，也会删除 pod。节点排空时会删除本地数据：

     $ oc adm drain <node1> <node2> --delete-emptydir-data=true

   • 把 --dry-run 选项设为 true，它会列出将要迁移的对象而不实际执行撤离：

     $ oc adm drain <node1> <node2>  --dry-run=true

     您可以使用 --selector=<node_selector> 选项来撤离选定节点上的 pod，而不指定具体的节点名称（如 <node1> <node2>）。

3. 完成后将节点标记为可调度。

   $ oc adm uncordon <node1>

流程

1. 为初始容器创建 pod：

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

      apiVersion: v1
      kind: Pod
      metadata:
        name: myapp-pod
        labels:
          app: myapp
      spec:
        securityContext:
          runAsNonRoot: true
          seccompProfile:
            type: RuntimeDefault
        containers:
        - name: myapp-container
          image: registry.access.redhat.com/ubi9/ubi:latest
          command: ['sh', '-c', 'echo The app is running! && sleep 3600']
          securityContext:
            allowPrivilegeEscalation: false
            capabilities:
              drop: [ALL]
        initContainers:
        - name: init-myservice
          image: registry.access.redhat.com/ubi9/ubi:latest
          command: ['sh', '-c', 'until getent hosts myservice; do echo waiting for myservice; sleep 2; done;']
          securityContext:
            allowPrivilegeEscalation: false
            capabilities:
              drop: [ALL]
        - name: init-mydb
          image: registry.access.redhat.com/ubi9/ubi:latest
          command: ['sh', '-c', 'until getent hosts mydb; do echo waiting for mydb; sleep 2; done;']
          securityContext:
            allowPrivilegeEscalation: false
            capabilities:
              drop: [ALL]

   2. 创建 pod：

      $ oc create -f myapp.yaml

   3. 查看 pod 的状态：

      $ oc get pods

      输出示例

      NAME                          READY     STATUS              RESTARTS   AGE
      myapp-pod                     0/1       Init:0/2            0          5s

      pod 状态 Init:0/2 表示它正在等待这两个服务。

2. 创建 myservice 服务。

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

      kind: Service
      apiVersion: v1
      metadata:
        name: myservice
      spec:
        ports:
        - protocol: TCP
          port: 80
          targetPort: 9376

   2. 创建 pod：

      $ oc create -f myservice.yaml

   3. 查看 pod 的状态：

      $ oc get pods

      输出示例

      NAME                          READY     STATUS              RESTARTS   AGE
      myapp-pod                     0/1       Init:1/2            0          5s

      pod 状态 Init:1/2 表示它正在等待一个服务，本例中为 mydb 服务。

3. 创建 mydb 服务：

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

      kind: Service
      apiVersion: v1
      metadata:
        name: mydb
      spec:
        ports:
        - protocol: TCP
          port: 80
          targetPort: 9377

   2. 创建 pod：

      $ oc create -f mydb.yaml

   3. 查看 pod 的状态：

      $ oc get pods

      输出示例

      NAME                          READY     STATUS              RESTARTS   AGE
      myapp-pod                     1/1       Running             0          2m

      pod 状态表示它不再等待服务并运行。