可伸缩性和性能

OpenShift Container Platform 4.9

扩展 OpenShift Container Platform 集群并调整产品环境的性能

摘要

本文档提供了扩展集群和优化 OpenShift Container Platform 环境性能的说明。

第 5 章 使用 Node Tuning Operator

了解 Node Tuning Operator,以及如何使用它通过编排 tuned 守护进程以管理节点级别的性能优化。

5.1. 关于 Node Tuning Operator

Node Tuning Operator 可以帮助您通过编排 TuneD 守护进程来管理节点级别的性能优化。大多数高性能应用程序都需要一定程度的内核级性能优化。Node Tuning Operator 为用户提供了一个统一的、节点一级的 sysctl 管理接口,并可以根据具体用户的需要灵活地添加自定义性能优化设置。

Operator 将为 OpenShift Container Platform 容器化 TuneD 守护进程作为一个 Kubernetes 守护进程集进行管理。它保证了自定义性能优化设置以可被守护进程支持的格式传递到在集群中运行的所有容器化的 TuneD 守护进程中。相应的守护进程会在集群的所有节点上运行,每个节点上运行一个。

在发生触发配置集更改的事件时,或通过接收和处理终止信号安全终止容器化 TuneD 守护进程时,容器化 TuneD 守护进程所应用的节点级设置将被回滚。

在版本 4.1 及更高版本中,OpenShift Container Platform 标准安装中包含了 Node Tuning Operator。

5.2. 访问 Node Tuning Operator 示例规格

使用此流程来访问 Node Tuning Operator 的示例规格。

流程

  1. 运行:

    $ oc get Tuned/default -o yaml -n openshift-cluster-node-tuning-operator

默认 CR 旨在为 OpenShift Container Platform 平台提供标准的节点级性能优化,它只能被修改来设置 Operator Management 状态。Operator 将覆盖对默认 CR 的任何其他自定义更改。若进行自定义性能优化,请创建自己的 Tuned CR。新创建的 CR 将与默认的 CR 合并,并基于节点或 pod 标识和配置文件优先级对节点应用自定义调整。

警告

虽然在某些情况下,对 pod 标识的支持可以作为自动交付所需调整的一个便捷方式,但我们不鼓励使用这种方法,特别是在大型集群中。默认 Tuned CR 并不带有 pod 标识匹配。如果创建了带有 pod 标识匹配的自定义配置集,则该功能将在此时启用。在以后的 Node Tuning Operator 版本中可能会弃用 pod 标识功能。

5.3. 在集群中设置默认配置集

以下是在集群中设置的默认配置集。

apiVersion: tuned.openshift.io/v1
kind: Tuned
metadata:
  name: default
  namespace: openshift-cluster-node-tuning-operator
spec:
  recommend:
  - profile: "openshift-control-plane"
    priority: 30
    match:
    - label: "node-role.kubernetes.io/master"
    - label: "node-role.kubernetes.io/infra"

  - profile: "openshift-node"
    priority: 40

从 OpenShift Container Platform 4.9 开始,所有 OpenShift TuneD 配置集都随 TuneD 软件包一起提供。您可以使用 oc exec 命令查看这些配置集的内容:

$ oc exec $tuned_pod -n openshift-cluster-node-tuning-operator -- find /usr/lib/tuned/openshift{,-control-plane,-node} -name tuned.conf -exec grep -H ^ {} \;

5.4. 验证是否应用了 TuneD 配置集

验证应用到集群节点的 TuneD 配置集。

$ oc get profile -n openshift-cluster-node-tuning-operator

输出示例

NAME             TUNED                     APPLIED   DEGRADED   AGE
master-0         openshift-control-plane   True      False      6h33m
master-1         openshift-control-plane   True      False      6h33m
master-2         openshift-control-plane   True      False      6h33m
worker-a         openshift-node            True      False      6h28m
worker-b         openshift-node            True      False      6h28m

  • NAME:配置集(Profile)对象的名称。每个节点有一个 Profile 对象,其名称相互匹配。
  • TUNED:要应用的 TuneD 配置集的名称。
  • APPLIED:如果 TuneD 守护进程应用了所需的配置集,则为 True。(True/False/Unknown)。
  • DEGRADED:如果在应用 TuneD 配置集时报告了任何错误则为 TrueTrue/False/Unknown)。
  • AGE:创建 Profile 对象后经过的时间。

5.5. 自定义调整规格

Operator 的自定义资源 (CR) 包含两个主要部分。第一部分是 profile:,这是 TuneD 配置集及其名称的列表。第二部分是 recommend:,用来定义配置集选择逻辑。

多个自定义调优规格可以共存,作为 Operator 命名空间中的多个 CR。Operator 会检测到是否存在新 CR 或删除了旧 CR。所有现有的自定义性能优化设置都会合并,同时更新容器化 TuneD 守护进程的适当对象。

管理状态

通过调整默认的 Tuned CR 来设置 Operator Management 状态。默认情况下,Operator 处于 Managed 状态,默认的 Tuned CR 中没有 spec.managementState 字段。Operator Management 状态的有效值如下:

  • Managed: Operator 会在配置资源更新时更新其操作对象
  • Unmanaged: Operator 将忽略配置资源的更改
  • Removed: Operator 将移除 Operator 置备的操作对象和资源

配置集数据

profile: 部分列出了 TuneD 配置集及其名称。

profile:
- name: tuned_profile_1
  data: |
    # TuneD profile specification
    [main]
    summary=Description of tuned_profile_1 profile

    [sysctl]
    net.ipv4.ip_forward=1
    # ... other sysctl's or other TuneD daemon plugins supported by the containerized TuneD

# ...

- name: tuned_profile_n
  data: |
    # TuneD profile specification
    [main]
    summary=Description of tuned_profile_n profile

    # tuned_profile_n profile settings

建议的配置集

profile: 选择逻辑通过 CR 的 recommend: 部分来定义。recommend: 部分是根据选择标准推荐配置集的项目列表。

recommend:
<recommend-item-1>
# ...
<recommend-item-n>

列表中的独立项:

- machineConfigLabels: 1
    <mcLabels> 2
  match: 3
    <match> 4
  priority: <priority> 5
  profile: <tuned_profile_name> 6
1
可选。
2
MachineConfig 标签的键/值字典。键必须是唯一的。
3
如果省略,则会假设配置集匹配,除非设置了优先级更高的配置集,或设置了 machineConfigLabels
4
可选列表。
5
配置集排序优先级。较低数字表示优先级更高(0 是最高优先级)。
6
在匹配项中应用的 TuneD 配置集。例如 tuned_profile_1

<match> 是一个递归定义的可选数组,如下所示:

- label: <label_name> 1
  value: <label_value> 2
  type: <label_type> 3
    <match> 4
1
节点或 pod 标签名称。
2
可选的节点或 pod 标签值。如果省略,<label_name> 足以匹配。
3
可选的对象类型(nodepod)。如果省略,会使用 node
4
可选的 <match> 列表。

如果不省略 <match>,则所有嵌套的 <match> 部分也必须评估为 true。否则会假定 false,并且不会应用或建议具有对应 <match> 部分的配置集。因此,嵌套(子级 <match> 部分)会以逻辑 AND 运算来运作。反之,如果匹配 <match> 列表中任何一项,整个 <match> 列表评估为 true。因此,该列表以逻辑 OR 运算来运作。

如果定义 了 machineConfigLabels,基于机器配置池的匹配会对给定的 recommend: 列表项打开。<mcLabels> 指定机器配置标签。机器配置会自动创建,以在配置集 <tuned_profile_name> 中应用主机设置,如内核引导参数。这包括使用与 <mcLabels> 匹配的机器配置选择器查找所有机器配置池,并在分配了找到的机器配置池的所有节点上设置配置集 <tuned_profile_name>。要针对同时具有 master 和 worker 角色的节点,您必须使用 master 角色。

列表项 matchmachineConfigLabels 由逻辑 OR 操作符连接。match 项首先以短电路方式评估。因此,如果它被评估为 true,则不考虑 MachineConfigLabels 项。

重要

当使用基于机器配置池的匹配时,建议将具有相同硬件配置的节点分组到同一机器配置池中。不遵循这个原则可能会导致在共享同一机器配置池的两个或者多个节点中 TuneD 操作对象导致内核参数冲突。

示例:基于节点或 pod 标签的匹配

- match:
  - label: tuned.openshift.io/elasticsearch
    match:
    - label: node-role.kubernetes.io/master
    - label: node-role.kubernetes.io/infra
    type: pod
  priority: 10
  profile: openshift-control-plane-es
- match:
  - label: node-role.kubernetes.io/master
  - label: node-role.kubernetes.io/infra
  priority: 20
  profile: openshift-control-plane
- priority: 30
  profile: openshift-node

根据配置集优先级,以上 CR 针对容器化 TuneD 守护进程转换为 recommend.conf 文件。优先级最高 (10) 的配置集是 openshift-control-plane-es,因此会首先考虑它。在给定节点上运行的容器化 TuneD 守护进程会查看同一节点上是否在运行设有 tuned.openshift.io/elasticsearch 标签的 pod。如果没有,则整个 <match> 部分评估为 false。如果存在具有该标签的 pod,为了让 <match> 部分评估为 true,节点标签也需要是 node-role.kubernetes.io/masternode-role.kubernetes.io/infra

如果这些标签对优先级为 10 的配置集而言匹配,则应用 openshift-control-plane-es 配置集,并且不考虑其他配置集。如果节点/pod 标签组合不匹配,则考虑优先级第二高的配置集 (openshift-control-plane)。如果容器化 TuneD Pod 在具有标签 node-role.kubernetes.io/masternode-role.kubernetes.io/infra 的节点上运行,则应用此配置集。

最后,配置集 openshift-node 的优先级最低 (30)。它没有 <match> 部分,因此始终匹配。如果给定节点上不匹配任何优先级更高的配置集,它会作为一个适用于所有节点的配置集来设置 openshift-node 配置集。

决定工作流

示例:基于机器配置池的匹配

apiVersion: tuned.openshift.io/v1
kind: Tuned
metadata:
  name: openshift-node-custom
  namespace: openshift-cluster-node-tuning-operator
spec:
  profile:
  - data: |
      [main]
      summary=Custom OpenShift node profile with an additional kernel parameter
      include=openshift-node
      [bootloader]
      cmdline_openshift_node_custom=+skew_tick=1
    name: openshift-node-custom

  recommend:
  - machineConfigLabels:
      machineconfiguration.openshift.io/role: "worker-custom"
    priority: 20
    profile: openshift-node-custom

为尽量减少节点的重新引导情况,为目标节点添加机器配置池将匹配的节点选择器标签,然后创建上述 Tuned CR,最后创建自定义机器配置池。

5.6. 自定义调整示例

从默认 CR 中使用 TuneD 配置集

以下 CR 对带有标签 tuned.openshift.io/ingress-node-label 的 OpenShift Container Platform 节点应用节点一级的自定义调整。

示例:使用 openshift-control-plane TuneD 配置集进行自定义性能优化

apiVersion: tuned.openshift.io/v1
kind: Tuned
metadata:
  name: ingress
  namespace: openshift-cluster-node-tuning-operator
spec:
  profile:
  - data: |
      [main]
      summary=A custom OpenShift ingress profile
      include=openshift-control-plane
      [sysctl]
      net.ipv4.ip_local_port_range="1024 65535"
      net.ipv4.tcp_tw_reuse=1
    name: openshift-ingress
  recommend:
  - match:
    - label: tuned.openshift.io/ingress-node-label
    priority: 10
    profile: openshift-ingress

重要

对于开发自定义配置集的人员。我们强烈建议包括在默认 Tuned CR 中提供的默认 TuneD 守护进程配置集。上面的示例使用默认 openshift-control-plane 配置集。

使用内置 TuneD 配置集

由于 NTO 管理的守护进程集已被成功推出,TuneD 操作对象会管理 TuneD 守护进程的同一版本。要列出守护进程支持的内置 TuneD 配置集,请以以下方式查询任何 TuneD pod:

$ oc exec $tuned_pod -n openshift-cluster-node-tuning-operator -- find /usr/lib/tuned/ -name tuned.conf -printf '%h\n' | sed 's|^.*/||'

您可以使用自定义调优规格中检索的配置集名称。

示例:使用内置 hpc-compute TuneD 配置集

apiVersion: tuned.openshift.io/v1
kind: Tuned
metadata:
  name: openshift-node-hpc-compute
  namespace: openshift-cluster-node-tuning-operator
spec:
  profile:
  - data: |
      [main]
      summary=Custom OpenShift node profile for HPC compute workloads
      include=openshift-node,hpc-compute
    name: openshift-node-hpc-compute

  recommend:
  - match:
    - label: tuned.openshift.io/openshift-node-hpc-compute
    priority: 20
    profile: openshift-node-hpc-compute

除了内置的 hpc-compute 配置集外,上面的示例还包括默认 Tuned CR 中提供的 openshift-node TuneD 守护进程配置集,以对计算节点使用特定于 OpenShift 的调优。

5.7. 支持的 TuneD 守护进程插件

在使用 Tuned CR 的 profile: 部分中定义的自定义配置集时,以下 TuneD 插件都受到支持,但 [main] 部分除外:

  • audio
  • cpu
  • disk
  • eeepc_she
  • modules
  • mounts
  • net
  • scheduler
  • scsi_host
  • selinux
  • sysctl
  • sysfs
  • usb
  • video
  • vm

其中一些插件提供了不受支持的动态性能优化功能。目前不支持以下 TuneD 插件:

  • bootloader
  • script
  • systemd

如需更多信息,请参阅 Available TuneD Plug-insGetting Started with TuneD

第 6 章 使用 Cluster Loader

Cluster Loader 是一个将大量对象部署到集群的工具程序,它可创建用户定义的集群对象。构建、配置并运行 Cluster Loader 以测量处于各种集群状态的 OpenShift Container Platform 部署的性能指标。

重要

Cluster Loader 现已弃用,并将在以后的发行版本中删除。

6.1. 安装 Cluster Loader

流程

  1. 要拉取容器镜像,请运行:

    $ podman pull quay.io/openshift/origin-tests:4.9

6.2. 运行 Cluster Loader

先决条件

  • 软件仓库会提示您进行验证。registry 凭证允许您访问没有公开的镜像。使用您在安装时产生的现有身份验证凭证。

流程

  1. 使用内置的测试配置执行 Cluster Loader,它会部署五个模板构建并等待它们完成:

    $ podman run -v ${LOCAL_KUBECONFIG}:/root/.kube/config:z -i \
    quay.io/openshift/origin-tests:4.9 /bin/bash -c 'export KUBECONFIG=/root/.kube/config && \
    openshift-tests run-test "[sig-scalability][Feature:Performance] Load cluster \
    should populate the cluster [Slow][Serial] [Suite:openshift]"'

    或者,通过设置 VIPERCONFIG 环境变量来执行带有用户定义的配置的 Cluster Loader:

    $ podman run -v ${LOCAL_KUBECONFIG}:/root/.kube/config:z \
    -v ${LOCAL_CONFIG_FILE_PATH}:/root/configs/:z \
    -i quay.io/openshift/origin-tests:4.9 \
    /bin/bash -c 'KUBECONFIG=/root/.kube/config VIPERCONFIG=/root/configs/test.yaml \
    openshift-tests run-test "[sig-scalability][Feature:Performance] Load cluster \
    should populate the cluster [Slow][Serial] [Suite:openshift]"'

    在这个示例中,${LOCAL_KUBECONFIG} 代表 kubeconfig 在本地文件系统中的路径。另外,还有一个名为 ${LOCAL_CONFIG_FILE_PATH}的目录,它被挂载到包含名为 test.yaml的配置文件的容器中。另外,如果 test.yaml 引用了任何外部模板文件或 podspec 文件,则也应该被挂载到容器中。

6.3. 配置 Cluster Loader

该工具创建多个命名空间(项目),其中包含多个模板或 pod。

6.3.1. Cluster Loader 配置文件示例

Cluster Loader 的配置文件是一个基本的 YAML 文件:

provider: local 1
ClusterLoader:
  cleanup: true
  projects:
    - num: 1
      basename: clusterloader-cakephp-mysql
      tuning: default
      ifexists: reuse
      templates:
        - num: 1
          file: cakephp-mysql.json

    - num: 1
      basename: clusterloader-dancer-mysql
      tuning: default
      ifexists: reuse
      templates:
        - num: 1
          file: dancer-mysql.json

    - num: 1
      basename: clusterloader-django-postgresql
      tuning: default
      ifexists: reuse
      templates:
        - num: 1
          file: django-postgresql.json

    - num: 1
      basename: clusterloader-nodejs-mongodb
      tuning: default
      ifexists: reuse
      templates:
        - num: 1
          file: quickstarts/nodejs-mongodb.json

    - num: 1
      basename: clusterloader-rails-postgresql
      tuning: default
      templates:
        - num: 1
          file: rails-postgresql.json

  tuningsets: 2
    - name: default
      pods:
        stepping: 3
          stepsize: 5
          pause: 0 s
        rate_limit: 4
          delay: 0 ms
1
端到端测试的可选设置。设置为 local 以避免额外的日志信息。
2
调整集允许速率限制和分步,可以生成几批 pod,同时在两组间暂停使用。在继续执行前,Cluster Loader 会监控上一步的完成情况。
3
为每 N 个对象被创建后,会暂停 M 秒。
4
在创建不同对象期间,限制率会等待 M 毫秒。

本例假定对任何外部模板文件或 pod spec 文件的引用也会挂载到容器中。

重要

如果您在 Microsoft Azure 上运行 Cluster Loader,则必须将 AZURE_AUTH_LOCATION 变量设置为包含 terraform.azure.auto.tfvars.json 输出结果的文件,该文件存在于安装程序目录中。

6.3.2. 配置字段

表 6.1. 顶层 Cluster Loader 字段

字段描述

cleanup

可设置为 truefalse。每个配置有一个定义。如果设置为 truecleanup 会删除所有由 Cluster Loader 在测试结束时创建的命名空间(项目)。

projects

包含一个或多个定义的子对象。在 projects下,定义了要创建的每个命名空间,projects 有几个必需的子标题。

tuningsets

每个配置都有一个定义的子对象。tuningset 允许用户定义一个调整集,为创建项目或对象(pods、模板等)添加可配置的计时。

sync

每个配置都有一个定义的可选子对象。在创建对象的过程中添加同步的可能性。

表 6.2. projects 下的字段

字段描述

num

整数。定义要创建项目的数量。

basename

字符串项目基本名称的一个定义。在Basename后面会附加相同命名空间的计数以避免冲突。

tuning

字符串需要应用到在这个命名空间里部署的项目的 tuning 设置。

ifexists

包含 reusedelete 的字符串。如果发现一个项目或者命名空间的名称与执行期间创建的项目或命名空间的名称相同时,需要进行什么操作。

configmaps

键值对列表。键是配置映射名称,值是指向创建配置映射的文件的路径。

secrets

键值对列表。key 是 secret 名称,值是一个指向用来创建 secret 的文件的路径。

pods

要部署的 pod 的一个或者多个定义的子对象。

templates

要部署模板的一个或者多个定义的子对象。

表 6.3. podstemplates 下的字段

字段描述

num

整数。要部署的 pod 或模板数量。

image

字符串到可以拉取镜像的软件仓库的 docker 镜像 URL。

basename

字符串要创建的模板(或 pod)的基本名称的一个定义。

file

字符串到要创建的 pod 规格或模板的本地文件的路径。

parameters

健值对。在 parameters 下,您可以指定一组值在 pod 或模板中进行覆盖。

表 6.4. tuningsets 下的字段

字段描述

name

字符串tuning 集的名称,该名称将与在一个项目中定义 turning 时指定的名称匹配。

pods

指定应用于 pod 的 tuningsets 的子对象。

templates

指定应用于模板的 tuningsets 的子对象。

表 6.5. tuningsets podstuningsets templates 下的字段

字段描述

stepping

子对象。如果要在步骤创建模式中创建对象,需要使用的步骤配置。

rate_limit

子对象。用来限制对象创建率的频率限制 turning 集。

表 6.6. tuningsets podstuningsets templates, stepping 下的字段

字段描述

stepsize

整数。在暂停对象创建前要创建的对象数量。

pause

整数。在创建了由 stepsize 定义的对象数后需要暂停的秒数。

timeout

整数。如果对象创建失败,在失败前要等待的秒数。

delay

整数。在创建请求间等待多少毫秒 (ms)

表 6.7. sync 下的字段

字段描述

server

带有 enabledport 字段的子对象。布尔值 enabled 定义了是否启动用于 pod 同步的 HTTP 服务器。整数值 port 定义了要监听的 HTTP 服务器端口(默认为 9090)。

running

布尔值等待带有与selectors 匹配的标签的 pod 进入 Running 状态。

succeeded

布尔值等待带有与selectors 匹配的标签的 pod 进入 Completed 状态。

selectors

匹配处于 RunningCompleted 状态 的 pod 的选择器列表。

timeout

字符串等待处于 RunningCompleted 状态的 pod 的同步超时时间。对于不是 0 的值,其时间单位是:[ns|us|ms|s|m|h]

