安装后配置

1. Cordon.对于额外的工作负载，MCO 会将节点标记为不可调度。
2. Drain.MCO 终止节点上运行的所有工作负载，导致工作负载重新调度到其他节点上。
3. Apply.MCO 根据需要将新配置写入节点。
4. 重新启动.MCO 重启节点。
5. Uncordon.对于工作负载，MCO 将节点标记为可调度。

流程

1. 要查看集群中为每个机器配置池 (MCP) 中可用 MCO 管理的节点数量，请运行以下命令：

   $ oc get machineconfigpool

   输出示例

   NAME      CONFIG                    UPDATED  UPDATING   DEGRADED  MACHINECOUNT  READYMACHINECOUNT  UPDATEDMACHINECOUNT DEGRADEDMACHINECOUNT  AGE
   master    rendered-master-06c9c4…   True     False      False     3             3                  3                   0                     4h42m
   worker    rendered-worker-f4b64…    False    True       False     3             2                  2                   0                     4h42m

   其中：

   UPDATED

   True 状态表示 MCO 已将当前机器配置应用到该 MCP 中的节点。当前机器配置在 oc get mcp 输出中的 STATUS 字段中指定。False 状态表示 MCP 中的节点正在更新。

   UPDATING

   True 状态表示 MCO 正在按照 MachineConfigPool 自定义资源中的规定应用到该 MCP 中的至少一个节点。所需的机器配置是新编辑的机器配置。要进行更新的节点可能不适用于调度。False 状态表示 MCP 中的所有节点都已更新。

   DEGRADED

   True 状态表示 MCO 被禁止将当前或所需的机器配置应用到该 MCP 中的至少一个节点，或者配置失败。降级的节点可能不适用于调度。False 状态表示 MCP 中的所有节点都就绪。

   MACHINECOUNT

   表示该 MCP 中的机器总数。

   READYMACHINECOUNT

   指明 MCP 中准备进行调度的机器总数。

   UPDATEDMACHINECOUNT

   指明 MCP 中有当前机器配置的机器总数。

   DEGRADEDMACHINECOUNT

   指明 MCP 中标记为 degraded 或 unreconcilable 的机器总数。

   在前面的输出中，有三个 control plane (master) 节点和三个 worker 节点。control plane MCP 和关联的节点更新至当前机器配置。worker MCP 中的节点会更新为所需的机器配置。worker MCP 中的两个节点被更新，一个仍在更新，如 UPDATEDMACHINECOUNT 为 2。没有问题，如 DEGRADEDMACHINECOUNT 为 0，DEGRADED 为 False。

   虽然 MCP 中的节点正在更新，但 CONFIG 下列出的机器配置是当前的机器配置，该配置会从这个配置进行更新。更新完成后，列出的机器配置是所需的机器配置，它被更新为 MCP。

   注意

   如果节点被封锁，则该节点不包含在 READYMACHINECOUNT 中，但包含在 MACHINECOUNT 中。另外，MCP 状态被设置为 UPDATING。因为节点具有当前的机器配置，所以它被计算在 UPDATEDMACHINECOUNT 总计：

   输出示例

   NAME      CONFIG                    UPDATED  UPDATING   DEGRADED  MACHINECOUNT  READYMACHINECOUNT  UPDATEDMACHINECOUNT DEGRADEDMACHINECOUNT  AGE
   master    rendered-master-06c9c4…   True     False      False     3             3                  3                   0                     4h42m
   worker    rendered-worker-c1b41a…   False    True       False     3             2                  3                   0                     4h42m

2. 要通过检查 MachineConfigPool 自定义资源来检查 MCP 中的节点状态，请运行以下命令：

   $ oc describe mcp worker

   输出示例

   ...
     Degraded Machine Count:     0
     Machine Count:              3
     Observed Generation:        2
     Ready Machine Count:        3
     Unavailable Machine Count:  0
     Updated Machine Count:      3
   Events:                       <none>

   注意

   如果节点被封锁，则节点不包含在 Ready Machine Count 中。它包含在 Unavailable Machine Count 中：

   输出示例

   ...
     Degraded Machine Count:     0
     Machine Count:              3
     Observed Generation:        2
     Ready Machine Count:        2
     Unavailable Machine Count:  1
     Updated Machine Count:      3

3. 要查看每个现有的 MachineConfig 对象，请运行以下命令：

   $ oc get machineconfigs

   输出示例

   NAME                             GENERATEDBYCONTROLLER          IGNITIONVERSION  AGE
   00-master                        2c9371fbb673b97a6fe8b1c52...   3.2.0            5h18m
   00-worker                        2c9371fbb673b97a6fe8b1c52...   3.2.0            5h18m
   01-master-container-runtime      2c9371fbb673b97a6fe8b1c52...   3.2.0            5h18m
   01-master-kubelet                2c9371fbb673b97a6fe8b1c52…     3.2.0            5h18m
   ...
   rendered-master-dde...           2c9371fbb673b97a6fe8b1c52...   3.2.0            5h18m
   rendered-worker-fde...           2c9371fbb673b97a6fe8b1c52...   3.2.0            5h18m

   请注意，列为 rendered 的 MachineConfig 对象并不意味着要更改或删除。

4. 要查看特定机器配置的内容（本例中为 01-master-kubelet），请运行以下命令：

   $ oc describe machineconfigs 01-master-kubelet

   命令的输出显示此 MachineConfig 对象同时包含配置文件(cloud.conf 和 kubelet.conf) 和 systemd 服务(Kubernetes Kubelet)：

   输出示例

   Name:         01-master-kubelet
   ...
   Spec:
     Config:
       Ignition:
         Version:  3.2.0
       Storage:
         Files:
           Contents:
             Source:   data:,
           Mode:       420
           Overwrite:  true
           Path:       /etc/kubernetes/cloud.conf
           Contents:
             Source:   data:,kind%3A%20KubeletConfiguration%0AapiVersion%3A%20kubelet.config.k8s.io%2Fv1beta1%0Aauthentication%3A%0A%20%20x509%3A%0A%20%20%20%20clientCAFile%3A%20%2Fetc%2Fkubernetes%2Fkubelet-ca.crt%0A%20%20anonymous...
           Mode:       420
           Overwrite:  true
           Path:       /etc/kubernetes/kubelet.conf
       Systemd:
         Units:
           Contents:  [Unit]
   Description=Kubernetes Kubelet
   Wants=rpc-statd.service network-online.target crio.service
   After=network-online.target crio.service
   
   ExecStart=/usr/bin/hyperkube \
       kubelet \
         --config=/etc/kubernetes/kubelet.conf \ ...

流程

1. 创建一个 Butane 配置，包括 chrony.conf 文件的内容。例如，要在 worker 节点上配置 chrony，请创建一个 99-worker-chrony.bu 文件。

   注意

   如需有关 Butane 的信息，请参阅"使用 Butane 创建机器配置"。

   variant: openshift
   version: 4.12.0
   metadata:
     name: 99-worker-chrony 1
     labels:
       machineconfiguration.openshift.io/role: worker 2
   storage:
     files:
     - path: /etc/chrony.conf
       mode: 0644 3
       overwrite: true
       contents:
         inline: |
           pool 0.rhel.pool.ntp.org iburst 4
           driftfile /var/lib/chrony/drift
           makestep 1.0 3
           rtcsync
           logdir /var/log/chrony

   1 2

   在 control plane 节点上，在这两个位置中将 master 替换为 worker。

   3

   为机器配置文件的 mode 字段指定数值模式。在创建文件并应用更改后，模式 将转换为十进制值。您可以使用 oc get mc <mc-name> -o yaml 命令来检查 YAML 文件。

   4

   指定任何有效的、可访问的时间源，如 DHCP 服务器提供的源。或者，您可以指定以下 NTP 服务器：1.rhel.pool.ntp.org, 2.rhel.pool.ntp.org, 或 3.rhel.pool.ntp.org。

2. 使用 Butane 生成 MachineConfig 对象文件 99-worker-chrony.yaml，其中包含要交付至节点的配置：

   $ butane 99-worker-chrony.bu -o 99-worker-chrony.yaml

3. 使用以下两种方式之一应用配置：

   • 如果集群还没有运行，在生成清单文件后，将 MachineConfig 对象文件添加到 <installation_directory>/openshift 目录中，然后继续创建集群。

   • 如果集群已在运行，请应用该文件：

     $ oc apply -f ./99-worker-chrony.yaml

流程

1. 创建 MachineConfig CR，为指定节点角色禁用 chronyd。

   1. 在 disable-chronyd.yaml 文件中保存以下 YAML：

      apiVersion: machineconfiguration.openshift.io/v1
      kind: MachineConfig
      metadata:
        labels:
          machineconfiguration.openshift.io/role: <node_role> 1
        name: disable-chronyd
      spec:
        config:
          ignition:
            version: 3.2.0
          systemd:
            units:
              - contents: |
                  [Unit]
                  Description=NTP client/server
                  Documentation=man:chronyd(8) man:chrony.conf(5)
                  After=ntpdate.service sntp.service ntpd.service
                  Conflicts=ntpd.service systemd-timesyncd.service
                  ConditionCapability=CAP_SYS_TIME
                  [Service]
                  Type=forking
                  PIDFile=/run/chrony/chronyd.pid
                  EnvironmentFile=-/etc/sysconfig/chronyd
                  ExecStart=/usr/sbin/chronyd $OPTIONS
                  ExecStartPost=/usr/libexec/chrony-helper update-daemon
                  PrivateTmp=yes
                  ProtectHome=yes
                  ProtectSystem=full
                  [Install]
                  WantedBy=multi-user.target
                enabled: false
                name: "chronyd.service"

      1

      要禁用 chronyd 的节点角色，如 master。

   2. 运行以下命令来创建 MachineConfig CR：

      $ oc create -f disable-chronyd.yaml

流程

1. 列出 OpenShift Container Platform 集群的现有 MachineConfig 对象，以确定如何标记您的机器配置：

   $ oc get MachineConfig

   输出示例

   NAME                                               GENERATEDBYCONTROLLER                      IGNITIONVERSION   AGE
   00-master                                          52dd3ba6a9a527fc3ab42afac8d12b693534c8c9   3.2.0             33m
   00-worker                                          52dd3ba6a9a527fc3ab42afac8d12b693534c8c9   3.2.0             33m
   01-master-container-runtime                        52dd3ba6a9a527fc3ab42afac8d12b693534c8c9   3.2.0             33m
   01-master-kubelet                                  52dd3ba6a9a527fc3ab42afac8d12b693534c8c9   3.2.0             33m
   01-worker-container-runtime                        52dd3ba6a9a527fc3ab42afac8d12b693534c8c9   3.2.0             33m
   01-worker-kubelet                                  52dd3ba6a9a527fc3ab42afac8d12b693534c8c9   3.2.0             33m
   99-master-generated-registries                     52dd3ba6a9a527fc3ab42afac8d12b693534c8c9   3.2.0             33m
   99-master-ssh                                                                                 3.2.0             40m
   99-worker-generated-registries                     52dd3ba6a9a527fc3ab42afac8d12b693534c8c9   3.2.0             33m
   99-worker-ssh                                                                                 3.2.0             40m
   rendered-master-23e785de7587df95a4b517e0647e5ab7   52dd3ba6a9a527fc3ab42afac8d12b693534c8c9   3.2.0             33m
   rendered-worker-5d596d9293ca3ea80c896a1191735bb1   52dd3ba6a9a527fc3ab42afac8d12b693534c8c9   3.2.0             33m

2. 创建一个用于标识内核参数的 MachineConfig 对象文件（例如 05-worker-kernelarg-selinuxpermissive.yaml）

   apiVersion: machineconfiguration.openshift.io/v1
   kind: MachineConfig
   metadata:
     labels:
       machineconfiguration.openshift.io/role: worker1
     name: 05-worker-kernelarg-selinuxpermissive2
   spec:
     kernelArguments:
       - enforcing=03

   1

   仅将新内核参数应用到 worker 节点。

   2

   用于标识它插入到机器配置中的什么位置（05）以及发挥什么作用（添加一个内核参数来配置 SELinux permissive 模式）。

   3

   将确切的内核参数标识为 enforcing=0。

3. 创建新机器配置：

   $ oc create -f 05-worker-kernelarg-selinuxpermissive.yaml

4. 检查机器配置以查看是否添加了新配置：

   $ oc get MachineConfig

   输出示例

   NAME                                               GENERATEDBYCONTROLLER                      IGNITIONVERSION   AGE
   00-master                                          52dd3ba6a9a527fc3ab42afac8d12b693534c8c9   3.2.0             33m
   00-worker                                          52dd3ba6a9a527fc3ab42afac8d12b693534c8c9   3.2.0             33m
   01-master-container-runtime                        52dd3ba6a9a527fc3ab42afac8d12b693534c8c9   3.2.0             33m
   01-master-kubelet                                  52dd3ba6a9a527fc3ab42afac8d12b693534c8c9   3.2.0             33m
   01-worker-container-runtime                        52dd3ba6a9a527fc3ab42afac8d12b693534c8c9   3.2.0             33m
   01-worker-kubelet                                  52dd3ba6a9a527fc3ab42afac8d12b693534c8c9   3.2.0             33m
   05-worker-kernelarg-selinuxpermissive                                                         3.2.0             105s
   99-master-generated-registries                     52dd3ba6a9a527fc3ab42afac8d12b693534c8c9   3.2.0             33m
   99-master-ssh                                                                                 3.2.0             40m
   99-worker-generated-registries                     52dd3ba6a9a527fc3ab42afac8d12b693534c8c9   3.2.0             33m
   99-worker-ssh                                                                                 3.2.0             40m
   rendered-master-23e785de7587df95a4b517e0647e5ab7   52dd3ba6a9a527fc3ab42afac8d12b693534c8c9   3.2.0             33m
   rendered-worker-5d596d9293ca3ea80c896a1191735bb1   52dd3ba6a9a527fc3ab42afac8d12b693534c8c9   3.2.0             33m

5. 检查节点：

   $ oc get nodes

   输出示例

   NAME                           STATUS                     ROLES    AGE   VERSION
   ip-10-0-136-161.ec2.internal   Ready                      worker   28m   v1.25.0
   ip-10-0-136-243.ec2.internal   Ready                      master   34m   v1.25.0
   ip-10-0-141-105.ec2.internal   Ready,SchedulingDisabled   worker   28m   v1.25.0
   ip-10-0-142-249.ec2.internal   Ready                      master   34m   v1.25.0
   ip-10-0-153-11.ec2.internal    Ready                      worker   28m   v1.25.0
   ip-10-0-153-150.ec2.internal   Ready                      master   34m   v1.25.0

   您可以发现，在应用更改时每个 worker 节点上的调度都会被禁用。

6. 前往其中一个 worker 节点并列出内核命令行参数（主机上的 /proc/cmdline 中），以检查内核参数确实已发挥作用：

   $ oc debug node/ip-10-0-141-105.ec2.internal

   输出示例

   Starting pod/ip-10-0-141-105ec2internal-debug ...
   To use host binaries, run `chroot /host`
   
   sh-4.2# cat /host/proc/cmdline
   BOOT_IMAGE=/ostree/rhcos-... console=tty0 console=ttyS0,115200n8
   rootflags=defaults,prjquota rw root=UUID=fd0... ostree=/ostree/boot.0/rhcos/16...
   coreos.oem.id=qemu coreos.oem.id=ec2 ignition.platform.id=ec2 enforcing=0
   
   sh-4.2# exit

   您应看到 enforcing=0 参数已添加至其他内核参数。

流程

1. 要在 control plane 节点上启用多路径安装后：

   • 创建机器配置文件，如 99-master-kargs-mpath.yaml，该文件指示集群添加 master 标签并标识多路径内核参数，例如：

     apiVersion: machineconfiguration.openshift.io/v1
     kind: MachineConfig
     metadata:
       labels:
         machineconfiguration.openshift.io/role: "master"
       name: 99-master-kargs-mpath
     spec:
       kernelArguments:
         - 'rd.multipath=default'
         - 'root=/dev/disk/by-label/dm-mpath-root'