6.4. 已知问题

  • 当在没有配置的情况下调用 Cluster Loader 会失败。(BZ#1761925)
  • 如果用户模板中没有定义 IDENTIFIER 参数,则模板创建失败,错误信息为:error: unknown parameter name "IDENTIFIER"。如果部署模板,在模板中添加这个参数以避免出现这个错误:

    {
      "name": "IDENTIFIER",
      "description": "Number to append to the name of resources",
      "value": "1"
    }

    如果部署 pod,则不需要添加该参数。

第 7 章 使用 CPU Manager

CPU Manager 管理 CPU 组并限制特定 CPU 的负载。

CPU Manager 对于有以下属性的负载有用:

  • 需要尽可能多的 CPU 时间。
  • 对处理器缓存丢失非常敏感。
  • 低延迟网络应用程序。
  • 需要与其他进程协调,并从共享一个处理器缓存中受益。

7.1. 设置 CPU Manager

流程

  1. 可选:标记节点:

    # oc label node perf-node.example.com cpumanager=true
  2. 编辑启用 CPU Manager 的节点的 MachineConfigPool 。在这个示例中,所有 worker 都启用了 CPU Manager:

    # oc edit machineconfigpool worker
  3. 为 worker 机器配置池添加标签:

    metadata:
      creationTimestamp: 2020-xx-xxx
      generation: 3
      labels:
        custom-kubelet: cpumanager-enabled
  4. 创建 KubeletConfigcpumanager-kubeletconfig.yaml,自定义资源 (CR) 。请参阅上一步中创建的标签,以便使用新的 kubelet 配置更新正确的节点。请参见 MachineConfigPoolSelector 部分:

    apiVersion: machineconfiguration.openshift.io/v1
    kind: KubeletConfig
    metadata:
      name: cpumanager-enabled
    spec:
      machineConfigPoolSelector:
        matchLabels:
          custom-kubelet: cpumanager-enabled
      kubeletConfig:
         cpuManagerPolicy: static 1
         cpuManagerReconcilePeriod: 5s 2
    1
    指定一个策略:
    • none.这个策略明确启用了现有的默认 CPU 关联性方案,从而不会出现超越调度程序自动进行的关联性。
    • static。此策略允许具有某些资源特征的 pod 获得提高 CPU 关联性和节点上专用的 pod。
    2
    可选。指定 CPU Manager 协调频率。默认值为 5s
  5. 创建动态 kubelet 配置:

    # oc create -f cpumanager-kubeletconfig.yaml

    这会在 kubelet 配置中添加 CPU Manager 功能,如果需要,Machine Config Operator(MCO)将重启节点。要启用 CPU Manager,则不需要重启。

  6. 检查合并的 kubelet 配置:

    # oc get machineconfig 99-worker-XXXXXX-XXXXX-XXXX-XXXXX-kubelet -o json | grep ownerReference -A7

    输出示例

           "ownerReferences": [
                {
                    "apiVersion": "machineconfiguration.openshift.io/v1",
                    "kind": "KubeletConfig",
                    "name": "cpumanager-enabled",
                    "uid": "7ed5616d-6b72-11e9-aae1-021e1ce18878"
                }
            ]

  7. 检查 worker 是否有更新的 kubelet.conf

    # oc debug node/perf-node.example.com
    sh-4.2# cat /host/etc/kubernetes/kubelet.conf | grep cpuManager

    输出示例

    cpuManagerPolicy: static        1
    cpuManagerReconcilePeriod: 5s   2

    1 2
    当创建 KubeletConfig CR 时会定义这些设置。
  8. 创建请求一个或多个内核的 pod。限制和请求都必须将其 CPU 值设置为一个整数。这是专用于此 pod 的内核数:

    # cat cpumanager-pod.yaml

    输出示例

    apiVersion: v1
    kind: Pod
    metadata:
      generateName: cpumanager-
    spec:
      containers:
      - name: cpumanager
        image: gcr.io/google_containers/pause-amd64:3.0
        resources:
          requests:
            cpu: 1
            memory: "1G"
          limits:
            cpu: 1
            memory: "1G"
      nodeSelector:
        cpumanager: "true"

  9. 创建 pod:

    # oc create -f cpumanager-pod.yaml
  10. 确定为您标记的节点调度了 pod:

    # oc describe pod cpumanager

    输出示例

    Name:               cpumanager-6cqz7
    Namespace:          default
    Priority:           0
    PriorityClassName:  <none>
    Node:  perf-node.example.com/xxx.xx.xx.xxx
    ...
     Limits:
          cpu:     1
          memory:  1G
        Requests:
          cpu:        1
          memory:     1G
    ...
    QoS Class:       Guaranteed
    Node-Selectors:  cpumanager=true

  11. 确认正确配置了 cgroups。获取 pause 进程的进程 ID(PID):

    # ├─init.scope
    │ └─1 /usr/lib/systemd/systemd --switched-root --system --deserialize 17
    └─kubepods.slice
      ├─kubepods-pod69c01f8e_6b74_11e9_ac0f_0a2b62178a22.slice
      │ ├─crio-b5437308f1a574c542bdf08563b865c0345c8f8c0b0a655612c.scope
      │ └─32706 /pause

    服务质量(QoS)等级为 Guaranteed 的 pod 被放置到 kubepods.slice 中。其它 QoS 等级的 pod 会位于 kubepods 的子 cgroups 中:

    # cd /sys/fs/cgroup/cpuset/kubepods.slice/kubepods-pod69c01f8e_6b74_11e9_ac0f_0a2b62178a22.slice/crio-b5437308f1ad1a7db0574c542bdf08563b865c0345c86e9585f8c0b0a655612c.scope
    # for i in `ls cpuset.cpus tasks` ; do echo -n "$i "; cat $i ; done

    输出示例

    cpuset.cpus 1
    tasks 32706

  12. 检查任务允许的 CPU 列表:

    # grep ^Cpus_allowed_list /proc/32706/status

    输出示例

     Cpus_allowed_list:    1

  13. 确认系统中的另一个 pod(在这个示例中,QoS 等级为 burstable 的 pod)不能在为等级为Guaranteed 的 pod 分配的内核中运行:

    # cat /sys/fs/cgroup/cpuset/kubepods.slice/kubepods-besteffort.slice/kubepods-besteffort-podc494a073_6b77_11e9_98c0_06bba5c387ea.slice/crio-c56982f57b75a2420947f0afc6cafe7534c5734efc34157525fa9abbf99e3849.scope/cpuset.cpus
    0
    # oc describe node perf-node.example.com

    输出示例

    ...
    Capacity:
     attachable-volumes-aws-ebs:  39
     cpu:                         2
     ephemeral-storage:           124768236Ki
     hugepages-1Gi:               0
     hugepages-2Mi:               0
     memory:                      8162900Ki
     pods:                        250
    Allocatable:
     attachable-volumes-aws-ebs:  39
     cpu:                         1500m
     ephemeral-storage:           124768236Ki
     hugepages-1Gi:               0
     hugepages-2Mi:               0
     memory:                      7548500Ki
     pods:                        250
    -------                               ----                           ------------  ----------  ---------------  -------------  ---
      default                                 cpumanager-6cqz7               1 (66%)       1 (66%)     1G (12%)         1G (12%)       29m
    
    Allocated resources:
      (Total limits may be over 100 percent, i.e., overcommitted.)
      Resource                    Requests          Limits
      --------                    --------          ------
      cpu                         1440m (96%)       1 (66%)

    这个 VM 有两个 CPU 内核。system-reserved 设置保留 500 millicores,这代表一个内核中的一半被从节点的总容量中减小,以达到 Node Allocatable 的数量。您可以看到 Allocatable CPU 是 1500 毫秒。这意味着您可以运行一个 CPU Manager pod,因为每个 pod 需要一个完整的内核。一个完整的内核等于 1000 毫秒。如果您尝试调度第二个 pod,系统将接受该 pod,但不会调度它:

    NAME                    READY   STATUS    RESTARTS   AGE
    cpumanager-6cqz7        1/1     Running   0          33m
    cpumanager-7qc2t        0/1     Pending   0          11s

第 8 章 使用拓扑管理器

拓扑管理器(Topology Manager)从 CPU Manager、设备管理器和其他 Hint 提供者收集提示信息,以匹配相同非统一 内存访问(NUMA)节点上的所有 QoS 类的 pod 资源(如 CPU、SR-IOV VF 和其他设备资源)。

拓扑管理器使用收集来的提示信息中获得的拓扑信息,根据配置的 Topology Manager 策略以及请求的 Pod 资源,决定节点是否被节点接受或拒绝。

拓扑管理器对希望使用硬件加速器来支持对工作延迟有极高要求的操作及高吞吐并发计算的负载很有用。

注意

要使用拓扑管理器,必须使用 static 策略的 CPU Manager。有关 CPU Manager 的详情请参考使用 CPU Manager

8.1. 拓扑管理器策略

拓扑管理器通过从 Hint 提供者(如 CPU Manager 和设备管理器)收集拓扑提示来调整所有级别服务质量(QoS)的 Pod 资源,并使用收集的提示来匹配 Pod 资源。

注意

要将 CPU 资源与 Pod 规格中的其他请求资源匹配,必须使用 static CPU Manager 策略启用 CPU Manager。

拓扑管理器支持四个分配策略,这些策略在 cpumanager-enabled 自定义资源(CR)中定义:

none 策略
这是默认策略,不执行任何拓扑对齐调整。
best-effort 策略
对于带有 best-effort 拓扑管理策略的 pod 中的每个容器,kubelet 会调用每个 Hint 提供者来发现其资源的可用性。使用这些信息,拓扑管理器会保存那个容器的首选 NUMA 节点关联性设置。如果关联性没有被首选设置,则拓扑管理器会保存这个设置,并把 pod 分配给节点。
restricted 策略
对于带有 restricted 拓扑管理策略的 pod 中的每个容器,kubelet 会调用每个 Hint 提供者来发现其资源的可用性。使用这些信息,拓扑管理器会保存那个容器的首选 NUMA 节点关联性设置。如果关联性没有被首选,则拓扑管理器会从节点拒绝这个 pod,从而导致 pod 处于 Terminated 状态,且 pod 准入失败。
single-numa-node 策略
对于带有 single-numa-node 拓扑管理策略的 pod 中的每个容器,kubelet 会调用每个 Hint 提供者来发现其资源的可用性。使用这个信息,拓扑管理器会决定单个 NUMA 节点关联性是否可能。如果是,pod 将会分配给该节点。如果无法使用单一 NUMA 节点关联性,则拓扑管理器会拒绝来自节点的 pod。这会导致 pod 处于 Terminated 状态,且 pod 准入失败。

8.2. 设置拓扑管理器

要使用拓扑管理器,您必须在 cpumanager-enabled 自定义资源(CR)中配置分配策略。如果您设置了 CPU Manager,则该文件可能会存在。如果这个文件不存在,您可以创建该文件。

先决条件

  • 将 CPU Manager 策略配置为 static。请参考扩展和性能文档中的使用 CPU Manager 部分 。

流程

激活 Topolgy Manager:

  1. cpumanager-enabled 自定义资源(CR)中配置拓扑管理器分配策略。

    $ oc edit KubeletConfig cpumanager-enabled
    apiVersion: machineconfiguration.openshift.io/v1
    kind: KubeletConfig
    metadata:
      name: cpumanager-enabled
    spec:
      machineConfigPoolSelector:
        matchLabels:
          custom-kubelet: cpumanager-enabled
      kubeletConfig:
         cpuManagerPolicy: static 1
         cpuManagerReconcilePeriod: 5s
         topologyManagerPolicy: single-numa-node 2
    1
    此参数必须是 static
    2
    指定所选拓扑管理器分配策略。在这里,策略是 single-numa-node。有效值为:defaultbest-effortrestrictedsingle-numa-node

其他资源

有关 CPU Manager 的详情请参考使用 CPU Manager

8.3. Pod 与拓扑管理器策略的交互

以下的 Pod specs 示例演示了 Pod 与 Topology Manager 的交互。

因为没有指定资源请求或限制,以下 pod 以 BestEffort QoS 类运行。

spec:
  containers:
  - name: nginx
    image: nginx

因为请求小于限制,下一个 pod 以 Burstable QoS 类运行。

spec:
  containers:
  - name: nginx
    image: nginx
    resources:
      limits:
        memory: "200Mi"
      requests:
        memory: "100Mi"

如果所选策略不是 none,则拓扑管理器将不考虑其中任何一个 Pod 规格。

因为请求等于限制,最后一个 pod 以 Guaranteed QoS 类运行。

spec:
  containers:
  - name: nginx
    image: nginx
    resources:
      limits:
        memory: "200Mi"
        cpu: "2"
        example.com/device: "1"
      requests:
        memory: "200Mi"
        cpu: "2"
        example.com/device: "1"

拓扑管理器将考虑这个 pod。拓扑管理器会参考 CPU Manager 的静态策略,该策略可返回可用 CPU 的拓扑结构。拓扑管理器还参考设备管理器来发现可用设备的拓扑结构,如 example.com/device。

拓扑管理器将使用此信息存储该容器的最佳拓扑。在本 pod 中,CPU Manager 和设备管理器将在资源分配阶段使用此存储的信息。

第 9 章 扩展 Cluster Monitoring Operator

OpenShift Container Platform 会提供 Cluster Monitoring Operator 在基于 Prometheus 的监控堆栈中收集并存储的数据。作为管理员,您可以在一个 dashboard 接口(Grafana)中查看系统资源、容器和组件指标。

重要

如果您使用附加的 Prometheus PVC 运行集群监控,在集群升级过程中可能会出现 OOM 终止的情况。当 Prometheus 使用持久性存储时,Prometheus 内存在升级过程中会加倍,并在升级完成后的几小时内仍会是这个情况。为了避免 OOM 终止问题,允许升级前有双倍可用内存的 worker 节点。例如,如果您在最低推荐节点上运行监控(2 个内核,8 GB RAM),将内存增加到 16 GB。如需更多信息,请参阅 BZ#1925061

9.1. Prometheus 数据库存储要求

红帽对不同的扩展大小进行了各种测试。

注意

以下 Prometheus 存储要求并不具有规定性。取决于工作负载活动和资源使用情况,集群中可能会观察到更高资源消耗。

表 9.1. Prometheus 数据库的存储要求取决于集群中的节点/pod 数量

节点数量pod 数量每天增加的 Prometheus 存储每 15 天增加的 Prometheus 存储RAM 空间(每个缩放大小)网络(每个 tsdb 块)

50

1800

6.3 GB

94 GB

6 GB

16 MB

100

3600

13 GB

195 GB

10 GB

26 MB

150

5400

19 GB

283 GB

12 GB

36 MB

200

7200

25 GB

375 GB

14 GB

46 MB

大约 20%的预期大小被添加为开销,以保证存储要求不会超过计算的值。

上面的计算用于默认的 OpenShift Container Platform Cluster Monitoring Operator。

注意

CPU 利用率会有轻微影响。这个比例为在每 50 个节点和 1800 个 pod 的 40 个内核中大约有 1 个。

针对 OpenShift Container Platform 的建议

  • 至少使用三个基础架构(infra)节点。
  • 至少使用三个带有 NVMe(non-volatile memory express)驱动的 openshift-container-storage 节点。

9.2. 配置集群监控

流程

为 Prometheus 增加存储容量:

  1. 创建 YAML 配置文件 cluster-monitoring-config.yml。例如:

    apiVersion: v1
    kind: ConfigMap
    data:
      config.yaml: |
        prometheusOperator:
          baseImage: quay.io/coreos/prometheus-operator
          prometheusConfigReloaderBaseImage: quay.io/coreos/prometheus-config-reloader
          configReloaderBaseImage: quay.io/coreos/configmap-reload
          nodeSelector:
            node-role.kubernetes.io/infra: ""
        prometheusK8s:
          retention: {{PROMETHEUS_RETENTION_PERIOD}} 1
          baseImage: openshift/prometheus
          nodeSelector:
            node-role.kubernetes.io/infra: ""
          volumeClaimTemplate:
            spec:
              storageClassName: gp2
              resources:
                requests:
                  storage: {{PROMETHEUS_STORAGE_SIZE}} 2
        alertmanagerMain:
          baseImage: openshift/prometheus-alertmanager
          nodeSelector:
            node-role.kubernetes.io/infra: ""
          volumeClaimTemplate:
            spec:
              storageClassName: gp2
              resources:
                requests:
                  storage: {{ALERTMANAGER_STORAGE_SIZE}} 3
        nodeExporter:
          baseImage: openshift/prometheus-node-exporter
        kubeRbacProxy:
          baseImage: quay.io/coreos/kube-rbac-proxy
        kubeStateMetrics:
          baseImage: quay.io/coreos/kube-state-metrics
          nodeSelector:
            node-role.kubernetes.io/infra: ""
        grafana:
          baseImage: grafana/grafana
          nodeSelector:
            node-role.kubernetes.io/infra: ""
        auth:
          baseImage: openshift/oauth-proxy
        k8sPrometheusAdapter:
          nodeSelector:
            node-role.kubernetes.io/infra: ""
    metadata:
      name: cluster-monitoring-config
    namespace: openshift-monitoring
    1
    一个典型的值是 PROMETHEUS_retention_PERIOD=15d。时间单位使用以下后缀之一 : s 、m 、h 、d。
    2
    一个典型的值是 PROMETHEUS_STORAGE_SIZE=2000Gi。存储值可以是一个纯整数,也可以是带有以下后缀之一的整数: E 、P 、T 、G 、M 、K。您也可以使用以下效果相同的后缀:Ei 、Pi 、Ti 、Gi 、Mi 、Ki。
    3
    一个典型的值 是 alertmanager_STORAGE_SIZE=20Gi。存储值可以是一个纯整数,也可以是带有以下后缀之一的整数: E 、P 、T 、G 、M 、K。您也可以使用以下效果相同的后缀:Ei 、Pi 、Ti 、Gi 、Mi 、Ki。
  2. 设置值,如保留周期和存储大小。
  3. 运行以下命令应用这些更改:

    $ oc create -f cluster-monitoring-config.yml

第 10 章 根据对象限制规划您的环境

在规划 OpenShift Container Platform 集群时,请考虑以下对象限制。

这些限制基于最大可能的集群。对于较小的集群,最大值限制会较低。很多因素会影响指定的阈值,包括 etcd 版本或者存储数据格式。

重要

这些指南适用于带有软件定义网络(SDN)而不是开放虚拟网络(OVN)的 OpenShift Container Platform。

在大多数情况下,超过这些限制会降低整体性能。它不一定意味着集群会出现错误。

10.1. OpenShift Container Platform 为主发行版本测试了集群最大值

为 OpenShift Container Platform 3.x 测试的云平台: Red Hat OpenStack Platform(RHOSP)、Amazon Web Services 和 Microsoft Azure。为 OpenShift Container Platform 4.x 测试的云平台: Amazon Web Services、Microsoft Azure 和 Google Cloud Platform。

最大类型3.x 测试的最大值4.x 测试的最大值

节点数

2,000

2,000 [1]

pod 数量 [2]

150,000

150,000

每个节点的 pod 数量

250

500 [3]

每个内核的 pod 数量

没有默认值。

没有默认值。

命名空间数量 [4]

10,000

10,000

构建(build)数

10,000(默认 pod RAM 512 Mi)- 管道 (Pipeline) 策略

10,000(默认 pod RAM 512 Mi)- Source-to-Image (S2I) 构建策略

每个命名空间的 pod 数量 [5]

25,000

25,000

服务数 [6]

10,000

10,000

每个命名空间的服务数

5,000

5,000

每个服务中的后端数

5,000

5,000

每个命名空间的部署数量 [5]

2,000

2,000

  1. 暂停部署的 pod,以便在 2000 节点规模上压力测试 OpenShift 的 control plane 组件。
  2. 这里的 pod 数量是 test pod 的数量。实际的 pod 数量取决于应用程序的内存、CPU 和存储要求。
  3. 这在一个有 100 个 work 节点,每个 worker 节点有 500 个 pod 的集群中测试。默认 maxPods 仍为 250。要获得 500 maxPods,则必须使用自定义 kubelet 配置将 maxPods 设置为 500 来创建集群。如果需要 500 个用户 Pod,则需要 hostPrefix22,因为节点上已经运行了 10-15 个系统 pod。带有 Persistent VolumeClaim (PVC) 的最大 pod 数量取决于分配 PVC 的后端存储。在我们的测试中,只有 OpenShift Container Storage v4 (OCS v4) 能够满足本文档中提到的每个节点的 pod 数量。
  4. 当有大量活跃的项目时,如果键空间增长过大并超过空间配额,etcd 的性能将会受到影响。强烈建议您定期维护 etcd 存储,包括通过碎片管理释放 etcd 存储。
  5. 系统中有一些控制循环,它们必须对给定命名空间中的所有对象进行迭代,以作为对一些状态更改的响应。在单一命名空间中有大量给定类型的对象可使这些循环的运行成本变高,并降低对给定状态变化的处理速度。限制假设系统有足够的 CPU 、内存和磁盘来满足应用程序的要求。
  6. 每个服务端口和每个服务后端在 iptables 中都有对应条目。给定服务的后端数量会影响端点对象的大小,这会影响到整个系统发送的数据大小。
注意

红帽没有提供调整 OpenShift Container Platform 集群大小的直接指导。这是因为,确定您的集群是否处于 OpenShift Container Platform 支持的边界内,需要仔细考虑所有限制集群扩展的多维因素。

10.2. 测试集群最大值的 OpenShift Container Platform 环境和配置

AWS 云平台:

节点FlavorvCPURAM(GiB)磁盘类型磁盘大小(GiB)/IOS数量区域

Master/etcd [1]

r5.4xlarge

16

128

io1

220 / 3000

3

us-west-2

Infra [2]

m5.12xlarge

48

192

gp2

100

3

us-west-2

Workload [3]

m5.4xlarge

16

64

gp2

500 [4]

1

us-west-2

Worker

m5.2xlarge

8

32

gp2

100

3/25/250/500 [5]

us-west-2

  1. 带有 3000 个 IOPS 的 io1 磁盘用于 master/etcd 节点,因为 etcd 非常大,且敏感延迟。
  2. Infra 节点用于托管 Monitoring、Ingress 和 Registry 组件,以确保它们有足够资源可大规模运行。
  3. 工作负载节点专用于运行性能和可扩展工作负载生成器。
  4. 使用更大的磁盘,以便有足够的空间存储在运行性能和可扩展性测试期间收集的大量数据。
  5. 在迭代中扩展了集群,且性能和可扩展性测试是在指定节点数中执行的。

IBM Power 系统平台:

节点vCPURAM(GiB)磁盘类型磁盘大小(GiB)/IOS数量

Master/etcd [1]

16

32

io1

每 GB 120 / 3 IOPS

3

Infra [2]

16

64

gp2

120

2

Workload [3]

16

256

gp2

120 [4]

1

Worker

16

64

gp2

120

3/25/250/500 [5]

  1. 带有 120 / 3 IOPS 的 io1 磁盘用于 master/etcd 节点,因为 etcd 非常大,且敏感延迟。
  2. Infra 节点用于托管 Monitoring、Ingress 和 Registry 组件,以确保它们有足够资源可大规模运行。
  3. 工作负载节点专用于运行性能和可扩展工作负载生成器。
  4. 使用更大的磁盘,以便有足够的空间存储在运行性能和可扩展性测试期间收集的大量数据。
  5. 在迭代中扩展了集群,且性能和可扩展性测试是在指定节点数中执行的。

10.3. 如何根据经过测试的集群限制规划您的环境

重要

在节点中过度订阅物理资源会影响在 pod 放置过程中对 Kubernetes 调度程序的资源保证。了解可以采取什么措施避免内存交换。

某些限制只在单一维度中扩展。当很多对象在集群中运行时,它们会有所不同。

本文档中给出的数字基于红帽的测试方法、设置、配置和调整。这些数字会根据您自己的设置和环境而有所不同。

在规划您的环境时,请确定每个节点会运行多少 个 pod :

required pods per cluster / pods per node = total number of nodes needed

每个节点上的 Pod 数量做多为 250。而在某个节点中运行的 pod 的具体数量取决于应用程序本身。请参阅 如何根据应用程序要求规划您的环境 中的内容来计划应用程序的内存、CPU 和存储要求。

示例情境

如果您计划把集群的规模限制在有 2200 个 pod,则需要至少有 5 个节点,假设每个节点最多有 500 个 pod:

2200 / 500 = 4.4

如果将节点数量增加到 20,那么 pod 的分布情况将变为每个节点有 110 个 pod:

2200 / 20 = 110

其中:

required pods per cluster / total number of nodes = expected pods per node

10.4. 如何根据应用程序要求规划您的环境

考虑应用程序环境示例:

pod 类型pod 数量最大内存CPU 内核持久性存储

Apache

100

500 MB

0.5

1 GB

node.js

200

1 GB

1

1 GB

postgresql

100

1 GB

2

10 GB

JBoss EAP

100

1 GB

1

1 GB

推断的要求: 550 个 CPU 内核、450GB RAM 和 1.4TB 存储。

根据您的具体情况,节点的实例大小可以被增大或降低。在节点上通常会使用资源过度分配。在这个部署场景中,您可以选择运行多个额外的较小节点,或数量更少的较大节点来提供同样数量的资源。在做出决定前应考虑一些因素,如操作的灵活性以及每个实例的成本。

节点类型数量CPURAM (GB)

节点(选择 1)

100

4

16

节点(选择 2)

50

8

32

节点(选择 3)

25

16

64

有些应用程序很适合于过度分配的环境,有些则不适合。大多数 Java 应用程序以及使用巨页的应用程序都不允许使用过度分配功能。它们的内存不能用于其他应用程序。在上面的例子中,环境大约会出现 30% 过度分配的情况,这是一个常见的比例。

应用程序 pod 可以使用环境变量或 DNS 访问服务。如果使用环境变量,当 pod 在节点上运行时,对于每个活跃服务,则 kubelet 的变量都会注入。集群感知 DNS 服务器监视 Kubernetes API 提供了新服务,并为每个服务创建一组 DNS 记录。如果整个集群中启用了 DNS,则所有 pod 都应自动根据其 DNS 名称解析服务。如果您必须超过 5000 服务,可以使用 DNS 进行服务发现。当使用环境变量进行服务发现时,参数列表超过了命名空间中 5000 服务后允许的长度,则 pod 和部署将失败。要解决这个问题,请禁用部署的服务规格文件中的服务链接:

---
apiVersion: v1
kind: Template
metadata:
  name: deployment-config-template
  creationTimestamp:
  annotations:
    description: This template will create a deploymentConfig with 1 replica, 4 env vars and a service.
    tags: ''
objects:
- apiVersion: v1
  kind: DeploymentConfig
  metadata:
    name: deploymentconfig${IDENTIFIER}
  spec:
    template:
      metadata:
        labels:
          name: replicationcontroller${IDENTIFIER}
      spec:
        enableServiceLinks: false
        containers:
        - name: pause${IDENTIFIER}
          image: "${IMAGE}"
          ports:
          - containerPort: 8080
            protocol: TCP
          env:
          - name: ENVVAR1_${IDENTIFIER}
            value: "${ENV_VALUE}"
          - name: ENVVAR2_${IDENTIFIER}
            value: "${ENV_VALUE}"
          - name: ENVVAR3_${IDENTIFIER}
            value: "${ENV_VALUE}"
          - name: ENVVAR4_${IDENTIFIER}
            value: "${ENV_VALUE}"
          resources: {}
          imagePullPolicy: IfNotPresent
          capabilities: {}
          securityContext:
            capabilities: {}
            privileged: false
        restartPolicy: Always
        serviceAccount: ''
    replicas: 1
    selector:
      name: replicationcontroller${IDENTIFIER}
    triggers:
    - type: ConfigChange
    strategy:
      type: Rolling
- apiVersion: v1
  kind: Service
  metadata:
    name: service${IDENTIFIER}
  spec:
    selector:
      name: replicationcontroller${IDENTIFIER}
    ports:
    - name: serviceport${IDENTIFIER}
      protocol: TCP
      port: 80
      targetPort: 8080
    portalIP: ''
    type: ClusterIP
    sessionAffinity: None
  status:
    loadBalancer: {}
parameters:
- name: IDENTIFIER
  description: Number to append to the name of resources
  value: '1'
  required: true
- name: IMAGE
  description: Image to use for deploymentConfig
  value: gcr.io/google-containers/pause-amd64:3.0
  required: false
- name: ENV_VALUE
  description: Value to use for environment variables
  generate: expression
  from: "[A-Za-z0-9]{255}"
  required: false
labels:
  template: deployment-config-template

可在命名空间中运行的应用程序 pod 数量取决于服务数量以及环境变量用于服务发现时的服务名称长度。系统中的ARG_MAX 为新进程定义最大参数长度,默认设置为 2097152 KiB。Kubelet 将环境变量注入到要在命名空间中运行的每个 pod 中,包括:

  • <SERVICE_NAME>_SERVICE_HOST=<IP>
  • <SERVICE_NAME>_SERVICE_PORT=<PORT>
  • <SERVICE_NAME>_PORT=tcp://<IP>:<PORT>
  • <SERVICE_NAME>_PORT_<PORT>_TCP=tcp://<IP>:<PORT>
  • <SERVICE_NAME>_PORT_<PORT>_TCP_PROTO=tcp
  • <SERVICE_NAME>_PORT_<PORT>_TCP_PORT=<PORT>
  • <SERVICE_NAME>_PORT_<PORT>_TCP_ADDR=<ADDR>

如果参数长度超过允许的值,服务名称中的字符数会受到影响,命名空间中的 pod 将开始失败。例如,在一个带有 5000 服务的命名空间中,服务名称的限制为 33 个字符,它可让您在命名空间中运行 5000 个 Pod。

第 11 章 优化存储

优化存储有助于最小化所有资源中的存储使用。通过优化存储,管理员可帮助确保现有存储资源以高效的方式工作。

11.1. 可用的持久性存储选项

了解持久性存储选项,以便可以优化 OpenShift Container Platform 环境。

表 11.1. 可用存储选项

存储类型描述例子

Block

  • 在操作系统 (OS) 中作为块设备
  • 适用于需要完全控制存储,并绕过文件系统在低层直接操作文件的应用程序
  • 也称为存储区域网络 (SAN)
  • 不可共享,这意味着,每次只有一个客户端可以挂载这种类型的端点

AWS EBS 和 VMware vSphere 支持在 OpenShift Container Platform 中的原生动态持久性卷 (PV)置备 。

File

  • 在 OS 中作为要挂载的文件系统导出
  • 也称为网络附加存储(Network Attached Storage,NAS)
  • 取决于不同的协议、实现、厂商及范围,其并行性、延迟、文件锁定机制和其它功能可能会有很大不同。

RHEL NFS、NetApp NFS [1] 和供应商 NFS

对象

  • 通过 REST API 端点访问
  • 可配置用于 OpenShift Container Platform Registry
  • 应用程序必须在应用程序和(/或)容器中构建其驱动程序。

AWS S3

  1. NetApp NFS 在使用 Trident 插件时支持动态 PV 置备。
重要

目前,OpenShift Container Platform 4.9 不支持 CNS。

11.3. 数据存储管理

下表总结了 OpenShift Container Platform 组件写入数据的主要目录。

表 11.3. 用于存储 OpenShift Container Platform 数据的主目录

目录备注大小预期增长

/var/log

所有组件的日志文件。

10 到 30 GB。

日志文件可能会快速增长 ; 大小可以通过增加磁盘或使用日志轮转来管理。

/var/lib/etcd

用于存储数据库的 etcd 存储。

小于 20 GB。

数据库可增大到 8 GB。

随着环境增长会缓慢增长。只存储元数据。

每多加 8 GB 内存需要额外 20-25 GB。

/var/lib/containers

这是 CRI-O 运行时的挂载点。用于活跃容器运行时的存储,包括 Pod 和本地镜像存储。不适用于 registry 存储。

有 16 GB 内存的节点需要 50 GB。请注意,这个大小不应该用于决定最小集群要求。

每多加 8 GB 内存需要额外 20-25 GB。

增长受运行容器容量的限制。

/var/lib/kubelet

pod 的临时卷(Ephemeral volume)存储。这包括在运行时挂载到容器的任何外部存储。包括环境变量、kube secret 和不受持久性卷支持的数据卷。

可变

如果需要存储的 pod 使用持久性卷,则最小。如果使用临时存储,可能会快速增长。

第 12 章 优化路由

OpenShift Container Platform HAProxy 路由器扩展以优化性能。

12.1. Ingress Controller(router)性能的基线

OpenShift Container Platform Ingress Controller,或称为路由器,是所有用于 OpenShift Container Platform 服务的外部流量的入站点。

当根据每秒处理的 HTTP 请求来评估单个 HAProxy 路由器性能时,其性能取决于多个因素。特别是:

  • HTTP keep-alive/close 模式
  • 路由类型
  • 对 TLS 会话恢复客户端的支持
  • 每个目标路由的并行连接数
  • 目标路由数
  • 后端服务器页面大小
  • 底层基础结构(网络/SDN 解决方案、CPU 等)

具体环境中的性能会有所不同,红帽实验室在一个有 4 个 vCPU/16GB RAM 的公共云实例中进行测试。一个 HAProxy 路由器处理由后端终止的 100 个路由服务提供 1kB 静态页面,每秒处理以下传输数。

在 HTTP 的 keep-alive 模式下:

EncryptionLoadBalancerServiceHostNetwork

none

21515

29622

edge

16743

22913

passthrough

36786

53295

re-encrypt

21583

25198

在 HTTP 关闭(无 keep-alive)情境中:

EncryptionLoadBalancerServiceHostNetwork

none

5719

8273

edge

2729

4069

passthrough

4121

5344

re-encrypt

2320

2941

默认 Ingress Controller 配置使用 ROUTER_THREADS=4,并测试了两个不同的端点发布策略 (LoadBalancerService/hostnetwork) 。TLS 会话恢复用于加密路由。使用 HTTP keep-alive 设置,单个 HAProxy 路由器可在页面大小小到 8 kB 时充满 1 Gbit NIC。

当在使用现代处理器的裸机中运行时,性能可以期望达到以上公共云实例测试性能的大约两倍。这个开销是由公有云的虚拟化层造成的,基于私有云虚拟化的环境也会有类似的开销。下表是有关在路由器后面的应用程序数量的指导信息:

应用程序数量应用程序类型

5-10

静态文件/web 服务器或者缓存代理

100-1000

生成动态内容的应用程序

取决于所使用的技术,HAProxy 通常可支持 5 到 1000 个程序的路由。Ingress Controller 性能可能会受其后面的应用程序的能力和性能的限制,如使用的语言,静态内容或动态内容。

如果有多个服务于应用程序的 Ingress 或路由器,则应该使用路由器分片(router sharding)以帮助横向扩展路由层。

如需有关 Ingress 分片的更多信息,请参阅使用路由标签使用命名空间标签配置 Ingress Controller 分片

12.2. Ingress Controller(路由器)性能优化

OpenShift Container Platform 不再支持通过设置以下环境变量来修改 Ingress Controller 的部署: ROUTER_THREADSROUTER_DEFAULT_TUNNEL_TIMEOUTROUTER_DEFAULT_CLIENT_TIMEOUTROUTER_DEFAULT_SERVER_TIMEOUTRELOAD_INTERVAL

您可以修改 Ingress Controller 的部署,但当 Ingress Operator 被启用时,其配置会被覆盖。

第 13 章 优化网络

OpenShift SDN 使用 OpenvSwitch、虚拟可扩展 LAN(VXLAN)隧道、OpenFlow 规则和 iptables。这个网络可以通过使用 jumbo 帧、网络接口控制器 (NIC) 卸载、多队列和 ethtool 设置来调节。

OVN-Kubernetes 使用 Geneve(通用网络虚拟化封装)而不是 VXLAN 作为隧道协议。

VXLAN 提供通过 VLAN 的好处,比如网络从 4096 增加到一千六百万,以及跨物理网络的第 2 层连接。这允许服务后的所有 pod 相互通信,即使它们在不同系统中运行也是如此。

VXLAN 在用户数据报协议(UDP)数据包中封装所有隧道流量。但是,这会导致 CPU 使用率增加。这些外部数据包和内部数据包集都遵循常规的校验规则,以保证在传输过程中不会损坏数据。根据 CPU 性能,这种额外的处理开销可能会降低吞吐量,与传统的非覆盖网络相比会增加延迟。

云、虚拟机和裸机 CPU 性能可以处理很多 Gbps 网络吞吐量。当使用高带宽链接(如 10 或 40 Gbps)时,性能可能会降低。基于 VXLAN 的环境里存在一个已知问题,它并不适用于容器或 OpenShift Container Platform。由于 VXLAN 的实现,任何依赖于 VXLAN 隧道的网络都会有相似的性能。

如果您希望超过 Gbps,可以:

  • 试用采用不同路由技术的网络插件,比如边框网关协议(BGP)。
  • 使用 VXLAN-offload 功能的网络适配器。VXLAN-offload 将数据包校验和相关的 CPU 开销从系统 CPU 移动到网络适配器的专用硬件中。这会释放 Pod 和应用程序使用的 CPU 周期,并允许用户利用其网络基础架构的全部带宽。

VXLAN-offload 不会降低延迟。但是,即使延迟测试也会降低 CPU 使用率。

13.1. 为您的网络优化 MTU

有两个重要的最大传输单元 (MTU):网络接口控制器 (NIC) MTU 和集群网络 MTU。

NIC MTU 仅在 OpenShift Container Platform 安装时进行配置。MTU 必须小于或等于您网络 NIC 的最大支持值。如果您要优化吞吐量,请选择最大可能的值。如果您要优化最小延迟,请选择一个较低值。

SDN 覆盖的 MTU 必须至少小于 NIC MTU 50 字节。此帐户用于 SDN overlay 标头。因此,在一个普通以太网网络中,将其设置为 1450。在 jumbo 帧以太网网络中,将其设置为 8950

对于 OVN 和 Geneve,MTU 必须至少小于 NIC MTU 100 字节。

注意

这个 50 字节覆 overlay 头与 OpenShift SDN 相关。其他 SDN 解决方案可能需要该值更大或更少。

13.3. IPsec 的影响

因为加密和解密节点主机使用 CPU 电源,所以启用加密时,无论使用的 IP 安全系统是什么,性能都会影响节点上的吞吐量和 CPU 使用量。

IPsec 在到达 NIC 前,会在 IP 有效负载级别加密流量,以保护用于 NIC 卸载的字段。这意味着,在启用 IPSec 时,一些 NIC 加速功能可能无法使用,并可能导致吞吐量降低并增加 CPU 用量。

第 14 章 管理裸机主机

在裸机集群中安装 OpenShift Container Platform 时,您可以使用机器(machine)机器集(machineset)自定义资源(CR)为集群中存在的裸机主机置备和管理裸机节点。

14.1. 关于裸机主机和节点

要将 Red Hat Enterprise Linux CoreOS(RHCOS)裸机主机置备为集群中的节点,首先创建一个与裸机主机硬件对应的 MachineSet 自定义资源(CR)对象。裸机主机机器集描述了特定于您的配置的基础架构组件。将特定的 Kubernetes 标签应用于这些机器集,然后将基础架构组件更新为仅在那些机器上运行。

当您扩展包含 metal3.io/autoscale-to-hosts 注解的相关 MachineSet 时,Machine CR 会被自动创建。OpenShift Container Platform 使用 Machine CR 来置备与 MachineSet CR 中指定的主机对应的裸机节点。

14.2. 维护裸机主机

您可从 OpenShift Container Platform Web 控制台维护集群中的裸机主机详情。导航到 ComputeBare Metal Hosts,然后从 Actions 下拉菜单中选择一个任务。您可以在此处管理诸如 BMC 详情、主机的引导 MAC 地址、启用电源管理等项目。您还可以查看主机的网络接口和驱动器详情。

您可以将裸机主机移入维护模式。当您将主机移入维护模式时,调度程序会将所有受管工作负载从对应的裸机节点中移出。在处于维护模式时不会调度新的工作负载。

您可以在 web 控制台中取消置备裸机主机。取消置备主机执行以下操作:

  1. 使用 cluster.k8s.io/delete-machine: true注解裸机主机 CR
  2. 缩减相关的机器集
注意

在不先将守护进程集和未管理的静态 pod 移动到另一节点的情况下,关闭主机电源可能会导致服务中断和数据丢失。

14.2.1. 使用 web 控制台在集群中添加裸机主机

您可以在 web 控制台中在集群中添加裸机主机。

先决条件

  • 在裸机上安装 RHCOS 集群。
  • 以具有 cluster-admin 特权的用户身份登录。

流程

  1. 在 web 控制台中,导航到 ComputeBare Metal Hosts
  2. 选择 Add HostNew with Dialog
  3. 为新的裸机主机指定唯一名称。
  4. 设置 引导 MAC 地址
  5. 设置 基板管理控制台(BMC)地址.
  6. 可选:为主机启用电源管理。这允许 OpenShift Container Platform 控制主机的电源状态。
  7. 输入主机的基板管理控制器(BMC)的用户凭据。
  8. 选择在创建后打开主机电源,然后选择 Create
  9. 向上扩展副本数,以匹配可用的裸机主机数量。导航到 ComputeMachineSets,然后从 Actions 下拉菜单中选择 Edit Machine count 来增加集群中的机器副本数量。
注意

您还可以使用 oc scale 命令和适当的裸机机器集来管理裸机节点的数量。

14.2.2. 在 web 控制台中使用 YAML 在集群中添加裸机主机

您可以使用描述裸机主机的 YAML 文件在 web 控制台中在集群中添加裸机主机。

先决条件

  • 在裸机基础架构上安装 RHCOS 计算机器,以便在集群中使用。
  • 以具有 cluster-admin 特权的用户身份登录。
  • 为裸机主机创建 Secret CR。

流程

  1. 在 web 控制台中,导航到 ComputeBare Metal Hosts
  2. 选择 Add HostNew from YAML
  3. 复制并粘贴以下 YAML,使用您的主机详情修改相关字段:

    apiVersion: metal3.io/v1alpha1
    kind: BareMetalHost
    metadata:
      name: <bare_metal_host_name>
    spec:
      online: true
      bmc:
        address: <bmc_address>
        credentialsName: <secret_credentials_name>  1
        disableCertificateVerification: True
      bootMACAddress: <host_boot_mac_address>
      hardwareProfile: unknown
    1
    credentialsName 必须引用有效的 Secret CR。如果在 credentialsName 中没有引用有效的 Secret,则 baremetal-operator 无法管理裸机主机。如需有关 secret 以及如何创建 secret 的更多信息,请参阅了解 secret
  4. 选择 Create 以保存 YAML 并创建新的裸机主机。
  5. 向上扩展副本数,以匹配可用的裸机主机数量。导航到 ComputeMachineSets,然后从 Actions 下拉菜单中选择 Edit Machine count 来增加集群中的机器数量。

    注意

    您还可以使用 oc scale 命令和适当的裸机机器集来管理裸机节点的数量。

14.2.3. 自动将机器扩展到可用的裸机主机数量

要自动创建与可用 BareMetalHost 对象数量匹配的 Machine 对象数量,请在 MachineSet 对象中添加 metal3.io/autoscale-to-hosts 注解。

先决条件

  • 安装 RHCOS 裸机计算机器以在集群中使用,并创建对应的 BareMetalHost 对象。
  • 安装 OpenShift Container Platform CLI(oc)。
  • 以具有 cluster-admin 特权的用户身份登录。

流程

  1. 通过添加 metal3.io/autoscale-to-hosts 注解来注解您要配置的用于自动扩展的机器集。将 <machineset> 替换为机器集的名称。

    $ oc annotate machineset <machineset> -n openshift-machine-api 'metal3.io/autoscale-to-hosts=<any_value>'

    等待新的缩放计算机启动。

注意

当您使用 BareMetalHost 对象在集群中创建机器时,BareMetalHost 上更改了标签或选择器,BareMetalHost 对象仍然会根据创建 Machine 对象的 MachineSet 进行计数。

第 15 章 巨页的作用及应用程序如何使用它们

15.1. 巨页的作用

内存在块(称为页)中进行管理。在大多数系统中,页的大小为 4Ki。1Mi 内存相当于 256 个页,1Gi 内存相当于 256,000 个页。CPU 有内置的内存管理单元,可在硬件中管理这些页的列表。Translation Lookaside Buffer (TLB) 是虚拟页到物理页映射的小型硬件缓存。如果在硬件指令中包括的虚拟地址可以在 TLB 中找到,则其映射信息可以被快速获得。如果没有包括在 TLN 中,则称为 TLB miss。系统将会使用基于软件的,速度较慢的地址转换机制,从而出现性能降低的问题。因为 TLB 的大小是固定的,因此降低 TLB miss 的唯一方法是增加页的大小。

巨页指一个大于 4Ki 的内存页。在 x86_64 构架中,有两个常见的巨页大小: 2Mi 和 1Gi。在其它构架上的大小会有所不同。要使用巨页,必须写相应的代码以便应用程序了解它们。Transparent Huge Pages(THP)试图在应用程序不需要了解的情况下自动管理巨页,但这个技术有一定的限制。特别是,它的页大小会被限为 2Mi。当有较高的内存使用率时,THP 可能会导致节点性能下降,或出现大量内存碎片(因为 THP 的碎片处理)导致内存页被锁定。因此,有些应用程序可能更适用于(或推荐)使用预先分配的巨页,而不是 THP。

在 OpenShift Container Platform 中,pod 中的应用程序可以分配并消耗预先分配的巨页。

15.2. 应用程序如何使用巨页

节点必须预先分配巨页以便节点报告其巨页容量。一个节点只能预先分配一个固定大小的巨页。

巨页可以使用名为 hugepages-<size> 的容器一级的资源需求被消耗。其中 size 是特定节点上支持的整数值的最精简的二进制标记。例如:如果某个节点支持 2048KiB 页大小,它将会有一个可调度的资源 hugepages-2Mi。与 CPU 或者内存不同,巨页不支持过量分配。

apiVersion: v1
kind: Pod
metadata:
  generateName: hugepages-volume-
spec:
  containers:
  - securityContext:
      privileged: true
    image: rhel7:latest
    command:
    - sleep
    - inf
    name: example
    volumeMounts:
    - mountPath: /dev/hugepages
      name: hugepage
    resources:
      limits:
        hugepages-2Mi: 100Mi 1
        memory: "1Gi"
        cpu: "1"
  volumes:
  - name: hugepage
    emptyDir:
      medium: HugePages
1
巨页指定要分配的准确内存数量。不要将这个值指定为巨页内存大小乘以页的大小。例如,巨页的大小为 2MB,如果应用程序需要使用由巨页组成的 100MB 的内存,则需要分配 50 个巨页。OpenShift Container Platform 会进行相应的计算。如上例所示,您可以直接指定 100MB

分配特定大小的巨页

有些平台支持多个巨页大小。要分配指定大小的巨页,在巨页引导命令参数前使用巨页大小选择参数hugepagesz=<size><size> 的值必须以字节为单位,并可以使用一个可选的后缀 [kKmMgG]。默认的巨页大小可使用 default_hugepagesz=<size> 引导参数定义。

巨页要求

  • 巨页面请求必须等于限制。如果指定了限制,则它是默认的,但请求不是。
  • 巨页在 pod 范围内被隔离。容器隔离功能计划在以后的版本中推出。
  • 后端为巨页的 EmptyDir 卷不能消耗大于 pod 请求的巨页内存。
  • 通过带有 SHM_HUGETLBshmget() 来使用巨页的应用程序,需要运行一个匹配 proc/sys/vm/hugetlb_shm_group 的 supplemental 组。

其他资源

15.3. 使用 Downward API 消耗巨页资源

您可以使用 Downward API 注入容器消耗的巨页资源的信息。

您可以将资源分配作为环境变量、卷插件或两者都注入。您在容器中开发和运行的应用可以通过读取指定卷中的环境变量或文件来确定可用的资源。

流程

  1. 创建一个类似以下示例的 hugepages-volume-pod.yaml 文件:

    apiVersion: v1
    kind: Pod
    metadata:
      generateName: hugepages-volume-
      labels:
        app: hugepages-example
    spec:
      containers:
      - securityContext:
          capabilities:
            add: [ "IPC_LOCK" ]
        image: rhel7:latest
        command:
        - sleep
        - inf
        name: example
        volumeMounts:
        - mountPath: /dev/hugepages
          name: hugepage
        - mountPath: /etc/podinfo
          name: podinfo
        resources:
          limits:
            hugepages-1Gi: 2Gi
            memory: "1Gi"
            cpu: "1"
          requests:
            hugepages-1Gi: 2Gi
        env:
        - name: REQUESTS_HUGEPAGES_1GI 1
          valueFrom:
            resourceFieldRef:
              containerName: example
              resource: requests.hugepages-1Gi
      volumes:
      - name: hugepage
        emptyDir:
          medium: HugePages
      - name: podinfo
        downwardAPI:
          items:
            - path: "hugepages_1G_request" 2
              resourceFieldRef:
                containerName: example
                resource: requests.hugepages-1Gi
                divisor: 1Gi
    1
    指定从 requests.hugepages-1Gi 中读取资源,并将值作为 REQUESTS_HUGEPAGES_1GI 环境变量公开。
    2
    指定从 requests.hugepages-1Gi 中读取资源,并将值作为文件 /etc/podinfo/hugepages_1G_request 公开。
  2. hugepages-volume-pod.yaml 文件创建 pod:

    $ oc create -f hugepages-volume-pod.yaml

验证

  1. 检查 REQUESTS_HUGEPAGES_1GI 环境变量的值:

    $ oc exec -it $(oc get pods -l app=hugepages-example -o jsonpath='{.items[0].metadata.name}') \
         -- env | grep REQUESTS_HUGEPAGES_1GI

    输出示例

    REQUESTS_HUGEPAGES_1GI=2147483648

  2. 检查 /etc/podinfo/hugepages_1G_request 文件的值:

    $ oc exec -it $(oc get pods -l app=hugepages-example -o jsonpath='{.items[0].metadata.name}') \
         -- cat /etc/podinfo/hugepages_1G_request

    输出示例

    2

15.4. 配置巨页

节点必须预先分配在 OpenShift Container Platform 集群中使用的巨页。保留巨页的方法有两种: 在引导时和在运行时。在引导时进行保留会增加成功的可能性,因为内存还没有很大的碎片。Node Tuning Operator 目前支持在特定节点上分配巨页。

15.4.1. 在引导时

流程

要减少节点重启的情况,请按照以下步骤顺序进行操作:

  1. 通过标签标记所有需要相同巨页设置的节点。

    $ oc label node <node_using_hugepages> node-role.kubernetes.io/worker-hp=
  2. 创建一个包含以下内容的文件,并把它命名为 hugepages_tuning.yaml

    apiVersion: tuned.openshift.io/v1
    kind: Tuned
    metadata:
      name: hugepages 1
      namespace: openshift-cluster-node-tuning-operator
    spec:
      profile: 2
      - data: |
          [main]
          summary=Boot time configuration for hugepages
          include=openshift-node
          [bootloader]
          cmdline_openshift_node_hugepages=hugepagesz=2M hugepages=50 3
        name: openshift-node-hugepages
    
      recommend:
      - machineConfigLabels: 4
          machineconfiguration.openshift.io/role: "worker-hp"
        priority: 30
        profile: openshift-node-hugepages
    1
    将 Tuned 资源的 name 设置为 hugepages
    2
    profile 部分设置为分配巨页。
    3
    请注意,参数顺序是非常重要的,因为有些平台支持各种大小的巨页。
    4
    启用基于机器配置池的匹配。
  3. 创建 Tuned hugepages 对象

    $ oc create -f hugepages-tuned-boottime.yaml
  4. 创建一个带有以下内容的文件,并把它命名为 hugepages-mcp.yaml

    apiVersion: machineconfiguration.openshift.io/v1
    kind: MachineConfigPool
    metadata:
      name: worker-hp
      labels:
        worker-hp: ""
    spec:
      machineConfigSelector:
        matchExpressions:
          - {key: machineconfiguration.openshift.io/role, operator: In, values: [worker,worker-hp]}
      nodeSelector:
        matchLabels:
          node-role.kubernetes.io/worker-hp: ""
  5. 创建机器配置池:

    $ oc create -f hugepages-mcp.yaml

因为有足够的非碎片内存,worker-hp 机器配置池中的所有节点现在都应分配 50 个 2Mi 巨页。

$ oc get node <node_using_hugepages> -o jsonpath="{.status.allocatable.hugepages-2Mi}"
100Mi
警告

目前,这个功能只在 Red Hat Enterprise Linux CoreOS(RHCOS)8.x worker 节点上被支持。在 Red Hat Enterprise Linux(RHEL)7.x worker 节点上,目前不支持 TuneD [bootloader] 插件。

第 16 章 低延迟节点的 Performance Addon Operator

16.1. 了解低延迟

在 Telco / 5G 领域,Edge 计算对于减少延迟和拥塞问题,以及提高应用程序性能方面扮演了关键角色。

简单地说,延迟决定了数据(packets)从发送方到接收方的速度,以及在接收方处理后返回到发送方的速度。显然,维护一个最低延迟速度的网络构架是满足 5G 的网络性能要求的关键。对于 4G 技术,它的平均延迟为 50ms,与之相比,5G 的目标是达到 1ms 或更少的延迟。这个对延迟的降低会将无线网络的吞吐量提高 10 倍。

很多在 Telco 空间部署的应用程序都需要低延迟,它们只能容忍零数据包丢失。针对零数据包丢失进行调节有助于缓解降低网络性能的固有问题。如需更多信息,请参阅 Red Hat OpenStack Platform(RHOSP)中的 Zero Packet Los 调节

Edge 计算也可用于降低延迟率。它位于云的边缘,并且更接近用户。这可大大减少用户和远程数据中心之间的距离,从而减少应用程序响应时间和性能延迟。

管理员必须能够集中管理多个 Edge 站点和本地服务,以便所有部署都可以以最低的管理成本运行。它们还需要一个简便的方法来部署和配置其集群的某些节点,以实现实时低延迟和高性能目的。低延迟节点对于如 Cloud-native Network Functions(CNF)和 Data Plane Development Kit(DPDK) 等应用程序非常有用。

OpenShift Container Platform 目前提供在 OpenShift Container Platform 集群上调整软件的机制,以获取实时运行和低延迟时间(响应时间小于 20 微秒)。这包括调整内核和 OpenShift Container Platform 设置值、安装内核和重新配置机器。但是这个方法需要设置四个不同的 Operator,并执行很多配置,这些配置在手动完成时比较复杂,并容易出错。

OpenShift Container Platform 提供了一个 Performance Addon Operator 来实现自动性能优化,从而实现 OpenShift 应用程序的低延迟性能。集群管理员使用此性能配置集配置,这有助于以更可靠的方式进行更改。管理员可以指定是否要将内核更新至 kernel-rt,为集群和操作系统日常任务保留 CPU(包括 pod infra 容器),以及隔离 CPU,以便应用程序容器运行工作负载。

16.1.1. 关于低延迟和实时应用程序超线程

超线程是一个 Intel 处理器技术,它允许物理 CPU 处理器内核作为两个逻辑内核同时执行两个独立的线程。超线程可以为并行处理很有用的某些工作负载类型的系统吞吐量提供更好的系统吞吐量。默认的 OpenShift Container Platform 配置需要默认启用超线程。

对于电信领域的应用程序,设计您的应用程序架构非常重要,以尽量减小延迟。超线程会降低性能,并严重影响需要低延迟的计算负载的吞吐量。禁用超线程可确保性能的可预测性,并可减少这些工作负载的处理时间。

注意

超线程实现和配置会因运行 OpenShift Container Platform 的硬件而异。如需了解特定于该硬件的超线程实现的更多详情,请参考相关的主机硬件调节信息。禁用超线程可以增加集群的每个内核的成本。

16.2. 安装 Performance Addon Operator

Performance Addon Operator 提供了在一组节点上启用高级节点性能调整的功能。作为集群管理员,您可以使用 OpenShift Container Platform CLI 或 Web 控制台安装 Performance Addon Operator。

16.2.1. 使用 CLI 安装 Operator

作为集群管理员,您可以使用 CLI 安装 Operator。

先决条件

  • 在裸机硬件上安装的集群。
  • 安装 OpenShift CLI(oc)。
  • 以具有 cluster-admin 特权的用户身份登录。

流程

  1. 通过完成以下操作,为 Performance Addon Operator 创建命名空间:

    1. 创建用于定义 openshift-performance-addon-operator 命名空间的以下 Namespace 自定义资源(CR),然后在 pao-namespace.yaml 文件中保存 YAML:

      apiVersion: v1
      kind: Namespace
      metadata:
        name: openshift-performance-addon-operator
        annotations:
          workload.openshift.io/allowed: management
    2. 运行以下命令创建命名空间:

      $ oc create -f pao-namespace.yaml
  2. 通过创建以下对象,在您上一步创建的命名空间中安装 Performance Addon Operator:

    1. 创建以下 OperatorGroup CR,并在 pao-operatorgroup.yaml 文件中保存 YAML:

      apiVersion: operators.coreos.com/v1
      kind: OperatorGroup
      metadata:
        name: openshift-performance-addon-operator
        namespace: openshift-performance-addon-operator
    2. 运行以下命令来创建 OperatorGroup CR:

      $ oc create -f pao-operatorgroup.yaml
    3. 运行以下命令获取下一步所需的 channel 值。

      $ oc get packagemanifest performance-addon-operator -n openshift-marketplace -o jsonpath='{.status.defaultChannel}'

      输出示例

      4.9

    4. 创建以下订阅 CR,并将 YAML 保存到 pao-sub.yaml 文件中:

      订阅示例

      apiVersion: operators.coreos.com/v1alpha1
      kind: Subscription
      metadata:
        name: openshift-performance-addon-operator-subscription
        namespace: openshift-performance-addon-operator
      spec:
        channel: "<channel>" 1
        name: performance-addon-operator
        source: redhat-operators 2
        sourceNamespace: openshift-marketplace

      1
      使用在前一步中获得的值指定 .status.defaultChannel 参数。
      2
      您必须指定 redhat-operators 值。
    5. 运行以下命令创建订阅对象:

      $ oc create -f pao-sub.yaml
    6. 进入 openshift-performance-addon-operator 项目:

      $ oc project openshift-performance-addon-operator

16.2.2. 使用 Web 控制台安装 Performance Addon Operator

作为集群管理员,您可以使用 web 控制台安装 Performance Addon Operator。

注意

如上一节所述,您必须创建 Namespace CR 和 OperatorGroup CR。

流程

  1. 使用 OpenShift Container Platform Web 控制台安装 Performance Addon Operator:

    1. 在 OpenShift Container Platform Web 控制台中,点击 OperatorsOperatorHub
    2. 从可用的 Operator 列表中选择 Performance Addon Operator,然后点 Install
    3. Install Operator 页面中,选择 All namespaces on the cluster。然后点击 Install
  2. 可选:验证 performance-addon-operator 是否已成功安装:

    1. 切换到 OperatorsInstalled Operators 页面。
    2. 确保 openshift-performance-addon-operator 项目中列出的 Performance Addon OperatorStatusInstallSucceeded

      注意

      在安装过程中,Operator 可能会显示 Failed 状态。如果安装过程结束后有 InstallSucceeded 信息,您可以忽略这个 Failed 信息。

      如果 Operator 没有被成功安装,请按照以下步骤进行故障排除:

      • 进入 Operators → Installed Operators 页面,检查 Operator SubscriptionsInstall Plans 选项卡中的 Status 项中是否有任何错误。
      • 进入 WorkloadsPods 页面,在 performance-addon-operator 项目中检查 pod 的日志。

16.3. 升级 Performance Addon Operator

您可以手动升级到 Performance Addon Operator 的下一个次版本,并使用 web 控制台监控更新的状态。

16.3.1. 关于升级 Performance Addon Operator

  • 您可以使用 OpenShift Container Platform web 控制台更改 Operator 订阅的频道把 Performance Addon Operator 升级到下一个次要版本。
  • 您可在安装 Performance Addon Operator 的过程中启用自动 z-stream 更新功能。
  • 更新通过 Marketplace Operator 实现,该 Operator 会在 OpenShift Container Platform 安装过程中部署。Marketplace Operator 使外部 Operator 可供集群使用。
  • 更新完成所需时间取决于您的网络连接情况。大部分自动更新可在十五分钟内完成。

16.3.1.1. Performance Addon Operator 升级对您的集群有什么影响

  • 低延迟性能和巨页均不会受到影响。
  • 更新 Operator 应该不会造成任何意外重启。

16.3.1.2. 将 Performance Addon Operator 升级到下一个次版本

您可以使用 OpenShift Container Platform Web 控制台修改 Operator 订阅的频道,将 Performance Addon Operator 手动升级到下一个次版本 。

先决条件

  • 使用具有 cluster-admin 角色的用户访问集群。

流程

  1. 访问 Web 控制台,进入 OperatorsInstalled Operators
  2. 点击Performance Addon Operator 打开 Operator Details 页面。
  3. 单击 Subscription 选项卡,以打开 Subscription 详情页面。
  4. Update 频道窗格中,点击版本号右侧的铅笔图标打开 Change Subscription 更新频道窗口。
  5. 选择下一个次要版本。例如,如果要升级到 Performance Addon Operator 4.9,请选择 4.9
  6. Save
  7. 通过导航到 Operators → Installed Operators 来检查升级的状态。您还可以通过运行以下 oc 命令来检查状态:

    $ oc get csv -n openshift-performance-addon-operator

16.3.1.3. 当以前安装到特定命名空间时,升级 Performance Addon Operator

如果您之前已将 Performance Addon Operator 安装到集群中的特定命名空间中,如 openshift-performance-addon-operator,修改 OperatorGroup 对象以在升级前删除 targetNamespaces 条目。

先决条件

  • 安装 OpenShift Container Platform CLI(oc)。
  • 以具有 cluster-admin 权限的用户身份登录 OpenShift 集群。

流程

  1. 运行以下命令,编辑 Performance Addon Operator OperatorGroup CR 并删除包含 targetNamespaces 条目的 spec 元素:

    $ oc patch operatorgroup -n openshift-performance-addon-operator openshift-performance-addon-operator --type json -p '[{ "op": "remove", "path": "/spec" }]'
  2. 等待 Operator Lifecycle Manager(OLM)处理更改。
  3. 验证 OperatorGroup CR 更改是否已成功应用。检查 OperatorGroup CR spec 元素是否已删除:

    $ oc describe -n openshift-performance-addon-operator og openshift-performance-addon-operator
  4. 执行 Performance Addon Operator 升级。

16.3.2. 监控升级状态

监控 Performance Addon Operator 升级状态的最佳方法是查看 ClusterServiceVersion(CSV) PHASE。您还可以在 web 控制台中或通过运行 oc get csv 命令来监控 CSV 状况。

注意

PHASE 和状况值均是基于可用信息的近似值。

先决条件

  • 使用具有 cluster-admin 角色的用户访问集群。
  • 安装 OpenShift CLI(oc)。

流程

  1. 运行以下命令:

    $ oc get csv
  2. 查看输出,检查 PHASE 字段。例如:

    VERSION    REPLACES                                         PHASE
    4.9.0      performance-addon-operator.v4.9.0                Installing
    4.8.0                                                       Replacing
  3. 再次运行 get csv 以验证输出:

    # oc get csv

    输出示例

    NAME                                DISPLAY                      VERSION   REPLACES                            PHASE
    performance-addon-operator.v4.9.0   Performance Addon Operator   4.9.0     performance-addon-operator.v4.8.0   Succeeded

16.4. 置备实时和低延迟工作负载

很多行业和机构需要非常高的计算性能,并需要低且可预测的延迟,特别是银行和电信业。对于这些行业,它们有其特殊的要求,OpenShift Container Platform 提供了一个 Performance Addon Operator 来实现自动调整,以便为 OpenShift Container Platform 应用程序实现低延迟性能和响应时间。

集群管理员可以使用此性能配置集配置以更可靠的方式进行这些更改。管理员可以指定是否将内核更新至 kernel-rt(实时),为集群和操作系统日常任务保留 CPU(包括 pod infra 容器),以及隔离 CPU,以便应用程序容器运行工作负载。

警告

执行探测与需要保证 CPU 的应用程序结合使用可能会导致延迟高峰。建议使用其他探测,如正确配置的网络探测集合作为替代方案。

16.4.1. 已知的实时限制

注意

在大多数部署中,当您使用具有三个 control plane 节点和三个 worker 节点的标准集群时,只有 worker 节点上支持 kernel-rt。OpenShift Container Platform 部署中的紧凑和单一节点会有例外。对于在单一节点中安装,在单个 control plane 节点上支持 kernel-rt。

要充分利用实时模式,容器必须使用升级的权限运行。如需了解有关授予特权的信息,请参阅为容器设置能力

OpenShift Container Platform 会限制允许的功能,因此您可能需要创建 SecurityContext

注意

使用 Red Hat Enterprise Linux CoreOS(RHCOS)系统的裸机安装完全支持此步骤。

在确定正确的性能预期时,应该意识到实时内核并不是万能的。它的目的是提供一个持续的、低延迟的确定性机制,从而提供可预测的响应时间。在系统中,会存在与实时内核关联的额外内核开销。这是因为在单独调度的线程中处理硬件中断。某些增加的工作负载开销会导致整个吞吐量下降。实际的影响依赖于特定的负载,范围从 0% 到 30%。然而,这是获得确定性所需要付出的代价。

16.4.2. 使用实时功能置备 worker

  1. 在集群上安装 Performance Addon Operator。
  2. 可选:在 OpenShift Container Platform 集群中添加节点。请参阅设置 BIOS 参数
  3. 使用 oc 命令,将标签 worker-rt 添加到需要实时功能的 worker 节点。
  4. 为实时节点创建新机器配置池:

    apiVersion: machineconfiguration.openshift.io/v1
    kind: MachineConfigPool
    metadata:
      name: worker-rt
      labels:
        machineconfiguration.openshift.io/role: worker-rt
    spec:
      machineConfigSelector:
        matchExpressions:
          - {
               key: machineconfiguration.openshift.io/role,
               operator: In,
               values: [worker, worker-rt],
            }
      paused: false
      nodeSelector:
        matchLabels:
          node-role.kubernetes.io/worker-rt: ""

    请注意,为带有标签 worker-rt 的节点组创建机器配置池 worker-rt

  5. 使用节点角色标签将节点添加到正确的机器配置池中。

    注意

    您必须决定使用实时工作负载配置哪些节点。您可以配置集群中的所有节点,或者节点的子集。期望所有节点的 Performance Addon Operator 都是专用机器配置池的一部分。如果使用所有节点,则必须将 Performance Addon Operator 指向 worker 节点角色标签。如果使用子集,您必须将节点分组到新机器配置池中。

  6. 使用正确的 housekeeping 内核和 realTimeKernel: enabled: true 创建 PerformanceProfile
  7. 您必须在 PerformanceProfile 中设置 machineConfigPoolSelector

      apiVersion: performance.openshift.io/v2
      kind: PerformanceProfile
      metadata:
       name: example-performanceprofile
      spec:
      ...
        realTimeKernel:
          enabled: true
        nodeSelector:
           node-role.kubernetes.io/worker-rt: ""
        machineConfigPoolSelector:
           machineconfiguration.openshift.io/role: worker-rt
  8. 验证匹配的机器配置池是否存在一个标签:

    $ oc describe mcp/worker-rt

    输出示例

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

  9. OpenShift Container Platform 将开始配置节点,这可能涉及多次重启。等待节点处于稳定状态。这个过程所需要的时间取决于您所使用的具体硬件,预计每个节点需要 20 分钟。
  10. 验证所有内容是否按预期工作。

16.4.3. 验证实时内核安装

使用这个命令确定安装了实时内核:

$ oc get node -o wide

记录带有角色 worker-rt,包括 4.18.0-211.rt5.23.el8.x86_64 字符串的 worker。

NAME                               	STATUS   ROLES           	AGE 	VERSION                  	INTERNAL-IP
EXTERNAL-IP   OS-IMAGE                                       	KERNEL-VERSION
CONTAINER-RUNTIME
rt-worker-0.example.com	          Ready	 worker,worker-rt   5d17h   v1.22.1
128.66.135.107   <none>    	        Red Hat Enterprise Linux CoreOS 46.82.202008252340-0 (Ootpa)
4.18.0-211.rt5.23.el8.x86_64   cri-o://1.22.1-90.rhaos4.9.git4a0ac05.el8-rc.1
[...]

16.4.4. 创建一个实时工作负载

使用以下步骤准备一个使用实时功能的工作负载。

流程

  1. 创建带有 Guaranteed 类 QoS 类的 pod。
  2. 可选:禁用 DPDK 的 CPU 负载均衡。
  3. 分配正确的节点选择器。

在编写应用程序时,请遵循应用程序调整和部署中的常规建议。

16.4.5. 创建带有 Guaranteed 类 QoS 类的 pod

在创建带有 Guaranteed 类的 QoS 类的 pod 时请注意以下几点:

  • pod 中的每个容器都必须具有内存限制和内存请求,且它们必须相同。
  • pod 中的每个容器都必须具有 CPU 限制和 CPU 请求,且它们必须相同。

以下示例显示了一个容器的 pod 的配置文件。容器设置了内存限制和内存请求,均为 200 MiB。容器具有 CPU 限制和 CPU 请求,均为 1 CPU。

apiVersion: v1
kind: Pod
metadata:
  name: qos-demo
  namespace: qos-example
spec:
  containers:
  - name: qos-demo-ctr
    image: <image-pull-spec>
    resources:
      limits:
        memory: "200Mi"
        cpu: "1"
      requests:
        memory: "200Mi"
        cpu: "1"
  1. 创建 pod:

    $ oc  apply -f qos-pod.yaml --namespace=qos-example
  2. 查看有关 pod 的详细信息:

    $ oc get pod qos-demo --namespace=qos-example --output=yaml

    输出示例

    spec:
      containers:
        ...
    status:
      qosClass: Guaranteed

    注意

    如果容器指定了自己的内存限值,但没有指定内存请求,OpenShift Container Platform 会自动分配与限制匹配的内存请求。同样,如果容器指定了自己的 CPU 限值,但没有指定 CPU 请求,OpenShift Container Platform 会自动分配与限制匹配的 CPU 请求。

16.4.6. 可选:禁用 DPDK 的 CPU 负载均衡

禁用或启用 CPU 负载均衡的功能在 CRI-O 级别实现。CRI-O 下的代码仅在满足以下要求时禁用或启用 CPU 负载均衡。

  • pod 必须使用 performance-<profile-name> 运行时类。您可以通过查看性能配置集的状态来获得正确的名称,如下所示:

    apiVersion: performance.openshift.io/v2
    kind: PerformanceProfile
    ...
    status:
      ...
      runtimeClass: performance-manual
  • pod 必须具有 cpu-load-balancing.crio.io: true 注解。

Performance Addon Operator 负责在相关节点下创建高性能运行时处理器配置片断,并在集群下创建高性能运行时类。它具有与默认运行时处理相同的内容,但它启用了 CPU 负载均衡配置功能。

要禁用 pod 的 CPU 负载均衡,Pod 规格必须包括以下字段:

apiVersion: v1
kind: Pod
metadata:
  ...
  annotations:
    ...
    cpu-load-balancing.crio.io: "disable"
    ...
  ...
spec:
  ...
  runtimeClassName: performance-<profile_name>
  ...
注意

仅在启用了 CPU 管理器静态策略,以及带有保证 QoS 使用整个 CPU 的 pod 时,禁用 CPU 负载均衡。否则,禁用 CPU 负载均衡会影响集群中其他容器的性能。

16.4.7. 分配适当的节点选择器

为节点分配 pod 的首选方法是使用与性能配置集相同的节点选择器,如下所示:

apiVersion: v1
kind: Pod
metadata:
  name: example
spec:
  # ...
  nodeSelector:
    node-role.kubernetes.io/worker-rt: ""

如需更多信息,请参阅使用节点选择器将 pod 放置到特定的节点上

16.4.8. 将工作负载调度到具有实时功能的 worker

使用与附加到机器配置的节点匹配的标签选择器,这些选择器是为低延迟配置的。如需更多信息,请参阅将 pod 分配给节点

16.4.9. 管理设备中断处理保证 pod 隔离 CPU

Performance Addon Operator 可以通过将主机 CPU 划分为保留的 CPU 来管理主机 CPU,以进行集群和操作系统日常任务(包括 pod infra 容器),以及用于应用程序容器运行工作负载的隔离 CPU。这可让您将低延迟工作负载的 CPU 设置为隔离状态。

设备中断在所有隔离和保留 CPU 之间平衡负载,以避免出现 CPU 超载问题,但运行有保证 pod 的 CPU 除外。当为 pod 设置相关注解时,保证 pod CPU 无法处理设备中断。

在性能配置集中,globallyDisableIrqLoadBalancing 用于管理设备中断是否被处理。对于某些工作负载,保留 CPU 并不总是足以处理设备中断,因此不会在隔离的 CPU 上禁用设备中断。默认情况下,Performance Addon Operator 不会禁用隔离 CPU 上的设备中断。

要实现低延迟,有些(而非全部)pod 需要它们运行的 CPU 不处理设备中断。pod 注解 irq-load-balancing.crio.io 用于定义是否处理设备中断。配置后,CRI-O 仅在 pod 正在运行时禁用设备中断。

16.4.9.1. 禁用 Performance Addon Operator 中的全局设备中断处理

要将 Performance Addon Operator 配置为禁用隔离 CPU 集的全局设备中断,将 performance 配置集中的 globallyDisableIrqLoadBalancing 字段设置为 true。在为 true 时,会忽略有冲突的 pod 注解。在为 false 时,IRQ 负载会在所有 CPU 之间平衡。

一个性能配置集片段演示了这个设置:

apiVersion: performance.openshift.io/v2
kind: PerformanceProfile
metadata:
  name: manual
spec:
  globallyDisableIrqLoadBalancing: true
...

16.4.9.2. 禁用单个 pod 的中断处理

要禁用单个 pod 的中断处理,确保在性能配置集中将 globallyDisableIrqLoadBalancing 设置为 false。然后,在 pod 规格中,将 irq-load-balancing.crio.iocpu-load-balancing.crio.io pod 注解设置为 disable。如下例所示的 pod 规格片断示例:

apiVersion: performance.openshift.io/v2
kind: Pod
metadata:
  annotations:
      irq-load-balancing.crio.io: "disable"
      cpu-load-balancing.crio.io: "disable"
spec:
    runtimeClassName: performance-<profile_name>
...

16.4.10. 升级性能配置集以使用设备中断处理

当您将 Performance Addon Operator 性能配置集自定义资源定义(CRD)从 v1 或 v1alpha1 升级到 v2 时,现有配置集会将 globallyDisableIrqLoadBalancing 设置为 true

注意

globallyDisableIrqLoadBalancing 被设置为 true 时,设备中断会在所有 CPU 间进行,只要它们不属于一个保证的 pod。

16.4.10.1. 支持的 API 版本

Performance Addon Operator 在性能配置集 apiVersion 字段中支持 v2v1v1alpha1。v1 和 v1alpha1 API 相同。v2 API 包括一个可选的布尔值项 globallyDisableIrqLoadBalancing,默认值为 false

16.4.10.1.1. 将 Performance Addon Operator API 从 v1alpha1 升级到 v1

当将 Performance Addon Operator API 版本从 v1alpha1 升级到 v1 时,,v1alpha1 性能配置集会通过"None" Conversion 策略自行转换,并提供给带有 API 版本 v1 的 Performance Addon Operator。

16.4.10.1.2. 将 Performance Addon Operator API 从 v1alpha1 或 v1 升级到 v2

当从旧的 Performance Addon Operator API 版本升级时,现有的 v1 和 v1alpha1 性能配置集将使用转换 Webhook 转换,它将注入 globallyDisableIrqLoadBalancing 字段,值为 true

16.4.11. 为 IRQ 动态负载平衡配置节点

要将集群节点配置为处理 IRQ 动态负载平衡,请执行以下操作:

  1. 以具有 cluster-admin 权限的用户身份登录 OpenShift Container Platform 集群。
  2. 将性能配置集 apiVersion 设置为使用 performance.openshift.io/v2
  3. 删除 globallyDisableIrqLoadBalancing 字段,或把它设置为 false
  4. 设置适当的隔离 CPU 和保留的 CPU。以下片段演示了保留 2 个 CPU 的配置集。对于在 isolated CPU 集中运行的 pod,启用 IRQ 负载均衡:

    apiVersion: performance.openshift.io/v2
    kind: PerformanceProfile
    metadata:
      name: dynamic-irq-profile
    spec:
      cpu:
        isolated: 2-5
        reserved: 0-1
    ...
    注意

    当您配置保留的和隔离的 CPU 时,pod 中的 infra 容器将使用保留的 CPU,应用程序容器则使用隔离的 CPU。

  5. 创建使用独有 CPU 的 pod,并将 irq-load-balancing.crio.iocpu-quota.crio.io 注解设置为 disable。例如:

    apiVersion: v1
    kind: Pod
    metadata:
      name: dynamic-irq-pod
      annotations:
         irq-load-balancing.crio.io: "disable"
         cpu-quota.crio.io: "disable"
    spec:
      containers:
      - name: dynamic-irq-pod
        image: "quay.io/openshift-kni/cnf-tests:4.9"
        command: ["sleep", "10h"]
        resources:
          requests:
            cpu: 2
            memory: "200M"
          limits:
            cpu: 2
            memory: "200M"
      nodeSelector:
        node-role.kubernetes.io/worker-cnf: ""
      runtimeClassName: performance-dynamic-irq-profile
    ...
  6. 以 performance-<profile_name> 格式输入 pod 的 runtimeClassName,其中 <profile_name> 是来自 PerformanceProfile YAML 的 name,在本例中是 performance-dynamic-irq-profile
  7. 将节点选择器设置为以 cnf-worker 为目标。
  8. 确保 pod 正确运行。状态应该为 running,并应正确设置了 cnf-worker 节点:

    $ oc get pod -o wide

    预期输出

    NAME              READY   STATUS    RESTARTS   AGE     IP             NODE          NOMINATED NODE   READINESS GATES
    dynamic-irq-pod   1/1     Running   0          5h33m   <ip-address>   <node-name>   <none>           <none>

  9. 获取为 IRQ 动态负载均衡配置的 pod 运行 CPU:

    $ oc exec -it dynamic-irq-pod -- /bin/bash -c "grep Cpus_allowed_list /proc/self/status | awk '{print $2}'"

    预期输出

    Cpus_allowed_list:  2-3

  10. 确保正确应用节点配置。SSH 到节点以验证配置。

    $ oc debug node/<node-name>

    预期输出

    Starting pod/<node-name>-debug ...
    To use host binaries, run `chroot /host`
    
    Pod IP: <ip-address>
    If you don't see a command prompt, try pressing enter.
    
    sh-4.4#

  11. 验证可以使用节点文件系统:

    sh-4.4# chroot /host

    预期输出

    sh-4.4#

  12. 确保默认系统 CPU 关联性掩码不包括 dynamic-irq-pod CPU,如 CPU 2 和 3。

    $ cat /proc/irq/default_smp_affinity

    输出示例

    33

  13. 确定系统 IRQ 没有配置为在 dynamic-irq-pod CPU 中运行:

    find /proc/irq/ -name smp_affinity_list -exec sh -c 'i="$1"; mask=$(cat $i); file=$(echo $i); echo $file: $mask' _ {} \;

    输出示例

    /proc/irq/0/smp_affinity_list: 0-5
    /proc/irq/1/smp_affinity_list: 5
    /proc/irq/2/smp_affinity_list: 0-5
    /proc/irq/3/smp_affinity_list: 0-5
    /proc/irq/4/smp_affinity_list: 0
    /proc/irq/5/smp_affinity_list: 0-5
    /proc/irq/6/smp_affinity_list: 0-5
    /proc/irq/7/smp_affinity_list: 0-5
    /proc/irq/8/smp_affinity_list: 4
    /proc/irq/9/smp_affinity_list: 4
    /proc/irq/10/smp_affinity_list: 0-5
    /proc/irq/11/smp_affinity_list: 0
    /proc/irq/12/smp_affinity_list: 1
    /proc/irq/13/smp_affinity_list: 0-5
    /proc/irq/14/smp_affinity_list: 1
    /proc/irq/15/smp_affinity_list: 0
    /proc/irq/24/smp_affinity_list: 1
    /proc/irq/25/smp_affinity_list: 1
    /proc/irq/26/smp_affinity_list: 1
    /proc/irq/27/smp_affinity_list: 5
    /proc/irq/28/smp_affinity_list: 1
    /proc/irq/29/smp_affinity_list: 0
    /proc/irq/30/smp_affinity_list: 0-5

一些 IRQ 控制器不支持 IRQ 重新平衡,并将始终将所有在线 CPU 公开为 IRQ 掩码。这些 IRQ 控制器在 CPU 0 上运行。如需了解主机配置的更多信息,请 SSH 到主机并运行以下命令,将 <irq-num> 替换为您要查询的 CPU 号码:

$ cat /proc/irq/<irq-num>/effective_affinity

16.4.12. 为集群配置超线程

要为 OpenShift Container Platform 集群配置超线程,请将性能配置集中的 CPU 线程设置为为保留或隔离的 CPU 池配置的相同内核。

注意

如果您配置了性能配置集,然后更改主机的超线程配置,请确保更新 PerformanceProfile YAML 中的 CPU isolatedreserved字段以匹配新配置。

警告

禁用之前启用的主机超线程配置可能会导致 PerformanceProfile YAML 中列出的 CPU 内核 ID 错误。此不正确的配置可能会导致节点不可用,因为无法找到列出的 CPU。

先决条件

  • 使用具有 cluster-admin 角色的用户访问集群。
  • 安装 OpenShift CLI(oc)。

流程

  1. 确定在您要配置的主机的 CPU 上运行哪些线程。

    您可以通过登录到集群并运行以下命令来查看在主机 CPU 上运行哪些线程:

    $ lscpu --all --extended

    输出示例

    CPU NODE SOCKET CORE L1d:L1i:L2:L3 ONLINE MAXMHZ    MINMHZ
    0   0    0      0    0:0:0:0       yes    4800.0000 400.0000
    1   0    0      1    1:1:1:0       yes    4800.0000 400.0000
    2   0    0      2    2:2:2:0       yes    4800.0000 400.0000
    3   0    0      3    3:3:3:0       yes    4800.0000 400.0000
    4   0    0      0    0:0:0:0       yes    4800.0000 400.0000
    5   0    0      1    1:1:1:0       yes    4800.0000 400.0000
    6   0    0      2    2:2:2:0       yes    4800.0000 400.0000
    7   0    0      3    3:3:3:0       yes    4800.0000 400.0000

    在这个示例中,在四个物理 CPU 内核中运行了 8 个逻辑 CPU 内核。CPU0 和 CPU4 在物理 Core0 中运行,CPU1 和 CPU5 在物理 Core 1 中运行,以此类推。

    另外要查看为特定物理 CPU 内核设定的线程(以下示例中的cpu0 ),打开命令提示符并运行以下命令:

    $ cat /sys/devices/system/cpu/cpu0/topology/thread_siblings_list

    输出示例

    0-4

  2. PerformanceProfile YAML 中应用隔离和保留的 CPU。例如,您可以将逻辑内核 CPU0 和 CPU4 设置为 隔离,逻辑内核 CPU1 为 CPU3,CPU5 则设为 CPU7,保留 为 CPU7。当您配置保留的和隔离的 CPU 时,pod 中的 infra 容器将使用保留的 CPU,应用程序容器则使用隔离的 CPU。

    ...
      cpu:
        isolated: 0,4
        reserved: 1-3,5-7
    ...
    注意

    保留和隔离的 CPU 池不得重叠,并且必须一起跨越 worker 节点中的所有可用内核。

重要

大多数 Intel 处理器上默认启用超线程。如果启用超线程,特定内核处理的所有线程都必须被隔离或者在同一个内核中处理。

16.4.12.1. 禁用低延迟应用程序超线程

在为低延迟进程配置集群时,请考虑是否要在部署集群前禁用超线程。要禁用超线程,请执行以下操作:

  1. 创建一个适合您的硬件和拓扑的性能配置集。
  2. nosmt 设为附加内核参数。以下示例的性能配置集演示了此设置:

    apiVersion: performance.openshift.io/v2
    kind: PerformanceProfile
    metadata:
      name: example-performanceprofile
    spec:
      additionalKernelArgs:
        - nmi_watchdog=0
        - audit=0
        - mce=off
        - processor.max_cstate=1
        - idle=poll
        - intel_idle.max_cstate=0
        - nosmt
      cpu:
        isolated: 2-3
        reserved: 0-1
      hugepages:
        defaultHugepagesSize: 1G
        pages:
          - count: 2
            node: 0
            size: 1G
      nodeSelector:
        node-role.kubernetes.io/performance: ''
      realTimeKernel:
        enabled: true
    注意

    当您配置保留的和隔离的 CPU 时,pod 中的 infra 容器将使用保留的 CPU,应用程序容器则使用隔离的 CPU。

16.5. 使用性能配置集调整节点以实现低延迟

性能配置集可让您控制属于特定机器配置池的节点的延迟调整方面。指定设置后,PerformanceProfile 对象将编译为执行实际节点级别调整的多个对象:

  • 操作节点的 MachineConfig 文件。
  • 用于配置拓扑管理器、CPU Manager 和 OpenShift Container Platform 节点的 KubeletConfig 文件。
  • 配置 Node Tuning Operator 的 Tuned 配置集。

您可以使用性能配置集指定是否将内核更新至 kernel-rt,分配大页面,以及划分 CPU 以执行内务处理或运行工作负载。

注意

您可以手动创建 PerformanceProfile 对象,或使用 Performance Profile Creator (PPC) 生成性能配置集。有关 PPC 的更多信息,请参见以下的其他资源。

性能配置集示例

apiVersion: performance.openshift.io/v2
kind: PerformanceProfile
metadata:
 name: performance
spec:
 cpu:
  isolated: "5-15" 1
  reserved: "0-4" 2
 hugepages:
  defaultHugepagesSize: "1G"
  pages:
  - size: "1G"
    count: 16
    node: 0
 realTimeKernel:
  enabled: true  3
 numa:  4
  topologyPolicy: "best-effort"
 nodeSelector:
  node-role.kubernetes.io/worker-cnf: "" 5

1
使用此字段隔离要用于工作负载的应用容器的特定 CPU。
2
使用此字段保留要用于 infra 容器进行内务的特定 CPU。
3
使用此字段在节点上安装实时内核。有效值为 true 或者 false。设置 true 值将安装实时内核。
4
使用此字段配置拓扑管理器策略。有效值为 none (默认)、best-effortrestrictedsingle-numa-node。如需更多信息,请参阅拓扑管理器策略
5
使用此字段指定节点选择器,将性能配置集应用到特定的节点。

其他资源

有关使用 Performance Profile Creator (PPC) 生成性能配置集的详情,请参考创建性能配置集

16.5.1. 配置巨页

节点必须预先分配在 OpenShift Container Platform 集群中使用的巨页。使用 Performance Addon Operator 在指定节点上分配巨页。

OpenShift Container Platform 提供了创建和分配巨页的方法。Performance Addon Operator 提供了一种更易于使用性能配置集的方法。

例如,在性能配置集的 hugepages pages 部分,您可以指定多个块的 sizecount 以及可选的 node:

hugepages:
   defaultHugepagesSize: "1G"
   pages:
   - size:  "1G"
     count:  4
     node:  0 1
1
node 是分配巨页的 NUMA 节点。如果省略了 node,该页面将平均分布在所有 NUMA 节点中。
注意

等待显示更新已完成的相关机器配置池状态。

这些是分配巨页的唯一配置步骤。

验证

  • 要验证配置,请查看节点上的 /proc/meminfo 文件:

    $ oc debug node/ip-10-0-141-105.ec2.internal
    # grep -i huge /proc/meminfo

    输出示例

    AnonHugePages:    ###### ##
    ShmemHugePages:        0 kB
    HugePages_Total:       2
    HugePages_Free:        2
    HugePages_Rsvd:        0
    HugePages_Surp:        0
    Hugepagesize:       #### ##
    Hugetlb:            #### ##

  • 使用 oc describe 报告新大小:

    $ oc describe node worker-0.ocp4poc.example.com | grep -i huge

    输出示例

                                       hugepages-1g=true
     hugepages-###:  ###
     hugepages-###:  ###

16.5.2. 分配多个巨页大小

您可以在同一容器下请求具有不同大小的巨页。这样,您可以定义由具有不同巨页大小的容器组成的更复杂的 pod。

例如,您可以把大小定义为 1G2M,Performance Addon Operator 会在节点上配置这两个大小,如下所示:

spec:
  hugepages:
    defaultHugepagesSize: 1G
    pages:
    - count: 1024
      node: 0
      size: 2M
    - count: 4
      node: 1
      size: 1G

16.5.3. 为 infra 和应用程序容器限制 CPU

通用内务处理和工作负载任务使用 CPU 的方式可能会影响对延迟敏感的进程。默认情况下,容器运行时使用所有在线 CPU 一起运行所有容器,这可能导致上下文切换和延迟激增。对 CPU 进行分区可防止无状态进程通过相互分离来干扰对延迟敏感的进程。下表描述了在使用 Performance Add-On Operator 调整节点后在 CPU 上运行的进程:

表 16.1. 进程的 CPU 分配

进程类型详情

Burstable 和 best-effort pod

在除了运行低延迟工作负载外的任意 CPU 上运行

基础架构 pod

在除了运行低延迟工作负载外的任意 CPU 上运行

中断

重定向到保留的 CPU(OpenShift Container Platform 4.9 及更新的版本中可选)

内核进程

固定保留的 CPU

对延迟敏感的工作负载 pod

固定到隔离池中的特定专用 CPU

OS 进程/systemd 服务

固定保留的 CPU

使用的确切分区模式取决于许多因素,如硬件、工作负载特性和预期的系统负载。以下是一些用例示例:

  • 如果对延迟敏感的工作负载使用特定的硬件,如网络接口控制器(NIC),请确保隔离池中的 CPU 尽可能地与这个硬件接近。至少,您应该将工作负载放在同一个非统一内存访问 (NUMA) 节点中。
  • 保留的池用于处理所有中断。根据系统网络,分配一个足够大小的保留池来处理所有传入的数据包中断。在 4.9 及更新的版本中,可以选择性地将工作负载标记为敏感。

在决定哪些特定 CPU 用于保留和隔离分区时,需要详细分析和测量。设备和内存的 NUMA 紧密度等因素扮演了角色。选择也取决于工作负载架构和具体的用例。

重要

保留和隔离的 CPU 池不得重叠,并且必须一起跨越 worker 节点中的所有可用内核。

为确保内务处理任务和工作负载不会相互干扰,请在性能配置集的 spec 部分指定两组 CPU。

  • isolated - 指定应用程序容器工作负载的 CPU。这些 CPU 的延迟最低。这个组中的进程没有中断,例如,可以达到更高的 DPDK 零数据包丢失带宽。
  • reserved - 为集群和操作系统日常任务指定 CPU。reserved 组中的线程经常会比较繁忙。不要在 reserved 组中运行对延迟敏感的应用程序。对延迟敏感的应用程序在 isolated 组中运行。

流程

  1. 创建适合环境硬件和拓扑的性能配置集。
  2. 使用您想要为 infra 和应用程序容器保留和隔离的 CPU 添加 reservedisolated 参数:

    apiVersion: performance.openshift.io/v2
    kind: PerformanceProfile
    metadata:
      name: infra-cpus
    spec:
      cpu:
        reserved: "0-4,9" 1
        isolated: "5-8" 2
      nodeSelector: 3
        node-role.kubernetes.io/worker: ""
    1
    指定 infra 容器用于执行集群和操作系统日常任务的 CPU。
    2
    指定应用程序容器运行工作负载的 CPU。
    3
    可选:指定一个节点选择器,以将性能配置集应用到特定的节点。

16.6. 使用 Performance Addon Operator 减少 NIC 队列

Performance Addon Operator 允许您通过配置性能配置集来调整每个网络设备的网络接口控制器 (NIC) 队列计数。设备网络队列允许在不同物理队列之间分布数据包,每个队列获得用于数据包处理的独立线程。

在实时或低延迟系统中,固定到隔离 CPU 的所有不必要的中断请求行(IRQ)必须移到保留或日常 CPU。

在部署需要系统、OpenShift Container Platform 网络或使用 Data Plane Development Kit(DPDK)工作负载的混合部署中,需要多个队列才能实现良好的吞吐量,并且 NIC 队列的数量应该会调整或保持不变。例如,为了实现低延迟,应该将基于 DPDK 的工作负载的 NIC 队列数量减少到仅保留或日常 CPU 的数量。

默认情况下,每个 CPU 会创建太多的队列,在为低延迟调优时,这些队列不适用于托管 CPU 的中断表中。减少队列数量可以进行正确的调优。数量较小的队列意味着在 IRQ 表中包括较少数量的中断。

16.6.1. 使用性能配置集调整 NIC 队列

通过性能配置集,您可以调整每个网络设备的队列计数。

支持的网络设备:

  • 非虚拟网络设备
  • 支持多个队列的网络设备(通道)

不支持的网络设备:

  • 纯软件网络接口
  • 块设备
  • Intel DPDK 虚拟功能

先决条件

  • 使用具有 cluster-admin 角色的用户访问集群。
  • 安装 OpenShift CLI(oc)。

流程

  1. 以具有 cluster-admin 权限的用户身份登录运行 Performance Addon Operator 的 OpenShift Container Platform 集群。
  2. 创建并应用适合您的硬件和拓扑的性能配置集。有关创建配置集的指南,请参阅"创建性能配置集"部分。
  3. 编辑这个创建的性能配置集:

    $ oc edit -f <your_profile_name>.yaml
  4. 使用 net 对象填充 spec 字段。对象列表可以包含两个字段:

    • userLevelNetworking 是一个必需字段,指定为布尔值标记。如果 userLevelNetworkingtrue,则队列数将设置为所有支持设备的保留 CPU 计数。默认值为 false
    • devices 是一个可选字段,指定队列设置为保留 CPU 数的设备列表。如果设备列表为空,则配置适用于所有网络设备。配置如下:

      • interfaceName:此字段指定接口名称,并支持 shell 样式的通配符,可以是正数或负数。

        • 通配符语法示例如下: <string> .*
        • 负规则的前缀为感叹号。要将网络队列更改应用到排除列表以外的所有设备,请使用 !<device>。例如 !eno1
      • vendorID:网络设备供应商 ID,以带有 0x 前缀的 16 位十六进制数字代表。
      • deviceID:网络设备 ID(model),以带有 0x 前缀的 16 位十六进制数字代表。

        注意

        当指定 deviceID 时,还必须定义 vendorID。与设备条目 interfaceNamevendorIDvendorIDdeviceID 中指定的所有设备标识符相匹配的设备会被视为一个网络设备。然后,此网络设备的 net 队列数设置为保留的 CPU 计数。

        当指定了两个或多个设备时,网络队列数将设置为与其中一个设备匹配的任何网络设备。

  5. 使用此示例性能配置集将所有设备的队列数设置为保留的 CPU 计数:

    apiVersion: performance.openshift.io/v2
    kind: PerformanceProfile
    metadata:
      name: manual
    spec:
      cpu:
        isolated: 3-51,54-103
        reserved: 0-2,52-54
      net:
        userLevelNetworking: true
      nodeSelector:
        node-role.kubernetes.io/worker-cnf: ""
  6. 使用这个示例性能配置集,将所有与任何定义的设备标识符匹配的保留 CPU 数设置为保留的 CPU 计数:

    apiVersion: performance.openshift.io/v2
    kind: PerformanceProfile
    metadata:
      name: manual
    spec:
      cpu:
        isolated: 3-51,54-103
        reserved: 0-2,52-54
      net:
        userLevelNetworking: true
        devices:
        - interfaceName: “eth0”
        - interfaceName: “eth1”
        - vendorID: “0x1af4”
        deviceID: “0x1000”
      nodeSelector:
        node-role.kubernetes.io/worker-cnf: ""
  7. 使用这个示例性能配置集,将所有以接口名称 eth 开头的设备的队列数设置为保留的 CPU 计数:

    apiVersion: performance.openshift.io/v2
    kind: PerformanceProfile
    metadata:
      name: manual
    spec:
      cpu:
        isolated: 3-51,54-103
        reserved: 0-2,52-54
      net:
        userLevelNetworking: true
        devices:
        - interfaceName: “eth*”
      nodeSelector:
        node-role.kubernetes.io/worker-cnf: ""
  8. 使用这个示例性能配置集。将所有设备的队列数设置为保留的 CPU 计数,该接口具有 eno1 以外的任何接口:

    apiVersion: performance.openshift.io/v2
    kind: PerformanceProfile
    metadata:
      name: manual
    spec:
      cpu:
        isolated: 3-51,54-103
        reserved: 0-2,52-54
      net:
        userLevelNetworking: true
        devices:
        - interfaceName: “!eno1”
      nodeSelector:
        node-role.kubernetes.io/worker-cnf: ""
  9. 使用这个示例性能配置集,将所有具有接口名称 eth0vendorID0x1af4deviceID0x1000 的设备的队列数设置为保留 CPU 数:

    apiVersion: performance.openshift.io/v2
    kind: PerformanceProfile
    metadata:
      name: manual
    spec:
      cpu:
        isolated: 3-51,54-103
        reserved: 0-2,52-54
      net:
        userLevelNetworking: true
        devices:
        - interfaceName: “eth0”
          vendorID: “0x1af4”
          deviceID: “0x1000”
      nodeSelector:
        node-role.kubernetes.io/worker-cnf: ""
  10. 应用更新的性能配置集:

    $ oc apply -f <your_profile_name>.yaml

16.6.2. 验证队列状态

在这一部分中,一些示例演示了不同的性能配置集以及如何验证是否应用了更改。

示例 1

在本例中,网络队列数为所有支持的设备设置为保留 CPU 数(2)。

性能配置集中的相关部分是:

apiVersion: performance.openshift.io/v2
metadata:
  name: performance
spec:
  kind: PerformanceProfile
  spec:
    cpu:
      reserved: 0-1  #total = 2
      isolated: 2-8
    net:
      userLevelNetworking: true
# ...
  • 使用以下命令显示与设备关联的队列状态:

    注意

    在应用了性能配置集的节点中运行这个命令。

    $ ethtool -l <device>
  • 在应用配置集前验证队列状态:

    $ ethtool -l ens4

    输出示例

    Channel parameters for ens4:
    Pre-set maximums:
    RX:         0
    TX:         0
    Other:      0
    Combined:   4
    Current hardware settings:
    RX:         0
    TX:         0
    Other:      0
    Combined:   4

  • 应用配置集后验证队列状态:

    $ ethtool -l ens4

    输出示例

    Channel parameters for ens4:
    Pre-set maximums:
    RX:         0
    TX:         0
    Other:      0
    Combined:   4
    Current hardware settings:
    RX:         0
    TX:         0
    Other:      0
    Combined:   2 1

1
该组合通道显示为所有支持的设备保留 CPU 的总数为 2。这与性能配置集中配置的内容匹配。

示例 2

在本例中,针对具有特定 vendorID所有受支持的网络设备,网络队列数设置为保留 CPU 数(2)。

性能配置集中的相关部分是:

apiVersion: performance.openshift.io/v2
metadata:
  name: performance
spec:
  kind: PerformanceProfile
  spec:
    cpu:
      reserved: 0-1  #total = 2
      isolated: 2-8
    net:
      userLevelNetworking: true
      devices:
      - vendorID = 0x1af4
# ...
  • 使用以下命令显示与设备关联的队列状态:

    注意

    在应用了性能配置集的节点中运行这个命令。

    $ ethtool -l <device>
  • 应用配置集后验证队列状态:

    $ ethtool -l ens4

    输出示例

    Channel parameters for ens4:
    Pre-set maximums:
    RX:         0
    TX:         0
    Other:      0
    Combined:   4
    Current hardware settings:
    RX:         0
    TX:         0
    Other:      0
    Combined:   2 1

1
带有 vendorID=0x1af4 的所有支持设备的预留 CPU 总数为 2。例如,如果存在另一个网络设备 ens2,其 vendorID=0x1af4 也具有总计的网络队列为 2。这与性能配置集中配置的内容匹配。

示例 3

在本例中,针对与任何定义的设备标识符匹配的所有受支持网络设备,网络队列数设置为保留 CPU 数(2)。

命令 udevadm info 提供了有关设备的详细报告。在这个示例中,设备是:

# udevadm info -p /sys/class/net/ens4
...
E: ID_MODEL_ID=0x1000
E: ID_VENDOR_ID=0x1af4
E: INTERFACE=ens4
...
# udevadm info -p /sys/class/net/eth0
...
E: ID_MODEL_ID=0x1002
E: ID_VENDOR_ID=0x1001
E: INTERFACE=eth0
...
  • 对于 interfaceName 等于 eth0 的设备,以及具有 vendorID=0x1af4 的设备,并使用以下性能配置集,将网络队列设置为 2:

    apiVersion: performance.openshift.io/v2
    metadata:
      name: performance
    spec:
      kind: PerformanceProfile
        spec:
          cpu:
            reserved: 0-1  #total = 2
            isolated: 2-8
          net:
            userLevelNetworking: true
            devices:
            - interfaceName = eth0
            - vendorID = 0x1af4
    ...
  • 应用配置集后验证队列状态:

    $ ethtool -l ens4

    输出示例

    Channel parameters for ens4:
    Pre-set maximums:
    RX:         0
    TX:         0
    Other:      0
    Combined:   4
    Current hardware settings:
    RX:         0
    TX:         0
    Other:      0
    Combined:   2 1

    1
    带有 vendorID=0x1af4 的所有支持设备的预留 CPU 总数设置为 2。例如,如果存在另一个带有 vendorID=0x1af4 的网络设备 ens2,则其总子网队列也将设置为 2。类似地,interfaceName 等于 eth0 的设备会将总网络队列设置为 2。

16.6.3. 与调整 NIC 队列关联的日志记录

详细说明所分配设备的日志消息记录在相应的 Tuned 守护进程日志中。以下信息可能会记录到 /var/log/tuned/tuned.log 文件中:

  • 记录了一个 INFO 信息,详细描述了成功分配的设备:

    INFO tuned.plugins.base: instance net_test (net): assigning devices ens1, ens2, ens3
  • 如果无法分配任何设备,则会记录 WARNING 信息:

    WARNING  tuned.plugins.base: instance net_test: no matching devices available

16.7. 为平台验证进行端到端测试

Cloud-native Network Function (CNF)测试镜像是一个容器化测试套件,用于验证运行 CNF 有效负载所需的功能。您可以使用此镜像验证启用了 CNF 的 OpenShift 集群,其中安装了运行 CNF 工作负载所需的所有组件。

由镜像运行的测试被分为三个不同的阶段:

  • 简单集群验证
  • 设置
  • 端到端测试

验证阶段检查集群中是否正确部署了所有需要测试的功能。

验证包括:

  • 划分属于要测试的机器的机器配置池
  • 在节点上启用 SCTP
  • 通过机器配置启用 xt_u32 内核模块
  • 安装了 Performance Addon Operator
  • 安装了 SR-IOV Operator
  • 安装了 PTP Operator
  • 通过机器配置启用 contain-mount-namespace 模式
  • 使用 OVN-kubernetes 作为集群网络供应商

延迟测试(CNF-test 容器的一部分)也需要相同的验证。有关运行延迟测试的更多信息,请参阅运行延迟测试部分。

每次执行测试时都会执行环境配置。这包括创建 SR-IOV 节点策略、性能配置集或 PTP 配置集等项目。允许测试对已进行了配置的集群进行配置可能会影响集群的功能。另外,对配置项目(如 SR-IOV 节点策略)的更改可能会导致环境临时不可用,直到处理配置更改为止。

16.7.1. 先决条件

  • 测试入口点是 /usr/bin/test-run.sh。它运行设置测试集和真实的符合度测试套件。最低要求是为其提供 kubeconfig 文件及其相关的 $KUBECONFIG 环境变量,并挂载在一个卷中。
  • 测试假设集群中已存在指定功能(以 Operator 的方式)、在集群或机器配置中启用了相关的标记。
  • 有些测试需要已存在的机器配置池将其更改附加到其中。这必须在运行测试前在集群中创建。

    默认 worker 池为 worker-cnf,可使用以下清单创建:

    apiVersion: machineconfiguration.openshift.io/v1
    kind: MachineConfigPool
    metadata:
      name: worker-cnf
      labels:
        machineconfiguration.openshift.io/role: worker-cnf
    spec:
      machineConfigSelector:
        matchExpressions:
          - {
              key: machineconfiguration.openshift.io/role,
              operator: In,
              values: [worker-cnf, worker],
            }
      paused: false
      nodeSelector:
        matchLabels:
          node-role.kubernetes.io/worker-cnf: ""

    您可以使用 ROLE_WORKER_CNF 变量覆盖 worker 池名称:

    $ docker run -v $(pwd)/:/kubeconfig -e KUBECONFIG=/kubeconfig/kubeconfig -e
    ROLE_WORKER_CNF=custom-worker-pool registry.redhat.io/openshift4/cnf-tests-rhel8:v4.9 /usr/bin/test-run.sh
    注意

    目前,不是所有测试都选择性地在属于该池的节点中运行。

16.7.2. 空运行

使用此命令以空运行模式运行。这可用于检查测试套件中的内容,并为镜像将要运行的所有测试提供输出。

$ docker run -v $(pwd)/:/kubeconfig -e KUBECONFIG=/kubeconfig/kubeconfig registry.redhat.io/openshift4/cnf-tests-rhel8:v4.9 /usr/bin/test-run.sh -ginkgo.dryRun -ginkgo.v

16.7.3. 断开连接的模式

CNF 测试镜像支持在断开连接的集群中运行测试,这意味着无法访问外部 registry。这分为两个步骤:

  1. 执行镜像。
  2. 指示测试以使用来自自定义 registry 的镜像。

16.7.3.1. 将镜像镜像(mirror)到集群可访问的自定义 registry

mirror 中提供了镜像可执行文件,以提供 oc 需要的输入来镜像运行测试到本地 registry 所需的镜像。

从可通过互联网访问集群和 registry.redhat.io 的中间机器运行这个命令:

$ docker run -v $(pwd)/:/kubeconfig -e KUBECONFIG=/kubeconfig/kubeconfig registry.redhat.io/openshift4/cnf-tests-rhel8:v4.9 /usr/bin/mirror -registry my.local.registry:5000/ |  oc image mirror -f -

然后,按照以下部分中有关覆盖用于获取镜像的 registry 的说明进行操作。

16.7.3.2. 指示测试使用来自自定义 registry 中的镜像

这可以通过设置 IMAGE_REGISTRY 环境变量完成:

$ docker run -v $(pwd)/:/kubeconfig -e KUBECONFIG=/kubeconfig/kubeconfig -e IMAGE_REGISTRY="my.local.registry:5000/" -e CNF_TESTS_IMAGE="custom-cnf-tests-image:latests" registry.redhat.io/openshift4/cnf-tests-rhel8:v4.9 /usr/bin/test-run.sh

16.7.3.3. 镜像到集群内部 registry

OpenShift Container Platform 提供了一个内建的容器镜像 registry,它作为一个标准的工作负载在集群中运行。

流程

  1. 通过使用路由公开到 registry 的外部访问权限:

    $ oc patch configs.imageregistry.operator.openshift.io/cluster --patch '{"spec":{"defaultRoute":true}}' --type=merge
  2. 获取 registry 端点:

    REGISTRY=$(oc get route default-route -n openshift-image-registry --template='{{ .spec.host }}')
  3. 创建用于公开镜像的命名空间:

    $ oc create ns cnftests
  4. 将该镜像流供用于测试的所有命名空间使用。这需要允许 test 命名空间从 cnftests 镜像流中获取镜像。

    $ oc policy add-role-to-user system:image-puller system:serviceaccount:sctptest:default --namespace=cnftests
    $ oc policy add-role-to-user system:image-puller system:serviceaccount:cnf-features-testing:default --namespace=cnftests
    $ oc policy add-role-to-user system:image-puller system:serviceaccount:performance-addon-operators-testing:default --namespace=cnftests
    $ oc policy add-role-to-user system:image-puller system:serviceaccount:dpdk-testing:default --namespace=cnftests
    $ oc policy add-role-to-user system:image-puller system:serviceaccount:sriov-conformance-testing:default --namespace=cnftests
    $ oc policy add-role-to-user system:image-puller system:serviceaccount:xt-u32-testing:default --namespace=cnftests
    $ oc policy add-role-to-user system:image-puller system:serviceaccount:vrf-testing:default --namespace=cnftests
    $ oc policy add-role-to-user system:image-puller system:serviceaccount:gatekeeper-testing:default --namespace=cnftests
    $ oc policy add-role-to-user system:image-puller system:serviceaccount:ovs-qos-testing:default --namespace=cnftests
  5. 检索 docker secret 名称和 auth 令牌:

    SECRET=$(oc -n cnftests get secret | grep builder-docker | awk {'print $1'}
    TOKEN=$(oc -n cnftests get secret $SECRET -o jsonpath="{.data['\.dockercfg']}" | base64 --decode | jq '.["image-registry.openshift-image-registry.svc:5000"].auth')
  6. 编写类似如下的 dockerauth.json:

    echo "{\"auths\": { \"$REGISTRY\": { \"auth\": $TOKEN } }}" > dockerauth.json
  7. 进行镜像:

    $ docker run -v $(pwd)/:/kubeconfig -e KUBECONFIG=/kubeconfig/kubeconfig registry.redhat.io/openshift4/cnf-tests-rhel8:v4.9 /usr/bin/mirror -registry $REGISTRY/cnftests |  oc image mirror --insecure=true -a=$(pwd)/dockerauth.json -f -
  8. 运行测试:

    $ docker run -v $(pwd)/:/kubeconfig -e KUBECONFIG=/kubeconfig/kubeconfig -e IMAGE_REGISTRY=image-registry.openshift-image-registry.svc:5000/cnftests cnf-tests-local:latest /usr/bin/test-run.sh

16.7.3.4. 对不同的镜像集进行镜像(mirror)

流程

  1. mirror 命令会默认尝试镜像 u/s 镜像。这可以通过向镜像传递带有以下格式的文件来覆盖:

    [
        {
            "registry": "public.registry.io:5000",
            "image": "imageforcnftests:4.9"
        },
        {
            "registry": "public.registry.io:5000",
            "image": "imagefordpdk:4.9"
        }
    ]
  2. 把它传递给 mirror 命令,例如将其在本地保存为 images.json。使用以下命令,本地路径挂载到容器内的 /kubeconfig 中,并可传递给 mirror 命令。

    $ docker run -v $(pwd)/:/kubeconfig -e KUBECONFIG=/kubeconfig/kubeconfig registry.redhat.io/openshift4/cnf-tests-rhel8:v4.9 /usr/bin/mirror --registry "my.local.registry:5000/" --images "/kubeconfig/images.json" |  oc image mirror -f -

16.7.4. 在单一节点集群中运行

在单一节点集群中运行测试会导致以下限制:

  • 某些测试的超时时间较长,包括 SR-IOV 和 SCTP 测试
  • 跳过需要 master 和 worker 节点的测试

超时时间较长,可能会影响到 SR-IOV 和 SCTP 测试。需要节点重启的重新配置会导致重启整个环境,包括 OpenShift control plane,因此完成时间较长。所有需要 master 和 worker 节点的 PTP 测试都会被跳过。不需要额外的配置,因为测试会在启动时检查节点数量并相应地调整测试行为。

PTP 测试可在发现模式下运行。测试查找在集群外配置的 PTP master。

如需更多信息,请参阅发现模式部分。

要启用发现模式,必须如下设置 DISCOVERY_MODE 环境变量来指示测试:

$ docker run -v $(pwd)/:/kubeconfig:Z -e KUBECONFIG=/kubeconfig/kubeconfig -e
DISCOVERY_MODE=true registry.redhat.io/openshift-kni/cnf-tests /usr/bin/test-run.sh
所需的参数
  • ROLE_WORKER_CNF=master - 必需的,因为 master 是唯一要属于该节点的机器池。
  • XT_U32TEST_HAS_NON_CNF_WORKERS=false - 需要指示 xt_u32 负测试跳过,因为只有加载模块的节点。
  • SCTPTEST_HAS_NON_CNF_WORKERS=false - 需要指示 SCTP 负测试跳过,因为只有加载模块的节点。

16.7.5. 测试对集群的影响

根据功能,运行测试套件可能会对集群造成不同影响。通常,只有 SCTP 测试不会更改集群配置。所有其他特性对配置都会有不同影响。

16.7.5.1. SCTP

SCTP 测试只在不同的节点上运行不同的 pod 以检查是否可以连接性。集群上的影响与在两个节点上运行简单的 pod 相关。

16.7.5.2. XT_U32

XT_U32 测试在不同节点上运行 pod 来检查使用 xt_u32 的 iptables 规则。集群上的影响与在两个节点上运行简单的 pod 相关。

16.7.5.3. SR-IOV

SR-IOV 测试需要更改 SR-IOV 网络配置,其中测试会创建并销毁不同类型的配置。

如果已在集群上安装了现有的 SR-IOV 网络配置,这可能会受到影响,因为可能存在冲突,这取决于这些配置的优先级。

同时,测试的结果可能受到现有配置的影响。

16.7.5.4. PTP

PTP 测试在集群的一组节点中应用 PTP 配置。和 SR-IOV 一样,这可能会与已经存在的任何 PTP 配置冲突,结果无法预计。

16.7.5.5. 性能

性能测试在集群中应用性能配置集。这样做的效果是更改节点配置、保留 CPU、分配内存大页面以及将内核软件包设置为实时。如果集群中已有名为 performance 的配置集,则测试不会部署它。

16.7.5.6. DPDK

DPDK 依赖于性能和 SR-IOV 功能,因此测试套件同时配置性能配置集和 SR-IOV 网络,因此影响与 SR-IOV 测试和性能测试中所述的影响相同。

16.7.5.7. container-mount-namespace

container-mount-namespace 模式的验证测试只检查是否存在适当的 MachineConfig 对象并激活,且不会对节点产生额外的影响。

16.7.5.8. 清理

运行测试套件后,,清理所有悬停的资源。

16.7.6. 覆盖测试镜像参数

根据具体要求,测试可以使用不同的镜像。测试使用两个镜像,可使用以下环境变量进行修改:

  • CNF_TESTS_IMAGE
  • DPDK_TESTS_IMAGE

例如,要更改 CNF_TESTS_IMAGE 使用自定义 registry,请运行以下命令:

$ docker run -v $(pwd)/:/kubeconfig -e KUBECONFIG=/kubeconfig/kubeconfig -e CNF_TESTS_IMAGE="custom-cnf-tests-image:latests" registry.redhat.io/openshift4/cnf-tests-rhel8:v4.9 /usr/bin/test-run.sh

16.7.6.1. Ginkgo 参数

测试套件基于 ginkgo BDD 框架。这意味着,它接受可以用于过滤或跳过测试的参数。

您可以使用 -ginkgo.focus 参数来过滤一组测试:

$ docker run -v $(pwd)/:/kubeconfig -e KUBECONFIG=/kubeconfig/kubeconfig registry.redhat.io/openshift4/cnf-tests-rhel8:v4.9 /usr/bin/test-run.sh -ginkgo.focus="performance|sctp"

您只能使用 -ginkgo.focus 参数运行延迟测试。

要只运行延迟测试,您必须提供 -ginkgo.focus 参数以及包含需要测试的性能配置集名称的 PERF_TEST_PROFILE 环境变量。例如:

$ docker run --rm -v $KUBECONFIG:/kubeconfig -e KUBECONFIG=/kubeconfig -e LATENCY_TEST_RUN=true -e LATENCY_TEST_RUNTIME=600 -e OSLAT_MAXIMUM_LATENCY=20 -e PERF_TEST_PROFILE=<performance_profile_name> registry.redhat.io/openshift4/cnf-tests-rhel8:v4.9 /usr/bin/test-run.sh -ginkgo.focus="\[performance\]\[config\]|\[performance\]\ Latency\ Test"
注意

有一个特定的测试需要 SR-IOV 和 SCTP。由于 focus 参数的选择性,这个测试会被仅放置 sriov 匹配器来触发。如果测试是针对安装了 SR-IOV 但不安装 SCTP 的集群执行,添加 -ginkgo.skip=SCTP 参数会导致测试跳过 SCTP 测试。

16.7.6.2. 可用功能

要过滤的可用功能集包括:

  • performance
  • sriov
  • ptp
  • sctp
  • xt_u32
  • dpdk
  • container-mount-namespace

16.7.7. 发现模式

发现模式允许您在不更改其配置的情况下,验证集群的功能。在测试时使用现有环境配置。测试会尝试查找所需的配置项目,并使用这些项目来执行测试。如果没有找到运行特定测试所需的资源,则会跳过测试,为用户提供正确的信息。测试完成后,不会清理预配置的配置项目,测试环境可立即用于另一个测试运行。

某些配置项目仍由测试创建。这些是运行测试所需的特定项,例如 SR-IOV 网络。这些配置项目会在自定义命名空间中创建,并在执行测试后进行清理。

一个额外的好处是可以减少测试运行时间。因为已经有配置项目,因此不需要时间进行环境配置和分配。

要启用发现模式,必须如下设置 DISCOVERY_MODE 环境变量来指示测试:

$ docker run -v $(pwd)/:/kubeconfig:Z -e KUBECONFIG=/kubeconfig/kubeconfig -e
DISCOVERY_MODE=true registry.redhat.io/openshift-kni/cnf-tests /usr/bin/test-run.sh

16.7.7.1. 所需的环境配置先决条件

SR-IOV 测试

大多数 SR-IOV 测试需要以下资源:

  • SriovNetworkNodePolicy.
  • 至少有一个资源由 SriovNetworkNodePolicy 指定的资源为可分配的资源 ; 至少 5 个资源数才被视为足够。

有些测试有额外的要求:

  • 节点上有可用策略资源的未使用设备,其链接状态为 DOWN,而不是桥接 slave。
  • 一个 SriovNetworkNodePolicy,其 MTU 值为 9000

DPDK 测试

与 DPDK 相关的测试需要:

  • 一个性能配置集。
  • 一个 SR-IOV 策略。
  • 具有可用于 SR-IOV 策略的资源的节点,并使用 PerformanceProfile 节点选择器。

PTP 测试

  • 一个从 PtpConfigptp4lOpts="-s" ,phc2sysOpts="-a -r")。
  • 具有与 slave PtpConfig 匹配标签的节点。

SCTP 测试

  • SriovNetworkNodePolicy.
  • SriovNetworkNodePolicy 和启用 SCTP 的 MachineConfig 匹配的节点。

XT_U32 测试

  • 具有启用 XT_U32 机器配置的节点。

Performance Operator 测试

不同的测试有不同的要求。其中一些是:

  • 一个性能配置集。
  • 带有 profile.Spec.CPU.Isolated = 1 的性能配置集。
  • 带有 profile.Spec.RealTimeKernel.Enabled == true 的性能配置集。
  • 没有使用巨页的节点。

container-mount-namespace 测试

  • 具有启用 container-mount-namespace 模式的机器配置节点

16.7.7.2. 限制测试过程中使用的节点

通过指定 NODES_SELECTOR 环境变量来限制执行测试的节点。然后,测试创建的任何资源都仅限于指定的节点。

$ docker run -v $(pwd)/:/kubeconfig:Z -e KUBECONFIG=/kubeconfig/kubeconfig -e
NODES_SELECTOR=node-role.kubernetes.io/worker-cnf registry.redhat.io/openshift-kni/cnf-tests /usr/bin/test-run.sh

16.7.7.3. 使用单个性能配置集

DPDK 测试所需的资源高于性能测试套件所需的资源。为加快执行速度,可使用提供 DPDK 测试套件的测试使用的性能配置集覆盖。

要做到这一点,类似以下内容的配置集可以挂载到容器中,并可指示性能测试来部署它。

apiVersion: performance.openshift.io/v2
kind: PerformanceProfile
metadata:
  name: performance
spec:
  cpu:
    isolated: "4-15"
    reserved: "0-3"
  hugepages:
    defaultHugepagesSize: "1G"
    pages:
    - size: "1G"
      count: 16
      node: 0
  realTimeKernel:
    enabled: true
  nodeSelector:
    node-role.kubernetes.io/worker-cnf: ""
注意

当您配置保留的和隔离的 CPU 时,pod 中的 infra 容器将使用保留的 CPU,应用程序容器则使用隔离的 CPU。

要覆盖所使用的性能配置集,清单必须挂载到容器中,且必须通过设置 PERFORMANCE_PROFILE_MANIFEST_OVERRIDE 参数来指示测试:

$ docker run -v $(pwd)/:/kubeconfig:Z -e KUBECONFIG=/kubeconfig/kubeconfig -e
PERFORMANCE_PROFILE_MANIFEST_OVERRIDE=/kubeconfig/manifest.yaml registry.redhat.io/openshift-kni/cnf-tests /usr/bin/test-run.sh

16.7.7.4. 禁用性能配置集清理

如果没有在发现模式中运行,该套件会清理所有生成的工件和配置。这包括性能配置集。

删除性能配置集时,机器配置池会被修改并重启节点。在进行了新的迭代后,会生成新的配置集。这会导致在不同测试运行间存在较长的测试周期。

要加快这个过程,设置 CLEAN_PERFORMANCE_PROFILE="false" 来指示测试不清理性能配置集。这样,下一个迭代将不需要创建并等待它被应用。

$ docker run -v $(pwd)/:/kubeconfig:Z -e KUBECONFIG=/kubeconfig/kubeconfig -e
CLEAN_PERFORMANCE_PROFILE="false" registry.redhat.io/openshift-kni/cnf-tests /usr/bin/test-run.sh

16.7.8. 运行延迟测试

假设 kubeconfig 文件位于当前目录中,运行测试套件的命令为:

$ docker run -v $(pwd)/:/kubeconfig -e KUBECONFIG=/kubeconfig/kubeconfig registry.redhat.io/openshift4/cnf-tests-rhel8:v4.9 /usr/bin/test-run.sh

您的 kubeconfig 文件可以从正在运行的容器内被消耗。

警告

您必须以 Discovery 模式运行延迟测试。如果没有以 Discovery 模式运行,延迟测试可以更改集群的配置。

在 OpenShift Container Platform 4.9 中,您还可以从 CNF-test 容器运行延迟测试。延迟测试允许验证节点调优是否足以满足您的工作负载要求。

三个工具用于测量系统的延迟:

  • hwlatdetect
  • cyclictest
  • oslat

每个工具都有特定的用途。按顺序使用工具来获取可靠的测试结果。

  1. hwlatdetect 工具测量裸机硬件能够达到的基准。在继续下一个延迟测试前,请确保测量 hwlatdetect 的数量满足所需的阈值,因为操作系统调优无法修复硬件延迟激增。
  2. cyclictest 工具在 hwlatdetect 通过验证后验证记时器的延迟。cyclictest 工具调度重复的计时器,并测量所需与实际触发时间之间的差别。这种差别可以发现与中断或进程优先级导致的调优相关的基本问题。
  3. oslat 工具的行为与 CPU 密集型 DPDK 应用程序相似,并测量对模拟 CPU 重度数据处理的繁忙循环的所有中断。

默认情况下禁用延迟测试。要启用延迟测试,您必须将 LATENCY_TEST_RUN 环境变量添加到测试调用中,并将其值设为 true。例如,LATENCY_TEST_RUN=true

测试引进了以下环境变量:

  • LATENCY_TEST_CPUS 变量指定运行延迟测试的 pod 使用的 CPU 数量。
  • LATENCY_TEST_RUNTIME 变量指定延迟测试必须运行的时间(以秒为单位)。
  • CYCLICTEST_MAXIMUM_LATENCY 变量指定在cyclictest 运行期间唤醒之前预期的所有线程的最大延迟。
  • HWLATDETECT_MAXIMUM_LATENCY 变量指定工作负载和操作系统可接受的最大硬件延迟。
  • OSLAT_MAXIMUM_LATENCY 变量指定 oslat 测试结果可接受的最大延迟。
  • MAXIMUM_LATENCY 是您可以适用于所有测试的统一变量。
注意

特定于特定测试的变量优先于统一变量。

您可以使用 ginkgo.focus 标志来运行特定的测试。

16.7.8.1. 运行 hwlatdetect

要执行 hwlatdetect,请运行以下命令:

$ docker run -v $(pwd)/:/kubeconfig -e KUBECONFIG=/kubeconfig/kubeconfig -e LATENCY_TEST_RUN=true -e DISCOVERY_MODE=true -e ROLE_WORKER_CNF=worker-cnf -e LATENCY_TEST_RUNTIME=600 -e MAXIMUM_LATENCY=20  registry.redhat.io/openshift4/cnf-tests-rhel8:v4.9 /usr/bin/test-run.sh -ginko.focus=”hwladetect”

以上命令会运行 hwlatdetect 工具 10 分钟(600 秒)。当观察到的最大延迟低于 MAXIMUM_LATENCY (20 μs) 时,测试可以成功运行,命令行则显示 SUCCESS!

失败输出示例

$ docker run -v $KUBECONFIG:/root/kubeconfig:Z -e KUBECONFIG=/root/kubeconfig -e PERF_TEST_PROFILE=performance -e ROLE_WORKER_CNF=worker-cnf -e LATENCY_TEST_RUN=true -e LATENCY_TEST_RUNTIME=40 -e MAXIMUM_LATENCY=1 -e LATENCY_TEST_CPUS=10 -e DISCOVERY_MODE=true quay.io/titzhak/cnf-tests:latest usr/bin/test-run.sh -ginkgo.focus="hwlatdetect" 1
running /usr/bin//validationsuite -ginkgo.focus=hwlatdetect
...
Discovery mode enabled, skipping setup
running /usr/bin//cnftests -ginkgo.focus=hwlatdetect
I0812 09:53:57.108148      19 request.go:668] Waited for 1.049207747s due to client-side throttling, not priority and fairness, request: GET:https://api.cnfdc8.t5g.lab.eng.bos.redhat.com:6443/apis/autoscaling/v1?timeout=32s
Running Suite: CNF Features e2e integration tests
=================================================
Random Seed: 1628762033
Will run 1 of 138 specs

SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS
------------------------------
• [SLOW TEST:26.144 seconds]
[performance] Latency Test
/go/src/github.com/openshift-kni/cnf-features-deploy/vendor/github.com/openshift-kni/performance-addon-operators/functests/4_latency/latency.go:84
  with the hwlatdetect image
  /go/src/github.com/openshift-kni/cnf-features-deploy/vendor/github.com/openshift-kni/performance-addon-operators/functests/4_latency/latency.go:224
    should succeed
    /go/src/github.com/openshift-kni/cnf-features-deploy/vendor/github.com/openshift-kni/performance-addon-operators/functests/4_latency/latency.go:232
------------------------------
SSSSSSSSSSSSSSSSSSSSSS

detector: tracer
   parameters:
        Latency threshold: 1us 2
        Sample window:     10000000us
        Sample width:      950000us
     Non-sampling period:  9050000us
        Output File:       None

Starting test
test finished
Max Latency: 35us 3
Samples recorded: 2
Samples exceeding threshold: 2
ts: 1628174377.074638224, inner:20, outer:35
ts: 1628174387.359881340, inner:21, outer:34
; err: exit status 1
goroutine 1 [running]:
k8s.io/klog.stacks(0xc000070200, 0xc000106400, 0x21b, 0x3c2)
	/remote-source/app/vendor/k8s.io/klog/klog.go:875 +0xb9