2. 在 worker 节点上启用多路径安装后：

   • 创建机器配置文件，如 99-worker-kargs-mpath.yaml，该文件指示集群添加 worker 标签并标识多路径内核参数，例如：

     apiVersion: machineconfiguration.openshift.io/v1
     kind: MachineConfig
     metadata:
       labels:
         machineconfiguration.openshift.io/role: "worker"
       name: 99-worker-kargs-mpath
     spec:
       kernelArguments:
         - 'rd.multipath=default'
         - 'root=/dev/disk/by-label/dm-mpath-root'

3. 使用之前创建的 master 或 worker YAML 文件创建新机器配置：

   $ oc create -f ./99-worker-kargs-mpath.yaml

4. 检查机器配置以查看是否添加了新配置：

   $ oc get MachineConfig

   输出示例

   NAME                                               GENERATEDBYCONTROLLER                      IGNITIONVERSION   AGE
   00-master                                          52dd3ba6a9a527fc3ab42afac8d12b693534c8c9   3.2.0             33m
   00-worker                                          52dd3ba6a9a527fc3ab42afac8d12b693534c8c9   3.2.0             33m
   01-master-container-runtime                        52dd3ba6a9a527fc3ab42afac8d12b693534c8c9   3.2.0             33m
   01-master-kubelet                                  52dd3ba6a9a527fc3ab42afac8d12b693534c8c9   3.2.0             33m
   01-worker-container-runtime                        52dd3ba6a9a527fc3ab42afac8d12b693534c8c9   3.2.0             33m
   01-worker-kubelet                                  52dd3ba6a9a527fc3ab42afac8d12b693534c8c9   3.2.0             33m
   99-master-generated-registries                     52dd3ba6a9a527fc3ab42afac8d12b693534c8c9   3.2.0             33m
   99-master-ssh                                                                                 3.2.0             40m
   99-worker-generated-registries                     52dd3ba6a9a527fc3ab42afac8d12b693534c8c9   3.2.0             33m
   99-worker-kargs-mpath                              52dd3ba6a9a527fc3ab42afac8d12b693534c8c9   3.2.0             105s
   99-worker-ssh                                                                                 3.2.0             40m
   rendered-master-23e785de7587df95a4b517e0647e5ab7   52dd3ba6a9a527fc3ab42afac8d12b693534c8c9   3.2.0             33m
   rendered-worker-5d596d9293ca3ea80c896a1191735bb1   52dd3ba6a9a527fc3ab42afac8d12b693534c8c9   3.2.0             33m

5. 检查节点：

   $ oc get nodes

   输出示例

   NAME                           STATUS                     ROLES    AGE   VERSION
   ip-10-0-136-161.ec2.internal   Ready                      worker   28m   v1.25.0
   ip-10-0-136-243.ec2.internal   Ready                      master   34m   v1.25.0
   ip-10-0-141-105.ec2.internal   Ready,SchedulingDisabled   worker   28m   v1.25.0
   ip-10-0-142-249.ec2.internal   Ready                      master   34m   v1.25.0
   ip-10-0-153-11.ec2.internal    Ready                      worker   28m   v1.25.0
   ip-10-0-153-150.ec2.internal   Ready                      master   34m   v1.25.0

   您可以发现，在应用更改时每个 worker 节点上的调度都会被禁用。

6. 前往其中一个 worker 节点并列出内核命令行参数（主机上的 /proc/cmdline 中），以检查内核参数确实已发挥作用：

   $ oc debug node/ip-10-0-141-105.ec2.internal

   输出示例

   Starting pod/ip-10-0-141-105ec2internal-debug ...
   To use host binaries, run `chroot /host`
   
   sh-4.2# cat /host/proc/cmdline
   ...
   rd.multipath=default root=/dev/disk/by-label/dm-mpath-root
   ...
   
   sh-4.2# exit

   您应看到添加的内核参数。

流程

1. 为实时内核创建一个机器配置：创建一个 YAML 文件（例如，99-worker-realtime.yaml），其中包含一个 realtime 内核类型的 MachineConfig 对象。本例告诉集群在所有 worker 节点中使用实时内核：

   $ cat << EOF > 99-worker-realtime.yaml
   apiVersion: machineconfiguration.openshift.io/v1
   kind: MachineConfig
   metadata:
     labels:
       machineconfiguration.openshift.io/role: "worker"
     name: 99-worker-realtime
   spec:
     kernelType: realtime
   EOF

2. 将机器配置添加到集群。键入以下内容将机器配置添加到集群中：

   $ oc create -f 99-worker-realtime.yaml

3. 检查实时内核： 每当受影响节点重新引导后，登录到集群，并运行以下命令来确保您配置的节点组中使用实时内核替换了常规内核：

   $ oc get nodes

   输出示例

   NAME                                        STATUS  ROLES    AGE   VERSION
   ip-10-0-143-147.us-east-2.compute.internal  Ready   worker   103m  v1.25.0
   ip-10-0-146-92.us-east-2.compute.internal   Ready   worker   101m  v1.25.0
   ip-10-0-169-2.us-east-2.compute.internal    Ready   worker   102m  v1.25.0

   $ oc debug node/ip-10-0-143-147.us-east-2.compute.internal

   输出示例

   Starting pod/ip-10-0-143-147us-east-2computeinternal-debug ...
   To use host binaries, run `chroot /host`
   
   sh-4.4# uname -a
   Linux <worker_node> 4.18.0-147.3.1.rt24.96.el8_1.x86_64 #1 SMP PREEMPT RT
           Wed Nov 27 18:29:55 UTC 2019 x86_64 x86_64 x86_64 GNU/Linux

   内核名称包含 rt 和 "PREMPT RT" 来表示这是一个实时内核。

4. 要返回常规内核，请删除 MachineConfig 对象：

   $ oc delete -f 99-worker-realtime.yaml

流程

1. 创建一个 Butane 配置文件 40-worker-custom-journald.bu，其中包含带有所需设置的 /etc/systemd/journald.conf 文件。

   注意

   有关 Butane 的信息，请参阅"使用 Butane 创建机器配置"。

   variant: openshift
   version: 4.12.0
   metadata:
     name: 40-worker-custom-journald
     labels:
       machineconfiguration.openshift.io/role: worker
   storage:
     files:
     - path: /etc/systemd/journald.conf
       mode: 0644
       overwrite: true
       contents:
         inline: |
           # Disable rate limiting
           RateLimitInterval=1s
           RateLimitBurst=10000
           Storage=volatile
           Compress=no
           MaxRetentionSec=30s

2. 使用 Butane 生成 MachineConfig 对象文件 40-worker-custom-journald.yaml，包含要发送到 worker 节点的配置：

   $ butane 40-worker-custom-journald.bu -o 40-worker-custom-journald.yaml

3. 将机器配置应用到池：

   $ oc apply -f 40-worker-custom-journald.yaml

4. 检查是否应用新机器配置，并且节点是否处于降级状态。它可能需要几分钟时间。worker 池将显示更新进行中，每个节点都成功应用了新的机器配置：

   $ oc get machineconfigpool
   NAME   CONFIG             UPDATED UPDATING DEGRADED MACHINECOUNT READYMACHINECOUNT UPDATEDMACHINECOUNT DEGRADEDMACHINECOUNT AGE
   master rendered-master-35 True    False    False    3            3                 3                   0                    34m
   worker rendered-worker-d8 False   True     False    3            1                 1                   0                    34m

5. 要检查是否应用了更改，您可以登录到 worker 节点：

   $ oc get node | grep worker
   ip-10-0-0-1.us-east-2.compute.internal   Ready    worker   39m   v0.0.0-master+$Format:%h$
   $ oc debug node/ip-10-0-0-1.us-east-2.compute.internal
   Starting pod/ip-10-0-141-142us-east-2computeinternal-debug ...
   ...
   sh-4.2# chroot /host
   sh-4.4# cat /etc/systemd/journald.conf
   # Disable rate limiting
   RateLimitInterval=1s
   RateLimitBurst=10000
   Storage=volatile
   Compress=no
   MaxRetentionSec=30s
   sh-4.4# exit

流程

1. 为扩展创建机器配置：创建一个 YAML 文件（如 80-extensions.yaml），其中包含 MachineConfig extensions 对象。本例告诉集群添加 usbguard 扩展。

   $ cat << EOF > 80-extensions.yaml
   apiVersion: machineconfiguration.openshift.io/v1
   kind: MachineConfig
   metadata:
     labels:
       machineconfiguration.openshift.io/role: worker
     name: 80-worker-extensions
   spec:
     config:
       ignition:
         version: 3.2.0
     extensions:
       - usbguard
   EOF

2. 将机器配置添加到集群。键入以下内容将机器配置添加到集群中：

   $ oc create -f 80-extensions.yaml

   这会将所有 worker 节点设置为安装 usbguard 的 rpm 软件包。

3. 检查是否应用了扩展：

   $ oc get machineconfig 80-worker-extensions

   输出示例

   NAME                 GENERATEDBYCONTROLLER IGNITIONVERSION AGE
   80-worker-extensions                       3.2.0           57s

4. 检查是否应用新机器配置，并且节点是否处于降级状态。它可能需要几分钟时间。worker 池将显示更新进行中，每台机器都成功应用了新机器配置：

   $ oc get machineconfigpool

   输出示例

   NAME   CONFIG             UPDATED UPDATING DEGRADED MACHINECOUNT READYMACHINECOUNT UPDATEDMACHINECOUNT DEGRADEDMACHINECOUNT AGE
   master rendered-master-35 True    False    False    3            3                 3                   0                    34m
   worker rendered-worker-d8 False   True     False    3            1                 1                   0                    34m

5. 检查扩展。要检查是否应用了扩展，请运行：

   $ oc get node | grep worker

   输出示例

   NAME                                        STATUS  ROLES    AGE   VERSION
   ip-10-0-169-2.us-east-2.compute.internal    Ready   worker   102m  v1.25.0

   $ oc debug node/ip-10-0-169-2.us-east-2.compute.internal

   输出示例

   ...
   To use host binaries, run `chroot /host`
   sh-4.4# chroot /host
   sh-4.4# rpm -q usbguard
   usbguard-0.7.4-4.el8.x86_64.rpm

流程

1. 创建 Butane 配置文件 98-worker-firmware-blob.bu，它会更新搜索路径，以便其为 root 所有且对本地存储可写。以下示例将本地工作站的自定义 blob 文件放在 /var/lib/firmware 下的节点上。

   注意

   有关 Butane 的信息，请参阅"使用 Butane 创建机器配置"。

   自定义固件 blob 的 Butane 配置文件

   variant: openshift
   version: 4.12.0
   metadata:
     labels:
       machineconfiguration.openshift.io/role: worker
     name: 98-worker-firmware-blob
   storage:
     files:
     - path: /var/lib/firmware/<package_name> 1
       contents:
         local: <package_name> 2
       mode: 0644 3
   openshift:
     kernel_arguments:
       - 'firmware_class.path=/var/lib/firmware' 4

   1

   设置将固件软件包复制到的节点上的路径。

   2

   指定包含从运行 Butane 的系统上本地文件目录中读取的内容的文件。本地文件的路径相对于 files-dir 目录，必须在下一步中使用 --files-dir 选项指定它。

   3

   为 RHCOS 节点上的文件设置权限。建议把选项设置为 0644 。

   4

   firmware_class.path 参数自定义内核搜索路径，在其中查找从本地工作站复制到节点的根文件系统的自定义固件 Blob。这个示例使用 /var/lib/firmware 作为自定义路径。

2. 运行 Butane 生成 MachineConfig 对象文件，该文件使用名为 98-worker-firmware-blob.yaml 的本地工作站中的固件 blob 副本。固件 blob 包含要传送到节点的配置。以下示例使用 --files-dir 选项指定工作站上本地文件或目录所在的目录：

   $ butane 98-worker-firmware-blob.bu -o 98-worker-firmware-blob.yaml --files-dir <directory_including_package_name>

3. 通过两种方式之一将配置应用到节点：

   • 如果集群还没有运行，在生成清单文件后，将 MachineConfig 对象文件添加到 <installation_directory>/openshift 目录中，然后继续创建集群。

   • 如果集群已在运行，请应用该文件：

     $ oc apply -f 98-worker-firmware-blob.yaml

     已为您创建一个 MachineConfig 对象 YAML 文件，以完成机器的配置。

4. 如果将来需要更新 MachineConfig 对象，请保存 Butane 配置。

先决条件

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

   1. 查看机器配置池：

      $ oc describe machineconfigpool <name>

      例如：

      $ oc describe machineconfigpool worker

      输出示例

      apiVersion: machineconfiguration.openshift.io/v1
      kind: MachineConfigPool
      metadata:
        creationTimestamp: 2019-02-08T14:52:39Z
        generation: 1
        labels:
          custom-kubelet: set-max-pods 1

      1

      如果添加了标签，它会出现在 labels 下。

   2. 如果标签不存在，则添加一个键/值对：

      $ oc label machineconfigpool worker custom-kubelet=set-max-pods

流程

1. 查看您可以选择的可用机器配置对象：

   $ oc get machineconfig

   默认情况下，与 kubelet 相关的配置为 01-master-kubelet 和 01-worker-kubelet。

2. 检查每个节点的最大 pod 的当前值：

   $ oc describe node <node_name>

   例如：

   $ oc describe node ci-ln-5grqprb-f76d1-ncnqq-worker-a-mdv94

   在 Allocatable 小节中找到 value: pods: <value>：

   输出示例

   Allocatable:
    attachable-volumes-aws-ebs:  25
    cpu:                         3500m
    hugepages-1Gi:               0
    hugepages-2Mi:               0
    memory:                      15341844Ki
    pods:                        250

3. 通过创建一个包含 kubelet 配置的自定义资源文件，设置 worker 节点上的每个节点的最大 pod：

   重要

   以特定机器配置池为目标的 kubelet 配置也会影响任何依赖的池。例如，为包含 worker 节点的池创建 kubelet 配置也适用于任何子集池，包括包含基础架构节点的池。要避免这种情况，您必须使用仅包含 worker 节点的选择表达式创建新的机器配置池，并让 kubelet 配置以这个新池为目标。

   apiVersion: machineconfiguration.openshift.io/v1
   kind: KubeletConfig
   metadata:
     name: set-max-pods
   spec:
     machineConfigPoolSelector:
       matchLabels:
         custom-kubelet: set-max-pods 1
     kubeletConfig:
       maxPods: 500 2

   1

   输入机器配置池中的标签。

   2

   添加 kubelet 配置。在本例中，使用 maxPods 设置每个节点的最大 pod。

   注意

   kubelet 与 API 服务器进行交互的频率取决于每秒的查询数量 (QPS) 和 burst 值。如果每个节点上运行的 pod 数量有限，使用默认值（kubeAPIQPS 为 50，kubeAPIBurst 为 100）就可以。如果节点上有足够 CPU 和内存资源，则建议更新 kubelet QPS 和 burst 速率。

   apiVersion: machineconfiguration.openshift.io/v1
   kind: KubeletConfig
   metadata:
     name: set-max-pods
   spec:
     machineConfigPoolSelector:
       matchLabels:
         custom-kubelet: set-max-pods
     kubeletConfig:
       maxPods: <pod_count>
       kubeAPIBurst: <burst_rate>
       kubeAPIQPS: <QPS>

   1. 为带有标签的 worker 更新机器配置池：

      $ oc label machineconfigpool worker custom-kubelet=set-max-pods

   2. 创建 KubeletConfig 对象：

      $ oc create -f change-maxPods-cr.yaml

   3. 验证 KubeletConfig 对象是否已创建：

      $ oc get kubeletconfig

      输出示例

      NAME                AGE
      set-max-pods        15m

      根据集群中的 worker 节点数量，等待每个 worker 节点被逐个重启。对于有 3 个 worker 节点的集群，这个过程可能需要大约 10 到 15 分钟。