k8s.io/klog.(*loggingT).output(0x5bed00, 0xc000000003, 0xc00010a0e0, 0x53ea81, 0x7, 0x33, 0x0)
	/remote-source/app/vendor/k8s.io/klog/klog.go:826 +0x35f
k8s.io/klog.(*loggingT).printf(0x5bed00, 0x3, 0x5082da, 0x33, 0xc000113f58, 0x2, 0x2)
	/remote-source/app/vendor/k8s.io/klog/klog.go:707 +0x153
k8s.io/klog.Fatalf(...)
	/remote-source/app/vendor/k8s.io/klog/klog.go:1276
main.main()
	/remote-source/app/cnf-tests/pod-utils/hwlatdetect-runner/main.go:51 +0x897

1
用户提供的 docker 参数。
2
用户使用 MAX_LATENCYHWLATDETECT_MAX_LATENCY 环境变量配置的延迟阈值。
3
测试期间测量的最大延迟值。

16.7.8.2. 运行 cyclictest

要执行 cyclictest,请运行以下命令:

$ docker run -v $(pwd)/:/kubeconfig -e KUBECONFIG=/kubeconfig/kubeconfig -e LATENCY_TEST_RUN=true -e DISCOVERY_MODE=true -e ROLE_WORKER_CNF=worker-cnf -e LATENCY_TEST_CPUS=10 -e LATENCY_TEST_RUNTIME=600 -e MAXIMUM_LATENCY=20  registry.redhat.io/openshift4/cnf-tests-rhel8:v4.9 /usr/bin/test-run.sh -ginkgo.focus="cyclictest"

以上命令会运行 cyclictest 工具 10 分钟(600 秒)。当观察到的最大延迟低于 MAXIMUM_LATENCY (20 μs) 时,测试可以成功运行,命令行则显示 SUCCESS!

失败输出示例

$docker run -v $KUBECONFIG:/root/kubeconfig:Z -e KUBECONFIG=/root/kubeconfig -e PERF_TEST_PROFILE=performance -e ROLE_WORKER_CNF=worker-cnf -e LATENCY_TEST_RUN=true -e LATENCY_TEST_RUNTIME=600 -e MAXIMUM_LATENCY=20 -e LATENCY_TEST_CPUS=10 -e DISCOVERY_MODE=true quay.io/titzhak/cnf-tests:latest usr/bin/test-run.sh -ginkgo.v -ginkgo.focus="cyclictest" 1

Discovery mode enabled, skipping setup
running /usr/bin//cnftests -ginkgo.v -ginkgo.focus=cyclictest
I0811 15:02:36.350033      20 request.go:668] Waited for 1.049965918s due to client-side throttling, not priority and fairness, request: GET:https://api.cnfdc8.t5g.lab.eng.bos.redhat.com:6443/apis/machineconfiguration.openshift.io/v1?timeout=32s
Running Suite: CNF Features e2e integration tests
=================================================
Random Seed: 1628694153
Will run 1 of 138 specs

SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS
------------------------------
[performance] Latency Test with the cyclictest image
  should succeed
  /go/src/github.com/openshift-kni/cnf-features-deploy/vendor/github.com/openshift-kni/performance-addon-operators/functests/4_latency/latency.go:200
STEP: Waiting two minutes to download the latencyTest image
STEP: Waiting another two minutes to give enough time for the cluster to move the pod to Succeeded phase
Aug 11 15:03:06.826: [INFO]: found mcd machine-config-daemon-wf4w8 for node cnfdc8.clus2.t5g.lab.eng.bos.redhat.com

• Failure [22.527 seconds]
[performance] Latency Test
/go/src/github.com/openshift-kni/cnf-features-deploy/vendor/github.com/openshift-kni/performance-addon-operators/functests/4_latency/latency.go:84
  with the cyclictest image
  /go/src/github.com/openshift-kni/cnf-features-deploy/vendor/github.com/openshift-kni/performance-addon-operators/functests/4_latency/latency.go:188
    should succeed [It]
    /go/src/github.com/openshift-kni/cnf-features-deploy/vendor/github.com/openshift-kni/performance-addon-operators/functests/4_latency/latency.go:200

    The current latency 17 is bigger than the expected one 20 2
    Expected
        <bool>: false
    to be true

    /go/src/github.com/openshift-kni/cnf-features-deploy/vendor/github.com/openshift-kni/performance-addon-operators/functests/4_latency/latency.go:219

Log file created at: 2021/08/11 15:02:51
Running on machine: cyclictest-knk7d
Binary: Built with gc go1.16.6 for linux/amd64
Log line format: [IWEF]mmdd hh:mm:ss.uuuuuu threadid file:line] msg
I0811 15:02:51.092254       1 node.go:37] Environment information: /proc/cmdline: BOOT_IMAGE=(hd0,gpt3)/ostree/rhcos-612d89f4519a53ad0b1a132f4add78372661bfb3994f5fe115654971aa58a543/vmlinuz-4.18.0-305.10.2.rt7.83.el8_4.x86_64 ip=dhcp random.trust_cpu=on console=tty0 console=ttyS0,115200n8 ostree=/ostree/boot.1/rhcos/612d89f4519a53ad0b1a132f4add78372661bfb3994f5fe115654971aa58a543/0 ignition.platform.id=openstack root=UUID=5a4ddf16-9372-44d9-ac4e-3ee329e16ab3 rw rootflags=prjquota skew_tick=1 nohz=on rcu_nocbs=1-3 tuned.non_isolcpus=000000ff,ffffffff,ffffffff,fffffff1 intel_pstate=disable nosoftlockup tsc=nowatchdog intel_iommu=on iommu=pt isolcpus=managed_irq,1-3 systemd.cpu_affinity=0,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103 default_hugepagesz=1G hugepagesz=2M hugepages=128 nmi_watchdog=0 audit=0 mce=off processor.max_cstate=1 idle=poll intel_idle.max_cstate=0
I0811 15:02:51.092427       1 node.go:44] Environment information: kernel version 4.18.0-305.10.2.rt7.83.el8_4.x86_64
I0811 15:02:51.092450       1 main.go:48] running the cyclictest command with arguments [-D 600 -p 1 -t 10 -a 2,4,6,8,10,54,56,58,60,62 -h 30 -i 1000 --quiet] 3
I0811 15:03:06.147253       1 main.go:54] succeeded to run the cyclictest command: # /dev/cpu_dma_latency set to 0us
# Histogram
000000 000000	000000	000000	000000	000000	000000	000000	000000	000000	000000
000001 000000	005561	027778	037704	011987	000000	120755	238981	081847	300186
000002 587440	581106	564207	554323	577416	590635	474442	357940	513895	296033
000003 011751	011441	006449	006761	008409	007904	002893	002066	003349	003089
000004 000527	001079	000914	000712	001451	001120	000779	000283	000350	000251

More histogram entries ...
# Min Latencies: 00002 00001 00001 00001 00001 00002 00001 00001 00001 00001
# Avg Latencies: 00002 00002 00002 00001 00002 00002 00001 00001 00001 00001
# Max Latencies: 00018 00465 00361 00395 00208 00301 02052 00289 00327 00114 4
# Histogram Overflows: 00000 00220 00159 00128 00202 00017 00069 00059 00045 00120
# Histogram Overflow at cycle number:
# Thread 0:
# Thread 1: 01142 01439 05305 … # 00190 others
# Thread 2: 20895 21351 30624 … # 00129 others
# Thread 3: 01143 17921 18334 … # 00098 others
# Thread 4: 30499 30622 31566 ... # 00172 others
# Thread 5: 145221 170910 171888 ...
# Thread 6: 01684 26291 30623 ...# 00039 others
# Thread 7: 28983 92112 167011 … 00029 others
# Thread 8: 45766 56169 56171 ...# 00015 others
# Thread 9: 02974 08094 13214 ... # 00090 others

1
用户提供的 docker 参数。
2
系统会通知用户测量的延迟和配置延迟。
3
cyclictest 命令的参数。
4
每个线程上测量的最大延迟。

16.7.8.3. 运行 oslat

$ docker run -v $(pwd)/:/kubeconfig -e KUBECONFIG=/kubeconfig/kubeconfig -e LATENCY_TEST_RUN=true -e DISCOVERY_MODE=true -e ROLE_WORKER_CNF=worker-cnf -e LATENCY_TEST_CPUS=7 -e LATENCY_TEST_RUNTIME=600 -e MAXIMUM_LATENCY=20  registry.redhat.io/openshift4/cnf-tests-rhel8:v4.9 /usr/bin/test-run.sh -ginkgo.focus="oslat"

以上命令会运行 cyclictest 工具 10 分钟(600 秒)。当观察到的最大延迟低于 MAXIMUM_LATENCY (20 μs) 时,测试可以成功运行,命令行则显示 SUCCESS!

失败输出示例

$ docker run -v $KUBECONFIG:/root/kubeconfig:Z -e KUBECONFIG=/root/kubeconfig -e IMAGE_REGISTRY=quay.io/titzhak -e CNF_TESTS_IMAGE=cnf-tests:latest -e PERF_TEST_PROFILE=performance -e ROLE_WORKER_CNF=worker-cnf -e LATENCY_TEST_RUN=true -e LATENCY_TEST_RUNTIME=600 -e DISCOVERY_MODE=true -e MAXIMUM_LATENCY=20 -e LATENCY_TEST_CPUS=7 quay.io/titzhak/cnf-tests:latest usr/bin/test-run.sh -ginkgo.v -ginkgo.focus="oslat" 1

running /usr/bin//validationsuite -ginkgo.v -ginkgo.focus=oslat
I0829 12:36:55.386776       8 request.go:668] Waited for 1.000303471s due to client-side throttling, not priority and fairness, request: GET:https://api.cnfdc8.t5g.lab.eng.bos.redhat.com:6443/apis/authentication.k8s.io/v1?timeout=32s
Running Suite: CNF Features e2e validation
==========================================

Discovery mode enabled, skipping setup
running /usr/bin//cnftests -ginkgo.v -ginkgo.focus=oslat
I0829 12:37:01.219077      20 request.go:668] Waited for 1.050010755s due to client-side throttling, not priority and fairness, request: GET:https://api.cnfdc8.t5g.lab.eng.bos.redhat.com:6443/apis/snapshot.storage.k8s.io/v1beta1?timeout=32s
Running Suite: CNF Features e2e integration tests
=================================================
Random Seed: 1630240617
Will run 1 of 142 specs

SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS
------------------------------
[performance] Latency Test with the oslat image
  should succeed
  /go/src/github.com/openshift-kni/cnf-features-deploy/vendor/github.com/openshift-kni/performance-addon-operators/functests/4_latency/latency.go:134
STEP: Waiting two minutes to download the latencyTest image
STEP: Waiting another two minutes to give enough time for the cluster to move the pod to Succeeded phase
Aug 29 12:37:59.324: [INFO]: found mcd machine-config-daemon-wf4w8 for node cnfdc8.clus2.t5g.lab.eng.bos.redhat.com

• Failure [49.246 seconds]
[performance] Latency Test
/go/src/github.com/openshift-kni/cnf-features-deploy/vendor/github.com/openshift-kni/performance-addon-operators/functests/4_latency/latency.go:59
  with the oslat image
  /go/src/github.com/openshift-kni/cnf-features-deploy/vendor/github.com/openshift-kni/performance-addon-operators/functests/4_latency/latency.go:112
    should succeed [It]
    /go/src/github.com/openshift-kni/cnf-features-deploy/vendor/github.com/openshift-kni/performance-addon-operators/functests/4_latency/latency.go:134

    The current latency 27 is bigger than the expected one 20 2
    Expected
        <bool>: false
    to be true
 /go/src/github.com/openshift-kni/cnf-features-deploy/vendor/github.com/openshift-kni/performance-addon-operators/functests/4_latency/latency.go:168

Log file created at: 2021/08/29 13:25:21
Running on machine: oslat-57c2g
Binary: Built with gc go1.16.6 for linux/amd64
Log line format: [IWEF]mmdd hh:mm:ss.uuuuuu threadid file:line] msg
I0829 13:25:21.569182       1 node.go:37] Environment information: /proc/cmdline: BOOT_IMAGE=(hd0,gpt3)/ostree/rhcos-612d89f4519a53ad0b1a132f4add78372661bfb3994f5fe115654971aa58a543/vmlinuz-4.18.0-305.10.2.rt7.83.el8_4.x86_64 ip=dhcp random.trust_cpu=on console=tty0 console=ttyS0,115200n8 ostree=/ostree/boot.0/rhcos/612d89f4519a53ad0b1a132f4add78372661bfb3994f5fe115654971aa58a543/0 ignition.platform.id=openstack root=UUID=5a4ddf16-9372-44d9-ac4e-3ee329e16ab3 rw rootflags=prjquota skew_tick=1 nohz=on rcu_nocbs=1-3 tuned.non_isolcpus=000000ff,ffffffff,ffffffff,fffffff1 intel_pstate=disable nosoftlockup tsc=nowatchdog intel_iommu=on iommu=pt isolcpus=managed_irq,1-3 systemd.cpu_affinity=0,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103 default_hugepagesz=1G hugepagesz=2M hugepages=128 nmi_watchdog=0 audit=0 mce=off processor.max_cstate=1 idle=poll intel_idle.max_cstate=0
I0829 13:25:21.569345       1 node.go:44] Environment information: kernel version 4.18.0-305.10.2.rt7.83.el8_4.x86_64
I0829 13:25:21.569367       1 main.go:53] Running the oslat command with arguments [--duration 600 --rtprio 1 --cpu-list 4,6,52,54,56,58 --cpu-main-thread 2] 3
I0829 13:35:22.632263       1 main.go:59] Succeeded to run the oslat command: oslat V 2.00
Total runtime: 		600 seconds
Thread priority: 	SCHED_FIFO:1
CPU list: 		4,6,52,54,56,58
CPU for main thread: 	2
Workload: 		no
Workload mem: 		0 (KiB)
Preheat cores: 		6

Pre-heat for 1 seconds...
Test starts...
Test completed.

        Core:	 4 6 52 54 56 58
    CPU Freq:	 2096 2096 2096 2096 2096 2096 (Mhz)
    001 (us):	 19390720316 19141129810 20265099129 20280959461 19391991159 19119877333
    002 (us):	 5304 5249 5777 5947 6829 4971
    003 (us):	 28 14 434 47 208 21
    004 (us):	 1388 853 123568 152817 5576 0
    005 (us):	 207850 223544 103827 91812 227236 231563
    006 (us):	 60770 122038 277581 323120 122633 122357
    007 (us):	 280023 223992 63016 25896 214194 218395
    008 (us):	 40604 25152 24368 4264 24440 25115
    009 (us):	 6858 3065 5815 810 3286 2116
    010 (us):	 1947 936 1452 151 474 361
  ...
     Minimum:	 1 1 1 1 1 1 (us)
     Average:	 1.000 1.000 1.000 1.000 1.000 1.000 (us)
     Maximum:	 37 38 49 28 28 19 (us) 4
     Max-Min:	 36 37 48 27 27 18 (us)
    Duration:	 599.667 599.667 599.667 599.667 599.667 599.667 (sec)

1 3
运行 oslat 命令的 CPU 列表。七个 CPU 通过 LATENCY_TEST_CPUS 变量提供。仅显示六个 CPU,因为另外一个用于运行 oslat 工具。
2
系统会通知用户测量的延迟和配置延迟。
4
每个 CPU 上测量的最大延迟值(以微秒为单位)。

16.7.9. 故障排除

集群必须从容器内访问。您可以运行以下命令验证:

$ docker run -v $(pwd)/:/kubeconfig -e KUBECONFIG=/kubeconfig/kubeconfig
registry.redhat.io/openshift-kni/cnf-tests oc get nodes

如果这不起作用,则可能是跨 DNS、MTU 大小或者防火墙问题导致的。

16.7.10. 测试报告

CNF 端到端测试会产生两个输出:一个 JUnit 测试输出和测试失败报告。

16.7.10.1. JUnit 测试输出

通过传递 --junit 参数和转储报告所在路径来生成兼容 JUnit 的 XML:

$ docker run -v $(pwd)/:/kubeconfig -v $(pwd)/junitdest:/path/to/junit -e KUBECONFIG=/kubeconfig/kubeconfig registry.redhat.io/openshift4/cnf-tests-rhel8:v4.9 /usr/bin/test-run.sh --junit /path/to/junit

16.7.10.2. 测试失败报告

通过传递 --report 参数来生成包含集群状态信息以及用于故障排除的资源的报告,其方法是通过 --report 参数并使用报告转储的路径:

$ docker run -v $(pwd)/:/kubeconfig -v $(pwd)/reportdest:/path/to/report -e KUBECONFIG=/kubeconfig/kubeconfig registry.redhat.io/openshift4/cnf-tests-rhel8:v4.9 /usr/bin/test-run.sh --report /path/to/report

16.7.10.3. podman 备注

当以非 root 和非特权身份执行 podman 时,挂载路径可能会因为 "permission denied" 错误而失败。要使它正常工作,在卷创建中附加 :Z, 例如,使用 -v $(pwd)/:/kubeconfig:Z 以允许 podman 进行正确的 SELinux 重新标记。

16.7.10.4. 在 OpenShift Container Platform 4.4 中运行

除以下情况外,CNF 端到端测试与 OpenShift Container Platform 4.4 兼容:

[test_id:28466][crit:high][vendor:cnf-qe@redhat.com][level:acceptance] Should contain configuration injected through openshift-node-performance profile
[test_id:28467][crit:high][vendor:cnf-qe@redhat.com][level:acceptance] Should contain configuration injected through the openshift-node-performance profile

您可以通过添加 -ginkgo.skip "28466|28467" 参数来跳过这些测试。

16.7.10.5. 使用单个性能配置集

DPDK 测试需要的资源超过性能测试套件所需要的资源。为加快执行速度,您可以使用提供 DPDK 测试套件的配置集覆盖测试使用的性能配置集。

要做到这一点,类似以下内容的配置集可以挂载到容器中,并可指示性能测试来部署它。

apiVersion: performance.openshift.io/v2
kind: PerformanceProfile
metadata:
 name: performance
spec:
 cpu:
  isolated: "5-15"
  reserved: "0-4"
 hugepages:
  defaultHugepagesSize: "1G"
  pages:
  - size: "1G"
    count: 16
    node: 0
 realTimeKernel:
  enabled: true
 numa:
  topologyPolicy: "best-effort"
 nodeSelector:
  node-role.kubernetes.io/worker-cnf: ""
注意

当您配置保留的和隔离的 CPU 时,pod 中的 infra 容器将使用保留的 CPU,应用程序容器则使用隔离的 CPU。

要覆盖性能配置集,清单必须挂载到容器中,且必须通过设置 PERFORMANCE_PROFILE_MANIFEST_OVERRIDE 来指示测试:

$ docker run -v $(pwd)/:/kubeconfig:Z -e KUBECONFIG=/kubeconfig/kubeconfig -e PERFORMANCE_PROFILE_MANIFEST_OVERRIDE=/kubeconfig/manifest.yaml registry.redhat.io/openshift4/cnf-tests-rhel8:v4.9 /usr/bin/test-run.sh

16.8. 调试低延迟 CNF 调整状态

PerformanceProfile 自定义资源(CR)包含报告调整状态和调试延迟降级问题的状态字段。这些字段报告描述 Operator 协调功能状态的条件。

当附加到性能配置集的机器配置池处于降级状态时会出现一个典型的问题,从而导致 PerformanceProfile 状态降级。在这种情况下,机器配置池会给出一个失败信息。

Performance Addon Operator 包含 performanceProfile.spec.status.Conditions status 字段:

Status:
  Conditions:
    Last Heartbeat Time:   2020-06-02T10:01:24Z
    Last Transition Time:  2020-06-02T10:01:24Z
    Status:                True
    Type:                  Available
    Last Heartbeat Time:   2020-06-02T10:01:24Z
    Last Transition Time:  2020-06-02T10:01:24Z
    Status:                True
    Type:                  Upgradeable
    Last Heartbeat Time:   2020-06-02T10:01:24Z
    Last Transition Time:  2020-06-02T10:01:24Z
    Status:                False
    Type:                  Progressing
    Last Heartbeat Time:   2020-06-02T10:01:24Z
    Last Transition Time:  2020-06-02T10:01:24Z
    Status:                False
    Type:                  Degraded

Status 字段包含指定 Type 值来指示性能配置集状态的 Conditions

Available
所有机器配置和 Tuned 配置集都已被成功创建,且集群组件可用于处理它们(NTO、MCO、Kubelet)。
Upgradeable
代表 Operator 维护的资源是否处于可安全升级的状态。
Progressing
表示已从性能配置集启动部署过程。
Degraded

如果出现以下情况代表错误:

  • 验证性能配置集失败。
  • 创建所有相关组件未能成功完成。

每个类型都包括以下字段:

状态
特定类型的状态(truefalse)。
Timestamp
事务的时间戳。
Reason string
机器可读的原因。
Message string
描述状态和错误详情的人类可读的原因信息(如果存在)。

16.8.1. 机器配置池

性能配置集及其创建的产品会根据关联的机器配置池(MCP)应用到节点。MCP 包含有关应用由性能附加组件创建的机器配置的有价值的信息,它包括了内核 arg、Kube 配置、巨页分配和 rt-kernel 部署。性能附加控制器监控 MCP 中的更改,并相应地更新性能配置集状态。

MCP 返回到性能配置集状态的唯一条件是 MCP 处于 Degraded 状态,这会导致 performaceProfile.status.condition.Degraded = true

示例

以下示例是创建关联机器配置池(worker-cnf)的性能配置集:

  1. 关联的机器配置池处于降级状态:

    # oc get mcp

    输出示例

    NAME         CONFIG                                                 UPDATED   UPDATING   DEGRADED   MACHINECOUNT   READYMACHINECOUNT   UPDATEDMACHINECOUNT   DEGRADEDMACHINECOUNT   AGE
    master       rendered-master-2ee57a93fa6c9181b546ca46e1571d2d       True      False      False      3              3                   3                     0                      2d21h
    worker       rendered-worker-d6b2bdc07d9f5a59a6b68950acf25e5f       True      False      False      2              2                   2                     0                      2d21h
    worker-cnf   rendered-worker-cnf-6c838641b8a08fff08dbd8b02fb63f7c   False     True       True       2              1                   1                     1                      2d20h

  2. MCP 的 describe 部分包括了原因:

    # oc describe mcp worker-cnf

    输出示例

      Message:               Node node-worker-cnf is reporting: "prepping update:
      machineconfig.machineconfiguration.openshift.io \"rendered-worker-cnf-40b9996919c08e335f3ff230ce1d170\" not
      found"
        Reason:                1 nodes are reporting degraded status on sync

  3. 降级状态也应该出现在标记为 degraded = true 的性能配置集的 status 字段中:

    # oc describe performanceprofiles performance

    输出示例

    Message: Machine config pool worker-cnf Degraded Reason: 1 nodes are reporting degraded status on sync.
    Machine config pool worker-cnf Degraded Message: Node yquinn-q8s5v-w-b-z5lqn.c.openshift-gce-devel.internal is
    reporting: "prepping update: machineconfig.machineconfiguration.openshift.io
    \"rendered-worker-cnf-40b9996919c08e335f3ff230ce1d170\" not found".    Reason:  MCPDegraded
       Status:  True
       Type:    Degraded

16.9. 为红帽支持收集调试数据延迟

在提交问题单时同时提供您的集群信息,可以帮助红帽支持为您进行排除故障。

您可使用 must-gather 工具来收集有关 OpenShift Container Platform 集群的诊断信息,包括节点调整、NUMA 拓扑和其他调试延迟设置问题所需的信息。

为了获得快速支持,请提供 OpenShift Container Platform 和低延迟调整的诊断信息。

16.9.1. 关于 must-gather 工具

oc adm must-gather CLI 命令可收集最有助于解决问题的集群信息,如:

  • 资源定义
  • 审计日志
  • 服务日志

您在运行该命令时,可通过包含 --image 参数来指定一个或多个镜像。指定镜像后,该工具便会收集有关相应功能或产品的信息。在运行 oc adm must-gather 时,集群上会创建一个新 pod。在该 pod 上收集数据,并保存至以 must-gather.local 开头的一个新目录中。该目录在当前工作目录中创建。

16.9.2. 关于收集低延迟数据

使用 oc adm must-gather CLI 命令来收集有关集群的信息,包括与低延迟性能优化相关的功能和对象,包括:

  • Performance Addon Operator 命名空间和子对象。
  • MachineConfigPool 和关联的 MachineConfig 对象。
  • Node Tuning Operator 和关联的 Tuned 对象。
  • Linux 内核命令行选项。
  • CPU 和 NUMA 拓扑
  • 基本 PCI 设备信息和 NUMA 本地性。

要使用 must-gather 来收集 Performance Addon Operator 调试信息,您必须指定 Performance Addon Operator must-gather 镜像:

--image=registry.redhat.io/openshift4/performance-addon-operator-must-gather-rhel8:v4.9.

16.9.3. 收集有关特定功能的数据

您可通过将 oc adm must-gather CLI 命令与 --image--image-stream 参数结合使用来收集有关特定功能的调试信息。must-gather 工具支持多个镜像,这样您便可通过运行单个命令收集多个功能的数据。

注意

要收集除特定功能数据外的默认 must-gather 数据,请添加 --image-stream=openshift/must-gather 参数。

先决条件

  • 使用具有 cluster-admin 角色的用户访问集群。
  • 安装了 OpenShift Container Platform CLI(oc)。

流程

  1. 进入存储 must-gather 数据的目录。
  2. 使用一个或多个 --image--image-stream 参数运行 oc adm must-gather 命令。例如,以下命令可收集默认集群数据和具体与 Performance Addon Operator 相关的信息:

    $ oc adm must-gather \
     --image-stream=openshift/must-gather \ 1
    
     --image=registry.redhat.io/openshift4/performance-addon-operator-must-gather-rhel8:v4.9 2
    1
    默认 OpenShift Container Platform must-gather 镜像。
    2
    低延迟调整诊断的 must-gather 镜像。
  3. 从工作目录中创建的 must-gather 目录创建一个压缩文件。例如,在使用 Linux 操作系统的计算机上运行以下命令:

     $ tar cvaf must-gather.tar.gz must-gather.local.5421342344627712289/ 1
    1
    must-gather-local.5421342344627712289/ 替换为实际目录名称。
  4. 红帽客户门户中为您的问题单附上压缩文件。

其他资源

第 17 章 创建性能配置集

了解 Performance Profile Creator(PPC),以及如何使用它来创建性能配置集。

17.1. 关于性能配置集创建器

Performance Profile Creator(PPC)是一个命令行工具,附带 Performance Addon Operator,用于创建性能配置集。该工具消耗来自集群的 must-gather 数据以及几个用户提供的配置集参数。PPC 生成适合您的硬件和拓扑的性能配置集。

该工具使用以下方法之一运行:

  • 调用 podman
  • 调用一个打包程序脚本

17.1.1. 使用 must-gather 收集集群数据

Performance Profile Creator(PPC)工具需要 must-gather 数据。作为集群管理员,运行 must-gather 来收集有关集群的信息。

先决条件

  • 使用具有 cluster-admin 角色的用户访问集群。
  • 访问 Performance Addon Operator 镜像。
  • 已安装 OpenShift CLI(oc)。

流程

  1. 进入存储 must-gather 数据的目录。
  2. 在集群中运行 must-gather

    $ oc adm must-gather --image=<PAO_image> --dest-dir=<dir>
    注意

    must-gather 必须使用 performance-addon-operator-must-gather 镜像运行。输出可以被压缩(可选)。如果您正在运行性能配置集 Creator wrapper 脚本,则需要压缩输出。

    示例

    $ oc adm must-gather --image=registry.redhat.io/openshift4/performance-addon-operator-must-gather-rhel8:v4.9 --dest-dir=must-gather

  3. must-gather 目录创建一个压缩文件:

    $ tar cvaf must-gather.tar.gz must-gather/