4. 验证更改是否已应用到节点：

   1. 在 worker 节点上检查 maxPods 值已更改：

      $ oc describe node <node_name>

   2. 找到 Allocatable 小节：

       ...
      Allocatable:
        attachable-volumes-gce-pd:  127
        cpu:                        3500m
        ephemeral-storage:          123201474766
        hugepages-1Gi:              0
        hugepages-2Mi:              0
        memory:                     14225400Ki
        pods:                       500 1
       ...

      1

      在本例中，pods 参数应报告您在 KubeletConfig 对象中设置的值。

5. 验证 KubeletConfig 对象中的更改：

   $ oc get kubeletconfigs set-max-pods -o yaml

   这应该显示 True 状态和 type:Success，如下例所示：

   spec:
     kubeletConfig:
       maxPods: 500
     machineConfigPoolSelector:
       matchLabels:
         custom-kubelet: set-max-pods
   status:
     conditions:
     - lastTransitionTime: "2021-06-30T17:04:07Z"
       message: Success
       status: "True"
       type: Success

1. 为 ContainerRuntimeConfig CR 创建 YAML 文件：

   apiVersion: machineconfiguration.openshift.io/v1
   kind: ContainerRuntimeConfig
   metadata:
    name: overlay-size
   spec:
    machineConfigPoolSelector:
      matchLabels:
        pools.operator.machineconfiguration.openshift.io/worker: '' 1
    containerRuntimeConfig: 2
      logLevel: debug
      overlaySize: 8G

   1

   为您要修改的机器配置池指定一个标签。

   2

   根据需要设置参数。

2. 创建 ContainerRuntimeConfig CR：

   $ oc create -f <file_name>.yaml

3. 验证是否已创建 CR：

   $ oc get ContainerRuntimeConfig

   输出示例

   NAME           AGE
   overlay-size   3m19s

4. 检查是否创建了新的 containerruntime 机器配置：

   $ oc get machineconfigs | grep containerrun

   输出示例

   99-worker-generated-containerruntime   2c9371fbb673b97a6fe8b1c52691999ed3a1bfc2  3.2.0  31s

5. 监控机器配置池，直到所有系统都显示为 ready 状态：

   $ oc get mcp worker

   输出示例

   NAME    CONFIG               UPDATED  UPDATING  DEGRADED  MACHINECOUNT  READYMACHINECOUNT  UPDATEDMACHINECOUNT  DEGRADEDMACHINECOUNT  AGE
   worker  rendered-worker-169  False    True      False     3             1                  1                    0                     9h

6. 验证设置是否在 CRI-O 中应用：

   1. 打开到机器配置池中节点的 oc debug 会话，并运行 chroot /host。

      $ oc debug node/<node_name>

      sh-4.4# chroot /host

   2. 验证 crio.conf 文件中的更改：

      sh-4.4# crio config | grep 'log_level'

      输出示例

      log_level = "debug"

   3. 验证 'storage.conf' 文件中的更改：

      sh-4.4# head -n 7 /etc/containers/storage.conf

      输出示例

      [storage]
        driver = "overlay"
        runroot = "/var/run/containers/storage"
        graphroot = "/var/lib/containers/storage"
        [storage.options]
          additionalimagestores = []
          size = "8G"

流程

1. 创建配置对象：

   $ oc apply -f overlaysize.yml

2. 要将新的 CRI-O 配置应用到 worker 节点，请编辑 worker 机器配置池：

   $ oc edit machineconfigpool worker

3. 根据在 ContainerRuntimeConfig CRD 中设置的 matchLabels 名称添加 custom-crio 标签：

   apiVersion: machineconfiguration.openshift.io/v1
   kind: MachineConfigPool
   metadata:
     creationTimestamp: "2020-07-09T15:46:34Z"
     generation: 3
     labels:
       custom-crio: overlay-size
       machineconfiguration.openshift.io/mco-built-in: ""

4. 保存更改，然后查看机器配置：

   $ oc get machineconfigs

   新的 99-worker-generated-containerruntime 和 rendered-worker-xyz 对象被创建：

   输出示例

   99-worker-generated-containerruntime  4173030d89fbf4a7a0976d1665491a4d9a6e54f1   3.2.0             7m42s
   rendered-worker-xyz                   4173030d89fbf4a7a0976d1665491a4d9a6e54f1   3.2.0             7m36s

5. 创建这些对象后，监控机器配置池以了解要应用的更改：

   $ oc get mcp worker

   worker 节点将 UPDATING 显示为 True，以及机器数量、更新的数字和其他详情：

   输出示例

   NAME   CONFIG              UPDATED   UPDATING   DEGRADED  MACHINECOUNT  READYMACHINECOUNT  UPDATEDMACHINECOUNT   DEGRADEDMACHINECOUNT   AGE
   worker rendered-worker-xyz False True False     3             2                   2                    0                      20h

   完成后，worker 节点会从 UPDATING 转换回 False，UPDATEDMACHINECOUNT 数与 MACHINECOUNT 数匹配：

   输出示例

   NAME   CONFIG              UPDATED   UPDATING   DEGRADED  MACHINECOUNT  READYMACHINECOUNT  UPDATEDMACHINECOUNT   DEGRADEDMACHINECOUNT   AGE
   worker   rendered-worker-xyz   True      False      False      3         3            3             0           20h

   查看 worker 机器，您会看到新的 8 GB 最大大小配置适用于所有 worker：

   输出示例

   head -n 7 /etc/containers/storage.conf
   [storage]
     driver = "overlay"
     runroot = "/var/run/containers/storage"
     graphroot = "/var/lib/containers/storage"
     [storage.options]
       additionalimagestores = []
       size = "8G"

   在容器内，您会看到 root 分区现在为 8 GB：

   输出示例

   ~ $ df -h
   Filesystem                Size      Used Available Use% Mounted on
   overlay                   8.0G      8.0K      8.0G   0% /

流程

1. 运行以下命令，查看集群中的计算机器：

   $ oc get machinesets -n openshift-machine-api

   计算机器集以 <clusterid>-worker-<aws-region-az> 的形式列出。

2. 运行以下命令，查看集群中的计算机器：

   $ oc get machine -n openshift-machine-api

3. 运行以下命令，在要删除的计算机器上设置注解：

   $ oc annotate machine/<machine_name> -n openshift-machine-api machine.openshift.io/delete-machine="true"

4. 运行以下命令来扩展计算机器集：

   $ oc scale --replicas=2 machineset <machineset> -n openshift-machine-api

   或者：

   $ oc edit machineset <machineset> -n openshift-machine-api

   提示

   您还可以应用以下 YAML 来扩展计算机器集：

   apiVersion: machine.openshift.io/v1beta1
   kind: MachineSet
   metadata:
     name: <machineset>
     namespace: openshift-machine-api
   spec:
     replicas: 2

   您可以扩展或缩减计算机器。需要过几分钟以后新机器才可用。

   重要

   默认情况下，机器控制器会尝试排空在机器上运行的节点，直到成功为止。在某些情况下，如错误配置了 pod 中断预算，排空操作可能无法成功。如果排空操作失败，机器控制器无法继续删除机器。

   您可以通过在特定机器上注解 machine.openshift.io/exclude-node-draining 来跳过排空节点。

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

   $ oc edit scheduler cluster

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

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

   1

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

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

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

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

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

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

        1

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

        例如：

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

        提示

        您还可以应用以下 YAML 来向计算机器集中添加标签：

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

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

        例如：

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

        MachineSet 对象示例

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

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

        例如：

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

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

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

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

        例如：

        $ oc get nodes -l type=user-node

        输出示例

        NAME                                       STATUS   ROLES    AGE   VERSION
        ci-ln-l8nry52-f76d1-hl7m7-worker-c-vmqzp   Ready    worker   61s   v1.25.0

   • 直接向节点添加标签：

     1. 为节点编辑 Node 对象：

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

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

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

        提示

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

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

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

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

        例如：

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

        输出示例

        NAME                                       STATUS   ROLES    AGE   VERSION
        ci-ln-l8nry52-f76d1-hl7m7-worker-b-tgq49   Ready    worker   17m   v1.25.0

流程

1. 为要在 Local Zone 子网中运行的边缘 worker 节点部署示例应用程序创建一个 deployment 资源 YAML 文件。确保指定与边缘 worker 节点的污点匹配的正确容限。

   在 Local Zone 子网中运行的边缘 worker 节点配置的 deployment 资源示例

   kind: Namespace
   apiVersion: v1
   metadata:
     name: <local_zone_application_namespace>
   ---
   kind: PersistentVolumeClaim
   apiVersion: v1
   metadata:
     name: <pvc_name>
     namespace: <local_zone_application_namespace>
   spec:
     accessModes:
       - ReadWriteOnce
     resources:
       requests:
         storage: 10Gi
     storageClassName: gp2-csi 1
     volumeMode: Filesystem
   ---
   apiVersion: apps/v1
   kind: Deployment 2
   metadata:
     name: <local_zone_application> 3
     namespace: <local_zone_application_namespace> 4
   spec:
     selector:
       matchLabels:
         app: <local_zone_application>
     replicas: 1
     template:
       metadata:
         labels:
           app: <local_zone_application>
           zone-group: ${ZONE_GROUP_NAME} 5
       spec:
         securityContext:
           seccompProfile:
             type: RuntimeDefault
         nodeSelector: 6
           machine.openshift.io/zone-group: ${ZONE_GROUP_NAME}
         tolerations: 7
         - key: "node-role.kubernetes.io/edge"
           operator: "Equal"
           value: ""
           effect: "NoSchedule"
         containers:
           - image: openshift/origin-node
             command:
              - "/bin/socat"
             args:
               - TCP4-LISTEN:8080,reuseaddr,fork
               - EXEC:'/bin/bash -c \"printf \\\"HTTP/1.0 200 OK\r\n\r\n\\\"; sed -e \\\"/^\r/q\\\"\"'
             imagePullPolicy: Always
             name: echoserver
             ports:
               - containerPort: 8080
             volumeMounts:
               - mountPath: "/mnt/storage"
                 name: data
         volumes:
         - name: data
           persistentVolumeClaim:
             claimName: <pvc_name>

   1

   storageClassName ：对于 Local Zone 配置，您必须指定 gp2-csi。

   2

   kind ：定义 deployment 资源。

   3

   name ：指定 Local Zone 应用程序的名称。例如，local-zone-demo-app-nyc-1。

   4

   namespace ：定义您要运行用户工作负载的 AWS Local Zone 的命名空间。例如：local-zone-app-nyc-1a。

   5

   zone-group ：定义区域所属的组。例如，us-east-1-iah-1。

   6

   nodeSelector ：目标与指定标签匹配的边缘 worker 节点。

   7

   tolerations ：设置与 Local Zone 节点的 MachineSet 清单上定义的污点匹配的值。

2. 为节点创建 service 资源 YAML 文件。此资源将来自目标边缘 worker 节点的一个 pod 公开到在 Local Zone 网络中运行的服务。

   在 Local Zone 子网中运行的边缘 worker 节点配置的 service 资源示例

   apiVersion: v1
   kind: Service 1
   metadata:
     name:  <local_zone_application>
     namespace: <local_zone_application_namespace>
   spec:
     ports:
       - port: 80
         targetPort: 8080
         protocol: TCP
     type: NodePort
     selector: 2
       app: <local_zone_application>

   1

   kind ：定义 service 资源。

   2

   selector： 指定应用到受管 pod 的标签类型。

1. 中 worke worker 延迟配置集：

   1. 编辑 node.config 对象：

      $ oc edit nodes.config/cluster

   2. 添加 spec.workerLatencyProfile: MediumUpdateAverageReaction ：

      node.config 对象示例

      apiVersion: config.openshift.io/v1
      kind: Node
      metadata:
        annotations:
          include.release.openshift.io/ibm-cloud-managed: "true"
          include.release.openshift.io/self-managed-high-availability: "true"
          include.release.openshift.io/single-node-developer: "true"
          release.openshift.io/create-only: "true"
        creationTimestamp: "2022-07-08T16:02:51Z"
        generation: 1
        name: cluster
        ownerReferences:
        - apiVersion: config.openshift.io/v1
          kind: ClusterVersion
          name: version
          uid: 36282574-bf9f-409e-a6cd-3032939293eb
        resourceVersion: "1865"
        uid: 0c0f7a4c-4307-4187-b591-6155695ac85b
      spec:
        workerLatencyProfile: MediumUpdateAverageReaction 1
      
      # ...

      1

      指定中 worker 延迟策略。

      随着更改被应用，每个 worker 节点上的调度都会被禁用。

2. 可选：改为低 worker 延迟配置集：

   1. 编辑 node.config 对象：

      $ oc edit nodes.config/cluster

   2. 将 spec.workerLatencyProfile 值更改为 LowUpdateSlowReaction ：

      node.config 对象示例

      apiVersion: config.openshift.io/v1
      kind: Node
      metadata:
        annotations:
          include.release.openshift.io/ibm-cloud-managed: "true"
          include.release.openshift.io/self-managed-high-availability: "true"
          include.release.openshift.io/single-node-developer: "true"
          release.openshift.io/create-only: "true"
        creationTimestamp: "2022-07-08T16:02:51Z"
        generation: 1
        name: cluster
        ownerReferences:
        - apiVersion: config.openshift.io/v1
          kind: ClusterVersion
          name: version
          uid: 36282574-bf9f-409e-a6cd-3032939293eb
        resourceVersion: "1865"
        uid: 0c0f7a4c-4307-4187-b591-6155695ac85b
      spec:
        workerLatencyProfile: LowUpdateSlowReaction 1
      
      # ...

      1

      指定使用低 worker 延迟策略。

流程

1. 创建一个包含计算机器集自定义资源（CR）示例的新 YAML 文件，并将其命名为 <file_name>.yaml。

   确保设置 <clusterID> 和 <role> 参数值。

2. 可选：如果您不确定要为特定字段设置哪个值，您可以从集群中检查现有计算机器集：

   1. 要列出集群中的计算机器集，请运行以下命令：

      $ oc get machinesets -n openshift-machine-api

      输出示例

      NAME                                DESIRED   CURRENT   READY   AVAILABLE   AGE
      agl030519-vplxk-worker-us-east-1a   1         1         1       1           55m
      agl030519-vplxk-worker-us-east-1b   1         1         1       1           55m
      agl030519-vplxk-worker-us-east-1c   1         1         1       1           55m
      agl030519-vplxk-worker-us-east-1d   0         0                             55m
      agl030519-vplxk-worker-us-east-1e   0         0                             55m
      agl030519-vplxk-worker-us-east-1f   0         0                             55m

   2. 要查看特定计算机器集自定义资源 (CR) 的值，请运行以下命令：

      $ oc get machineset <machineset_name> \
        -n openshift-machine-api -o yaml

      输出示例

      apiVersion: machine.openshift.io/v1beta1
      kind: MachineSet
      metadata:
        labels:
          machine.openshift.io/cluster-api-cluster: <infrastructure_id> 1
        name: <infrastructure_id>-<role> 2
        namespace: openshift-machine-api
      spec:
        replicas: 1
        selector:
          matchLabels:
            machine.openshift.io/cluster-api-cluster: <infrastructure_id>
            machine.openshift.io/cluster-api-machineset: <infrastructure_id>-<role>
        template:
          metadata:
            labels:
              machine.openshift.io/cluster-api-cluster: <infrastructure_id>
              machine.openshift.io/cluster-api-machine-role: <role>
              machine.openshift.io/cluster-api-machine-type: <role>
              machine.openshift.io/cluster-api-machineset: <infrastructure_id>-<role>
          spec:
            providerSpec: 3
              ...

      1

      集群基础架构 ID。

      2

      默认节点标签。

      注意

      对于具有用户置备的基础架构的集群，计算机器集只能创建 worker 和 infra 类型机器。

      3

      计算机器设置 CR 的 <providerSpec> 部分中的值是特定于平台的。有关 CR 中的 <providerSpec> 参数的更多信息，请参阅您的供应商计算机器设置 CR 配置示例。