17.1.2. 使用 podman 运行 Performance Profile Creator

作为集群管理员,您可以运行 podman 和 Performance Profile Creator 来创建性能配置集。

先决条件

  • 使用具有 cluster-admin 角色的用户访问集群。
  • 在裸机硬件上安装的集群。
  • 安装了 podman 和 OpenShift CLI(oc)的节点。

流程

  1. 检查机器配置池:

    $ oc get mcp

    输出示例

    NAME         CONFIG                                                 UPDATED   UPDATING   DEGRADED   MACHINECOUNT   READYMACHINECOUNT   UPDATEDMACHINECOUNT   DEGRADEDMACHINECOUNT   AGE
    master       rendered-master-acd1358917e9f98cbdb599aea622d78b       True      False      False      3              3                   3                     0                      22h
    worker-cnf   rendered-worker-cnf-1d871ac76e1951d32b2fe92369879826   False     True       False      2              1                   1                     0                      22h

  2. 使用 Podman 验证 registry.redhat.io

    $ podman login registry.redhat.io
    Username: myrhusername
    Password: ************
  3. 可选:显示 PPC 工具的帮助信息:

    $ podman run --entrypoint performance-profile-creator registry.redhat.io/openshift4/performance-addon-rhel8-operator:v4.9 -h

    输出示例

    A tool that automates creation of Performance Profiles
    
    Usage:
      performance-profile-creator [flags]
    
    Flags:
          --disable-ht                        Disable Hyperthreading
      -h, --help                              help for performance-profile-creator
          --info string                       Show cluster information; requires --must-gather-dir-path, ignore the other arguments. [Valid values: log, json] (default "log")
          --mcp-name string                   MCP name corresponding to the target machines (required)
          --must-gather-dir-path string       Must gather directory path (default "must-gather")
          --power-consumption-mode string     The power consumption mode.  [Valid values: default, low-latency, ultra-low-latency] (default "default")
          --profile-name string               Name of the performance profile to be created (default "performance")
          --reserved-cpu-count int            Number of reserved CPUs (required)
          --rt-kernel                         Enable Real Time Kernel (required)
          --split-reserved-cpus-across-numa   Split the Reserved CPUs across NUMA nodes
          --topology-manager-policy string    Kubelet Topology Manager Policy of the performance profile to be created. [Valid values: single-numa-node, best-effort, restricted] (default "restricted")
          --user-level-networking             Run with User level Networking(DPDK) enabled

  4. 以发现模式运行 Performance Profile Creator 工具:

    注意

    发现模式使用 must-gather 的输出来检查您的集群。生成的输出包括以下信息:

    • 使用分配的 CPU ID 进行 NUMA 单元分区
    • 是否启用超线程

    使用此信息,您可以为提供给 Performance Profile Creator 工具的部分参数设置适当的值。

    $ podman run --entrypoint performance-profile-creator -v /must-gather:/must-gather:z registry.redhat.io/openshift4/performance-addon-rhel8-operator:v4.9 --info log --must-gather-dir-path /must-gather
    注意

    此命令使用性能配置集创建器作为 podman 的新入口点。它将主机的 must-gather 数据映射到容器镜像,并调用所需的用户提供的配置集参数来生成 my-performance-profile.yaml 文件。

    -v 选项可以是到以下的任一路径:

    • must-gather 输出目录
    • 包含 must-gather 解压缩 tarball 的现有目录

    info 选项要求值指定输出格式。可能的值有 log 和 JSON。JSON 格式被保留用于调试。

  5. 运行 podman

    $ podman run --entrypoint performance-profile-creator -v /must-gather:/must-gather:z registry.redhat.io/openshift4/performance-addon-rhel8-operator:v4.9 --mcp-name=worker-cnf --reserved-cpu-count=20 --rt-kernel=true --split-reserved-cpus-across-numa=false --topology-manager-policy=single-numa-node --must-gather-dir-path /must-gather  --power-consumption-mode=ultra-low-latency > my-performance-profile.yaml
    注意

    Performance Profile Creator 参数显示在 Performance Profile Creator 参数表中。需要以下参数:

    • reserved-cpu-count
    • mcp-name
    • rt-kernel

    本例中的 mcp-name 参数根据 oc get mcp 命令的输出设置为 worker-cnf。对于单节点 OpenShift(SNO),使用 --mcp-name=master

  6. 查看创建的 YAML 文件:

    $ cat my-performance-profile.yaml

    输出示例

    apiVersion: performance.openshift.io/v2
    kind: PerformanceProfile
    metadata:
      name: performance
    spec:
      additionalKernelArgs:
      - nmi_watchdog=0
      - audit=0
      - mce=off
      - processor.max_cstate=1
      - intel_idle.max_cstate=0
      - idle=poll
      cpu:
        isolated: 1,3,5,7,9,11,13,15,17,19-39,41,43,45,47,49,51,53,55,57,59-79
        reserved: 0,2,4,6,8,10,12,14,16,18,40,42,44,46,48,50,52,54,56,58
      nodeSelector:
        node-role.kubernetes.io/worker-cnf: ""
      numa:
        topologyPolicy: single-numa-node
      realTimeKernel:
        enabled: true

  7. 应用生成的配置集:

    注意

    在应用配置集前,安装 Performance Addon Operator。

    $ oc apply -f my-performance-profile.yaml

17.1.2.1. 如何运行 podman 创建性能配置集

以下示例演示了如何运行 podman 来创建具有 20 个保留 CPU 的性能配置集,这些 CPU 将在 NUMA 节点之间拆分。

节点硬件配置:

  • 80 个 CPU
  • 启用超线程
  • 两个 NUMA 节点
  • 编号为偶数的 CPU 在 NUMA 节点 0 上运行,编号为奇数的 CPU 在 NUMA 节点 1 上运行

运行 podman 以创建性能配置集:

$ podman run --entrypoint performance-profile-creator -v /must-gather:/must-gather:z registry.redhat.io/openshift4/performance-addon-rhel8-operator:v4.9 --mcp-name=worker-cnf --reserved-cpu-count=20 --rt-kernel=true --split-reserved-cpus-across-numa=true --must-gather-dir-path /must-gather > my-performance-profile.yaml

创建的配置集在以下 YAML 中描述:

  apiVersion: performance.openshift.io/v2
  kind: PerformanceProfile
  metadata:
    name: performance
  spec:
    cpu:
      isolated: 10-39,50-79
      reserved: 0-9,40-49
    nodeSelector:
      node-role.kubernetes.io/worker-cnf: ""
    numa:
      topologyPolicy: restricted
    realTimeKernel:
      enabled: true
注意

在这种情况下,在 NUMA 节点 0 上保留 10 个 CPU,NUMA 节点 1 上保留 10 个 CPU。

17.1.3. 运行性能配置集 Creator wrapper 脚本

性能配置集打包程序脚本简化了性能配置文件 Creator(PPC)工具的运行。它隐藏了运行 podman 的复杂性并指定映射目录,它支持创建性能配置集。

先决条件

  • 访问 Performance Addon Operator 镜像。
  • 访问 must-gather tarball。

流程

  1. 在本地机器上创建一个文件,例如 run-perf-profile-creator.sh

    $ vi run-perf-profile-creator.sh
  2. 将以下代码粘贴到文件中:

    #!/bin/bash
    
    readonly CONTAINER_RUNTIME=${CONTAINER_RUNTIME:-podman}
    readonly CURRENT_SCRIPT=$(basename "$0")
    readonly CMD="${CONTAINER_RUNTIME} run --entrypoint performance-profile-creator"
    readonly IMG_EXISTS_CMD="${CONTAINER_RUNTIME} image exists"
    readonly IMG_PULL_CMD="${CONTAINER_RUNTIME} image pull"
    readonly MUST_GATHER_VOL="/must-gather"
    
    PAO_IMG="registry.redhat.io/openshift4/performance-addon-rhel8-operator:v4.9"
    MG_TARBALL=""
    DATA_DIR=""
    
    usage() {
      print "Wrapper usage:"
      print "  ${CURRENT_SCRIPT} [-h] [-p image][-t path] -- [performance-profile-creator flags]"
      print ""
      print "Options:"
      print "   -h                 help for ${CURRENT_SCRIPT}"
      print "   -p                 Performance Addon Operator image"
      print "   -t                 path to a must-gather tarball"
    
      ${IMG_EXISTS_CMD} "${PAO_IMG}" && ${CMD} "${PAO_IMG}" -h
    }
    
    function cleanup {
      [ -d "${DATA_DIR}" ] && rm -rf "${DATA_DIR}"
    }
    trap cleanup EXIT
    
    exit_error() {
      print "error: $*"
      usage
      exit 1
    }
    
    print() {
      echo  "$*" >&2
    }
    
    check_requirements() {
      ${IMG_EXISTS_CMD} "${PAO_IMG}" || ${IMG_PULL_CMD} "${PAO_IMG}" || \
          exit_error "Performance Addon Operator image not found"
    
      [ -n "${MG_TARBALL}" ] || exit_error "Must-gather tarball file path is mandatory"
      [ -f "${MG_TARBALL}" ] || exit_error "Must-gather tarball file not found"
    
      DATA_DIR=$(mktemp -d -t "${CURRENT_SCRIPT}XXXX") || exit_error "Cannot create the data directory"
      tar -zxf "${MG_TARBALL}" --directory "${DATA_DIR}" || exit_error "Cannot decompress the must-gather tarball"
      chmod a+rx "${DATA_DIR}"
    
      return 0
    }
    
    main() {
      while getopts ':hp:t:' OPT; do
        case "${OPT}" in
          h)
            usage
            exit 0
            ;;
          p)
            PAO_IMG="${OPTARG}"
            ;;
          t)
            MG_TARBALL="${OPTARG}"
            ;;
          ?)
            exit_error "invalid argument: ${OPTARG}"
            ;;
        esac
      done
      shift $((OPTIND - 1))
    
      check_requirements || exit 1
    
      ${CMD} -v "${DATA_DIR}:${MUST_GATHER_VOL}:z" "${PAO_IMG}" "$@" --must-gather-dir-path "${MUST_GATHER_VOL}"
      echo "" 1>&2
    }
    
    main "$@"
  3. 为这个脚本中的每个人添加执行权限:

    $ chmod a+x run-perf-profile-creator.sh
  4. 可选:显示 run-perf-profile-creator.sh 命令用法:

    $ ./run-perf-profile-creator.sh -h

    预期输出

    Wrapper usage:
      run-perf-profile-creator.sh [-h] [-p image][-t path] -- [performance-profile-creator flags]
    
    Options:
       -h                 help for run-perf-profile-creator.sh
       -p                 Performance Addon Operator image 1
       -t                 path to a must-gather tarball 2
    
    A tool that automates creation of Performance Profiles
    
       Usage:
         performance-profile-creator [flags]
    
       Flags:
             --disable-ht                        Disable Hyperthreading
         -h, --help                              help for performance-profile-creator
             --info string                       Show cluster information; requires --must-gather-dir-path, ignore the other arguments. [Valid values: log, json] (default "log")
             --mcp-name string                   MCP name corresponding to the target machines (required)
             --must-gather-dir-path string       Must gather directory path (default "must-gather")
             --power-consumption-mode string     The power consumption mode.  [Valid values: default, low-latency, ultra-low-latency] (default "default")
             --profile-name string               Name of the performance profile to be created (default "performance")
             --reserved-cpu-count int            Number of reserved CPUs (required)
             --rt-kernel                         Enable Real Time Kernel (required)
             --split-reserved-cpus-across-numa   Split the Reserved CPUs across NUMA nodes
             --topology-manager-policy string    Kubelet Topology Manager Policy of the performance profile to be created. [Valid values: single-numa-node, best-effort, restricted] (default "restricted")
             --user-level-networking             Run with User level Networking(DPDK) enabled

    注意

    有两个参数类型:

    • wrapper 参数,即 -h-p-t
    • PPC 参数
    1
    可选:指定 Performance Addon Operator 镜像。如果没有设置,则会使用默认的上游镜像: registry.redhat.io/openshift4/performance-addon-rhel8-operator:v4.9
    2
    -t 是必需的打包程序脚本参数,并指定 must-gather tarball 的路径。
  5. 以发现模式运行性能配置集创建器工具:

    注意

    发现模式使用 must-gather 的输出来检查您的集群。生成的输出包括以下信息:

    • 使用分配的 CPU ID 进行 NUMA 单元分区
    • 是否启用超线程

    使用此信息,您可以为提供给 Performance Profile Creator 工具的部分参数设置适当的值。

    $ ./run-perf-profile-creator.sh -t /must-gather/must-gather.tar.gz -- --info=log
    注意

    info 选项要求值指定输出格式。可能的值有 log 和 JSON。JSON 格式被保留用于调试。

  6. 检查机器配置池:

    $ oc get mcp

    输出示例

    NAME         CONFIG                                                 UPDATED   UPDATING   DEGRADED   MACHINECOUNT   READYMACHINECOUNT   UPDATEDMACHINECOUNT   DEGRADEDMACHINECOUNT   AGE
    master       rendered-master-acd1358917e9f98cbdb599aea622d78b       True      False      False      3              3                   3                     0                      22h
    worker-cnf   rendered-worker-cnf-1d871ac76e1951d32b2fe92369879826   False     True       False      2              1                   1                     0                      22h

  7. 创建性能配置集:

    $ ./run-perf-profile-creator.sh -t /must-gather/must-gather.tar.gz -- --mcp-name=worker-cnf --reserved-cpu-count=2 --rt-kernel=true > my-performance-profile.yaml
    注意

    Performance Profile Creator 参数显示在 Performance Profile Creator 参数表中。需要以下参数:

    • reserved-cpu-count
    • mcp-name
    • rt-kernel

    本例中的 mcp-name 参数根据 oc get mcp 命令的输出设置为 worker-cnf。对于单节点 OpenShift(SNO),使用 --mcp-name=master

  8. 查看创建的 YAML 文件:

    $ cat my-performance-profile.yaml

    输出示例

    apiVersion: performance.openshift.io/v2
    kind: PerformanceProfile
    metadata:
      name: performance
    spec:
      cpu:
        isolated: 1-39,41-79
        reserved: 0,40
      nodeSelector:
        node-role.kubernetes.io/worker-cnf: ""
      numa:
        topologyPolicy: restricted
      realTimeKernel:
        enabled: false

  9. 应用生成的配置集:

    注意

    在应用配置集前,安装 Performance Addon Operator。

    $ oc apply -f my-performance-profile.yaml

17.1.4. Performance Profile Creator 参数

表 17.1. Performance Profile Creator 参数

参数描述

disable-ht

禁用超线程。

可能的值: truefalse

默认值: false

警告

如果此参数设为 true,则不应禁用 BIOS 中的超线程。禁用超线程通过内核命令行参数实现。

info

这会捕获集群信息,仅用于发现模式。发现模式还需要 must-gather-dir-path 参数。如果设置了任何其他参数,则忽略它们。

可能的值:

  • log
  • JSON

    注意

    这些选项定义输出格式,以保留用于调试的 JSON 格式。

默认: log

mcp-name

MCP 名称(如 worker-cnf)与目标机器对应。这个参数是必需的。

must-gather-dir-path

必须收集目录路径。这个参数是必需的。

当用户使用 wrapper 脚本 must-gather 运行该工具时,脚本本身会提供该工具,用户不得指定它。

power-consumption-mode

电源功耗模式。

可能的值:

  • default
  • low-latency
  • ultra-low-latency

默认: default

profile-name

要创建的性能配置集的名称。默认:performance.

reserved-cpu-count

保留 CPU 的数量。这个参数是必需的。

注意

这必须是一个自然数字。不允许使用 0 值。

rt-kernel

启用实时内核。这个参数是必需的。

可能的值: truefalse

split-reserved-cpus-across-numa

将保留的 CPU 划分到 NUMA 节点。

可能的值: truefalse

默认值: false

topology-manager-policy

要创建的性能配置集的 kubelet Topology Manager 策略。

可能的值:

  • single-numa-node
  • best-effort
  • restricted

默认: restricted

user-level-networking

在启用了用户级别网络(DPDK)的情况下运行。

可能的值: truefalse

默认值: false

17.2. 其他资源

第 18 章 在断开连接的环境中大规模部署分布式单元

使用 ZTP(zero touch provisioning)在断开连接的环境中的新边缘站点置备分布式单元。当站点连接到网络,结束于站点节点上部署和运行的 CNF 工作负载时,工作流将开始。

重要

用于 RAN 部署的 ZTP 只是一个技术预览功能。技术预览功能不被红帽产品服务等级协议 (SLA) 支持,且可能在功能方面有缺陷。红帽不推荐在生产环境中使用它们。这些技术预览功能可以使用户提早试用新的功能,并有机会在开发阶段提供反馈意见。

有关红帽技术预览功能支持范围的详情,请参阅 https://access.redhat.com/support/offerings/techpreview/

18.1. 大规模置备边缘站点

在数百个地点管理数百至数万个集群时,电信边缘计算带来了巨大的挑战。这些挑战需要完全自动化的管理解决方案,尽可能地不需要人工的互动。

零接触配置 (ZTP) 允许您通过在远程站点上声明配置裸机设备来调配新的边缘站点。模板或覆盖配置安装 CNF 工作负载所需的 OpenShift Container Platform 功能。端到端的功能测试套件用于验证与 CNF 相关的功能。所有配置本质上都是声明式的。

您可以通过为发送到边缘节点的 ISO 镜像创建声明配置来开始安装过程。镜像用于重复快速地调配大量节点,允许您与边缘节点字段中的要求保持同步。

服务提供商部署更分布式的移动网络架构,允许 5G 定义的模块化功能框架。这使服务提供商可以从基于设备的无线访问网络 (RAN) 迁移到开放云 RAN 架构,从而获得向最终用户交付服务的灵活性和敏捷性。

下图显示了 ZTP 在最边缘框架内的工作方式。

使用远边缘框架的 ZTP

18.2. GitOps 方法

ZTP 使用一组用于基础架构部署的 GitOps 部署实践,允许开发人员执行原本属于 IT 操作范围的任务。GitOps 使用 Git 存储库中存储的声明性规范(如 YAML 文件和其他定义的模式)来实现这些任务,从而提供用于部署基础架构的框架。Open Cluster Manager (OCM) 将声明性输出用于多站点部署。

使用 GitOps 方法的一个主要因素是要在大规模范围内实现可靠性。GitOps 可以帮助实现这个重大挑战。

GitOps 通过为每个站点的所需状态提供可追溯性、RBAC 和单一数据源来解决可靠性问题。GitOps 通过 webhook 提供结构、工具和事件驱动的操作来解决规模问题。

18.3. 关于 ZTP 以及单一节点上的分布单元

您可以使用支持的安装程序 (AI) 和启用了内核缩减技术的策略生成器,使用 Red Hat Advanced Cluster Management (RHACM) (ACM) 在单个节点上大规模安装分布式单元 (DU)。DU 安装是在断开连接的环境中使用 ZTP 完成的。

ACM 在 hub 和 spoke 架构中管理集群,其中单个 hub 集群管理多个 spoke 集群。ACM 从预定义的自定义资源 (CR) 应用无线访问网络 (RAN) 策略。使用 ZTP 和 AI 运行 ACM 置备和部署 spoke 集群的 hub 集群。DU 安装跟踪在单一节点上 OpenShift Container Platform 的 AI 安装。

AI 服务在裸机上运行的单一节点上处理 OpenShift Container Platform 的置备。安装 MultiClusterHub 自定义资源时,ACM 附带并部署受支持的安装程序。

使用 ZTP 和 AI,您可以置备 OpenShift Container Platform 单一节点来大规模运行 DU。在断开连接的环境中的分布式单元的 ZTP 概述如下:

  • 运行 ACM 的 hub 集群管理一个断开连接的内部 registry,用于镜像 OpenShift Container Platform 发行镜像。内部 registry 用于置备 spoke 单一节点。
  • 您可以在使用 YAML 进行格式化的清单文件中为您的 DU 管理裸机主机。您可以将清单文件存储在 Git 存储库中。
  • 您要在站点上安装 DU 裸机主机,并使主机做好调配准备。要进行置备,每个裸机主机都需要以下内容:

    • 网络连接 - 包括您的网络的 DNS.主机应该可通过 hub 和受管 spoke 集群访问。确定 hub 和要安装 hub 集群的主机之间有第 3 层连接。
    • 每个主机的基板管理控制器 (BMC) 详情 - ZTP 使用 BMC 详情来连接用于访问 BMC 的 URL 和凭证。创建 spoke 集群定义 CR。它们定义受管集群的相关元素。所需的 CR 如下:

      自定义资源描述

      命名空间

      受管单一节点集群的命名空间。

      BMCSecret CR

      主机 BMC 的凭证。

      Image Pull Secret CR

      断开连接的 registry 的 pull secret。

      AgentClusterInstall

      指定单一节点集群的配置,如网络、监控器 (control plane) 节点等。

      ClusterDeployment

      定义集群名称、域和其他详情。

      KlusterletAddonConfig

      管理 ManagedCluster 上用于 ACM 的附加组件的安装和终止。

      ManagedCluster

      描述 ACM 的受管集群。

      InfraEnv

      描述要在辅助安装程序服务创建的目的地节点上挂载的安装 ISO。这是清单创建阶段的最后一步。

      BareMetalHost

      描述裸机主机的详细信息,包括 BMC 和凭证详情。

  • 在主机清单存储库中检测到更改时,将触发主机管理事件来调配新的或更新的主机。
  • 主机已调配。当置备并成功重启主机时,主机代理会向 hub 集群报告 Ready 状态 。

18.4. ZTP 构建块

ACM 部署单节点 OpenShift (SNO),即 OpenShift Container Platform 安装在单一节点上,利用 ZTP。初始站点计划分为较小的组件,初始配置数据存储在 Git 存储库中。ZTP 使用声明性 GitOps 方法来部署这些节点。节点部署包括:

  • 在空白服务器上安装主机操作系统 (RHCOS)。
  • 在单一节点上部署 OpenShift 容器平台。
  • 创建集群策略和站点订阅。
  • 利用 GitOps 部署拓扑的“开发一次,随处部署”的模型。
  • 为服务器操作系统进行必要的网络配置。
  • 部署配置集 Operator 并执行任何所需的软件相关配置,如性能配置集、PTP 和 SR-IOV。
  • 下载运行工作负载 (CNF) 所需的镜像。

18.5. 单节点集群

您可以使用 ZTP 来部署单一节点集群,以便在断开连接的边缘站点的小硬件空间中运行分布式单元 (DU)。单一节点集群在一个裸机机器上运行 OpenShift Container Platform,因此单个节点运行。边缘服务器包含一个节点,它在低带宽或断开连接的边缘站点部署的同一主机上具有 Supervisor 功能和 worker 功能。

OpenShift Container Platform 在单一节点上配置为使用工作负载分区。工作负载分区将集群管理工作负载与用户工作负载隔离,并可在保留的一组 CPU 上运行集群管理工作负载。工作负载分区对于受资源约束的环境(如单节点生产部署)很有用,其中您要为用户工作负载保留大多数 CPU 资源,并将 OpenShift Container Platform 配置为在主机上使用较少的 CPU 资源。

在节点上托管 DU 应用程序的单一节点集群被分为以下配置类别:

  • 通用 - 由 hub 集群管理的所有单一节点集群站点的值相同。
  • 站点池 - 在池内通用,池大小可以是 1 到 n
  • 特定于站点 - 可能特定于不与其他站点重叠的网站,如 vlan。

18.6. 分布式单元部署的站点规划注意事项

分布式单元 (DU) 部署的站点规划非常复杂。以下是您在将 DU 主机引入生产环境中在线之前完成的任务概述。

  • 开发网络模型。网络模型取决于多个因素,如覆盖区域的大小、主机数量、投射流量负载、DNS 和 DHCP 要求。
  • 决定需要多少 DU 无线节点来为您的网络提供足够的覆盖范围和冗余。
  • 为 DU 主机硬件开发机械和电气规格。
  • 为各个 DU 站点安装制定建筑计划。
  • 调优生产的主机 BIOS 设置,并将 BIOS 配置部署到主机。
  • 在现场安装设备,将主机连接到网络,然后应用电源。
  • 配置现场交换机和路由器。
  • 为主机执行基本连接测试。
  • 建立生产网络连接,并验证主机与网络的连接。
  • 大规模配置和部署现场 DU 主机.
  • 测试和验证现场操作,执行 DU 主机的负载和规模测试,最后将 DU 基础架构置于实时生产环境中。

18.7. 分布式单元 (DU) 的低延迟

低延迟是 5G 网络开发中不可或缺的组成部分。电信网络要求尽可能少的信号延迟,以确保各种关键用例中的服务质量。

对于任何影响功能和安全性的计时限制的通信,低延迟处理都至关重要。例如,5G Telco 应用程序需要保证一毫秒的单向延迟才能满足物联网 (IoT) 的要求。低延迟对于未来自主车辆、智能工厂和在线游戏的发展也至关重要。这些环境中的网络几乎需要实时数据流。

低延迟系统与响应和处理时间相关。这包括保持通信协议平稳运行,确保设备安全性对错误条件快速响应,或者仅确保系统在接收大量数据时不会被阻碍。低延迟是无线传输的最佳同步的关键。

OpenShift Container Platform 通过使用多个技术和专用硬件设备,为 COTS 硬件上运行的 DU 启用低延迟处理:

RHCOS 的实时内核
确保以高度的进程确定性处理工作负载。
CPU 隔离
避免 CPU 调度延迟并确保 CPU 容量一致可用。
NUMA 感知
将内存和巨页与 CPU 和 PCI 设备对齐,使容器内存和巨页固定到 NUMA 节点。这可降低延迟并提高节点的性能。
巨页内存管理
使用巨页大小可减少访问页表所需的系统资源量,从而提高系统性能。
使用 PTP 进行精确计时同步
允许以子微秒的准确性在网络中的节点之间进行同步。

18.8. 为分布式单元裸机主机配置 BIOS

分布式单元 (DU) 主机要求在调配主机之前配置 BIOS。BIOS 配置取决于运行您的 DU 的特定硬件以及您安装的特定要求。

重要

在这个开发者预览版本中,客户负责为 DU 裸机主机配置和调优 BIOS。BIOS 的自动设置不由 ZTP 工作流处理。

流程

  1. UEFI/BIOS Boot Mode 设置为 UEFI
  2. 在主机引导顺序中,设置 Hard drive first
  3. 为您的硬件应用特定的 BIOS 配置。下表描述了 Intel Xeon Skylake 或 Intel Cascade Lake 服务器的代表 BIOS 配置,它基于 Intel FlexRAN 4G 和 5G 基带 PHY 参考设计。

    重要

    确切的 BIOS 配置取决于您的特定硬件和网络要求。以下示例配置仅用于说明目的。

    表 18.1. Intel Xeon Skylake 或 Cascade Lake 服务器的 BIOS 配置示例

    BIOS 设置Configuration

    CPU Power 和性能策略

    性能

    非核心频率扩展

    Disabled

    性能限制

    Disabled

    增强的 Intel SpeedStep ® Tech

    Enabled

    Intel 配置的 TDP

    Enabled

    可配置 TDP 级别

    2 级

    Intel® Turbo Boost Technology

    Enabled

    节能 Turbo

    Disabled

    硬件 P-State

    Disabled

    软件包 C-State

    C0/C1 状态

    C1E

    Disabled

    处理器 C6

    Disabled

注意

在 BIOS 中为主机启用全局 SR-IOV 和 VT-d 设置。这些设置与裸机环境相关。

18.9. 准备断开连接的环境

在大规模置备分布式单元 (DU) 前,您必须安装处理 DU 置备的 Red Hat Advanced Cluster Management (RHACM)。

RHACM 被部署为 OpenShift Container Platform hub 集群上的 Operator。它从带有内置安全策略的单一控制台控制集群和应用程序。RHACM 调配和管理您的 DU 主机.要在断开连接的环境中安装 RHACM,您需要创建一个镜像 registry,该 registry 会镜像包含所需 Operator 镜像的 Operator Lifecycle Manager (OLM) 目录。OLM 在集群中管理、安装和升级 Operator 及其依赖项。

您还可以使用断开连接的镜像主机来提供置备 DU 裸机主机操作系统的 RHCOS ISO 和 RootFS 磁盘镜像。

在受限网络中置备的基础架构上安装集群前,您必须将所需的容器镜像镜像(mirror)到那个环境中。您也可以在不受限制的网络中使用此流程来确保集群只使用满足您机构对外部内容控制的容器镜像。

重要

您必须可以访问互联网来获取所需的容器镜像。在这一流程中,您要将镜像 registry 放在可访问您的网络以及互联网的镜像(mirror)主机上。如果您无法访问镜像主机,请使用断开连接的步骤将镜像复制到可跨网络界限的设备中。

18.9.1. 断开连接的环境先决条件

您必须在托管 OpenShift Container Platform 集群的位置(如以下 registry 之一)中有一个支持 Docker v2-2 的容器镜像 registry:

如果您有 Red Hat Quay 权利,请参阅有关部署 Red Hat Quay 以了解概念验证的文档,或使用 Quay Operator。如果您需要额外的帮助来选择并安装 registry,请联络您的销售代表或红帽支持。

18.9.2. 关于镜像 registry

您可以镜像 OpenShift Container Platform 安装和后续的产品更新镜像(mirror)镜像(mirror)。这些步骤使用同样的过程。发行版本镜像(包含内容描述)及其引用的镜像都被镜像(mirror)。此外,Operator 目录源镜像及其引用的镜像必须针对您使用的每个 Operator 进行镜像(mirror)。镜像内容后,您要将每个集群配置为从镜像 registry 中检索此内容。

镜像 registry 可以是支持 Docker v2-2 的任何容器 registry。所有主要的云供应商 registry,以及 Red Hat Quay、Artifactory 和其他,都有所需的支持。使用其中一个 registry 可确保 OpenShift Container Platform 可在断开连接的环境中检查各个镜像的完整性。

重要

OpenShift Container Platform 集群的内部 registry 不能用作目标 registry,因为它不支持没有标签的推送(在镜像过程中需要这个功能)。

镜像 registry 必须可以被您置备的集群中的每台机器访问。如果 registry 无法访问,更新或常规操作(如工作负载重新定位)可能会失败。因此,您必须以高度可用的方式运行镜像 registry,镜像 registry 至少必须与 OpenShift Container Platform 集群的生产环境可用性相匹配。

使用 OpenShift Container Platform 镜像填充镜像 registry 时,可以采用以下两种情况。如果您的主机可以同时访问互联网和您的镜像 registry,而不能访问您的集群节点,您可以直接从该机器中镜像该内容。这个过程被称为 连接的镜像(mirror)。如果没有这样的主机,则必须将该镜像文件镜像到文件系统中,然后将该主机或者可移动介质放入受限环境中。这个过程被称为 断开连接的镜像

对于已镜像的 registry,若要查看拉取镜像的来源,您必须查看 Trying 以访问 CRI-O 日志中的日志条目。查看镜像拉取源的其他方法(如在节点上使用 crictl images 命令)显示非镜像镜像名称,即使镜像是从镜像位置拉取的。

其他资源

有关查看 CRI-O 日志以查看镜像源的详情,请参阅查看镜像拉取源

18.9.3. 准备您的镜像主机

执行镜像步骤前,必须准备主机以检索内容并将其推送到远程位置。

18.9.3.1. 通过下载二进制文件安装 OpenShift CLI

您需要安装 CLI(oc) 来使用命令行界面与 OpenShift Container Platform 进行交互。您可在 Linux 、Windows 或 macOS 上安装 oc

重要

如果安装了旧版本的 oc,则无法使用 OpenShift Container Platform 4.9 中的所有命令。下载并安装新版本的 oc

在 Linux 上安装 OpenShift CLI

您可以按照以下流程在 Linux 上安装 OpenShift CLI(oc)二进制文件。

流程

  1. 进入到红帽客户门户网站上的 OpenShift Container Platform 下载页面
  2. Version 下拉菜单中选择相应的版本。
  3. 单击 OpenShift v4.9 Linux Client 条目旁边的 Download Now,再保存文件。
  4. 解包存档:

    $ tar xvzf <file>
  5. oc 二进制代码放到 PATH 中的目录中。

    执行以下命令可以查看当前的 PATH 设置:

    $ echo $PATH

安装 OpenShift CLI 后,可以使用 oc 命令:

$ oc <command>
在 Windows 上安装 OpenShift CLI

您可以按照以下流程在 Windows 上安装 OpenShift CLI(oc)二进制代码。

流程

  1. 进入到红帽客户门户网站上的 OpenShift Container Platform 下载页面
  2. Version 下拉菜单中选择相应的版本。
  3. 单击 OpenShift v4.9 Windows OpenShift v4.9 Linux Client 条目旁边的 Download Now,再保存文件。
  4. 使用 ZIP 程序解压存档。
  5. oc 二进制代码放到 PATH 中的目录中。

    要查看您的 PATH,请打开命令提示窗口并执行以下命令:

    C:\> path

安装 OpenShift CLI 后,可以使用 oc 命令:

C:\> oc <command>
在 macOS 上安装 OpenShift CLI

您可以按照以下流程在 macOS 上安装 OpenShift CLI(oc)二进制代码。

流程

  1. 进入到红帽客户门户网站上的 OpenShift Container Platform 下载页面
  2. Version 下拉菜单中选择相应的版本。
  3. 单击 OpenShift v4.9 MacOSX Client 条目旁边的 Download Now,再保存文件。
  4. 解包和解压存档。
  5. oc 二进制文件移到 PATH 的目录中。

    要查看您的 PATH,打开一个终端窗口并执行以下命令:

    $ echo $PATH

安装 OpenShift CLI 后,可以使用 oc 命令:

$ oc <command>

18.9.3.2. 配置允许对容器镜像进行镜像的凭证

创建容器镜像 registry 凭证文件,允许将红帽的镜像镜像到您的镜像环境中。

先决条件

  • 配置了一个镜像(mirror) registry 在受限网络中使用。

流程