3. 运行以下命令来创建 MachineSet CR：

   $ oc create -f <file_name>.yaml

流程

1. 向您要充当应用程序节点的 worker 节点添加标签：

   $ oc label node <node-name> node-role.kubernetes.io/app=""

2. 向您要充当基础架构节点的 worker 节点添加标签：

   $ oc label node <node-name> node-role.kubernetes.io/infra=""

3. 检查相关节点现在是否具有 infra 角色或 app 角色：

   $ oc get nodes

4. 创建默认的集群范围节点选择器。默认节点选择器应用到在所有命名空间中创建的 pod。这会创建一个与 pod 上任何现有节点选择器交集的交集，这会额外限制 pod 的选择器。

   重要

   如果默认节点选择器键与 pod 标签的键冲突，则不会应用默认节点选择器。

   但是，不要设置可能会导致 pod 变得不可调度的默认节点选择器。例如，当 pod 的标签被设置为不同的节点角色（如 node-role.kubernetes.io/infra=""）时，将默认节点选择器设置为特定的节点角色（如 node-role.kubernetes.io/master=""）可能会导致 pod 无法调度。因此，将默认节点选择器设置为特定节点角色时要小心。

   您还可以使用项目节点选择器来避免集群范围节点选择器键冲突。

   1. 编辑 Scheduler 对象：

      $ oc edit scheduler cluster

   2. 使用适当的节点选择器添加 defaultNodeSelector 字段：

      apiVersion: config.openshift.io/v1
      kind: Scheduler
      metadata:
        name: cluster
      spec:
        defaultNodeSelector: node-role.kubernetes.io/infra="" 1
      # ...

      1

      这个示例节点选择器默认在基础架构节点上部署 pod。

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

流程

1. 向您要分配为带有特定标签的 infra 节点的节点添加标签：

   $ oc label node <node_name> <label>

   $ oc label node ci-ln-n8mqwr2-f76d1-xscn2-worker-c-6fmtx node-role.kubernetes.io/infra=

2. 创建包含 worker 角色和自定义角色作为机器配置选择器的机器配置池：

   $ cat infra.mcp.yaml

   输出示例

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

   1

   添加 worker 角色和自定义角色。

   2

   将您添加的标签作为 nodeSelector 添加到节点。

   注意

   自定义机器配置池从 worker 池中继承机器配置。自定义池使用任何针对 worker 池的机器配置，但增加了部署仅针对自定义池的更改的功能。由于自定义池从 worker 池中继承资源，对 worker 池的任何更改也会影响自定义池。

3. 具有 YAML 文件后，您可以创建机器配置池：

   $ oc create -f infra.mcp.yaml

4. 检查机器配置，以确保基础架构配置成功：

   $ oc get machineconfig

   输出示例

   NAME                                                        GENERATEDBYCONTROLLER                      IGNITIONVERSION   CREATED
   00-master                                                   365c1cfd14de5b0e3b85e0fc815b0060f36ab955   3.2.0             31d
   00-worker                                                   365c1cfd14de5b0e3b85e0fc815b0060f36ab955   3.2.0             31d
   01-master-container-runtime                                 365c1cfd14de5b0e3b85e0fc815b0060f36ab955   3.2.0             31d
   01-master-kubelet                                           365c1cfd14de5b0e3b85e0fc815b0060f36ab955   3.2.0             31d
   01-worker-container-runtime                                 365c1cfd14de5b0e3b85e0fc815b0060f36ab955   3.2.0             31d
   01-worker-kubelet                                           365c1cfd14de5b0e3b85e0fc815b0060f36ab955   3.2.0             31d
   99-master-1ae2a1e0-a115-11e9-8f14-005056899d54-registries   365c1cfd14de5b0e3b85e0fc815b0060f36ab955   3.2.0             31d
   99-master-ssh                                                                                          3.2.0             31d
   99-worker-1ae64748-a115-11e9-8f14-005056899d54-registries   365c1cfd14de5b0e3b85e0fc815b0060f36ab955   3.2.0             31d
   99-worker-ssh                                                                                          3.2.0             31d
   rendered-infra-4e48906dca84ee702959c71a53ee80e7             365c1cfd14de5b0e3b85e0fc815b0060f36ab955   3.2.0             23m
   rendered-master-072d4b2da7f88162636902b074e9e28e            5b6fb8349a29735e48446d435962dec4547d3090   3.2.0             31d
   rendered-master-3e88ec72aed3886dec061df60d16d1af            02c07496ba0417b3e12b78fb32baf6293d314f79   3.2.0             31d
   rendered-master-419bee7de96134963a15fdf9dd473b25            365c1cfd14de5b0e3b85e0fc815b0060f36ab955   3.2.0             17d
   rendered-master-53f5c91c7661708adce18739cc0f40fb            365c1cfd14de5b0e3b85e0fc815b0060f36ab955   3.2.0             13d
   rendered-master-a6a357ec18e5bce7f5ac426fc7c5ffcd            365c1cfd14de5b0e3b85e0fc815b0060f36ab955   3.2.0             7d3h
   rendered-master-dc7f874ec77fc4b969674204332da037            5b6fb8349a29735e48446d435962dec4547d3090   3.2.0             31d
   rendered-worker-1a75960c52ad18ff5dfa6674eb7e533d            5b6fb8349a29735e48446d435962dec4547d3090   3.2.0             31d
   rendered-worker-2640531be11ba43c61d72e82dc634ce6            5b6fb8349a29735e48446d435962dec4547d3090   3.2.0             31d
   rendered-worker-4e48906dca84ee702959c71a53ee80e7            365c1cfd14de5b0e3b85e0fc815b0060f36ab955   3.2.0             7d3h
   rendered-worker-4f110718fe88e5f349987854a1147755            365c1cfd14de5b0e3b85e0fc815b0060f36ab955   3.2.0             17d
   rendered-worker-afc758e194d6188677eb837842d3b379            02c07496ba0417b3e12b78fb32baf6293d314f79   3.2.0             31d
   rendered-worker-daa08cc1e8f5fcdeba24de60cd955cc3            365c1cfd14de5b0e3b85e0fc815b0060f36ab955   3.2.0             13d

   您应该会看到一个新的机器配置，带有 rendered-infra-* 前缀。

5. 可选：要部署对自定义池的更改，请创建一个机器配置，该配置使用自定义池名称作为标签，如本例中的 infra。请注意，这不是必须的，在此包括仅用于指示目的。这样，您可以只应用特定于 infra 节点的任何自定义配置。

   注意

   创建新机器配置池后，MCO 会为该池生成一个新的呈现配置，以及该池重启的关联节点以应用新配置。

   1. 创建机器配置：

      $ cat infra.mc.yaml

      输出示例

      apiVersion: machineconfiguration.openshift.io/v1
      kind: MachineConfig
      metadata:
        name: 51-infra
        labels:
          machineconfiguration.openshift.io/role: infra 1
      spec:
        config:
          ignition:
            version: 3.2.0
          storage:
            files:
            - path: /etc/infratest
              mode: 0644
              contents:
                source: data:,infra

      1

      将您添加的标签作为 nodeSelector 添加到节点。

   2. 将机器配置应用到 infra-labeled 节点：

      $ oc create -f infra.mc.yaml

6. 确认您的新机器配置池可用：

   $ oc get mcp

   输出示例

   NAME     CONFIG                                             UPDATED   UPDATING   DEGRADED   MACHINECOUNT   READYMACHINECOUNT   UPDATEDMACHINECOUNT   DEGRADEDMACHINECOUNT   AGE
   infra    rendered-infra-60e35c2e99f42d976e084fa94da4d0fc    True      False      False      1              1                   1                     0                      4m20s
   master   rendered-master-9360fdb895d4c131c7c4bebbae099c90   True      False      False      3              3                   3                     0                      91m
   worker   rendered-worker-60e35c2e99f42d976e084fa94da4d0fc   True      False      False      2              2                   2                     0                      91m

   在本例中，worker 节点被改为一个 infra 节点。

流程

1. 向 infra 节点添加污点以防止在其上调度用户工作负载：

   1. 确定节点是否具有污点：

      $ oc describe nodes <node_name>

      输出示例

      oc describe node ci-ln-iyhx092-f76d1-nvdfm-worker-b-wln2l
      Name:               ci-ln-iyhx092-f76d1-nvdfm-worker-b-wln2l
      Roles:              worker
       ...
      Taints:             node-role.kubernetes.io/infra:NoSchedule
       ...

      本例显示节点具有污点。您可以在下一步中继续向 pod 添加容限。

   2. 如果您还没有配置污点以防止在其上调度用户工作负载：

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

      例如：

      $ oc adm taint nodes node1 node-role.kubernetes.io/infra=reserved:NoExecute

      提示

      您还可以应用以下 YAML 来添加污点：

      kind: Node
      apiVersion: v1
      metadata:
        name: <node_name>
        labels:
          ...
      spec:
        taints:
          - key: node-role.kubernetes.io/infra
            effect: NoExecute
            value: reserved
        ...

      本例在 node1 上放置一个键为 node-role.kubernetes.io/infra 的污点，污点是 NoSchedule。具有 NoSchedule effect 的节点仅调度容许该污点的 pod，但允许现有 pod 继续调度到该节点上。

      注意

      如果使用 descheduler，则违反了节点污点的 pod 可能会从集群驱除。

2. 为要在 infra 节点上调度的 pod 配置添加容限，如路由器、registry 和监控工作负载。在 Pod 对象规格中添加以下代码：

   tolerations:
     - effect: NoExecute 1
       key: node-role.kubernetes.io/infra 2
       operator: Exists 3
       value: reserved 4

   1

   指定添加到节点的效果。

   2

   指定添加到节点的键。

   3

   指定 Exists Operator，以要求节点上存在一个带有键为 node-role.kubernetes.io/infra 的污点。

   4

   指定添加到节点的键值对污点的值。

   此容忍度与 oc adm taint 命令创建的污点匹配。具有此容忍度的 pod 可以调度到 infra 节点上。

   注意

   并不总是能够将通过 OLM 安装的 Operator 的 Pod 移到 infra 节点。移动 Operator Pod 的能力取决于每个 Operator 的配置。

3. 使用调度程序将 pod 调度到 infra 节点。详情请参阅控制节点上的 pod 放置的文档。

流程

1. 查看路由器 Operator 的 IngressController 自定义资源：

   $ oc get ingresscontroller default -n openshift-ingress-operator -o yaml

   命令输出类似于以下文本：

   apiVersion: operator.openshift.io/v1
   kind: IngressController
   metadata:
     creationTimestamp: 2019-04-18T12:35:39Z
     finalizers:
     - ingresscontroller.operator.openshift.io/finalizer-ingresscontroller
     generation: 1
     name: default
     namespace: openshift-ingress-operator
     resourceVersion: "11341"
     selfLink: /apis/operator.openshift.io/v1/namespaces/openshift-ingress-operator/ingresscontrollers/default
     uid: 79509e05-61d6-11e9-bc55-02ce4781844a
   spec: {}
   status:
     availableReplicas: 2
     conditions:
     - lastTransitionTime: 2019-04-18T12:36:15Z
       status: "True"
       type: Available
     domain: apps.<cluster>.example.com
     endpointPublishingStrategy:
       type: LoadBalancerService
     selector: ingresscontroller.operator.openshift.io/deployment-ingresscontroller=default

2. 编辑 ingresscontroller 资源，并更改 nodeSelector 以使用infra 标签：

   $ oc edit ingresscontroller default -n openshift-ingress-operator

     spec:
       nodePlacement:
         nodeSelector: 1
           matchLabels:
             node-role.kubernetes.io/infra: ""
         tolerations:
         - effect: NoSchedule
           key: node-role.kubernetes.io/infra
           value: reserved
         - effect: NoExecute
           key: node-role.kubernetes.io/infra
           value: reserved

   1

   添加 nodeSelector 参数，并设为适用于您想要移动的组件的值。您可以根据为节点指定的值，按所示格式使用 nodeSelector 或使用 <key>: <value> 对。如果您在 infrasructure 节点中添加了污点，还要添加匹配的容限。

3. 确认路由器 Pod 在 infra 节点上运行。

   1. 查看路由器 Pod 列表，并记下正在运行的 Pod 的节点名称：

      $ oc get pod -n openshift-ingress -o wide

      输出示例

      NAME                              READY     STATUS        RESTARTS   AGE       IP           NODE                           NOMINATED NODE   READINESS GATES
      router-default-86798b4b5d-bdlvd   1/1      Running       0          28s       10.130.2.4   ip-10-0-217-226.ec2.internal   <none>           <none>
      router-default-955d875f4-255g8    0/1      Terminating   0          19h       10.129.2.4   ip-10-0-148-172.ec2.internal   <none>           <none>

      在本例中，正在运行的 Pod 位于 ip-10-0-217-226.ec2.internal 节点上。

   2. 查看正在运行的 Pod 的节点状态：

      $ oc get node <node_name> 1

      1

      指定从 Pod 列表获得的 <node_name>。

      输出示例

      NAME                          STATUS  ROLES         AGE   VERSION
      ip-10-0-217-226.ec2.internal  Ready   infra,worker  17h   v1.25.0

      由于角色列表包含 infra，因此 Pod 在正确的节点上运行。

流程

1. 查看 config/instance 对象：

   $ oc get configs.imageregistry.operator.openshift.io/cluster -o yaml

   输出示例

   apiVersion: imageregistry.operator.openshift.io/v1
   kind: Config
   metadata:
     creationTimestamp: 2019-02-05T13:52:05Z
     finalizers:
     - imageregistry.operator.openshift.io/finalizer
     generation: 1
     name: cluster
     resourceVersion: "56174"
     selfLink: /apis/imageregistry.operator.openshift.io/v1/configs/cluster
     uid: 36fd3724-294d-11e9-a524-12ffeee2931b
   spec:
     httpSecret: d9a012ccd117b1e6616ceccb2c3bb66a5fed1b5e481623
     logging: 2
     managementState: Managed
     proxy: {}
     replicas: 1
     requests:
       read: {}
       write: {}
     storage:
       s3:
         bucket: image-registry-us-east-1-c92e88cad85b48ec8b312344dff03c82-392c
         region: us-east-1
   status:
   ...

2. 编辑 config/instance 对象：

   $ oc edit configs.imageregistry.operator.openshift.io/cluster

   spec:
     affinity:
       podAntiAffinity:
         preferredDuringSchedulingIgnoredDuringExecution:
         - podAffinityTerm:
             namespaces:
             - openshift-image-registry
             topologyKey: kubernetes.io/hostname
           weight: 100
     logLevel: Normal
     managementState: Managed
     nodeSelector: 1
       node-role.kubernetes.io/infra: ""
     tolerations:
     - effect: NoSchedule
       key: node-role.kubernetes.io/infra
       value: reserved
     - effect: NoExecute
       key: node-role.kubernetes.io/infra
       value: reserved

   1

   添加 nodeSelector 参数，并设为适用于您想要移动的组件的值。您可以根据为节点指定的值，按所示格式使用 nodeSelector 或使用 <key>: <value> 对。如果您在 infrasructure 节点中添加了污点，还要添加匹配的容限。

3. 验证 registry pod 已移至基础架构节点。

   1. 运行以下命令，以识别 registry pod 所在的节点：

      $ oc get pods -o wide -n openshift-image-registry

   2. 确认节点具有您指定的标签：

      $ oc describe node <node_name>

      查看命令输出，并确认 node-role.kubernetes.io/infra 列在 LABELS 列表中。

流程