在安装主机上完成以下步骤:

  1. 从 Red Hat OpenShift Cluster Manager 站点的 Pull Secret 页面下载 registry.redhat.io 的 pull secret,并将它保存到一个 .json 文件中。
  2. 为您的镜像 registry 生成 base64 编码的用户名和密码或令牌:

    $ echo -n '<user_name>:<password>' | base64 -w0 1
    BGVtbYk3ZHAtqXs=
    1
    通过 <user_name><password> 指定 registry 的用户名和密码。
  3. 以 JSON 格式创建您的 pull secret 副本:

    $ cat ./pull-secret.text | jq .  > <path>/<pull_secret_file_in_json>1
    1
    指定到存储 pull secret 的文件夹的路径,以及您创建的 JSON 文件的名称。

    该文件类似于以下示例:

    {
      "auths": {
        "cloud.openshift.com": {
          "auth": "b3BlbnNo...",
          "email": "you@example.com"
        },
        "quay.io": {
          "auth": "b3BlbnNo...",
          "email": "you@example.com"
        },
        "registry.connect.redhat.com": {
          "auth": "NTE3Njg5Nj...",
          "email": "you@example.com"
        },
        "registry.redhat.io": {
          "auth": "NTE3Njg5Nj...",
          "email": "you@example.com"
        }
      }
    }
  4. 编辑新文件并添加描述 registry 的部分:

      "auths": {
        "<mirror_registry>": { 1
          "auth": "<credentials>", 2
          "email": "you@example.com"
      },
    1
    对于 <mirror_registry>,指定 registry 域名,以及您的镜像 registry 用来提供内容的可选端口。例如: registry.example.comregistry.example.com:5000
    2
    使用 <credentials> 为您的镜像 registry 指定 base64 编码的用户名和密码。

    该文件类似于以下示例:

    {
      "auths": {
        "registry.example.com": {
          "auth": "BGVtbYk3ZHAtqXs=",
          "email": "you@example.com"
        },
        "cloud.openshift.com": {
          "auth": "b3BlbnNo...",
          "email": "you@example.com"
        },
        "quay.io": {
          "auth": "b3BlbnNo...",
          "email": "you@example.com"
        },
        "registry.connect.redhat.com": {
          "auth": "NTE3Njg5Nj...",
          "email": "you@example.com"
        },
        "registry.redhat.io": {
          "auth": "NTE3Njg5Nj...",
          "email": "you@example.com"
        }
      }
    }

18.9.3.3. 镜像 OpenShift Container Platform 镜像存储库

镜像要在集群安装或升级过程中使用的 OpenShift Container Platform 镜像仓库。

先决条件

  • 您的镜像主机可访问互联网。
  • 您已将镜像 registry 配置为在受限网络中使用,并可访问您配置的证书和凭证。
  • 您从 Red Hat OpenShift Cluster Manager 站点的 Pull Secret 页面下载了 pull secret,并已修改为包含镜像存储库身份验证。
  • 如果您使用没有设置 Subject Alternative Name 的自签名证书,则必须在这个过程中使用 GODEBUG=x509ignoreCN=0 前执行 oc 命令。如果没有设置此变量,oc 命令会失败并显示以下错误:

    x509: certificate relies on legacy Common Name field, use SANs or temporarily enable Common Name matching with GODEBUG=x509ignoreCN=0

流程

在镜像主机上完成以下步骤:

  1. 查看 OpenShift Container Platform 下载页面,以确定您要安装的 OpenShift Container Platform 版本,并决定 Repository Tags 页中的相应标签(tag)。
  2. 设置所需的环境变量:

    1. 导出发行版本信息:

      $ OCP_RELEASE=<release_version>

      对于 <release_version>,请指定与 OpenShift Container Platform 版本对应的标签,用于您的架构,如 4.5.4

    2. 导出本地 registry 名称和主机端口:

      $ LOCAL_REGISTRY='<local_registry_host_name>:<local_registry_host_port>'

      对于 <local_registry_host_name>,请指定镜像存储库的 registry 域名;对于 <local_registry_host_port>,请指定用于提供内容的端口。

    3. 导出本地存储库名称:

      $ LOCAL_REPOSITORY='<local_repository_name>'

      对于 <local_repository_name>,请指定要在 registry 中创建的仓库名称,如 ocp4/openshift4

    4. 导出要进行镜像的存储库名称:

      $ PRODUCT_REPO='openshift-release-dev'

      对于生产环境版本,必须指定 openshift-release-dev

    5. 导出 registry pull secret 的路径:

      $ LOCAL_SECRET_JSON='<path_to_pull_secret>'

      对于 <path_to_pull_secret>,请指定您创建的镜像 registry 的 pull secret 的绝对路径和文件名。

    6. 导出发行版本镜像:

      $ RELEASE_NAME="ocp-release"

      对于生产环境版本,您必须指定 ocp-release

    7. 为您的服务器导出构架类型,如 x86_64

      $ ARCHITECTURE=<server_architecture>
    8. 导出托管镜像的目录的路径:

      $ REMOVABLE_MEDIA_PATH=<path> 1
      1
      指定完整路径,包括开始的前斜杠(/)字符。
  3. 将版本镜像镜像(mirror)到内部容器 registry:

    • 如果您的镜像主机无法访问互联网,请执行以下操作:

      1. 将可移动介质连接到连接到互联网的系统。
      2. 查看要镜像的镜像和配置清单:

        $ oc adm release mirror -a ${LOCAL_SECRET_JSON}  \
             --from=quay.io/${PRODUCT_REPO}/${RELEASE_NAME}:${OCP_RELEASE}-${ARCHITECTURE} \
             --to=${LOCAL_REGISTRY}/${LOCAL_REPOSITORY} \
             --to-release-image=${LOCAL_REGISTRY}/${LOCAL_REPOSITORY}:${OCP_RELEASE}-${ARCHITECTURE} --dry-run
      3. 记录上一命令输出中的 imageContentSources 部分。您的镜像信息与您的镜像存储库相对应,您必须在安装过程中将 imageContentSources 部分添加到 install-config.yaml 文件中。
      4. 将镜像镜像到可移动介质的目录中:

        $ oc adm release mirror -a ${LOCAL_SECRET_JSON} --to-dir=${REMOVABLE_MEDIA_PATH}/mirror quay.io/${PRODUCT_REPO}/${RELEASE_NAME}:${OCP_RELEASE}-${ARCHITECTURE}
      5. 将介质上传到受限网络环境中,并将镜像上传到本地容器 registry。

        $ oc image mirror -a ${LOCAL_SECRET_JSON} --from-dir=${REMOVABLE_MEDIA_PATH}/mirror "file://openshift/release:${OCP_RELEASE}*" ${LOCAL_REGISTRY}/${LOCAL_REPOSITORY} 1
        1
        对于 REMOVABLE_MEDIA_PATH,您必须使用与镜像镜像时指定的同一路径。
    • 如果本地容器 registry 连接到镜像主机,请执行以下操作:

      1. 使用以下命令直接将发行版镜像推送到本地 registry:

        $ oc adm release mirror -a ${LOCAL_SECRET_JSON}  \
             --from=quay.io/${PRODUCT_REPO}/${RELEASE_NAME}:${OCP_RELEASE}-${ARCHITECTURE} \
             --to=${LOCAL_REGISTRY}/${LOCAL_REPOSITORY} \
             --to-release-image=${LOCAL_REGISTRY}/${LOCAL_REPOSITORY}:${OCP_RELEASE}-${ARCHITECTURE}

        该命令将发行信息提取为摘要,其输出包括安装集群时所需的 imageContentSources 数据。

      2. 记录上一命令输出中的 imageContentSources 部分。您的镜像信息与您的镜像存储库相对应,您必须在安装过程中将 imageContentSources 部分添加到 install-config.yaml 文件中。

        注意

        镜像名称在镜像过程中被修补到 Quay.io, podman 镜像将在 bootstrap 虚拟机的 registry 中显示 Quay.io。

  4. 要创建基于您镜像内容的安装程序,请提取内容并将其固定到发行版中:

    • 如果您的镜像主机无法访问互联网,请运行以下命令:

      $ oc adm release extract -a ${LOCAL_SECRET_JSON} --command=openshift-install "${LOCAL_REGISTRY}/${LOCAL_REPOSITORY}:${OCP_RELEASE}"
    • 如果本地容器 registry 连接到镜像主机,请运行以下命令:

      $ oc adm release extract -a ${LOCAL_SECRET_JSON} --command=openshift-install "${LOCAL_REGISTRY}/${LOCAL_REPOSITORY}:${OCP_RELEASE}-${ARCHITECTURE}"
      重要

      要确保将正确的镜像用于您选择的 OpenShift Container Platform 版本,您必须从镜像内容中提取安装程序。

      您必须在有活跃互联网连接的机器上执行这个步骤。

      如果您位于断开连接的环境中,请使用 --image 标志作为 must-gather 的一部分,指向有效负载镜像。

  5. 对于使用安装程序置备的基础架构的集群,运行以下命令:

    $ openshift-install

18.9.3.4. 在断开连接的镜像主机上添加 RHCOS ISO 和 RootFS 镜像

在您置备的基础架构上安装集群前,必须先创建 Red Hat Enterprise Linux CoreOS (RHCOS) 机器供其使用。使用断开连接的镜像来托管所需的 RHCOS 镜像,以置备分布式单元 (DU) 裸机主机。

先决条件

  • 部署和配置 HTTP 服务器以托管网络上的 RHCOS 镜像资源。您必须能够从计算机以及您创建的机器访问 HTTP 服务器。
重要

RHCOS 镜像可能不会随着 OpenShift Container Platform 的每一发行版本都有改变。您必须下载最高版本的镜像,其版本号应小于或等于您安装的 OpenShift Container Platform 版本。如果可用,请使用与 OpenShift Container Platform 版本匹配的镜像版本。您需要 ISO 和 RootFS 镜像在 DU 主机上安装 RHCOS。此安装类型不支持 RHCOS qcow2 镜像。

流程

  1. 登录到镜像主机。
  2. mirror.openshift.com 获取 RHCOS ISO 和 RootFS 镜像,例如:

    1. 将所需的镜像名称和 OpenShift Container Platform 版本导出为环境变量:

      $ export ISO_IMAGE_NAME=<iso_image_name> 1
      $ export ROOTFS_IMAGE_NAME=<rootfs_image_name> 1
      $ export OCP_VERSION=<ocp_version> 1
      1
      ISO 镜像名,如 rhcos-4.9.0-fc.1-x86_64-live.x86_64.iso
      1
      RootFS 镜像名,如 rhcos-4.9.0-fc.1-x86_64-live-rootfs.x86_64.img
      1
      OpenShift Container Platform 版本,如 latest-4.9
    2. 下载所需的镜像:

      $ sudo wget https://mirror.openshift.com/pub/openshift-v4/dependencies/rhcos/pre-release/${OCP_VERSION}/${ISO_IMAGE_NAME} -O /var/www/html/${ISO_IMAGE_NAME}
      $ sudo wget https://mirror.openshift.com/pub/openshift-v4/dependencies/rhcos/pre-release/${OCP_VERSION}/${ROOTFS_IMAGE_NAME} -O /var/www/html/${ROOTFS_IMAGE_NAME}

验证步骤

  • 验证下载的镜像是否成功,并在断开连接的镜像主机上提供,例如:

    $ wget http://$(hostname)/${ISO_IMAGE_NAME}

    预期输出

    ...
    Saving to: rhcos-4.9.0-fc.1-x86_64-live.x86_64.iso
    rhcos-4.9.0-fc.1-x86_64-  11%[====>    ]  10.01M  4.71MB/s
    ...

18.10. 在断开连接的环境中安装 Red Hat Advanced Cluster Management

您可以在断开连接的环境中 hub 集群上使用 Red Hat Advanced Cluster Management (RHACM),在多个受管 spoke 集群中管理分布式单元 (DU) 配置集的部署。

先决条件

  • 安装 OpenShift Container Platform CLI(oc)。
  • 以具有 cluster-admin 特权的用户身份登录。
  • 配置断开连接的镜像 registry 以在集群中使用。

    注意

    如果要将 Operator 部署到 spoke 集群,还必须将它们添加到此 registry 中。如需更多信息,请参阅镜像 Operator 目录

流程

18.11. 在裸机上启用支持的安装程序服务

Assisted Installer Service (AIS) 部署 OpenShift Container Platform 集群。Red Hat Advanced Cluster Management (RHACM) 提供 AIS。当您在 RHACM hub 集群上启用 MultiClusterHub Operator 时,会部署 AIS。

对于分布式单元 (DU),RHACM 支持在单个裸机主机上运行的 OpenShift Container Platform 部署。单一节点集群同时充当 control plane 和 worker 节点。

先决条件

  • 在 hub 集群上安装 OpenShift Container Platform 4.9。
  • 安装 RHACM 并创建 MultiClusterHub 资源。
  • 为数据库和文件系统存储创建持久性卷自定义资源 (CR)。
  • 已安装 OpenShift CLI(oc)。

流程

  1. 修改 HiveConfig 资源,以便为辅助安装程序启用功能门:

     $ oc patch hiveconfig hive --type merge -p '{"spec":{"targetNamespace":"hive","logLevel":"debug","featureGates":{"custom":{"enabled":["AlphaAgentInstallStrategy"]},"featureSet":"Custom"}}}'
  2. 修改 Provisioning 资源,以允许 Bare Metal Operator 监视所有命名空间:

     $ oc patch provisioning provisioning-configuration --type merge -p '{"spec":{"watchAllNamespaces": true }}'
  3. 创建 AgentServiceConfig CR。

    1. agent_service_config.yaml 文件中保存以下 YAML:

      apiVersion: agent-install.openshift.io/v1beta1
      kind: AgentServiceConfig
      metadata:
       name: agent
      spec:
        databaseStorage:
          accessModes:
          - ReadWriteOnce
          resources:
            requests:
              storage: <db_volume_size> 1
        filesystemStorage:
          accessModes:
          - ReadWriteOnce
          resources:
            requests:
              storage: <fs_volume_size> 2
        osImages: 3
          - openshiftVersion: "<ocp_version>" 4
            version: "<ocp_release_version>" 5
            url: "<iso_url>" 6
            rootFSUrl: "<root_fs_url>" 7
            cpuArchitecture: "x86_64"
      1
      databaseStorage 字段的卷大小,如 10Gi
      2
      filesystemStorage 字段的卷大小,例如 20Gi
      3
      操作系统镜像详细信息列表.示例描述了单个 OpenShift Container Platform OS 版本。
      4
      要安装的 OpenShift Container Platform 版本,如 4.8
      5
      特定的安装版本,例如:47.83.202103251640-0
      6
      7
    2. 运行以下命令来创建 AgentServiceConfig CR:

      $ oc create -f agent_service_config.yaml

      输出示例

      agentserviceconfig.agent-install.openshift.io/agent created

18.12. ZTP 自定义资源

ZTP 使用自定义资源 (CR) 对象来扩展 Kubernetes API,或将您自己的 API 引入项目或集群中。这些 CR 包含为 RAN 应用程序安装和配置集群所需的站点特定数据。

自定义资源定义 (CRD) 文件定义了您自己的对象类型。将 CRD 部署到受管集群会导致 Kubernetes API 服务器开始为整个生命周期提供指定的 CR。

对于受管集群上 <site>.yaml 文件中的每个 CR,ZTP 使用这些数据在为集群命名的目录中创建安装 CR。

ZTP 提供了在受管集群上定义和安装 CR 的两种方法:在置备单个集群时手动使用,在置备多个集群时采用自动化方法。

为单个集群手动创建 CR
在为单个集群创建 CR 时使用此方法。这是在大规模部署前测试 CR 的好方法。
为多个受管集群自动创建 CR
安装多个受管集群时,请使用自动 SiteConfig 方法,例如在最多 100 个集群的批处理中。SiteConfig 使用 ArgoCD 作为站点部署的 GitOps 方法引擎。完成包含部署所需所有参数的站点计划后,策略生成器会创建清单并将其应用到 hub 集群。

两种方法都创建 CR,如下表中所示。在集群站点中,自动发现镜像 ISO 文件会创建一个带有站点名称和具有集群名称的文件的目录。每个集群都有自己的命名空间,所有 CR 都位于该命名空间下。命名空间和 CR 名称与集群名称匹配。

资源描述使用

BareMetalHost

包含目标裸机机器基板管理控制器 (BMC) 的连接信息。

提供对 BMC 的访问,以便使用 Redfish 协议在目标机器上加载和引导发现镜像 ISO。

InfraEnv

包含将 OpenShift Container Platform 拉取到目标裸机机器的信息。

与 ClusterDeployment 一起使用,为受管集群生成发现 ISO。

AgentClusterInstall

指定受管集群的配置,如联网和 supervisor (control plane) 节点的数量。安装完成后,显示 kubeconfig 和凭证。

指定受管集群配置信息,并在安装集群期间提供状态。

ClusterDeployment

引用要使用的 AgentClusterInstall

InfraEnv 配合使用,为受管集群生成发现 ISO。

NMStateConfig

提供网络配置信息,如 MACIP 映射、DNS 服务器、默认路由和其他网络设置。如果使用 DHCP,则不需要此操作。

为受管集群的 Kube API 服务器设置静态 IP 地址。

Agent

包含有关目标裸机机的硬件信息。

当目标机器的发现镜像 ISO 启动时,会在 hub 上自动创建。

ManagedCluster

当集群由 hub 管理时,必须导入并已知的集群。此 Kubernetes 对象提供该接口。

hub 使用这个资源来管理和显示受管集群的状态。

KlusterletAddonConfig

包含要部署到 ManagedCluster 的 hub 提供的服务列表。

告知 hub 部署到 ManagedCluster 的附加服务。

命名空间

hub 上已存在的 ManagedCluster 资源的逻辑空间。每个站点都是唯一的。

将资源传播到 ManagedCluster

Secret

创建两个自定义资源: BMC SecretImage Pull Secret

  • BMC Secret 使用用户名和密码进行身份验证到目标裸机机器中。
  • Image Pull Secret 包含目标裸机上安装的 OpenShift Container Platform 镜像的身份验证信息。

ClusterImageSet

包含 OpenShift Container Platform 镜像信息,如存储库和镜像名称。

传递给资源以提供 OpenShift Container Platform 镜像。

18.13. 创建自定义资源以安装单个受管集群

此流程告诉您如何手动创建和部署单个受管集群。如果您要创建多个集群(可能是数百个),请使用"为多个受管集群创建 ZTP 自定义资源"中所述的 SiteConfig 方法。

先决条件

  • 启用辅助安装程序服务.
  • 确保网络连接:

    • hub 中的容器必须能够访问目标裸机机器的 Baseboard Management Controller (BMC) 地址。
    • 受管集群必须能够解析并访问 hub 的 API hostname*.app hostname。hub API 和 *.app 主机名示例:

      console-openshift-console.apps.hub-cluster.internal.domain.com
      api.hub-cluster.internal.domain.com
    • hub 必须能够解析并访问受管集群的 API 和 *.app 主机名。以下是受管集群 API 和 *.app 主机名的示例:

      console-openshift-console.apps.sno-managed-cluster-1.internal.domain.com
      api.sno-managed-cluster-1.internal.domain.com
    • 可从目标裸机机器访问 IP 的 DNS 服务器。
  • 受管集群的目标裸机机器具有以下硬件最低要求:

    • 4 个 CPU 或 8 个 vCPU
    • 32 GiB RAM
    • root 文件系统 120 GiB 磁盘
  • 在断开连接的环境中工作时,发行镜像需要被镜像(mirror)。使用这个命令镜像镜像:

    oc adm release mirror -a <pull_secret.json>
    --from=quay.io/openshift-release-dev/ocp-release:{{ mirror_version_spoke_release }}
    --to={{ provisioner_cluster_registry }}/ocp4 --to-release-image={{
    provisioner_cluster_registry }}/ocp4:{{ mirror_version_spoke_release }}
  • 您已将用于生成 spoke 集群 ISO 的 ISO 和 rootfs 镜像到 HTTP 服务器,并配置用于从中拉取镜像的设置。

    镜像必须与 ClusterImageSet 的版本匹配。若要部署 4.9.0 版本,需要将 rootfs 和 ISO 设置为 4.9.0。

流程

  1. 为每个需要部署的特定集群版本创建一个 ClusterImageSetClusterImageSet 具有以下格式:

    apiVersion: hive.openshift.io/v1
    kind: ClusterImageSet
    metadata:
      name: openshift-4.9.0-rc.0 1
    spec:
       releaseImage: quay.io/openshift-release-dev/ocp-release:4.9.0-x86_64 2
    1
    name 是您要部署的描述性版本。
    2
    releaseImage 需要指向要部署的特定发行镜像。
  2. 为受管集群创建 Namespace 定义:

    apiVersion: v1
    kind: Namespace
    metadata:
         name: <cluster-name> 1
         labels:
            name: <cluster-name> 2
    1 2
    cluster-name 是要置备的受管集群的名称。
  3. 创建 BMC Secret 自定义资源:

    apiVersion: v1
    data:
      password: <bmc-password> 1
      username: <bmc-username> 2
    kind: Secret
    metadata:
      name: <cluster-name>-bmc-secret
      namespace: <cluster-name>
    type: Opaque
    1
    BMC-password 是目标裸机机器的密码。必须经过 base-64 编码。
    2
    BMC-username 是目标裸机机器的用户名。必须经过 base-64 编码。
  4. 创建 Image Pull Secret 自定义资源:

    apiVersion: v1
    data:
      .dockerconfigjson: <pull-secret> 1
    kind: Secret
    metadata:
      name: assisted-deployment-pull-secret
      namespace: <cluster-name>
    type: kubernetes.io/dockerconfigjson
    1
    pull-secret 是 OpenShift Container Platform pull secret。必须经过 base-64 编码。
  5. 创建 AgentClusterInstall 自定义资源:

    apiVersion: extensions.hive.openshift.io/v1beta1
    kind: AgentClusterInstall
    metadata:
      # Only include the annotation if using OVN, otherwise omit the annotation
      annotations:
        agent-install.openshift.io/install-config-overrides: '{"networking":{"networkType":"OVNKubernetes"}}'
      name: <cluster-name>
      namespace: <cluster-name>
    spec:
      clusterDeploymentRef:
        name: <cluster-name>
      imageSetRef:
        name: <cluster-image-set> 1
      networking:
        clusterNetwork:
        - cidr: <cluster-network-cidr> 2
          hostPrefix: 23
        machineNetwork:
        - cidr: <machine-network-cidr> 3
        serviceNetwork:
        - <service-network-cidr> 4
      provisionRequirements:
        controlPlaneAgents: 1
        workerAgents: 0
      sshPublicKey: <public-key> 5
    1
    cluster-image-set 是用于在裸机上安装 OpenShift Container Platform 的 ClusterImageSet 自定义资源的名称。
    2
    cluster-network-cidr 是 CIDR 表示法中用于集群节点间通信的 IPv4 或 IPv6 地址块。
    3
    machine-network-cidr 是 CIDR 表示法中 IPv4 或 IPv6 地址的块,用于目标裸机服务器外部通信。还用于在置备 DU 单节点集群时决定 API 和 Ingress VIP 地址。
    4
    service-network-cidr 是 CIDR 表示法中 IPv4 或 IPv6 地址的块,用于集群服务内部通信。
    5
    以纯文本形式 输入的公钥 可用于在节点安装后通过 SSH 连接到节点。
    注意

    如果要在此时为受管集群配置静态 IP,请参阅本文档中的步骤为受管集群配置静态 IP 地址。

  6. 创建 ClusterDeployment 自定义资源:

    apiVersion: hive.openshift.io/v1
    kind: ClusterDeployment
    metadata:
      name: <cluster-name>
      namespace: <cluster-name>
    spec:
      baseDomain: <base-domain> 1
      clusterInstallRef:
        group: extensions.hive.openshift.io
        kind: AgentClusterInstall
        name: <cluster-name>
        version: v1beta1
      clusterName: <cluster-name>
      platform:
        agentBareMetal:
          agentSelector:
            matchLabels:
              cluster-name: <cluster-name>
      pullSecretRef:
        name: assisted-deployment-pull-secret
    1
    base-domain 是受管集群的基域。
  7. 创建 KlusterletAddonConfig 自定义资源:

    apiVersion: agent.open-cluster-management.io/v1
    kind: KlusterletAddonConfig
    metadata:
      name: <cluster-name>
      namespace: <cluster-name>
    spec:
      clusterName: <cluster-name>
      clusterNamespace: <cluster-name>
      clusterLabels:
        cloud: auto-detect
        vendor: auto-detect
      applicationManager:
        enabled: true
      certPolicyController:
        enabled: false
      iamPolicyController:
        enabled: false
      policyController:
        enabled: true
      searchCollector:
        enabled: false 1
    1
    enabled: 设置为 true 以启用 KlusterletAddonConfig 或 false 来禁用 KlusterletAddonConfig。禁用 searchCollector
  8. 创建 ManagedCluster 自定义资源:

    apiVersion: cluster.open-cluster-management.io/v1
    kind: ManagedCluster
    metadata:
      name: <cluster-name>
    spec:
      hubAcceptsClient: true
  9. 创建 InfraEnv 自定义资源:

    apiVersion: agent-install.openshift.io/v1beta1
    kind: InfraEnv
    metadata:
      name: <cluster-name>
      namespace: <cluster-name>
    spec:
      clusterRef:
        name: <cluster-name>
        namespace: <cluster-name>
      sshAuthorizedKey: <public-key> 1
      agentLabelSelector:
        matchLabels:
          cluster-name: <cluster-name>
      pullSecretRef:
        name: assisted-deployment-pull-secret
    1
    以纯文本形式输入 public-key,并在主机从 ISO 引导时通过 SSH 连接到目标裸机计算机。
  10. 创建 BareMetalHost 自定义资源:

    apiVersion: metal3.io/v1alpha1
    kind: BareMetalHost
    metadata:
      name: <cluster-name>
      namespace: <cluster-name>
      annotations:
        inspect.metal3.io: disabled
      labels:
        infraenvs.agent-install.openshift.io: "<cluster-name>"
    spec:
      bootMode: "UEFI"
      bmc:
        address: <bmc-address> 1
        disableCertificateVerification: true
        credentialsName: <cluster-name>-bmc-secret
      bootMACAddress: <mac-address> 2
      automatedCleaningMode: disabled
      online: true
    1
    BMC-address 是目标裸机上安装 ISO 的基板管理控制台地址。
    2
    MAC-address 是目标裸机机器的 MAC 地址。

    另外,您可以添加 bmac.agent-install.openshift.io/hostname: <host-name> 作为设置受管集群主机名的注解,否则它将默认为 DHCP 服务器或本地主机的主机名。

  11. 创建自定义资源后,将生成的自定义资源的整个目录推送到您为存储自定义资源创建的 Git 存储库。

后续步骤

要置备其他集群,请对每个集群重复此步骤。

18.13.1. 为受管集群配置静态 IP 地址

另外,在创建 AgentClusterInstall 自定义资源后,您可以为受管集群配置静态 IP 地址。

注意

您必须先创建此自定义资源,然后才能创建 ClusterDeployment 自定义资源。

先决条件

  • 部署并配置 AgentClusterInstall 自定义资源。

流程

  1. 创建 NMStateConfig 自定义资源:

    apiVersion: agent-install.openshift.io/v1beta1
    kind: NMStateConfig
    metadata:
     name: <cluster-name>
     namespace: <cluster-name>
     labels:
       sno-cluster-<cluster-name>: <cluster-name>
    spec:
     config:
       interfaces:
         - name: eth0
           type: ethernet
           state: up
           ipv4:
             enabled: true
             address:
               - ip: <ip-address> 1
                 prefix-length: <public-network-prefix> 2
             dhcp: false
       dns-resolver:
         config:
           server:
             - <dns-resolver> 3
       routes:
         config:
           - destination: 0.0.0.0/0
             next-hop-address: <gateway> 4
             next-hop-interface: eth0
             table-id: 254
     interfaces:
       - name: "eth0" 5
         macAddress: <mac-address> 6
    1
    ip-address 是目标裸机机器的静态 IP 地址。
    2
    public-network-prefix 是目标裸机的静态 IP 地址的子网前缀。
    3
    dns-resolver 是目标裸机机器的 DNS 服务器。
    4
    gateway 是目标裸机机器的网关。
    5
    name 必须与 interfaces 部分中指定的名称匹配。
    6
    Mac-address 是接口的 mac 地址。
  2. 在创建 BareMetalHost 自定义资源时,请确保其 mac 地址之一与 NMStateConfig 目标裸机中的 mac 地址匹配。
  3. 在创建 InfraEnv 自定义资源时,引用 InfraEnv 自定义资源中的 NMStateConfig 自定义资源中的标签:

    apiVersion: agent-install.openshift.io/v1beta1
    kind: InfraEnv
    metadata:
      name: <cluster-name>
      namespace: <cluster-name>
    spec:
      clusterRef:
        name: <cluster-name>
        namespace: <cluster-name>
      sshAuthorizedKey: <public-key>
      agentLabelSelector:
        matchLabels:
          cluster-name: <cluster-name>
      pullSecretRef:
        name: assisted-deployment-pull-secret
      nmStateConfigLabelSelector:
        matchLabels:
          sno-cluster-<cluster-name>: <cluster-name> # Match this label

18.13.2. 用于置备集群的自动发现镜像 ISO 流程

创建自定义资源后,会自动执行以下操作:

  1. 在目标机器上生成并启动发现镜像 ISO 文件。
  2. 当 ISO 文件成功在目标机器上启动时,它会报告目标计算机的硬件信息。
  3. 在所有主机被发现后,会安装 OpenShift Container Platform。
  4. 当 OpenShift Container Platform 完成安装后,hub 在目标集群上安装 klusterlet 服务。
  5. 请求的附加组件服务安装在目标集群中。

当在受管集群的 hub 上创建 Agent 自定义资源时,发现镜像 ISO 过程会完成。

18.13.3. 检查受管集群状态

通过检查集群状态,确保集群置备成功。

先决条件

  • 所有自定义资源都已配置并置备,在受管集群的 hub 上创建 Agent 自定义资源。

流程

  1. 检查受管集群的状态:

    $ oc get managedcluster

    True 表示受管集群已就绪。

  2. 检查代理状态:

    $ oc get agent -n <cluster-name>
  3. 使用 describe 命令,提供代理条件的深入描述。支持的状态包括 BackendErrorInputErrorValidationsFailingInFailedAgentIsConnected。这些状态与 AgentAgentClusterInstall 自定义资源相关。

    $ oc describe agent -n <cluster-name>
  4. 检查集群置备状态:

    $ oc get agentclusterinstall -n <cluster-name>
  5. 使用 describe 命令提供集群置备状态的深入描述:

    $ oc describe agentclusterinstall -n <cluster-name>
  6. 检查受管集群的附加服务的状态:

    $ oc get managedclusteraddon -n <cluster-name>
  7. 检索受管集群的 kubeconfig 文件的身份验证信息:

    $ oc get secret -n <cluster-name> <cluster-name>-admin-kubeconfig -o jsonpath={.data.kubeconfig} | base64 -d > <directory>/<cluster-name>-kubeconfig

18.13.4. 为断开连接的环境配置受管集群

完成前面的步骤后,按照以下步骤为断开连接的环境配置受管集群。

先决条件

  • 断开连接的 Red Hat Advanced Cluster Management (RHACM) 2.3 安装。
  • 在 HTTPD 服务器上托管 rootfsiso 镜像。

流程

  1. 创建包含镜像 registry 配置的 ConfigMap

    apiVersion: v1
    kind: ConfigMap
    metadata:
      name: assisted-installer-mirror-config
      namespace: assisted-installer
      labels:
        app: assisted-service
    data:
      ca-bundle.crt: <certificate> 1
      registries.conf: |  2
        unqualified-search-registries = ["registry.access.redhat.com", "docker.io"]
    
        [[registry]]
          location = <mirror-registry-url>  3
          insecure = false
          mirror-by-digest-only = true
    1
    certificate 是创建镜像 registry 时使用的镜像 registry 证书。
    2
    registry-config 是镜像 registry 的配置。
    3
    mirror-registry-url 是镜像 registry 的 URL。

    这会更新 AgentServiceConfig 自定义资源中的 mirrorRegistryRef,如下所示:

    输出示例

    apiVersion: agent-install.openshift.io/v1beta1
    kind: AgentServiceConfig
    metadata:
      name: agent
      namespace: assisted-installer
    spec:
      databaseStorage:
        volumeName: <db-pv-name>
        accessModes:
        - ReadWriteOnce
        resources:
          requests:
            storage: <db-storage-size>
      filesystemStorage:
        volumeName: <fs-pv-name>
        accessModes:
        - ReadWriteOnce
        resources:
          requests:
            storage: <fs-storage-size>
      mirrorRegistryRef:
        name: 'assisted-installer-mirror-config'
      osImages:
        - openshiftVersion: <ocp-version>
          rootfs: <rootfs-url> 1
          url: <iso-url> 2

    1 2
    rootfs-urliso-url 必须与 HTTPD 服务器的 URL 匹配。
  2. 对于断开连接的安装,您必须部署可通过断开连接的网络访问的 NTP 时钟。您可以配置 chrony 作为服务器,编辑 /etc/chrony.conf 文件,并添加以下允许的 IPv6 范围:

    # Allow NTP client access from local network.
    #allow 192.168.0.0/16
    local stratum 10
    bindcmdaddress ::
    allow 2620:52:0:1310::/64

18.13.5. 为断开连接的环境配置 IPv6 地址

另外,在创建 AgentClusterInstall 自定义资源时,您可以为受管集群配置 IPV6 地址。

流程

  1. AgentClusterInstall 自定义资源中,修改 IPv6 地址的 clusterNetworkserviceNetwork

    apiVersion: extensions.hive.openshift.io/v1beta1
    kind: AgentClusterInstall
    metadata:
      # Only include the annotation if using OVN, otherwise omit the annotation
      annotations:
        agent-install.openshift.io/install-config-overrides: '{"networking":{"networkType":"OVNKubernetes"}}'
      name: <cluster-name>
      namespace: <cluster-name>
    spec:
      clusterDeploymentRef:
        name: <cluster-name>
      imageSetRef:
        name: <cluster-image-set>
      networking:
        clusterNetwork:
        - cidr: "fd01::/48"
          hostPrefix: 64
        machineNetwork:
        - cidr: <machine-network-cidr>
        serviceNetwork:
        - "fd02::/112"
      provisionRequirements:
        controlPlaneAgents: 1
        workerAgents: 0
      sshPublicKey: <public-key>
  2. 使用您定义的 IPv6 地址更新 NMStateConfig 自定义资源。

18.13.6. 受管集群故障排除

使用这个流程诊断受管集群中可能出现的任何安装问题。

流程

  1. 检查受管集群的状态:

    $ oc get managedcluster

    输出示例

    NAME            HUB ACCEPTED   MANAGED CLUSTER URLS   JOINED   AVAILABLE   AGE
    SNO-cluster     true                                   True     True      2d19h

    如果 AVAILABLE 列中的状态为 True,受管集群由 hub 管理。

    如果 AVAILABLE 列中的状态为 Unknown,则受管集群不会由 hub 管理。使用以下步骤继续检查 以了解更多信息。

  2. 检查 AgentClusterInstall 安装状态:

    $ oc get clusterdeployment -n <cluster-name>

    输出示例

    NAME        PLATFORM            REGION   CLUSTERTYPE   INSTALLED    INFRAID    VERSION  POWERSTATE AGE
    Sno0026    agent-baremetal                               false                          Initialized
    2d14h

    如果 INSTALLED 列中的状态为 false,则安装会失败。

  3. 如果安装失败,输入以下命令查看 AgentClusterInstall 资源的状态:

    $ oc describe agentclusterinstall -n <cluster-name> <cluster-name>
  4. 解决错误并重置集群:

    1. 删除集群的命名空间:

      $ oc delete namespace <cluster-name>

      这会删除为此集群创建的所有命名空间范围自定义资源。

    2. 删除集群的受管集群资源:

      $ oc delete managedcluster <cluster-name>
    3. 为受管集群重新创建自定义资源。

18.14. 应用 RAN 策略来监控集群活动

ZTP 使用 Red Hat Advanced Cluster Management (RHACM) 来使用基于策略的监管方法自动监控集群活动,以应用无线访问网络 (RAN) 策略。

策略生成器 (PolicyGen) 是一个 Kustomize 插件,可帮助从预定义的自定义资源创建 ACM 策略。有三个主要项目:策略类别、源 CR 策略和 PolicyGenTemplate。PolicyGen 依赖于这些策略生成策略及其放置绑定和规则。

下图显示了 RAN 策略生成器如何与 GitOps 和 ACM 交互。

RAN 策略生成器

RAN 策略分为三个主要组:

Common
Common category 中存在的策略应用于由站点计划表示的所有集群。
Groups 类别中存在的策略应用到一组集群。每个集群组都可以具有自己在组类别下的策略。例如,Groups/group1 可以具有自己的策略,应用到属于 group1 的 群集。
Sites
Sites 类别中存在的策略应用到特定的集群。任何集群可能有自己的策略,它们存在于 Sites 类别中。例如,Sites/cluster1 会将自己的策略应用到 cluster1

下图显示了策略的生成方式。

生成策略

18.14.1. 应用源自定义资源策略

源自定义资源策略包括以下几项:

  • SR-IOV 策略
  • PTP 策略
  • Performance Add-on Operator 策略
  • MachineConfigPool 策略
  • SCTP 策略

您需要定义用于生成 ACM 策略的源自定义资源,并考虑可能的元数据或 spec/data 覆盖。例如,common-namespace-policy 包含所有受管集群中存在的 Namespace 定义。此 命名空间 放置在 Common 类别下,其 spec 或所有集群中的数据没有更改。

命名空间策略示例

以下示例显示了此命名空间的源自定义资源:

apiVersion: v1
kind: Namespace
metadata:
 name: openshift-sriov-network-operator
 labels:
   openshift.io/run-level: "1"

输出示例

应用此 命名空间 生成的策略包括上面定义的命名空间,而不做任何更改,如下例所示:

apiVersion: policy.open-cluster-management.io/v1
kind: Policy
metadata:
   name: common-sriov-sub-ns-policy
   namespace: common-sub
   annotations:
       policy.open-cluster-management.io/categories: CM Configuration Management
       policy.open-cluster-management.io/controls: CM-2 Baseline Configuration
       policy.open-cluster-management.io/standards: NIST SP 800-53
spec:
   remediationAction: enforce
   disabled: false
   policy-templates:
       - objectDefinition:
           apiVersion: policy.open-cluster-management.io/v1
           kind: ConfigurationPolicy
           metadata:
               name: common-sriov-sub-ns-policy-config
           spec:
               remediationAction: enforce
               severity: low
               namespaceselector:
                   exclude:
                       - kube-*
                   include:
                       - '*'
               object-templates:
                   - complianceType: musthave
                     objectDefinition:
                       apiVersion: v1
                       kind: Namespace
                       metadata:
                           labels:
                               openshift.io/run-level: "1"
                           name: openshift-sriov-network-operator

SRIOV 策略示例

以下示例显示了存在于不同集群中的一个 SriovNetworkNodePolicy 定义,每个集群都有不同的规格。这个示例还显示了 SriovNetworkNodePolicy 的源自定义资源:

apiVersion: sriovnetwork.openshift.io/v1
kind: SriovNetworkNodePolicy
metadata:
  name: sriov-nnp
  namespace: openshift-sriov-network-operator
spec:
  # The $ tells the policy generator to overlay/remove the spec.item in the generated policy.
  deviceType: $deviceType
  isRdma: false
  nicSelector:
    pfNames: [$pfNames]
  nodeSelector:
    node-role.kubernetes.io/worker: ""
  numVfs: $numVfs
  priority: $priority
  resourceName: $resourceName

输出示例

对于所有集群,SriovNetworkNodePolicy 名称和 namespace 相同,因此在 source SriovNetworkNodePolicy 中定义。但是,生成的策略需要 $deviceType$numVfs 作为输入参数,以便调整每个集群的策略。本例中显示了生成的策略:

apiVersion: policy.open-cluster-management.io/v1
kind: Policy
metadata:
    name: site-du-sno-1-sriov-nnp-mh-policy
    namespace: sites-sub
    annotations:
        policy.open-cluster-management.io/categories: CM Configuration Management
        policy.open-cluster-management.io/controls: CM-2 Baseline Configuration
        policy.open-cluster-management.io/standards: NIST SP 800-53
spec:
    remediationAction: enforce
    disabled: false
    policy-templates:
        - objectDefinition:
            apiVersion: policy.open-cluster-management.io/v1
            kind: ConfigurationPolicy
            metadata:
                name: site-du-sno-1-sriov-nnp-mh-policy-config
            spec:
                remediationAction: enforce
                severity: low
                namespaceselector:
                    exclude:
                        - kube-*
                    include:
                        - '*'
                object-templates:
                    - complianceType: musthave
                      objectDefinition:
                        apiVersion: sriovnetwork.openshift.io/v1
                        kind: SriovNetworkNodePolicy
                        metadata:
                            name: sriov-nnp-du-mh
                            namespace: openshift-sriov-network-operator
                        spec:
                            deviceType: vfio-pci
                            isRdma: false
                            nicSelector:
                                pfNames:
                                    - ens7f0
                            nodeSelector:
                                node-role.kubernetes.io/worker: ""
                            numVfs: 8
                            resourceName: du_mh
注意

不强制将所需的输入参数定义为 $value,如 $deviceType$ 告知策略生成器从生成的策略中覆盖或删除项目。否则,值不会改变。

18.14.2. PolicyGenTemplate

PolicyGenTemplate.yaml 文件是一个自定义资源定义(CRD),用于告知 PolicyGen 在何处对生成的策略和需要过量的策略进行分类。

以下示例显示了 PolicyGenTemplate.yaml 文件:

apiVersion: ran.openshift.io/v1
kind: PolicyGenTemplate
metadata:
  name: "group-du-sno"
  namespace: "group-du-sno"
spec:
  bindingRules:
    group-du-sno: ""
  mcp: "master"
  sourceFiles:
    - fileName: ConsoleOperatorDisable.yaml
      policyName: "console-policy"
    - fileName: ClusterLogging.yaml
      policyName: "cluster-log-policy"
      spec:
        curation:
          curator:
            schedule: "30 3 * * *"
          collection:
            logs:
              type: "fluentd"
              fluentd: {}

group-du-ranGen.yaml 文件在名为 group-du 的组中定义了一组策略。此文件定义 MachineConfigPool worker-du,用作 sourceFiles 中定义的任何其他策略的节点选择器。为 sourceFiles 中的所有源文件生成 ACM 策略。此外,生成单个放置绑定和放置规则,为 group-du 策略应用集群选择规则。

使用源文件 PtpConfigSlave.yaml 作为示例,PtpConfigSlave 具有 PtpConfig 自定义资源 (CR) 的定义。为 PtpConfigSlave 示例生成的策略名为 group-du-ptp-config-policy。生成的 group-du-ptp-config-policy 中定义的 PtpConfig CR 被命名为 du-ptp-slavePtpConfigSlave.yaml 中定义的 spec 放置在 du-ptp-slave 下,以及与源文件中定义的其他 spec 项目一起放置。

以下示例显示了 group-du-ptp-config-policy:

apiVersion: policy.open-cluster-management.io/v1
kind: Policy
metadata:
  name: group-du-ptp-config-policy
  namespace: groups-sub
  annotations:
    policy.open-cluster-management.io/categories: CM Configuration Management
    policy.open-cluster-management.io/controls: CM-2 Baseline Configuration
    policy.open-cluster-management.io/standards: NIST SP 800-53
spec:
    remediationAction: enforce
    disabled: false
    policy-templates:
        - objectDefinition:
            apiVersion: policy.open-cluster-management.io/v1
            kind: ConfigurationPolicy
            metadata:
                name: group-du-ptp-config-policy-config
            spec:
                remediationAction: enforce
                severity: low
                namespaceselector:
                    exclude:
                        - kube-*
                    include:
                        - '*'
                object-templates:
                    - complianceType: musthave
                      objectDefinition:
                        apiVersion: ptp.openshift.io/v1
                        kind: PtpConfig
                        metadata:
                            name: slave
                            namespace: openshift-ptp
                        spec:
                            recommend:
                                - match:
                                - nodeLabel: node-role.kubernetes.io/worker-du
                                  priority: 4
                                  profile: slave
                            profile:
                                - interface: ens5f0
                                  name: slave
                                  phc2sysOpts: -a -r -n 24
                                  ptp4lConf: |
                                    [global]
                                    #
                                    # Default Data Set
                                    #
                                    twoStepFlag 1
                                    slaveOnly 0
                                    priority1 128
                                    priority2 128
                                    domainNumber 24
                                    .....

18.14.3. 创建自定义资源策略时的注意事项

  • 定义用于创建 ACM 策略的自定义资源时,应考虑可能的元数据和 spec/data 覆盖。例如,如果自定义资源 metadata.name 在集群间没有改变,则应在自定义资源文件中设置 metadata.name 值。如果自定义资源在同一集群中有多个实例,则必须在策略模板文件中定义自定义资源 metadata.name
  • 要为特定机器配置池应用节点选择器,您必须将节点选择器值设置为 $mcp,以便策略生成器使用策略模板中定义的 mcp 覆盖 $mcp 值。
  • 订阅源文件不会改变。

18.14.4. 生成 RAN 策略

先决条件

  • 安装 Kustomize
  • 安装 golang

流程

  1. 使用以下命令构建插件:

    $ cd ztp/ztp-policy-generator/kustomize/plugin/policyGenerator/v1/policygenerator/
    $ go build -o PolicyGenerator

    kustomization.yaml 文件包含对 policyGenerator.yaml 文件的引用。以下示例显示了 PolicyGenerator 定义:

    apiVersion: policyGenerator/v1
    kind: PolicyGenerator
    metadata:
      name: acm-policy
      namespace: acm-policy-generator
    # The arguments should be given and defined as below with same order --policyGenTempPath= --sourcePath= --outPath= --stdout --customResources
    argsOneLiner: ./ranPolicyGenTempExamples ./sourcePolicies ./out true false

    其中:

    • policyGenTempPathpolicyGenTemp 文件的路径。
    • sourcePath:是源策略的路径。
    • outPath:是保存生成的 ACM 策略的路径。
    • stdout:如果为 true,请将生成的策略输出到控制台。
    • CustomResources: 如果为 true,从 sourcePolicies 文件生成没有 ACM 策略的 CR。
  2. 运行以下命令来测试 PolicyGen:

    $ cd cnf-features-deploy/ztp/ztp-policy-generator/
    $ XDG_CONFIG_HOME=./ kustomize build --enable-alpha-plugins

    out 目录会创建并带有预期的策略,如下例所示:

    out
    ├── common
    │   ├── common-log-sub-ns-policy.yaml
    │   ├── common-log-sub-oper-policy.yaml
    │   ├── common-log-sub-policy.yaml
    │   ├── common-pao-sub-catalog-policy.yaml
    │   ├── common-pao-sub-ns-policy.yaml
    │   ├── common-pao-sub-oper-policy.yaml
    │   ├── common-pao-sub-policy.yaml
    │   ├── common-policies-placementbinding.yaml
    │   ├── common-policies-placementrule.yaml
    │   ├── common-ptp-sub-ns-policy.yaml
    │   ├── common-ptp-sub-oper-policy.yaml
    │   ├── common-ptp-sub-policy.yaml
    │   ├── common-sriov-sub-ns-policy.yaml
    │   ├── common-sriov-sub-oper-policy.yaml
    │   └── common-sriov-sub-policy.yaml
    ├── groups
    │   ├── group-du
    │   │   ├── group-du-mc-chronyd-policy.yaml
    │   │   ├── group-du-mc-mount-ns-policy.yaml
    │   │   ├── group-du-mcp-du-policy.yaml
    │   │   ├── group-du-mc-sctp-policy.yaml
    │   │   ├── group-du-policies-placementbinding.yaml
    │   │   ├── group-du-policies-placementrule.yaml
    │   │   ├── group-du-ptp-config-policy.yaml
    │   │   └── group-du-sriov-operconfig-policy.yaml
    │   └── group-sno-du
    │       ├── group-du-sno-policies-placementbinding.yaml
    │       ├── group-du-sno-policies-placementrule.yaml
    │       ├── group-sno-du-console-policy.yaml
    │       ├── group-sno-du-log-forwarder-policy.yaml
    │       └── group-sno-du-log-policy.yaml
    └── sites
        └── site-du-sno-1
            ├── site-du-sno-1-policies-placementbinding.yaml
            ├── site-du-sno-1-policies-placementrule.yaml
            ├── site-du-sno-1-sriov-nn-fh-policy.yaml
            ├── site-du-sno-1-sriov-nnp-mh-policy.yaml
            ├── site-du-sno-1-sriov-nw-fh-policy.yaml
            ├── site-du-sno-1-sriov-nw-mh-policy.yaml
            └── site-du-sno-1-.yaml

    通用策略是扁平的,因为它们将应用到所有群集。但是,组和站点具有每个组和站点的子目录,因为它们将应用到不同的群集。

18.15. 集群置备

ZTP 使用分层方法调配集群。基本组件包括 Red Hat Enterprise Linux CoreOS (RHCOS)、集群的基本操作系统和 OpenShift Container Platform。安装这些组件后,worker 节点可以加入现有集群。当节点加入现有集群时,会应用 5G RAN 配置集 Operator。

下图说明了这种架构。

集群置备

每个集群中都部署了以下 RAN Operator:

  • 机器配置
  • 精度时间协议 (PTP)
  • Performance Addon Operator
  • SR-IOV
  • Local Storage Operator
  • Logging Operator

18.15.1. Machine Config Operator

Machine Config Operator 启用系统定义和低级系统设置,如工作负载分区、NTP 和 SCTP。此 Operator 与 OpenShift Container Platform 一起安装。

性能配置集及其创建的产品会根据关联的机器配置池(MCP)应用到节点。MCP 包含有关应用由性能附加组件创建的机器配置的有价值的信息,它包括了内核 arg、kube 配置、巨页分配和实时内核 (rt-kernel) 的部署。性能附加控制器监控 MCP 中的更改,并相应地更新性能配置集状态。

18.15.2. Performance Addon Operator

Performance Addon Operator 提供了在一组节点上启用高级节点性能调整的功能。

OpenShift Container Platform 提供了一个 Performance Addon Operator 来实现自动性能优化,以便为 OpenShift Container Platform 应用程序实现低延迟性能。集群管理员使用此性能配置集配置,这有助于以更可靠的方式进行更改。

管理员可以指定将内核更新到 rt-kernel,保留 CPU 用于管理工作负载,并使用 CPU 运行工作负载。

18.15.3. SR-IOV Operator

Single Root I/O Virtualization(SR-IOV)Network Operator 管理集群中的 SR-IOV 网络设备和网络附加。

SR-IOV Operator 允许在设备级别使用集群中运行的网络功能来虚拟和共享网络接口。

SR-IOV Network Operator 添加了 SriovOperatorConfig.sriovnetwork.openshift.io 自定义资源定义 (CRD)。Operator 会在 openshift-sriov-network-operator 命名空间中自动创建一个名为 default 的 SriovOperatorConfig 自定义资源。default 自定义资源包含集群的 SR-IOV Network Operator 配置。

18.15.4. 精度时间协议 Operator

PTP Operator 是一个用于同步网络中时钟的协议。与硬件支持一起使用时,PTP 可以降低微秒的准确性。PTP 支持在内核和用户空间之间被划分开。

PTP 同步的时钟按 master 工作程序层次结构进行组织。工作程序与其主节点同步,主节点可能是他们自己的员工。层次结构由最佳 master 时钟 (BMC) 算法自动创建和更新,该算法在每个时钟上运行。当时钟只有一个端口时,它可以是 master 或 worker,此类时钟被称为普通时钟 (OC)。具有多个端口的时钟可以在一个端口上主控,而在其他端口上工作程序则为主时钟,此类时钟称为边界时钟 (BC)。顶级主时钟称为协调主机时钟,可以通过使用全局定位系统 (GPS) 时间源同步。通过使用基于NC 的时间源,不同的网络可以与高度精确度同步。

18.16. 为多个受管集群创建 ZTP 自定义资源

如果您要安装多个受管集群,则 ZTP 使用 ArgoCD 和 SiteConfig 来管理创建自定义资源 (CR) 的进程,并使用 GitOps 方法为多个集群 (每次批处理不超过 100 个) 生成并应用策略。

安装和部署集群分为两个阶段,如下所示:

安装和部署集群的 GitOps 方法

18.16.1. 部署 ZTP 管道的先决条件

  • OpenShift 集群版本 4.8 或更高版本已安装 Red Hat GitOps Operator。
  • 已安装 Red Hat Advanced Cluster Management(RHACM)版本 2.3 或更高版本。
  • 对于断开连接的环境,请确保您的源数据 Git 存储库和 ztp-site-generator 容器镜像可从 hub 集群中访问。
  • 如果您需要额外的自定义内容,如额外安装清单或策略的自定义资源(CR),请将它们添加到 /usr/src/hook/ztp/source-crs/extra-manifest/ 目录中。同样,您可以将从 PolicyGenTemplate 引用的额外配置 CR 添加到 /usr/src/hook/ztp/source-crs/ 目录中。

    • 创建一个将额外清单添加到红帽提供的镜像的 Containerfile,例如:

      FROM <registry fqdn>/ztp-site-generator:latest 1
      COPY myInstallManifest.yaml /usr/src/hook/ztp/source-crs/extra-manifest/
      COPY mySourceCR.yaml /usr/src/hook/ztp/source-crs/
      1
      <registry fqdn> 必须指向包含红帽提供的 ztp-site-generator 容器镜像的 registry。
    • 构建包含这些额外文件的新容器镜像:

      $> podman build Containerfile.example

18.16.2. 安装 GitOps ZTP 管道

本节中的步骤告诉您如何完成以下任务:

  • 准备托管站点配置数据所需的 Git 存储库。
  • 配置 hub 集群以生成所需的安装和策略自定义资源 (CR)。
  • 使用 ZTP 部署受管集群。

18.16.2.1. 准备 ZTP Git 存储库

创建用于托管站点配置数据的 Git 存储库。ZTP 管道需要读取此存储库。

流程

  1. 使用 SiteConfigPolicyGenTemplate 自定义资源 (CR) 的单独路径创建一个目录结构。
  2. pre-sync.yamlpost-sync.yamlresource-hook-example/<policygentemplates>/ 添加到 PolicyGenTemplate CR 的路径。
  3. pre-sync.yamlpost-sync.yamlresource-hook-example/<siteconfig>/ 添加到 SiteConfig CR 的路径。

    注意

    如果您的 hub 集群在断开连接的环境中工作,则必须为所有四个 pre 和 post 同步 hook CR 更新 镜像

  4. 应用 policygentemplates.ran.openshift.iositeconfigs.ran.openshift.io CR 定义。

18.16.2.2. 为 ZTP 准备 hub 集群

您可以使用一组 ArgoCD 应用程序来配置 hub 集群,这些应用程序会根据 ZTP GitOps 流为每个站点生成所需的安装和策略自定义资源 (CR)。

流程

  1. 在 hub 集群上安装 Red Hat OpenShift GitOps Operator。
  2. 提取 ArgoCD 的管理员密码:

    $ oc get secret openshift-gitops-cluster -n openshift-gitops -o jsonpath='{.data.admin\.password}' | base64 -d
  3. 准备 ArgoCD 管道配置:

    1. 使用最新的容器镜像版本,从 ZTP 站点生成器容器中提取 ArgoCD 部署 CR:

      $ mkdir ztp
      $ podman run --rm -v `pwd`/ztp:/mnt/ztp:Z registry.redhat.io/openshift4/ztp-site-generate-rhel8:v4.9.0-1 /bin/bash -c "cp -ar /usr/src/hook/ztp/* /mnt/ztp/"

      本节中剩余的步骤与 ztp/gitops-subscriptions/argocd/ 目录相关。

    2. 使用适当的 URL、targetRevision 分支和路径值修改两个 ArgoCD 应用程序 deployment/clusters-app.yamldeployment/policies-app.yaml 的源值。路径值必须与 Git 存储库中使用的值匹配。

      修改 deployment/clusters-app.yaml

      apiVersion: v1
      kind: Namespace
      metadata:
           name: clusters-sub
      ---
      apiVersion: argoproj.io/v1alpha1
      kind: Application
      metadata:
           name: clusters
           namespace: openshift-gitops
      spec:
          destination:
               server: https://kubernetes.default.svc
               namespace: clusters-sub
        project: default
        source:
            path: ztp/gitops-subscriptions/argocd/resource-hook-example/siteconfig 1
            repoURL: https://github.com/openshift-kni/cnf-features-deploy 2
            targetRevision: master 3
        syncPolicy:
            automated:
                prune: true
                selfHeal: true
             syncOptions:
             - CreateNamespace=true
      1
      path 是包含集群的 siteconfig CR 的 ztp/gitops-subscriptions/argocd/ 文件路径。
      2
      repoURL 是 Git 存储库的 URL,其中包含了 siteconfig 自定义资源,用于定义用于安装集群的站点配置。
      3
      targetRevision 是包含相关站点配置数据的 Git 存储库上的分支。
    3. 修改 deployment/policies-app.yaml

      apiVersion: v1
      kind: Namespace
      metadata:
                name: policies-sub
      ---
      apiVersion: argoproj.io/v1alpha1
      kind: Application
      metadata:
            name: policies
            namespace: openshift-gitops
      spec:
        destination:
              server: https://kubernetes.default.svc
              namespace: policies-sub
        project: default
        source:
             directory:
                 recurse: true
              path: ztp/gitops-subscriptions/argocd/resource-hook-example/policygentemplates 1
              repoURL: https://github.com/openshift-kni/cnf-features-deploy 2
              targetRevision: master 3
        syncPolicy:
            automated:
                prune: true
                selfHeal: true
             syncOptions:
             - CreateNamespace=true
      1
      path 是包含集群的 policygentemplate s CR 的 ztp/gitops-subscriptions /argocd/ 文件路径。
      2
      repoURL 是 Git 存储库的 URL,其中包含用于指定站点配置数据的 policygentemplates 自定义资源。
      3
      targetRevision 是包含相关配置数据的 Git 存储库上的分支。
  4. 要将管道配置应用到 hub 集群,请输入以下命令:

    $ oc apply -k ./deployment

18.16.3. 创建站点 secret

将站点所需的 secret 添加到 hub 集群。这些资源必须位于带有与集群名称匹配的名称的命名空间中。

流程

  1. 创建用于向站点 Baseboard Management Controller (BMC) 进行身份验证的 secret。确保 secret 名称与 SiteConfig 中使用的名称匹配。在本例中,secret 名称为 test-sno-bmh-secret:

    apiVersion: v1
    kind: Secret
    metadata:
      name: test-sno-bmh-secret
      namespace: test-sno
    data:
      password: dGVtcA==
      username: cm9vdA==
    type: Opaque
  2. 为站点创建 pull secret。pull secret 必须包含安装 OpenShift 和所有附加组件 Operator 所需的所有凭证。在本例中,secret 名称是 assisted-deployment-pull-secret

    apiVersion: v1
    kind: Secret
    metadata:
      name: assisted-deployment-pull-secret
      namespace: test-sno
    type: kubernetes.io/dockerconfigjson
    data:
      .dockerconfigjson: <Your pull secret base64 encoded>
注意

secret 根据名称从 SiteConfig 自定义资源 (CR) 引用。命名空间必须与 SiteConfig 命名空间匹配。

18.16.4. 创建 SiteConfig 自定义资源

ArgoCD 充当站点部署的 GitOps 方法引擎。完成包含站点安装所需自定义资源的站点计划后,策略生成器会创建清单并将其应用到 hub 集群。

流程

  1. 创建一个或多个 SiteConfig 自定义资源(site-config.yaml 文件),其中包含集群的站点计划数据。例如:

    apiVersion: ran.openshift.io/v1
    kind: SiteConfig
    metadata:
      name: "test-sno"
      namespace: "test-sno"
    spec:
      baseDomain: "clus2.t5g.lab.eng.bos.redhat.com"
      pullSecretRef:
        name: "assisted-deployment-pull-secret"
      clusterImageSetNameRef: "openshift-4.9"
      sshPublicKey: "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQDB3dwhI5X0ZxGBb9VK7wclcPHLc8n7WAyKjTNInFjYNP9J+Zoc/ii+l3YbGUTuqilDwZN5rVIwBux2nUyVXDfaM5kPd9kACmxWtfEWTyVRootbrNWwRfKuC2h6cOd1IlcRBM1q6IzJ4d7+JVoltAxsabqLoCbK3svxaZoKAaK7jdGG030yvJzZaNM4PiTy39VQXXkCiMDmicxEBwZx1UsA8yWQsiOQ5brod9KQRXWAAST779gbvtgXR2L+MnVNROEHf1nEjZJwjwaHxoDQYHYKERxKRHlWFtmy5dNT6BbvOpJ2e5osDFPMEd41d2mUJTfxXiC1nvyjk9Irf8YJYnqJgBIxi0IxEllUKH7mTdKykHiPrDH5D2pRlp+Donl4n+sw6qoDc/3571O93+RQ6kUSAgAsvWiXrEfB/7kGgAa/BD5FeipkFrbSEpKPVu+gue1AQeJcz9BuLqdyPUQj2VUySkSg0FuGbG7fxkKeF1h3Sga7nuDOzRxck4I/8Z7FxMF/e8DmaBpgHAUIfxXnRqAImY9TyAZUEMT5ZPSvBRZNNmLbfex1n3NLcov/GEpQOqEYcjG5y57gJ60/av4oqjcVmgtaSOOAS0kZ3y9YDhjsaOcpmRYYijJn8URAH7NrW8EZsvAoF6GUt6xHq5T258c6xSYUm5L0iKvBqrOW9EjbLw== root@cnfdc2.clus2.t5g.lab.eng.bos.redhat.com"
      clusters:
      - clusterName: "test-sno"
        clusterType: "sno"
        clusterProfile: "du"
        clusterLabels:
          group-du-sno: ""
          common: true
          sites : "test-sno"
        clusterNetwork:
          - cidr: 1001:db9::/48
            hostPrefix: 64
        machineNetwork:
          - cidr: 2620:52:0:10e7::/64
        serviceNetwork:
          - 1001:db7::/112
        additionalNTPSources:
          - 2620:52:0:1310::1f6
        nodes:
          - hostName: "test-sno.clus2.t5g.lab.eng.bos.redhat.com"
            bmcAddress: "idrac-virtualmedia+https://[2620:52::10e7:f602:70ff:fee4:f4e2]/redfish/v1/Systems/System.Embedded.1"
            bmcCredentialsName:
              name: "test-sno-bmh-secret"
            bootMACAddress: "0C:42:A1:8A:74:EC"
            bootMode: "UEFI"
            rootDeviceHints:
              hctl: '0:1:0'
            cpuset: "0-1,52-53"
            nodeNetwork:
              interfaces:
                - name: eno1
                  macAddress: "0C:42:A1:8A:74:EC"
              config:
                interfaces:
                  - name: eno1
                    type: ethernet
                    state: up
                    macAddress: "0C:42:A1:8A:74:EC"
                    ipv4:
                      enabled: false
                    ipv6:
                      enabled: true
                      address:
                      - ip: 2620:52::10e7:e42:a1ff:fe8a:900
                        prefix-length: 64
                dns-resolver:
                  config:
                    search:
                    - clus2.t5g.lab.eng.bos.redhat.com
                    server:
                    - 2620:52:0:1310::1f6
                routes:
                  config:
                  - destination: ::/0
                    next-hop-interface: eno1
                    next-hop-address: 2620:52:0:10e7::fc
                    table-id: 254
  2. 保存文件并将其推送到可从 hub 集群访问的 ZTP Git 存储库,并定义为 ArgoCD 应用程序的源存储库。

ArgoCD 检测到应用没有同步。同步后,ArgoCD 会自动或手动将 PolicyGenTemplate 与 hub 集群同步,并启动关联的资源 hook。这些 hook 负责生成应用到 spoke 集群的策略封装配置 CR。资源 hook 将站点定义转换为安装自定义资源,并将其应用到 hub 集群:

  • Namespace - 每个站点都是唯一的
  • AgentClusterInstall
  • BareMetalHost
  • ClusterDeployment
  • InfraEnv
  • NMStateConfig
  • ExtraManifestsConfigMap - Extra 清单。其他清单包括工作负载分区、chronyd、挂载点隐藏、sctp 启用等等。
  • ManagedCluster
  • KlusterletAddonConfig

Red Hat Advanced Cluster Management (RHACM) (ACM) 会部署 hub 集群。

18.16.5. 创建 PolicyGenTemplates

使用以下步骤创建在 hub 集群的 Git 仓库中生成策略所需的 PolicyGenTemplates

流程

  1. 创建 PolicyGenTemplates,并将其保存到可从 hub 集群访问 ZTP Git 存储库,并定义为 ArgoCD 应用程序的源存储库。
  2. ArgoCD 检测到应用没有同步。同步后,ArgoCD 会将新的 PolicyGenTemplate 应用到 hub 集群,并启动相关的资源 hook。这些 hook 负责生成应用到 spoke 集群的策略封装配置 CR 并执行以下操作:

    1. 根据基本分布式单元 (DU) 配置集和所需的自定义,创建 Red Hat Advanced Cluster Management (RHACM) 策略。
    2. 将生成的策略应用到 hub 集群。

ZTP 进程创建定向 ACM 的策略,以将所需的配置应用到集群节点。

18.16.6. 检查安装状态

ArgoCD 管道检测到 Git 存储库中的 SiteConfigPolicyGenTemplate 自定义资源 (CR),并将它们同步到 hub 集群。在此过程中,它会生成安装和策略 CR,并将其应用到 hub 集群。您可以在 ArgoCD 仪表板中监控此同步的进度。

流程

  1. 使用以下命令监控集群安装进度:

    $ export CLUSTER=<clusterName>
    $ oc get agentclusterinstall -n $CLUSTER $CLUSTER -o jsonpath='{.status.conditions[?(@.type=="Completed")]}' | jq
    $ curl -sk $(oc get agentclusterinstall -n $CLUSTER $CLUSTER -o jsonpath='{.status.debugInfo.eventsURL}') | jq '.[-2,-1]'
  2. 使用 Red Hat Advanced Cluster Management (RHACM) 仪表板来监控策略协调的进度。

18.16.7. 站点清理

要删除站点以及关联的安装和策略自定义资源 (CR),请从 Git 仓库中删除 SiteConfig 和特定于站点的 PolicyGenTemplate CR。Pipeline hook 删除生成的 CR。

注意

在删除 SiteConfig CR 前,您必须将集群从 ACM 分离。

18.16.7.1. 删除 ArgoCD 管道

如果要删除 ArgoCD 管道和所有生成的工件,请使用以下步骤。

流程

  1. 从 ACM 分离所有集群。
  2. 从 Git 仓库中删除所有 SiteConfigPolicyGenTemplate 自定义资源 (CR)。
  3. 删除以下命名空间:

    • 所有策略命名空间:

       $ oc get policy -A
    • clusters-sub
    • policies-sub
  4. 使用 Kustomize 工具处理目录:

     $ oc delete -k cnf-features-deploy/ztp/gitops-subscriptions/argocd/deployment

18.17. GitOps ZTP 故障排除

如前文所述,ArgoCD 管道会将 SiteConfigPolicyGenTemplate 自定义资源 (CR) 从 Git 存储库同步到 hub 集群。在此过程中,同步后 hook 会创建也会应用到 hub 集群的安装和策略 CR。使用以下步骤排除在此过程中可能出现的问题。

18.17.1. 验证安装 CR 的生成

SiteConfig 将安装自定义资源 (CR) 应用到名称与站点名称匹配的命名空间中的 hub 集群。要检查状态,请输入以下命令:

$ oc get AgentClusterInstall -n <clusterName>

如果没有返回对象,请使用以下步骤对 SiteConfig 到安装 CR 的 ArgoCD 管道流进行故障排除。

流程

  1. 使用以下命令之一检查 SiteConfig 到 hub 集群的同步:

    $ oc get siteconfig -A

    $ oc get siteconfig -n clusters-sub

    如果缺少 SiteConfig,则出现以下情况之一:

    • clusters 应用程序无法将 CR 从 Git 存储库同步到 hub。使用以下命令验证以下内容:

      $ oc describe -n openshift-gitops application clusters

      检查 Status: Synced 并且 Revision: 是推送到订阅的存储库的提交的 SHA。

    • 预同步 hook 失败,可能是因为拉取容器镜像失败。检查 ArgoCD 仪表板,了解 clusters 应用程序中预同步作业的状态。
  2. 验证 post hook 作业是否运行:

    $ oc describe job -n clusters-sub siteconfig-post
    • 如果成功,返回的输出表示 succeeded: 1
    • 如果作业失败,ArgoCD 会重试它。在某些情况下,第一次通过将失败,第二次通过将指示作业通过。
  3. 检查 post hook 任务中的错误:

    $ oc get pod -n clusters-sub

    请注意 siteconfig-post-xxxxx pod 的名称:

    $ oc logs -n clusters-sub siteconfig-post-xxxxx

    如果日志指出错误,请更正条件,并将更正的 SiteConfigPolicyGenTemplate 推送到 Git 存储库。

18.17.2. 验证策略 CR 的生成

ArgoCD 在与创建它们的 PolicyGenTemplate 相同的命名空间中生成策略自定义资源 (CR)。相同的故障排除流程适用于从 PolicyGenTemplates 生成的所有策略 CR,无论它们是通用、组还是站点。

要检查策略 CR 的状态,请输入以下命令:

$ export NS=<namespace>
$ oc get policy -n $NS

返回的输出会显示预期的策略打包 CR 集合。如果没有返回对象,请使用以下步骤对 SiteConfig 到策略 CR 的 ArgoCD 管道流进行故障排除。

流程

  1. 检查 PolicyGenTemplate 到 hub 集群的同步:

    $ oc get policygentemplate -A

    $ oc get policygentemplate -n $NS

    如果没有同步 PolicyGenTemplate,会出现以下情况之一:

    • 集群应用程序无法将 CR 从 Git 存储库同步到 hub。使用以下命令验证以下内容:

      $ oc describe -n openshift-gitops application clusters

      检查 Status: Synced 并且 Revision: 是推送到订阅的存储库的提交的 SHA。

    • 预同步 hook 失败,可能是因为拉取容器镜像失败。检查 ArgoCD 仪表板,了解 clusters 应用程序中预同步作业的状态。
  2. 确保策略已复制到集群命名空间中。当 ACM 识别策略应用到 ManagedCluster 时,ACM 将策略 CR 对象应用到集群命名空间:

    $ oc get policy -n <clusterName>

    ACM 在此处复制所有适用的通用、组和站点策略。策略名称为 <policyNamespace><policyName>

  3. 检查放置规则中是否有没有复制到集群命名空间中的策略。这些策略的 PlacementRule 中的 matchSelector 应该与 ManagedCluster 上的标签匹配:

    $ oc get placementrule -n $NS
  4. 记录缺少的 common、group 或 site 策略的 PlacementRule 名称:

     oc get placementrule -n $NS <placmentRuleName> -o yaml
    • status decisions 值应包含您的集群名称。
    • spec 中 matchSelector键值 应与受管集群上的标签匹配。检查 ManagedCluster 上的标签:

       oc get ManagedCluster $CLUSTER -o jsonpath='{.metadata.labels}' | jq

      示例

      apiVersion: apps.open-cluster-management.io/v1
      kind: PlacementRule
      metadata:
        name: group-test1-policies-placementrules
        namespace: group-test1-policies
      spec:
        clusterSelector:
          matchExpressions:
          - key: group-test1
            operator: In
            values:
            - ""
      status:
        decisions:
        - clusterName: <myClusterName>
          clusterNamespace: <myClusterName>

  5. 确保所有策略都合规:

     oc get policy -n $CLUSTER

    如果 Namespace、OperatorGroup 和 Subscription 策略兼容,但 Operator 配置策略可能没有安装。