1. 编辑 cluster-monitoring-config 配置映射，并更改 nodeSelector 以使用 infra 标签：

   $ oc edit configmap cluster-monitoring-config -n openshift-monitoring

   apiVersion: v1
   kind: ConfigMap
   metadata:
     name: cluster-monitoring-config
     namespace: openshift-monitoring
   data:
     config.yaml: |+
       alertmanagerMain:
         nodeSelector: 1
           node-role.kubernetes.io/infra: ""
         tolerations:
         - key: node-role.kubernetes.io/infra
           value: reserved
           effect: NoSchedule
         - key: node-role.kubernetes.io/infra
           value: reserved
           effect: NoExecute
       prometheusK8s:
         nodeSelector:
           node-role.kubernetes.io/infra: ""
         tolerations:
         - key: node-role.kubernetes.io/infra
           value: reserved
           effect: NoSchedule
         - key: node-role.kubernetes.io/infra
           value: reserved
           effect: NoExecute
       prometheusOperator:
         nodeSelector:
           node-role.kubernetes.io/infra: ""
         tolerations:
         - key: node-role.kubernetes.io/infra
           value: reserved
           effect: NoSchedule
         - key: node-role.kubernetes.io/infra
           value: reserved
           effect: NoExecute
       k8sPrometheusAdapter:
         nodeSelector:
           node-role.kubernetes.io/infra: ""
         tolerations:
         - key: node-role.kubernetes.io/infra
           value: reserved
           effect: NoSchedule
         - key: node-role.kubernetes.io/infra
           value: reserved
           effect: NoExecute
       kubeStateMetrics:
         nodeSelector:
           node-role.kubernetes.io/infra: ""
         tolerations:
         - key: node-role.kubernetes.io/infra
           value: reserved
           effect: NoSchedule
         - key: node-role.kubernetes.io/infra
           value: reserved
           effect: NoExecute
       telemeterClient:
         nodeSelector:
           node-role.kubernetes.io/infra: ""
         tolerations:
         - key: node-role.kubernetes.io/infra
           value: reserved
           effect: NoSchedule
         - key: node-role.kubernetes.io/infra
           value: reserved
           effect: NoExecute
       openshiftStateMetrics:
         nodeSelector:
           node-role.kubernetes.io/infra: ""
         tolerations:
         - key: node-role.kubernetes.io/infra
           value: reserved
           effect: NoSchedule
         - key: node-role.kubernetes.io/infra
           value: reserved
           effect: NoExecute
       thanosQuerier:
         nodeSelector:
           node-role.kubernetes.io/infra: ""
         tolerations:
         - key: node-role.kubernetes.io/infra
           value: reserved
           effect: NoSchedule
         - key: node-role.kubernetes.io/infra
           value: reserved
           effect: NoExecute

   1

   添加 nodeSelector 参数，并设为适用于您想要移动的组件的值。您可以根据为节点指定的值，按所示格式使用 nodeSelector 或使用 <key>: <value> 对。如果您在 infrasructure 节点中添加了污点，还要添加匹配的容限。

2. 观察监控 pod 移至新机器：

   $ watch 'oc get pod -n openshift-monitoring -o wide'

3. 如果组件没有移到 infra 节点，请删除带有这个组件的 pod:

   $ oc delete pod -n openshift-monitoring <pod>

   已删除 pod 的组件在 infra 节点上重新创建。

1. 在 OpenShift Container Platform web 控制台中，切换到 Administration → Custom Resource Definitions 页面。
2. 在 Custom Resource Definitions 页面中，点击 FeatureGate。
3. 在 Custom Resource Definition Details 页面中，点 Instances 选项卡。
4. 点 集群 功能门，然后点 YAML 选项卡。

5. 编辑集群实例以添加特定的功能集：

   警告

   在集群中启用 TechPreviewNoUpgrade 功能集无法撤消，并会阻止次版本更新。您不应该在生产环境集群中启用此功能。

   功能门自定义资源示例

   apiVersion: config.openshift.io/v1
   kind: FeatureGate
   metadata:
     name: cluster 1
   # ...
   spec:
     featureSet: TechPreviewNoUpgrade 2

   1

   FeatureGate CR 的名称必须是 cluster。

   2

   添加要启用的功能集：

   • TechPreviewNoUpgrade 启用了特定的技术预览功能。

   保存更改后，会创建新的机器配置，然后更新机器配置池，并在应用更改时在每个节点上调度。

1. 从 Web 控制台中的 Administrator 视角，进入到 Compute → Nodes。
2. 选择一个节点。
3. 在 Node 详情页面中，点 Terminal。

4. 在终端窗口中，将根目录改为 /host ：

   sh-4.2# chroot /host

5. 查看 kubelet.conf 文件：

   sh-4.2# cat /etc/kubernetes/kubelet.conf

   输出示例

   # ...
   featureGates:
     InsightsOperatorPullingSCA: true,
     LegacyNodeRoleBehavior: false
   # ...

   在集群中启用列为 true 的功能。

   注意

   列出的功能因 OpenShift Container Platform 版本的不同而有所不同。

1. 编辑名为 cluster 的 FeatureGate CR：

   $ oc edit featuregate cluster

   警告

   在集群中启用 TechPreviewNoUpgrade 功能集无法撤消，并会阻止次版本更新。您不应该在生产环境集群中启用此功能。

   FeatureGate 自定义资源示例

   apiVersion: config.openshift.io/v1
   kind: FeatureGate
   metadata:
     name: cluster 1
   # ...
   spec:
     featureSet: TechPreviewNoUpgrade 2

   1

   FeatureGate CR 的名称必须是 cluster。

   2

   添加要启用的功能集：

   • TechPreviewNoUpgrade 启用了特定的技术预览功能。

   保存更改后，会创建新的机器配置，然后更新机器配置池，并在应用更改时在每个节点上调度。

1. 从 Web 控制台中的 Administrator 视角，进入到 Compute → Nodes。
2. 选择一个节点。
3. 在 Node 详情页面中，点 Terminal。

4. 在终端窗口中，将根目录改为 /host ：

   sh-4.2# chroot /host

5. 查看 kubelet.conf 文件：

   sh-4.2# cat /etc/kubernetes/kubelet.conf

   输出示例

   # ...
   featureGates:
     InsightsOperatorPullingSCA: true,
     LegacyNodeRoleBehavior: false
   # ...

   在集群中启用列为 true 的功能。

   注意

   列出的功能因 OpenShift Container Platform 版本的不同而有所不同。

流程

1. 修改 APIServer 对象：

   $ oc edit apiserver

2. 把 encryption 项类型设置为 aescbc：

   spec:
     encryption:
       type: aescbc 1

   1

   aescbc 类型表示 AES-CBC 使用 PKCS#7 padding 和 32 字节密钥来执行加密。

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

   加密过程开始。根据集群的大小，这个过程可能需要 20 分钟或更长的时间才能完成。

4. 验证 etcd 加密是否成功。

   1. 查看 OpenShift API 服务器的 Encrypted 状态条件，以验证其资源是否已成功加密：

      $ oc get openshiftapiserver -o=jsonpath='{range .items[0].status.conditions[?(@.type=="Encrypted")]}{.reason}{"\n"}{.message}{"\n"}'

      在成功加密后输出显示 EncryptionCompleted：

      EncryptionCompleted
      All resources encrypted: routes.route.openshift.io

      如果输出显示 EncryptionInProgress，加密仍在进行中。等待几分钟后重试。

   2. 查看 Kubernetes API 服务器的 Encrypted 状态条件，以验证其资源是否已成功加密：

      $ oc get kubeapiserver -o=jsonpath='{range .items[0].status.conditions[?(@.type=="Encrypted")]}{.reason}{"\n"}{.message}{"\n"}'

      在成功加密后输出显示 EncryptionCompleted：

      EncryptionCompleted
      All resources encrypted: secrets, configmaps

      如果输出显示 EncryptionInProgress，加密仍在进行中。等待几分钟后重试。

   3. 查看 OpenShift OAuth API 服务器的 Encrypted 状态条件，以验证其资源是否已成功加密：

      $ oc get authentication.operator.openshift.io -o=jsonpath='{range .items[0].status.conditions[?(@.type=="Encrypted")]}{.reason}{"\n"}{.message}{"\n"}'

      在成功加密后输出显示 EncryptionCompleted：

      EncryptionCompleted
      All resources encrypted: oauthaccesstokens.oauth.openshift.io, oauthauthorizetokens.oauth.openshift.io

      如果输出显示 EncryptionInProgress，加密仍在进行中。等待几分钟后重试。

流程

1. 修改 APIServer 对象：

   $ oc edit apiserver

2. 将 encryption 字段类型设置为 identity：

   spec:
     encryption:
       type: identity 1

   1

   identity 类型是默认值，意味着没有执行任何加密。

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

   解密过程开始。根据集群的大小，这个过程可能需要 20 分钟或更长的时间才能完成。

4. 验证 etcd 解密是否成功。

   1. 查看 OpenShift API 服务器的 Encrypted 状态条件，以验证其资源是否已成功解密：

      $ oc get openshiftapiserver -o=jsonpath='{range .items[0].status.conditions[?(@.type=="Encrypted")]}{.reason}{"\n"}{.message}{"\n"}'

      在成功解密后输出显示 DecryptionCompleted：

      DecryptionCompleted
      Encryption mode set to identity and everything is decrypted

      如果输出显示 DecryptionInProgress，解密仍在进行中。等待几分钟后重试。

   2. 查看 Kubernetes API 服务器的 Encrypted 状态条件，以验证其资源是否已成功解密：

      $ oc get kubeapiserver -o=jsonpath='{range .items[0].status.conditions[?(@.type=="Encrypted")]}{.reason}{"\n"}{.message}{"\n"}'

      在成功解密后输出显示 DecryptionCompleted：

      DecryptionCompleted
      Encryption mode set to identity and everything is decrypted

      如果输出显示 DecryptionInProgress，解密仍在进行中。等待几分钟后重试。

   3. 查看 OpenShift OAuth API 服务器的 Encrypted 状态条件，以验证其资源是否已成功解密：

      $ oc get authentication.operator.openshift.io -o=jsonpath='{range .items[0].status.conditions[?(@.type=="Encrypted")]}{.reason}{"\n"}{.message}{"\n"}'

      在成功解密后输出显示 DecryptionCompleted：

      DecryptionCompleted
      Encryption mode set to identity and everything is decrypted

      如果输出显示 DecryptionInProgress，解密仍在进行中。等待几分钟后重试。

流程

1. 以 root 用户身份为 control plane 节点启动一个 debug 会话：

   $ oc debug --as-root node/<node_name>

2. 在 debug shell 中将根目录改为 /host ：

   sh-4.4# chroot /host

3. 如果启用了集群范围代理，请运行以下命令导出 NO_PROXY、HTTP_PROXY 和 HTTPS_PROXY 环境变量：

   $ export HTTP_PROXY=http://<your_proxy.example.com>:8080

   $ export HTTPS_PROXY=https://<your_proxy.example.com>:8080

   $ export NO_PROXY=<example.com>

4. 在 debug shell 中运行 cluster-backup.sh 脚本，并传递保存备份的位置。

   提示

   cluster-backup.sh 脚本作为 etcd Cluster Operator 的一个组件被维护，它是 etcdctl snapshot save 命令的包装程序（wrapper）。

   sh-4.4# /usr/local/bin/cluster-backup.sh /home/core/assets/backup

   脚本输出示例

   found latest kube-apiserver: /etc/kubernetes/static-pod-resources/kube-apiserver-pod-6
   found latest kube-controller-manager: /etc/kubernetes/static-pod-resources/kube-controller-manager-pod-7
   found latest kube-scheduler: /etc/kubernetes/static-pod-resources/kube-scheduler-pod-6
   found latest etcd: /etc/kubernetes/static-pod-resources/etcd-pod-3
   ede95fe6b88b87ba86a03c15e669fb4aa5bf0991c180d3c6895ce72eaade54a1
   etcdctl version: 3.4.14
   API version: 3.4
   {"level":"info","ts":1624647639.0188997,"caller":"snapshot/v3_snapshot.go:119","msg":"created temporary db file","path":"/home/core/assets/backup/snapshot_2021-06-25_190035.db.part"}
   {"level":"info","ts":"2021-06-25T19:00:39.030Z","caller":"clientv3/maintenance.go:200","msg":"opened snapshot stream; downloading"}
   {"level":"info","ts":1624647639.0301006,"caller":"snapshot/v3_snapshot.go:127","msg":"fetching snapshot","endpoint":"https://10.0.0.5:2379"}
   {"level":"info","ts":"2021-06-25T19:00:40.215Z","caller":"clientv3/maintenance.go:208","msg":"completed snapshot read; closing"}
   {"level":"info","ts":1624647640.6032252,"caller":"snapshot/v3_snapshot.go:142","msg":"fetched snapshot","endpoint":"https://10.0.0.5:2379","size":"114 MB","took":1.584090459}
   {"level":"info","ts":1624647640.6047094,"caller":"snapshot/v3_snapshot.go:152","msg":"saved","path":"/home/core/assets/backup/snapshot_2021-06-25_190035.db"}
   Snapshot saved at /home/core/assets/backup/snapshot_2021-06-25_190035.db
   {"hash":3866667823,"revision":31407,"totalKey":12828,"totalSize":114446336}
   snapshot db and kube resources are successfully saved to /home/core/assets/backup

   在这个示例中，在 control plane 主机上的 /home/core/assets/backup/ 目录中创建了两个文件：

   • snapshot_<datetimestamp>.db：这个文件是 etcd 快照。cluster-backup.sh 脚本确认其有效。

   • static_kuberesources_<datetimestamp>.tar.gz：此文件包含静态 pod 的资源。如果启用了 etcd 加密，它也包含 etcd 快照的加密密钥。

     注意

     如果启用了 etcd 加密，建议出于安全考虑，将第二个文件与 etcd 快照分开保存。但是，需要这个文件才能从 etcd 快照中进行恢复。

     请记住，etcd 仅对值进行加密，而不对键进行加密。这意味着资源类型、命名空间和对象名称是不加密的。

流程

1. 选择一个要用作恢复主机的 control plane 主机。这是您要在其中运行恢复操作的主机。

2. 建立到每个 control plane 节点（包括恢复主机）的 SSH 连接。

   恢复过程启动后，Kubernetes API 服务器将无法访问，因此您无法访问 control plane 节点。因此，建议在一个单独的终端中建立到每个control plane 主机的 SSH 连接。

   重要

   如果没有完成这个步骤，将无法访问 control plane 主机来完成恢复过程，您将无法从这个状态恢复集群。

3. 将 etcd 备份目录复制复制到恢复 control plane 主机上。

   此流程假设您将 backup 目录（其中包含 etcd 快照和静态 pod 资源）复制到恢复 control plane 主机的 /home/core/ 目录中。

4. 在任何其他 control plane 节点上停止静态 pod。

   注意

   您不需要停止恢复主机上的静态 pod。

   1. 访问不是恢复主机的 control plane 主机。

   2. 将现有 etcd pod 文件从 Kubelet 清单目录中移出：

      $ sudo mv -v /etc/kubernetes/manifests/etcd-pod.yaml /tmp

   3. 验证 etcd pod 是否已停止。

      $ sudo crictl ps | grep etcd | egrep -v "operator|etcd-guard"

      命令输出应该为空。如果它不是空的，请等待几分钟后再重新检查。

   4. 将现有 Kubernetes API 服务器 pod 文件移出 kubelet 清单目录中：

      $ sudo mv -v /etc/kubernetes/manifests/kube-apiserver-pod.yaml /tmp

   5. 验证 Kubernetes API 服务器 pod 是否已停止。

      $ sudo crictl ps | grep kube-apiserver | egrep -v "operator|guard"

      命令输出应该为空。如果它不是空的，请等待几分钟后再重新检查。

   6. 将 etcd 数据目录移到不同的位置：

      $ sudo mv -v /var/lib/etcd/ /tmp

   7. 如果 /etc/kubernetes/manifests/keepalived.yaml 文件存在，且节点被删除，请按照以下步骤执行：

      1. 将 /etc/kubernetes/manifests/keepalived.yaml 文件从 kubelet 清单目录中移出：

         $ sudo mv -v /etc/kubernetes/manifests/keepalived.yaml /tmp

      2. 容器验证由 keepalived 守护进程管理的任何容器是否已停止：

         $ sudo crictl ps --name keepalived

         命令输出应该为空。如果它不是空的，请等待几分钟后再重新检查。

      3. 检查 control plane 是否已分配任何 Virtual IP (VIP)：

         $ ip -o address | egrep '<api_vip>|<ingress_vip>'

      4. 对于每个报告的 VIP，运行以下命令将其删除：

         $ sudo ip address del <reported_vip> dev <reported_vip_device>

   8. 在其他不是恢复主机的 control plane 主机上重复此步骤。
5. 访问恢复 control plane 主机。

6. 如果使用 keepalived 守护进程，请验证恢复 control plane 节点是否拥有 VIP：

   $ ip -o address | grep <api_vip>

   如果存在 VIP 的地址（如果存在）。如果 VIP 没有设置或配置不正确，这个命令会返回一个空字符串。

7. 如果启用了集群范围的代理，请确定已导出了 NO_PROXY、HTTP_PROXY和 HTTPS_PROXY 环境变量。

   提示

   您可以通过查看 oc get proxy cluster -o yaml 的输出来检查代理是否已启用。如果 httpProxy、httpsProxy和 noProxy 字段设置了值，则会启用代理。

8. 在恢复 control plane 主机上运行恢复脚本，提供到 etcd 备份目录的路径：

   $ sudo -E /usr/local/bin/cluster-restore.sh /home/core/assets/backup

   脚本输出示例

   ...stopping kube-scheduler-pod.yaml
   ...stopping kube-controller-manager-pod.yaml
   ...stopping etcd-pod.yaml
   ...stopping kube-apiserver-pod.yaml
   Waiting for container etcd to stop
   .complete
   Waiting for container etcdctl to stop
   .............................complete
   Waiting for container etcd-metrics to stop
   complete
   Waiting for container kube-controller-manager to stop
   complete
   Waiting for container kube-apiserver to stop
   ..........................................................................................complete
   Waiting for container kube-scheduler to stop
   complete
   Moving etcd data-dir /var/lib/etcd/member to /var/lib/etcd-backup
   starting restore-etcd static pod
   starting kube-apiserver-pod.yaml
   static-pod-resources/kube-apiserver-pod-7/kube-apiserver-pod.yaml
   starting kube-controller-manager-pod.yaml
   static-pod-resources/kube-controller-manager-pod-7/kube-controller-manager-pod.yaml
   starting kube-scheduler-pod.yaml
   static-pod-resources/kube-scheduler-pod-8/kube-scheduler-pod.yaml

   注意

   如果在上次 etcd 备份后更新了节点，则恢复过程可能会导致节点进入 NotReady 状态。

9. 检查节点以确保它们处于 Ready 状态。

   1. 运行以下命令:

      $ oc get nodes -w

      输出示例

      NAME                STATUS  ROLES          AGE     VERSION
      host-172-25-75-28   Ready   master         3d20h   v1.25.0
      host-172-25-75-38   Ready   infra,worker   3d20h   v1.25.0
      host-172-25-75-40   Ready   master         3d20h   v1.25.0
      host-172-25-75-65   Ready   master         3d20h   v1.25.0
      host-172-25-75-74   Ready   infra,worker   3d20h   v1.25.0
      host-172-25-75-79   Ready   worker         3d20h   v1.25.0
      host-172-25-75-86   Ready   worker         3d20h   v1.25.0
      host-172-25-75-98   Ready   infra,worker   3d20h   v1.25.0

      所有节点都可能需要几分钟时间报告其状态。

   2. 如果有任何节点处于 NotReady 状态，登录到节点，并从每个节点上的 /var/lib/kubelet/pki 目录中删除所有 PEM 文件。您可以 SSH 到节点，或使用 web 控制台中的终端窗口。

      $  ssh -i <ssh-key-path> core@<master-hostname>

      pki 目录示例

      sh-4.4# pwd
      /var/lib/kubelet/pki
      sh-4.4# ls
      kubelet-client-2022-04-28-11-24-09.pem  kubelet-server-2022-04-28-11-24-15.pem
      kubelet-client-current.pem              kubelet-server-current.pem

10. 在所有 control plane 主机上重启 kubelet 服务。

    1. 在恢复主机中运行以下命令：

       $ sudo systemctl restart kubelet.service

    2. 在所有其他 control plane 主机上重复此步骤。

11. 批准待处理的 CSR：

    注意

    没有 worker 节点的集群（如单节点集群或由三个可调度的 control plane 节点组成的集群）不会批准任何待处理的 CSR。您可以跳过此步骤中列出的所有命令。

    1. 获取当前 CSR 列表：

       $ oc get csr

       输出示例

       NAME        AGE    SIGNERNAME                                    REQUESTOR                                                                   CONDITION
       csr-2s94x   8m3s   kubernetes.io/kubelet-serving                 system:node:<node_name>                                                     Pending 1
       csr-4bd6t   8m3s   kubernetes.io/kubelet-serving                 system:node:<node_name>                                                     Pending 2
       csr-4hl85   13m    kubernetes.io/kube-apiserver-client-kubelet   system:serviceaccount:openshift-machine-config-operator:node-bootstrapper   Pending 3
       csr-zhhhp   3m8s   kubernetes.io/kube-apiserver-client-kubelet   system:serviceaccount:openshift-machine-config-operator:node-bootstrapper   Pending 4
       ...

       1 1 2

       一个待处理的 kubelet 服务 CSR（用于用户置备的安装）。

       3 4

       一个待处理的 node-bootstrapper CSR。

    2. 查看一个 CSR 的详细信息以验证其是否有效：

       $ oc describe csr <csr_name> 1

       1

       <csr_name> 是当前 CSR 列表中 CSR 的名称。

    3. 批准每个有效的 node-bootstrapper CSR：

       $ oc adm certificate approve <csr_name>

    4. 对于用户置备的安装，请批准每个有效的 kubelet 服务 CSR：

       $ oc adm certificate approve <csr_name>

12. 确认单个成员 control plane 已被成功启动。

    1. 从恢复主机上，验证 etcd 容器是否正在运行。

       $ sudo crictl ps | grep etcd | egrep -v "operator|etcd-guard"

       输出示例

       3ad41b7908e32       36f86e2eeaaffe662df0d21041eb22b8198e0e58abeeae8c743c3e6e977e8009                                                         About a minute ago   Running             etcd                                          0                   7c05f8af362f0

    2. 从恢复主机上，验证 etcd pod 是否正在运行。

       $ oc -n openshift-etcd get pods -l k8s-app=etcd

       输出示例

       NAME                                             READY   STATUS      RESTARTS   AGE
       etcd-ip-10-0-143-125.ec2.internal                1/1     Running     1          2m47s

       如果状态是 Pending，或者输出中列出了多个正在运行的 etcd pod，请等待几分钟，然后再次检查。

13. 如果使用 OVNKubernetes 网络插件，请删除与不是恢复 control plane 主机的 control plane 主机关联的节点对象。

    $ oc delete node <non-recovery-controlplane-host-1> <non-recovery-controlplane-host-2>

14. 验证 Cluster Network Operator (CNO) 是否已重新部署 OVN-Kubernetes control plane，并且不再引用非恢复控制器 IP 地址。要验证此结果，请定期检查以下命令的输出。等待返回空结果，然后继续下一步的所有主机上重启 Open Virtual Network (OVN) Kubernetes pod。

    $ oc -n openshift-ovn-kubernetes get ds/ovnkube-master -o yaml | grep -E '<non-recovery_controller_ip_1>|<non-recovery_controller_ip_2>'

    注意

    重新部署 OVN-Kubernetes control plane 并至少需要 5 到 10 分钟，并且上一命令返回空输出。

15. 如果使用 OVN-Kubernetes 网络插件，请在所有主机上重启 Open Virtual Network (OVN) Kubernetes pod。

    注意

    验证和变异准入 Webhook 可能会拒绝 pod。如果您添加了额外的 Webhook，其 failurePolicy 被设置为 Fail 的，则它们可能会拒绝 pod，恢复过程可能会失败。您可以通过在恢复集群状态时保存和删除 Webhook 来避免这种情况。成功恢复集群状态后，您可以再次启用 Webhook。

    另外，您可以在恢复集群状态时临时将 failurePolicy 设置为 Ignore。成功恢复集群状态后，您可以将 failurePolicy 设置为 Fail。

    1. 删除北向数据库 (nbdb) 和南向数据库 (sbdb)。使用 Secure Shell (SSH) 访问恢复主机和剩余的 control plane 节点，再运行以下命令：

       $ sudo rm -f /var/lib/ovn/etc/*.db

    2. 运行以下命令删除所有 OVN-Kubernetes control plane pod：

       $ oc delete pods -l app=ovnkube-master -n openshift-ovn-kubernetes

    3. 运行以下命令，确保任何 OVN-Kubernetes control plane pod 已再次部署，并处于 Running 状态：

       $ oc get pods -l app=ovnkube-master -n openshift-ovn-kubernetes

       输出示例

       NAME                   READY   STATUS    RESTARTS   AGE
       ovnkube-master-nb24h   4/4     Running   0          48s

    4. 运行以下命令删除所有 ovnkube-node pod：

       $ oc get pods -n openshift-ovn-kubernetes -o name | grep ovnkube-node | while read p ; do oc delete $p -n openshift-ovn-kubernetes ; done

    5. 运行以下命令，确保所有 ovnkube-node pod 已再次部署，并处于 Running 状态：

       $ oc get  pods -n openshift-ovn-kubernetes | grep ovnkube-node

16. 逐个删除并重新创建其他非恢复 control plane 机器。重新创建机器后，会强制一个新修订版本，etcd 会自动扩展。

    • 如果使用用户置备的裸机安装，您可以使用最初创建它时使用的相同方法重新创建 control plane 机器。如需更多信息，请参阅"在裸机上安装用户置备的集群"。

      警告

      不要为恢复主机删除并重新创建机器。

    • 如果您正在运行安装程序置备的基础架构，或者您使用 Machine API 创建机器，请按照以下步骤执行：

      警告

      不要为恢复主机删除并重新创建机器。

      对于安装程序置备的基础架构上的裸机安装，不会重新创建 control plane 机器。如需更多信息，请参阅"替换裸机控制平面节点"。

      1. 为丢失的 control plane 主机之一获取机器。

         在一个终端中使用 cluster-admin 用户连接到集群，运行以下命令：

         $ oc get machines -n openshift-machine-api -o wide

         输出示例：

         NAME                                        PHASE     TYPE        REGION      ZONE         AGE     NODE                           PROVIDERID                              STATE
         clustername-8qw5l-master-0                  Running   m4.xlarge   us-east-1   us-east-1a   3h37m   ip-10-0-131-183.ec2.internal   aws:///us-east-1a/i-0ec2782f8287dfb7e   stopped 1
         clustername-8qw5l-master-1                  Running   m4.xlarge   us-east-1   us-east-1b   3h37m   ip-10-0-143-125.ec2.internal   aws:///us-east-1b/i-096c349b700a19631   running
         clustername-8qw5l-master-2                  Running   m4.xlarge   us-east-1   us-east-1c   3h37m   ip-10-0-154-194.ec2.internal    aws:///us-east-1c/i-02626f1dba9ed5bba  running
         clustername-8qw5l-worker-us-east-1a-wbtgd   Running   m4.large    us-east-1   us-east-1a   3h28m   ip-10-0-129-226.ec2.internal   aws:///us-east-1a/i-010ef6279b4662ced   running
         clustername-8qw5l-worker-us-east-1b-lrdxb   Running   m4.large    us-east-1   us-east-1b   3h28m   ip-10-0-144-248.ec2.internal   aws:///us-east-1b/i-0cb45ac45a166173b   running
         clustername-8qw5l-worker-us-east-1c-pkg26   Running   m4.large    us-east-1   us-east-1c   3h28m   ip-10-0-170-181.ec2.internal   aws:///us-east-1c/i-06861c00007751b0a   running

         1

         这是用于丢失的 control plane 主机 ip-10-0-131-183.ec2.internal 的 control plane 机器。

      2. 运行以下命令，删除丢失的 control plane 主机的机器：

         $ oc delete machine -n openshift-machine-api clustername-8qw5l-master-0 1

         1

         为丢失的 control plane 主机指定 control plane 机器的名称。

         删除丢失的 control plane 主机的机器后，会自动置备新机器。

      3. 运行以下命令验证新机器是否已创建：

         $ oc get machines -n openshift-machine-api -o wide

         输出示例：

         NAME                                        PHASE          TYPE        REGION      ZONE         AGE     NODE                           PROVIDERID                              STATE
         clustername-8qw5l-master-1                  Running        m4.xlarge   us-east-1   us-east-1b   3h37m   ip-10-0-143-125.ec2.internal   aws:///us-east-1b/i-096c349b700a19631   running
         clustername-8qw5l-master-2                  Running        m4.xlarge   us-east-1   us-east-1c   3h37m   ip-10-0-154-194.ec2.internal    aws:///us-east-1c/i-02626f1dba9ed5bba  running
         clustername-8qw5l-master-3                  Provisioning   m4.xlarge   us-east-1   us-east-1a   85s     ip-10-0-173-171.ec2.internal    aws:///us-east-1a/i-015b0888fe17bc2c8  running 1
         clustername-8qw5l-worker-us-east-1a-wbtgd   Running        m4.large    us-east-1   us-east-1a   3h28m   ip-10-0-129-226.ec2.internal   aws:///us-east-1a/i-010ef6279b4662ced   running
         clustername-8qw5l-worker-us-east-1b-lrdxb   Running        m4.large    us-east-1   us-east-1b   3h28m   ip-10-0-144-248.ec2.internal   aws:///us-east-1b/i-0cb45ac45a166173b   running
         clustername-8qw5l-worker-us-east-1c-pkg26   Running        m4.large    us-east-1   us-east-1c   3h28m   ip-10-0-170-181.ec2.internal   aws:///us-east-1c/i-06861c00007751b0a   running

         1

         新机器 clustername-8qw5l-master-3 会被创建，并在阶段从 Provisioning 变为 Running 后就绪。

         创建新机器可能需要几分钟时间。当机器或节点返回一个健康状态时，etcd cluster Operator 将自动同步。

      4. 对不是恢复主机的每个已丢失的 control plane 主机重复此步骤。

17. 输入以下命令关闭仲裁保护：

    $ oc patch etcd/cluster --type=merge -p '{"spec": {"unsupportedConfigOverrides": {"useUnsupportedUnsafeNonHANonProductionUnstableEtcd": true}}}'

    此命令可确保您可以成功重新创建机密并推出静态 pod。

18. 在恢复主机中的一个单独的终端窗口中，运行以下命令来导出恢复 kubeconfig 文件：

    $ export KUBECONFIG=/etc/kubernetes/static-pod-resources/kube-apiserver-certs/secrets/node-kubeconfigs/localhost-recovery.kubeconfig

19. 强制 etcd 重新部署。

    在导出恢复 kubeconfig 文件的同一终端窗口中，运行以下命令：

    $ oc patch etcd cluster -p='{"spec": {"forceRedeploymentReason": "recovery-'"$( date --rfc-3339=ns )"'"}}' --type=merge 1

    1

    forceRedeploymentReason 值必须是唯一的，这就是为什么附加时间戳的原因。

    当 etcd cluster Operator 执行重新部署时，现有节点开始使用与初始 bootstrap 扩展类似的新 pod。

20. 输入以下命令重新打开仲裁保护：

    $ oc patch etcd/cluster --type=merge -p '{"spec": {"unsupportedConfigOverrides": null}}'

21. 您可以输入以下命令验证 unsupportedConfigOverrides 部分是否已从对象中删除：

    $ oc get etcd/cluster -oyaml

22. 验证所有节点是否已更新至最新的修订版本。

    在一个终端中使用 cluster-admin 用户连接到集群，运行以下命令：

    $ oc get etcd -o=jsonpath='{range .items[0].status.conditions[?(@.type=="NodeInstallerProgressing")]}{.reason}{"\n"}{.message}{"\n"}'

    查看 etcd 的NodeInstallerProgressing 状态条件，以验证所有节点是否处于最新的修订。在更新成功后，输出会显示 AllNodesAtLatestRevision：

    AllNodesAtLatestRevision
    3 nodes are at revision 7 1

    1

    在本例中，最新的修订版本号是 7。

    如果输出包含多个修订号，如 2 个节点为修订版本 6；1 个节点为修订版本 7，这意味着更新仍在进行中。等待几分钟后重试。

23. 在重新部署 etcd 后，为 control plane 强制进行新的 rollout。由于 kubelet 使用内部负载平衡器连接到 API 服务器，因此 Kubernetes API 将在其他节点上重新安装自己。

    在一个终端中使用 cluster-admin 用户连接到集群，运行以下命令。

    1. 为 Kubernetes API 服务器强制进行新的推出部署：

       $ oc patch kubeapiserver cluster -p='{"spec": {"forceRedeploymentReason": "recovery-'"$( date --rfc-3339=ns )"'"}}' --type=merge

       验证所有节点是否已更新至最新的修订版本。

       $ oc get kubeapiserver -o=jsonpath='{range .items[0].status.conditions[?(@.type=="NodeInstallerProgressing")]}{.reason}{"\n"}{.message}{"\n"}'

       查看 NodeInstallerProgressing 状态条件，以验证所有节点是否处于最新版本。在更新成功后，输出会显示 AllNodesAtLatestRevision：

       AllNodesAtLatestRevision
       3 nodes are at revision 7 1

       1

       在本例中，最新的修订版本号是 7。

       如果输出包含多个修订号，如 2 个节点为修订版本 6；1 个节点为修订版本 7，这意味着更新仍在进行中。等待几分钟后重试。

    2. 为 Kubernetes 控制器管理器强制进行新的推出部署：

       $ oc patch kubecontrollermanager cluster -p='{"spec": {"forceRedeploymentReason": "recovery-'"$( date --rfc-3339=ns )"'"}}' --type=merge

       验证所有节点是否已更新至最新的修订版本。

       $ oc get kubecontrollermanager -o=jsonpath='{range .items[0].status.conditions[?(@.type=="NodeInstallerProgressing")]}{.reason}{"\n"}{.message}{"\n"}'

       查看 NodeInstallerProgressing 状态条件，以验证所有节点是否处于最新版本。在更新成功后，输出会显示 AllNodesAtLatestRevision：

       AllNodesAtLatestRevision
       3 nodes are at revision 7 1

       1

       在本例中，最新的修订版本号是 7。

       如果输出包含多个修订号，如 2 个节点为修订版本 6；1 个节点为修订版本 7，这意味着更新仍在进行中。等待几分钟后重试。

    3. 为 Kubernetes 调度程序强制进行新的推出部署：

       $ oc patch kubescheduler cluster -p='{"spec": {"forceRedeploymentReason": "recovery-'"$( date --rfc-3339=ns )"'"}}' --type=merge

       验证所有节点是否已更新至最新的修订版本。

       $ oc get kubescheduler -o=jsonpath='{range .items[0].status.conditions[?(@.type=="NodeInstallerProgressing")]}{.reason}{"\n"}{.message}{"\n"}'

       查看 NodeInstallerProgressing 状态条件，以验证所有节点是否处于最新版本。在更新成功后，输出会显示 AllNodesAtLatestRevision：

       AllNodesAtLatestRevision
       3 nodes are at revision 7 1

       1

       在本例中，最新的修订版本号是 7。

       如果输出包含多个修订号，如 2 个节点为修订版本 6；1 个节点为修订版本 7，这意味着更新仍在进行中。等待几分钟后重试。

24. 验证所有 control plane 主机是否已启动并加入集群。

    在一个终端中使用 cluster-admin 用户连接到集群，运行以下命令：

    $ oc -n openshift-etcd get pods -l k8s-app=etcd

    输出示例

    etcd-ip-10-0-143-125.ec2.internal                2/2     Running     0          9h
    etcd-ip-10-0-154-194.ec2.internal                2/2     Running     0          9h
    etcd-ip-10-0-173-171.ec2.internal                2/2     Running     0          9h

1. 使用类似以下示例的对象定义来创建 YAML 文件：

   apiVersion: policy/v1 1
   kind: PodDisruptionBudget
   metadata:
     name: my-pdb
   spec:
     minAvailable: 2  2
     selector:  3
       matchLabels:
         name: my-pod

   1

   PodDisruptionBudget 是 policy/v1 API 组的一部分。

   2

   必须同时可用的最小 pod 数量。这可以是整数，也可以是指定百分比的字符串（如 20％）。

   3

   对一组资源进行的标签查询。matchLabels 和 matchExpressions 的结果在逻辑上是联合的。将此参数留空，如 selector {}，以选择项目中的所有 pod。

   或者：

   apiVersion: policy/v1 1
   kind: PodDisruptionBudget
   metadata:
     name: my-pdb
   spec:
     maxUnavailable: 25% 2
     selector: 3
       matchLabels:
         name: my-pod

   1

   PodDisruptionBudget 是 policy/v1 API 组的一部分。

   2

   同时不能使用的最多的 pod 数量。这可以是整数，也可以是指定百分比的字符串（如 20％）。

   3

   对一组资源进行的标签查询。matchLabels 和 matchExpressions 的结果在逻辑上是联合的。将此参数留空，如 selector {}，以选择项目中的所有 pod。

2. 运行以下命令，将对象添加到项目中：

   $ oc create -f </path/to/file> -n <project_name>

流程

1. 在 web 控制台的 Administrator 视角中，导航到 Workloads → Secrets。

2. 在 Secrets 页面的表中，找到您的云供应商的 root secret。

   平台	Secret 名称
   AWS	aws-creds
   Azure	azure-credentials
   GCP	gcp-credentials
   RHOSP	openstack-credentials
   RHV	ovirt-credentials
   VMware vSphere	vsphere-creds

3. 点击与 secret 相同的行 中的 Options 菜单，然后选择 Edit Secret。
4. 记录 Value 字段的内容。您可以使用这些信息验证在更新凭证后该值是否不同。
5. 使用云供应商的新身份验证信息更新 Value 字段的文本，然后点 Save。

6. 如果您要为没有启用 vSphere CSI Driver Operator 的 vSphere 集群更新凭证，您必须强制推出 Kubernetes 控制器管理器以应用更新的凭证。

   注意

   如果启用了 vSphere CSI Driver Operator，则不需要这一步。

   要应用更新的 vSphere 凭证，请以具有 cluster-admin 角色的用户身份登录到 OpenShift Container Platform CLI，并运行以下命令：

   $ oc patch kubecontrollermanager cluster \
     -p='{"spec": {"forceRedeploymentReason": "recovery-'"$( date )"'"}}' \
     --type=merge

   当凭证被推出时，Kubernetes Controller Manager Operator 的状态会报告 Progressing=true。要查看状态，请运行以下命令：

   $ oc get co kube-controller-manager

7. 如果集群的 CCO 配置为使用 mint 模式，请删除各个 CredentialsRequest 对象引用的每个组件 secret。

   1. 以具有 cluster-admin 角色的用户身份登录 OpenShift Container Platform CLI。

   2. 获取所有引用的组件 secret 的名称和命名空间：

      $ oc -n openshift-cloud-credential-operator get CredentialsRequest \
        -o json | jq -r '.items[] | select (.spec.providerSpec.kind=="<provider_spec>") | .spec.secretRef'

      其中 <provider_spec> 是您的云供应商的对应值：

      • AWS: AWSProviderSpec
      • GCP: GCPProviderSpec

      AWS 输出的部分示例

      {
        "name": "ebs-cloud-credentials",
        "namespace": "openshift-cluster-csi-drivers"
      }
      {
        "name": "cloud-credential-operator-iam-ro-creds",
        "namespace": "openshift-cloud-credential-operator"
      }

   3. 删除每个引用的组件 secret：

      $ oc delete secret <secret_name> \1
        -n <secret_namespace> 2

      1

      指定 secret 的名称。

      2

      指定包含 secret 的命名空间。

      删除 AWS secret 示例

      $ oc delete secret ebs-cloud-credentials -n openshift-cluster-csi-drivers

      您不需要从供应商控制台手动删除凭证。删除引用的组件 secret 将导致 CCO 从平台中删除现有凭证并创建新凭证。

1. 在 web 控制台的 Administrator 视角中，导航到 Workloads → Secrets。
2. 验证 Value 字段的内容已改变。

流程

1. 在 web 控制台的 Administrator 视角中，导航到 Workloads → Secrets。

2. 在 Secrets 页面的表中，找到您的云供应商的 root secret。

   平台	Secret 名称
   AWS	aws-creds
   GCP	gcp-credentials

3. 点击与 secret 相同的行 中的 Options 菜单，然后选择 Delete Secret。

流程

1. 确保用于安装集群的 kubeconfig 文件和用于安装集群的安装程序位于 RHEL 8 机器中。若要实现这一目标，一种方法是使用安装集群时所用的同一台机器。
2. 配置机器，以访问您计划用作计算机器的所有 RHEL 主机。您可以使用公司允许的任何方法，包括使用 SSH 代理或 VPN 的堡垒主机。

3. 在运行 playbook 的机器上配置一个用户，该用户对所有 RHEL 主机具有 SSH 访问权限。

   重要

   如果使用基于 SSH 密钥的身份验证，您必须使用 SSH 代理来管理密钥。

4. 如果还没有这样做，请使用 RHSM 注册机器，并为它附加一个带有 OpenShift 订阅的池：

   1. 使用 RHSM 注册机器：

      # subscription-manager register --username=<user_name> --password=<password>

   2. 从 RHSM 获取最新的订阅数据：

      # subscription-manager refresh

   3. 列出可用的订阅：

      # subscription-manager list --available --matches '*OpenShift*'

   4. 在上一命令的输出中，找到 OpenShift Container Platform 订阅的池 ID 并附加该池：

      # subscription-manager attach --pool=<pool_id>

5. 启用 OpenShift Container Platform 4.12 所需的存储库：

   # subscription-manager repos \
       --enable="rhel-8-for-x86_64-baseos-rpms" \
       --enable="rhel-8-for-x86_64-appstream-rpms" \
       --enable="rhocp-4.12-for-rhel-8-x86_64-rpms"

6. 安装所需的软件包，包括 openshift-ansible:

   # yum install openshift-ansible openshift-clients jq

   openshift-ansible 软件包提供了安装实用程序，并且会拉取将 RHEL 计算节点添加到集群所需要的其他软件包，如 Ansible、playbook 和相关的配置文件。openshift-clients 提供 oc CLI，jq 软件包则可改善命令行中 JSON 输出的显示。

1. 在每一主机上进行 RHSM 注册：

   # subscription-manager register --username=<user_name> --password=<password>

2. 从 RHSM 获取最新的订阅数据：

   # subscription-manager refresh

3. 列出可用的订阅：

   # subscription-manager list --available --matches '*OpenShift*'

4. 在上一命令的输出中，找到 OpenShift Container Platform 订阅的池 ID 并附加该池：

   # subscription-manager attach --pool=<pool_id>

5. 禁用所有 yum 存储库：

   1. 禁用所有已启用的 RHSM 存储库：

      # subscription-manager repos --disable="*"

   2. 列出剩余的 yum 存储库，并记录它们在 repo id 下的名称（若有）：

      # yum repolist

   3. 使用 yum-config-manager 禁用剩余的 yum 存储库：

      # yum-config-manager --disable <repo_id>

      或者，禁用所有存储库：

      # yum-config-manager --disable \*

      请注意，有大量可用存储库时可能需要花费几分钟

6. 仅启用 OpenShift Container Platform 4.12 所需的存储库：

   # subscription-manager repos \
       --enable="rhel-8-for-x86_64-baseos-rpms" \
       --enable="rhel-8-for-x86_64-appstream-rpms" \
       --enable="rhocp-4.12-for-rhel-8-x86_64-rpms" \
       --enable="fast-datapath-for-rhel-8-x86_64-rpms"

7. 停止并禁用主机上的防火墙：

   # systemctl disable --now firewalld.service

   注意

   请不要在以后启用防火墙。如果这样做，则无法访问 worker 上的 OpenShift Container Platform 日志。

1. 创建一个名为 /<path>/inventory/hosts 的 Ansible 清单文件，以定义您的计算机器主机和必要的变量：

   [all:vars]
   ansible_user=root 1
   #ansible_become=True 2
   
   openshift_kubeconfig_path="~/.kube/config" 3
   
   [new_workers] 4
   mycluster-rhel8-0.example.com
   mycluster-rhel8-1.example.com

   1

   指定要在远程计算机器上运行 Ansible 任务的用户名。

   2

   如果不将 root 指定为 ansible_user，您必须将 ansible_become 设置为 True，并为该用户分配 sudo 权限。

   3

   指定集群的 kubeconfig 文件的路径和文件名。

   4

   列出要添加到集群中的每台 RHEL 机器。必须为每个主机提供完全限定域名。此名称是集群用来访问机器的主机名，因此请设置用于访问机器的正确公共或私有名称。

2. 进入到 Ansible playbook 目录：

   $ cd /usr/share/ansible/openshift-ansible

3. 运行 playbook：

   $ ansible-playbook -i /<path>/inventory/hosts playbooks/scaleup.yml 1

   1

   对于<path> ，指定您创建的Ansible库存文件的路径。

流程

1. 查看机器列表并记录 RHCOS 计算机器的节点名称：

   $ oc get nodes -o wide

2. 对于每一台 RHCOS 计算机器，删除其节点：

   1. 通过运行 oc adm cordon 命令，将节点标记为不可调度：

      $ oc adm cordon <node_name> 1

      1

      指定其中一台 RHCOS 计算机器的节点名称。

   2. 清空节点中的所有 Pod：

      $ oc adm drain <node_name> --force --delete-emptydir-data --ignore-daemonsets 1

      1

      指定您隔离的 RHCOS 计算机器的节点名称。

   3. 删除节点：

      $ oc delete nodes <node_name> 1

      1

      指定您清空的 RHCOS 计算机器的节点名称。

3. 查看计算机器的列表，以确保仅保留 RHEL 节点：

   $ oc get nodes -o wide

4. 从集群的计算机器的负载均衡器中删除 RHCOS 机器。您可以删除虚拟机或重新制作 RHCOS 计算机器物理硬件的镜像。

流程

1. 使用 ISO 文件在更多计算机器上安装 RHCOS。在安装集群前，使用创建机器时使用的相同方法：

   • 将 ISO 镜像刻录到磁盘并直接启动。
   • 在 LOM 接口中使用 ISO 重定向。

2. 在不指定任何选项或中断实时引导序列的情况下引导 RHCOS ISO 镜像。等待安装程序在 RHCOS live 环境中引导进入 shell 提示符。

   注意

   您可以中断 RHCOS 安装引导过程来添加内核参数。但是，在这个 ISO 过程中，您应该使用以下步骤中所述的 coreos-installer 命令，而不是添加内核参数。

3. 运行 coreos-installer 命令并指定满足您的安装要求的选项。您至少必须指定指向节点类型的 Ignition 配置文件的 URL，以及您要安装到的设备：

   $ sudo coreos-installer install --ignition-url=http://<HTTP_server>/<node_type>.ign <device> --ignition-hash=sha512-<digest> 12

   1

   您必须使用 sudo 运行 coreos-installer 命令，因为 core 用户没有执行安装所需的 root 权限。

   2

   当 Ignition 配置文件通过 HTTP URL 获取时，需要 --ignition-hash 选项来验证集群节点上 Ignition 配置文件的真实性。<digest> 是上一步中获取的 Ignition 配置文件 SHA512 摘要。

   注意

   如果要通过使用 TLS 的 HTTPS 服务器提供 Ignition 配置文件，您可以在运行 coreos-installer 前将内部证书颁发机构(CA)添加到系统信任存储中。

   以下示例将引导节点安装初始化到 /dev/sda 设备。bootstrap 节点的 Ignition 配置文件从 IP 地址 192.168.1.2 的 HTTP Web 服务器获取：

   $ sudo coreos-installer install --ignition-url=http://192.168.1.2:80/installation_directory/bootstrap.ign /dev/sda --ignition-hash=sha512-a5a2d43879223273c9b60af66b44202a1d1248fc01cf156c46d4a79f552b6bad47bc8cc78ddf0116e80c59d2ea9e32ba53bc807afbca581aa059311def2c3e3b

4. 在机器的控制台上监控 RHCOS 安装的进度。

   重要

   在开始安装 OpenShift Container Platform 之前，确保每个节点中安装成功。观察安装过程可以帮助确定可能会出现 RHCOS 安装问题的原因。

5. 继续为集群创建更多计算机器。

流程

1. 确认 RHCOS 镜像的 PXE 或 iPXE 安装正确。

   • 对于 PXE：

     DEFAULT pxeboot
     TIMEOUT 20
     PROMPT 0
     LABEL pxeboot
         KERNEL http://<HTTP_server>/rhcos-<version>-live-kernel-<architecture> 1
         APPEND initrd=http://<HTTP_server>/rhcos-<version>-live-initramfs.<architecture>.img coreos.inst.install_dev=/dev/sda coreos.inst.ignition_url=http://<HTTP_server>/worker.ign coreos.live.rootfs_url=http://<HTTP_server>/rhcos-<version>-live-rootfs.<architecture>.img 2

     1

     指定上传到 HTTP 服务器的 live kernel 文件位置。

     2

     指定上传到 HTTP 服务器的 RHCOS 文件的位置。initrd 参数值是 live initramfs 文件的位置，coreos.inst.ignition_url 参数值是 worker Ignition 配置文件的位置，coreos.live.rootfs_url 参数值是 live rootfs 文件的位置。coreos.inst.ignition_url 和 coreos.live.rootfs_url 参数仅支持 HTTP 和 HTTPS。

1. 使用 PXE 或 iPXE 基础架构为集群创建所需的计算机器。

流程

1. 确认集群可以识别这些机器：

   $ oc get nodes

   输出示例

   NAME      STATUS    ROLES   AGE  VERSION
   master-0  Ready     master  63m  v1.25.0
   master-1  Ready     master  63m  v1.25.0
   master-2  Ready     master  64m  v1.25.0

   输出中列出了您创建的所有机器。

   注意

   在有些 CSR 被批准前，前面的输出可能不包括计算节点（也称为 worker 节点）。

2. 检查待处理的 CSR，并确保添加到集群中的每台机器都有 Pending 或 Approved 状态的客户端请求：

   $ oc get csr

   输出示例

   NAME        AGE     REQUESTOR                                                                   CONDITION
   csr-8b2br   15m     system:serviceaccount:openshift-machine-config-operator:node-bootstrapper   Pending
   csr-8vnps   15m     system:serviceaccount:openshift-machine-config-operator:node-bootstrapper   Pending
   ...

   在本例中，两台机器加入集群。您可能会在列表中看到更多已批准的 CSR。

3. 如果 CSR 没有获得批准，在您添加的机器的所有待处理 CSR 都处于 Pending 状态 后，请批准集群机器的 CSR：

   注意

   由于 CSR 会自动轮转，因此请在将机器添加到集群后一小时内批准您的 CSR。如果没有在一小时内批准它们，证书将会轮转，每个节点会存在多个证书。您必须批准所有这些证书。批准客户端 CSR 后，Kubelet 为服务证书创建一个二级 CSR，这需要手动批准。然后，如果 Kubelet 请求具有相同参数的新证书，则后续提供证书续订请求由 machine-approver 自动批准。

   注意

   对于在未启用机器 API 的平台上运行的集群，如裸机和其他用户置备的基础架构，您必须实施一种方法来自动批准 kubelet 提供证书请求(CSR)。如果没有批准请求，则 oc exec、ocrsh 和 oc logs 命令将无法成功，因为 API 服务器连接到 kubelet 时需要服务证书。与 Kubelet 端点联系的任何操作都需要此证书批准。该方法必须监视新的 CSR，确认 CSR 由 system: node 或 system:admin 组中的 node-bootstrapper 服务帐户提交，并确认节点的身份。

   • 要单独批准，请对每个有效的 CSR 运行以下命令：

     $ oc adm certificate approve <csr_name> 1

     1

     <csr_name> 是当前 CSR 列表中 CSR 的名称。

   • 要批准所有待处理的 CSR，请运行以下命令：

     $ oc get csr -o go-template='{{range .items}}{{if not .status}}{{.metadata.name}}{{"\n"}}{{end}}{{end}}' | xargs --no-run-if-empty oc adm certificate approve

     注意

     在有些 CSR 被批准前，一些 Operator 可能无法使用。

4. 现在，您的客户端请求已被批准，您必须查看添加到集群中的每台机器的服务器请求：

   $ oc get csr

   输出示例

   NAME        AGE     REQUESTOR                                                                   CONDITION
   csr-bfd72   5m26s   system:node:ip-10-0-50-126.us-east-2.compute.internal                       Pending
   csr-c57lv   5m26s   system:node:ip-10-0-95-157.us-east-2.compute.internal                       Pending
   ...

5. 如果剩余的 CSR 没有被批准，且处于 Pending 状态，请批准集群机器的 CSR：

   • 要单独批准，请对每个有效的 CSR 运行以下命令：

     $ oc adm certificate approve <csr_name> 1

     1

     <csr_name> 是当前 CSR 列表中 CSR 的名称。

   • 要批准所有待处理的 CSR，请运行以下命令：

     $ oc get csr -o go-template='{{range .items}}{{if not .status}}{{.metadata.name}}{{"\n"}}{{end}}{{end}}' | xargs oc adm certificate approve

6. 批准所有客户端和服务器 CSR 后，机器将 处于 Ready 状态。运行以下命令验证：

   $ oc get nodes

   输出示例

   NAME      STATUS    ROLES   AGE  VERSION
   master-0  Ready     master  73m  v1.25.0
   master-1  Ready     master  73m  v1.25.0
   master-2  Ready     master  74m  v1.25.0
   worker-0  Ready     worker  11m  v1.25.0
   worker-1  Ready     worker  11m  v1.25.0

   注意

   批准服务器 CSR 后可能需要几分钟时间让机器过渡到 Ready 状态。

流程

1. 在命令行中更改为 openshift-machine-api 命名空间：

   $ oc project openshift-machine-api

2. 从 worker-user-data secret 创建新 secret：

   1. 将 secret 的 userData 部分导出到文本文件：

      $ oc get secret worker-user-data --template='{{index .data.userData | base64decode}}' | jq > userData.txt

   2. 编辑文本文件，为要用于新节点的分区添加 storage, filesystems, 和 systemd 小节。您可以根据需要指定任何 Ignition 配置参数。

      注意

      不要更改 ignition 小节中的值。

      {
        "ignition": {
          "config": {
            "merge": [
              {
                "source": "https:...."
              }
            ]
          },
          "security": {
            "tls": {
              "certificateAuthorities": [
                {
                  "source": "data:text/plain;charset=utf-8;base64,.....=="
                }
              ]
            }
          },
          "version": "3.2.0"
        },
        "storage": {
          "disks": [
            {
              "device": "/dev/nvme1n1", 1
              "partitions": [
                {
                  "label": "var",
                  "sizeMiB": 50000, 2
                  "startMiB": 0 3
                }
              ]
            }
          ],
          "filesystems": [
            {
              "device": "/dev/disk/by-partlabel/var", 4
              "format": "xfs", 5
              "path": "/var" 6
            }
          ]
        },
        "systemd": {
          "units": [ 7
            {
              "contents": "[Unit]\nBefore=local-fs.target\n[Mount]\nWhere=/var\nWhat=/dev/disk/by-partlabel/var\nOptions=defaults,pquota\n[Install]\nWantedBy=local-fs.target\n",
              "enabled": true,
              "name": "var.mount"
            }
          ]
        }
      }

      1

      指定 AWS 块设备的绝对路径。

      2

      指定以兆字节为单位的数据分区大小。

      3

      指定以兆字节为单位的分区的开头。当在引导磁盘中添加数据分区时，推荐最少使用 25000 MB(Mebibytes)。root 文件系统会自动调整大小以填充所有可用空间（最多到指定的偏移值）。如果没有指定值，或者指定的值小于推荐的最小值，则生成的 root 文件系统会太小，而在以后进行的 RHCOS 重新安装可能会覆盖数据分区的开始部分。

      4

      指定到 /var 分区的绝对路径。

      5

      指定文件系统格式。

      6

      指定文件系统的挂载点，而 Ignition 运行时相对于根文件系统挂载的位置。这不一定与应在真实 root 中挂载的位置相同，但鼓励使其相同的位置。

      7

      定义将 /dev/disk/by-partlabel/var 设备挂载到 /var 分区的 systemd 挂载单元。

   3. 将 disableTemplating 部分从 work-user-data secret 提取到文本文件：

      $ oc get secret worker-user-data --template='{{index .data.disableTemplating | base64decode}}' | jq > disableTemplating.txt

   4. 从两个文本文件创建新用户数据机密文件。此用户数据 secret 将 userData.txt 文件中的额外节点分区信息传递给新创建的节点。

      $ oc create secret generic worker-user-data-x5 --from-file=userData=userData.txt --from-file=disableTemplating=disableTemplating.txt

3. 为新节点创建新计算机器集：

   1. 创建新的计算机器集 YAML 文件，类似于为 AWS 配置的文件。添加所需分区和新创建的用户数据 secret：

      提示

      使用现有计算机器集作为模板，并根据需要更改新节点的参数。

      apiVersion: machine.openshift.io/v1beta1
      kind: MachineSet
      metadata:
        labels:
          machine.openshift.io/cluster-api-cluster: auto-52-92tf4
        name: worker-us-east-2-nvme1n1 1
        namespace: openshift-machine-api
      spec:
        replicas: 1
        selector:
          matchLabels:
            machine.openshift.io/cluster-api-cluster: auto-52-92tf4
            machine.openshift.io/cluster-api-machineset: auto-52-92tf4-worker-us-east-2b
        template:
          metadata:
            labels:
              machine.openshift.io/cluster-api-cluster: auto-52-92tf4
              machine.openshift.io/cluster-api-machine-role: worker
              machine.openshift.io/cluster-api-machine-type: worker
              machine.openshift.io/cluster-api-machineset: auto-52-92tf4-worker-us-east-2b
          spec:
            metadata: {}
            providerSpec:
              value:
                ami:
                  id: ami-0c2dbd95931a
                apiVersion: awsproviderconfig.openshift.io/v1beta1
                blockDevices:
                - DeviceName: /dev/nvme1n1 2
                  ebs:
                    encrypted: true
                    iops: 0
                    volumeSize: 120
                    volumeType: gp2
                - DeviceName: /dev/nvme1n2 3
                  ebs:
                    encrypted: true
                    iops: 0
                    volumeSize: 50
                    volumeType: gp2
                credentialsSecret:
                  name: aws-cloud-credentials
                deviceIndex: 0
                iamInstanceProfile:
                  id: auto-52-92tf4-worker-profile
                instanceType: m6i.large
                kind: AWSMachineProviderConfig
                metadata:
                  creationTimestamp: null
                placement:
                  availabilityZone: us-east-2b
                  region: us-east-2
                securityGroups:
                - filters:
                  - name: tag:Name
                    values:
                    - auto-52-92tf4-worker-sg
                subnet:
                  id: subnet-07a90e5db1
                tags:
                - name: kubernetes.io/cluster/auto-52-92tf4
                  value: owned
                userDataSecret:
                  name: worker-user-data-x5 4

      1

      为新节点指定名称。

      2

      指定到 AWS 块设备的绝对路径，这里是一个加密的 EBS 卷。

      3

      可选。指定附加 EBS 卷。

      4

      指定用户数据 secret 文件。

   2. 创建计算机器集：

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

      机器可能需要一些时间才可用。

4. 验证新分区和节点是否已创建：

   1. 验证是否已创建计算机器设置：

      $ oc get machineset

      输出示例

      NAME                                               DESIRED   CURRENT   READY   AVAILABLE   AGE
      ci-ln-2675bt2-76ef8-bdgsc-worker-us-east-1a        1         1         1       1           124m
      ci-ln-2675bt2-76ef8-bdgsc-worker-us-east-1b        2         2         2       2           124m
      worker-us-east-2-nvme1n1                           1         1         1       1           2m35s 1

      1

      这是新的计算机器集。

   2. 验证新节点是否已创建：

      $ oc get nodes

      输出示例

      NAME                           STATUS   ROLES    AGE     VERSION
      ip-10-0-128-78.ec2.internal    Ready    worker   117m    v1.25.0
      ip-10-0-146-113.ec2.internal   Ready    master   127m    v1.25.0
      ip-10-0-153-35.ec2.internal    Ready    worker   118m    v1.25.0
      ip-10-0-176-58.ec2.internal    Ready    master   126m    v1.25.0
      ip-10-0-217-135.ec2.internal   Ready    worker   2m57s   v1.25.0 1
      ip-10-0-225-248.ec2.internal   Ready    master   127m    v1.25.0
      ip-10-0-245-59.ec2.internal    Ready    worker   116m    v1.25.0

      1

      这是新节点。

   3. 验证新节点上是否创建了自定义 /var 分区：

      $ oc debug node/<node-name> -- chroot /host lsblk

      例如：

      $ oc debug node/ip-10-0-217-135.ec2.internal -- chroot /host lsblk

      输出示例

      NAME        MAJ:MIN  RM  SIZE RO TYPE MOUNTPOINT
      nvme0n1     202:0    0   120G  0 disk
      |-nvme0n1p1 202:1    0     1M  0 part
      |-nvme0n1p2 202:2    0   127M  0 part
      |-nvme0n1p3 202:3    0   384M  0 part /boot
      `-nvme0n1p4 202:4    0 119.5G  0 part /sysroot
      nvme1n1     202:16   0    50G  0 disk
      `-nvme1n1p1 202:17   0  48.8G  0 part /var 1

      1

      nvme1n1 设备被挂载到 /var 分区。

流程

1. 创建一个 healthcheck.yml 文件，其中包含您的机器健康检查的定义。

2. 将 healthcheck.yml 文件应用到您的集群：

   $ oc apply -f healthcheck.yml

流程

1. 运行以下命令，查看集群中的计算机器：

   $ oc get machinesets -n openshift-machine-api

   计算机器集以 <clusterid>-worker-<aws-region-az> 的形式列出。

2. 运行以下命令，查看集群中的计算机器：

   $ oc get machine -n openshift-machine-api

3. 运行以下命令，在要删除的计算机器上设置注解：

   $ oc annotate machine/<machine_name> -n openshift-machine-api machine.openshift.io/delete-machine="true"

4. 运行以下命令来扩展计算机器集：

   $ oc scale --replicas=2 machineset <machineset> -n openshift-machine-api

   或者：

   $ oc edit machineset <machineset> -n openshift-machine-api

   提示

   您还可以应用以下 YAML 来扩展计算机器集：

   apiVersion: machine.openshift.io/v1beta1
   kind: MachineSet
   metadata:
     name: <machineset>
     namespace: openshift-machine-api
   spec:
     replicas: 2

   您可以扩展或缩减计算机器。需要过几分钟以后新机器才可用。

   重要

   默认情况下，机器控制器会尝试排空在机器上运行的节点，直到成功为止。在某些情况下，如错误配置了 pod 中断预算，排空操作可能无法成功。如果排空操作失败，机器控制器无法继续删除机器。

   您可以通过在特定机器上注解 machine.openshift.io/exclude-node-draining 来跳过排空节点。