流程

1. 登录到 Red Hat Hybrid Cloud 控制台。
2. 在 Red Hat OpenShift 标题中，点 Scale your application。
3. 在菜单中，单击 Clusters。
4. 点 Create cluster。
5. 点 Datacenter 选项卡。
6. 在 Assisted Installer 下，点 Create cluster。
7. 在 Cluster name 字段中输入集群名称。

8. 在 Base domain 字段中输入集群的基域。集群的所有子域将使用此基域。

   注意

   基域必须是有效的 DNS 名称。不得为基域设置通配符域。

9. 选择要安装的 OpenShift Container Platform 版本。

   注意

   对于 IBM Power 和 IBM zSystems 平台，只支持 OpenShift Container Platform 版本 4.13 及更新的版本。

10. 可选： 如果您要在单一节点上安装 OpenShift Container Platform，请选择 Install single node Openshift (SNO)。

    注意

    目前，IBM zSystems 和 IBM Power 平台还不支持 SNO。

11. 可选： Assisted Installer 已关联有与您的帐户关联的 pull secret。如果要使用不同的 pull secret，请选择 Edit pull secret。
12. 可选： 辅助安装程序默认使用 x86_64 CPU 架构。如果要在不同的架构上安装 OpenShift Container Platform，请选择要使用的架构。有效值为 arm64, ppc64le, 和 s390x。请记住，一些功能不适用于 arm64, ppc64le, 和 s390x CPU 架构。
13. 可选： 辅助安装程序默认为 DHCP 网络。如果集群节点需要使用静态 IP 配置、网桥或绑定，而不是使用 DHCP，请选择 Static IP、bridge 和 bond。
14. 可选：如果要启用安装磁盘的加密，对单节点 OpenShift，在Enable encryption of installation disks 中选择 Control plane node, worker。对于多节点集群，您可以选择 Control plane 节点 来加密 control plane 节点安装磁盘，选择 Workers 来加密 worker 节点安装磁盘。

流程

1. 选择互联网协议版本。有效选项为 IPv4 和 Dual stack。
2. 如果集群主机位于共享 VLAN 上，请输入 VLAN ID。

3. 输入网络范围内的 IP 地址。如果选择了 Dual stack 网络，则必须同时输入 IPv4 和 IPv6 地址。

   1. 以 CIDR 标记形式输入集群网络的 IP 地址范围。
   2. 输入默认网关 IP 地址。
   3. 输入 DNS 服务器 IP 地址。

4. 输入特定于主机的配置。

   1. 如果您只设置使用单一网络接口的静态 IP 地址，请使用表单视图输入主机的 IP 地址和 MAC 地址。
   2. 如果您使用多个接口、绑定或其他高级网络功能，请使用 YAML 视图并为使用 NMState 语法的每个主机输入所需的网络状态。然后，为在网络配置中使用的每个主机接口添加 MAC 地址和接口名称。

流程

1. 要安装 OpenShift Virtualization，请选择 Install OpenShift Virtualization。
2. 要安装多集群引擎 (MCE)，请选择 Install multicluster engine。
3. 要安装 OpenShift Data Foundation，请选择 Install OpenShift Data Foundation。
4. 要安装逻辑卷管理器，请选择 Install Logical Volume Manager。
5. 点 Next 进入下一步。

流程

1. 点 Add hosts 按钮并选择安装介质。

   1. 选择 Minimal image file: Provision with virtual media 以下载一个较小的镜像，该镜像会获取引导所需的数据。节点必须具有虚拟介质功能。这是 x86_64 和 arm64 架构的推荐方法。
   2. 选择 Full image file: Provision with physical media 以下载更大的完整镜像。这是 ppc64le 架构的推荐方法。

   3. 选择 iPXE: Provision from your network server，以使用 iPXE 引导主机。这是 s390x 架构的推荐方法。

      注意

      如果您在 RHEL KVM 上使用 iPXE 安装，在有些情况下，KVM 主机上的虚拟机不会在第一次引导时重启，需要手动启动。

2. 可选： 如果集群主机位于需要使用代理的防火墙后面，请选择 Configure cluster-wide proxy settings。输入代理服务器的 HTTP 和 HTTPS URL 的用户名、密码、IP 地址和端口。

3. 可选：添加一个 SSH 公钥，以便可以以 core 用户身份连接到集群节点。通过登录到集群节点，您可以在安装过程中为您提供调试信息。

   重要

   不要在生产环境中跳过这个过程，在生产环境中需要灾难恢复和调试。

   1. 如果您在本地计算机上没有现有的 SSH 密钥对，请按照 为集群节点 SSH 访问生成密钥对 的步骤进行操作。
   2. 在 SSH 公钥 字段中，单击 Browse 以上传包含 SSH 公钥的 id_rsa.pub 文件。或者，将文件拖放到文件管理器的字段中。要查看文件管理器中的文件，请在菜单中选择 Show hidden files。
4. 可选： 如果集群主机位于带有重新加密 man-in-the-middle (MITM)代理的网络中，或者集群需要信任证书用于容器镜像 registry，请选择 Configure cluster-wide trusted certificate。以 X.509 格式添加额外的证书。
5. 如果需要，配置发现镜像。
6. 可选：如果您要在一个平台上安装并希望与该平台集成，请选择 Integrate with your virtualization platform。您必须引导所有主机，并确保它们出现在主机清单中。所有主机必须位于同一平台上。
7. 点 Generate Discovery ISO 或 Generate Script File。
8. 下载发现 ISO 或 iPXE 脚本。
9. 使用发现镜像或 iPXE 脚本引导主机。

流程

1. 在主机的 Options (⋮) 菜单中，选择 Change hostname。如有必要，为主机输入一个新名称，然后点更改。您必须确保每个主机具有有效且唯一的主机名。

   或者，从 Actions 列表中选择 Change hostname 以重命名多个所选主机。在 Change Hostname 对话框中，输入新名称并包含 {{n}}，使每个主机名都是唯一的。然后点 更改。

   注意

   在键入时，您可以看到在 Preview 窗格中显示的新名称。所有选定的主机的名称都几乎相同，唯一的不同是每个主机都带有一个一位的递增数字。

2. 在 Options (⋮) 菜单中，您可以选择 Delete host 来删除一个主机。点 Delete 以确认删除。

   或者，从 Actions 列表中选择 Delete 同时删除多个所选主机。然后点 Delete hosts。

   注意

   在常规部署中，集群可以有三个或更多主机，其中三个主机必须是 control plane 主机。如果您删除一个也是 control plane 的主机，或者您只保留两个主机，则会出现一条信息表示系统未就绪。要恢复主机，您需要使用发现 ISO 重启它。

3. 在主机的 Options (⋮) 菜单中，可以选择 View host events（可选）。列表中的事件按时间顺序显示。

4. 对于多主机集群，在主机名旁边的 Role 列中，您可以点菜单来更改主机的角色。

   如果您没有选择角色，则 Assisted Installer 会自动分配角色。control plane 节点的最低硬件要求超过 worker 节点。如果为主机分配角色，请确保为满足最低硬件要求的主机分配 control plane 角色。

5. 点 Status 链接，以查看主机的硬件、网络和操作器验证。
6. 点主机名左侧的箭头，以展开主机详细信息。

流程

1. 在主机名旁边的复选框的左侧，单击以显示该主机的存储磁盘。
2. 如果主机有多个存储磁盘，您可以选择不同的磁盘来充当安装磁盘。点磁盘的 Role 下拉列表，然后选择 Installation disk。之前的安装磁盘的角色更改为 None。
3. 在默认情况下，所有可引导磁盘都会在安装过程中标记为重新格式化，但只读磁盘（如 CDROM ）除外。取消选择 Format 复选框以防止磁盘被重新格式化。安装磁盘必须重新格式化。在继续操作前备份任何敏感数据。

流程

1. 在 Networking 页面中，如果还没有为您选择，请选择以下之一：

   • Cluster-Managed Networking： 选择集群管理的联网意味着 Assisted Installer 将配置标准网络拓扑，包括 keepalived 和 Virtual Router Redundancy Protocol (VRRP) 用于管理 API 和 Ingress VIP 地址。

     注意

     目前，OpenShift Container Platform 版本 4.13 中的 IBM zSystems 和 IBM Power 不支持集群管理的网络。

   • 用户管理的联网 ：选择用户管理的网络允许您使用非标准网络拓扑部署 OpenShift Container Platform。例如，如果要使用外部负载均衡器而不是 keepalived 和 VRRP 部署，或者您想要在多个不同 L2 网络片段中部署集群节点。

2. 对于集群管理的联网，请配置以下设置：

   1. 定义 Machine 网络。您可以使用默认网络或选择子网。
   2. 定义一个 API 虚拟 IP。API 虚拟 IP 为所有用户提供与平台交互的端点。
   3. 定义一个 Ingress 虚拟 IP。Ingress 虚拟 IP 为来自集群外部的应用程序流量提供端点。

3. 对于用户管理的网络，请配置以下设置：

   1. 选择您的网络堆栈类型 ：

      • IPv4 ：当您的主机只使用 IPv4 时，请选择此类型。
      • Dual-stack：当主机将 IPv4 与 IPv6 一起使用时，您可以选择双栈。
   2. 定义 Machine 网络。您可以使用默认网络或选择子网。
   3. 定义一个 API 虚拟 IP。API 虚拟 IP 为所有用户提供与平台交互的端点。
   4. 定义一个 Ingress 虚拟 IP。Ingress 虚拟 IP 为来自集群外部的应用程序流量提供端点。
   5. 可选：您可以选择 Allocate IPs via DHCP server 来自动分配 API IP 和 Ingress IP 使用 DHCP 服务器。

4. 可选： 选择 Use advanced networking 来配置以下高级网络属性：

   • Cluster network CIDR ：定义从中分配 Pod IP 地址的 IP 地址块。
   • Cluster network host prefix ：定义分配给每个节点的子网前缀长度。
   • 服务网络 CIDR ：定义用于服务 IP 地址的 IP 地址。
   • Network type: 选择 Software-Defined Networking (SDN) 用于标准网络，或 Open Virtual Networking (OVN) 用于 IPv6, 双堆栈和电信功能。在 OpenShift Container Platform 4.12 及更新的版本中，OVN 是默认的 Container Network Interface (CNI)。

流程

1. 按 Begin Installation。
2. 点 Host Inventory 列表中的 Status 列中的链接，以查看特定主机的安装状态。

流程

1. 复制 kubeadmin 用户名和密码。

2. 下载 kubeconfig 文件，并将其复制到工作目录中的 auth 目录中：

   $ mkdir -p <working_directory>/auth

   $ cp kubeadmin <working_directory>/auth

   注意

   kubeconfig 文件可在完成安装后 24 小时下载。

3. 在您的环境中添加 kubeconfig 文件：

   $ export KUBECONFIG=<your working directory>/auth/kubeconfig

4. 使用 oc CLI 工具登录：

   $ oc login -u kubeadmin -p <password>

   将 <password> 替换为 kubeadmin 用户的密码。

5. 点 Web 控制台 URL 或点 Launch OpenShift Console 打开控制台。
6. 输入 kubeadmin 用户名和密码。按照 OpenShift Container Platform 控制台中的说明来配置身份提供程序并配置警报接收器。
7. 添加 OpenShift Container Platform 控制台的书签。
8. 完成任何安装后平台集成步骤。

流程

1. 在菜单中，点 OpenShift。
2. 在子菜单中，点 Downloads。
3. 在 OpenShift Cluster Manager API Token 下的 Tokens 部分中，点 View API Token。

4. 点 Load Token。

   重要

   禁用弹出窗口阻塞。

5. 在 API 令牌 部分中，复制离线令牌。

6. 在终端中，将离线令牌设置为 OFFLINE_TOKEN 变量：

   $ export OFFLINE_TOKEN=<copied_api_token>

   提示

   要使离线令牌永久生效，请将其添加到您的配置集中。

7. 点 Download ocm CLI。
8. 将下载的文件复制到您的路径中。例如，将文件复制到 /usr/bin 或 ~/.local/bin 并创建一个 ocm 符号链接。

9. 将身份验证命令复制并粘贴到终端中，然后按 Enter 键登录：

   $ ocm login --token="${OFFLINE_TOKEN}"

流程

1. 使用 OFFLINE_TOKEN 设置 API_TOKEN 变量以验证用户。

   1. （可选）在命令行终端上执行以下命令：

      $ export API_TOKEN=$( \
        curl \
        --silent \
        --header "Accept: application/json" \
        --header "Content-Type: application/x-www-form-urlencoded" \
        --data-urlencode "grant_type=refresh_token" \
        --data-urlencode "client_id=cloud-services" \
        --data-urlencode "refresh_token=${OFFLINE_TOKEN}" \
        "https://sso.redhat.com/auth/realms/redhat-external/protocol/openid-connect/token" \
        | jq --raw-output ".access_token" \
      )

   2. （可选）在命令行终端上登录到 ocm 客户端：

      $ ocm login --token="${OFFLINE_TOKEN}"

      然后，生成 API 令牌：

      $ export API_TOKEN=$(ocm token)

2. 在您的路径中为令牌生成方法创建一个脚本。例如：

   $ vim ~/.local/bin/refresh-token

   export API_TOKEN=$( \
     curl \
     --silent \
     --header "Accept: application/json" \
     --header "Content-Type: application/x-www-form-urlencoded" \
     --data-urlencode "grant_type=refresh_token" \
     --data-urlencode "client_id=cloud-services" \
     --data-urlencode "refresh_token=${OFFLINE_TOKEN}" \
     "https://sso.redhat.com/auth/realms/redhat-external/protocol/openid-connect/token" \
     | jq --raw-output ".access_token" \
   )

   然后保存文件。

3. 更改文件模式使其可执行：

   $ chmod +x ~/.local/bin/refresh-token

4. 刷新 API 令牌：

   $ source refresh-token

5. 运行以下命令验证您可以访问 API：

   $ curl -s https://api.openshift.com/api/assisted-install/v2/component-versions -H "Authorization: Bearer ${API_TOKEN}" | jq

   输出示例

   {
     "release_tag": "v2.11.3",
     "versions": {
       "assisted-installer": "registry.redhat.io/rhai-tech-preview/assisted-installer-rhel8:v1.0.0-211",
       "assisted-installer-controller": "registry.redhat.io/rhai-tech-preview/assisted-installer-reporter-rhel8:v1.0.0-266",
       "assisted-installer-service": "quay.io/app-sre/assisted-service:78d113a",
       "discovery-agent": "registry.redhat.io/rhai-tech-preview/assisted-installer-agent-rhel8:v1.0.0-195"
     }
   }

流程

1. 在菜单中，点 OpenShift。
2. 在子菜单中，点 Downloads。
3. 在 Pull secret 下的 Tokens 部分中，点 Download。

4. 要使用 shell 变量中的 pull secret，请执行以下命令：

   $ export PULL_SECRET=$(cat ~/Downloads/pull-secret.txt | jq -R .)

5. 要使用 jq 分片 pull secret 文件，请在 pull_secret 变量中引用它，将值传送到 tojson，以确保它被正确格式化为转义的 JSON。例如：

   $ curl https://api.openshift.com/api/assisted-install/v2/clusters \
   -H "Authorization: Bearer ${API_TOKEN}" \
   -H "Content-Type: application/json" \
   -d "$(jq --null-input \
           --slurpfile pull_secret ~/Downloads/pull-secret.txt ' 1
       {
           "name": "testcluster",
           "high_availability_mode": "None",
           "openshift_version": "4.11",
           "pull_secret": $pull_secret[0] | tojson, 2
           "base_dns_domain": "example.com"
       }
   ')"

   1

   对 pull secret 文件进行 Slurp。

   2

   格式化 pull secret 以转义 JSON 格式。

流程

1. 刷新 API 令牌：

   $ source refresh-token

2. 注册新集群。

   1. 可选： 您可以通过在请求中分片 pull secret 文件来注册新集群：

      $ curl -s -X POST https://api.openshift.com/api/assisted-install/v2/clusters \
      -H "Authorization: Bearer ${API_TOKEN}" \
      -H "Content-Type: application/json" \
      -d "$(jq --null-input \
          --slurpfile pull_secret ~/Downloads/pull-secret.txt '
      {
          "name": "testcluster",
          "openshift_version": "4.11",
          "cpu_architecture" : "<architecture_name>" 1
          "high_availability_mode": <cluster_type>, 2
          "base_dns_domain": "example.com",
          "pull_secret": $pull_secret[0] | tojson
      }
      ')" | jq '.id'

      注意

      1

      使用以下值：x86_64,arm64,ppc64le,s390x,multi.

      2

      使用默认值 full 来代表多节点 OpenShift 集群，或 none 代表单节点 OpenShift 集群。

   2. 可选： 您可以通过将配置写入 JSON 文件，然后在请求中引用它来注册新集群：

      cat << EOF > cluster.json
      {
        "name": "testcluster",
        "openshift_version": "4.11",
        "high_availability_mode": "<cluster_type>",
        "base_dns_domain": "example.com",
        "pull_secret": $PULL_SECRET
      }
      EOF

      $ curl -s -X POST "https://api.openshift.com/api/assisted-install/v2/clusters" \
        -d @./cluster.json \
        -H "Content-Type: application/json" \
        -H "Authorization: Bearer $API_TOKEN" \
        | jq '.id'

3. 将返回的 cluster_id 分配给 CLUSTER_ID 变量，并导出它：

   $ export CLUSTER_ID=<cluster_id>

   注意

   如果关闭终端会话，则需要在新的终端会话中再次导出 CLUSTER_ID 变量。

4. 检查新集群的状态：

   $ curl -s -X GET "https://api.openshift.com/api/assisted-install/v2/clusters/$CLUSTER_ID" \
     -H "Content-Type: application/json" \
     -H "Authorization: Bearer $API_TOKEN" \
     | jq

流程

1. 刷新 API 令牌：

   $ source refresh-token

2. 修改集群。例如：

   $ curl https://api.openshift.com/api/assisted-install/v2/clusters/${CLUSTER_ID} \
   -X PATCH \
   -H "Authorization: Bearer ${API_TOKEN}" \
   -H "Content-Type: application/json" \
   -d '
   {
       "ssh_public_key": "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQDZrD4LMkAEeoU2vShhF8VM+cCZtVRgB7tqtsMxms2q3TOJZAgfuqReKYWm+OLOZTD+DO3Hn1pah/mU3u7uJfTUg4wEX0Le8zBu9xJVym0BVmSFkzHfIJVTn6SfZ81NqcalisGWkpmkKXVCdnVAX6RsbHfpGKk9YPQarmRCn5KzkelJK4hrSWpBPjdzkFXaIpf64JBZtew9XVYA3QeXkIcFuq7NBuUH9BonroPEmIXNOa41PUP1IWq3mERNgzHZiuU8Ks/pFuU5HCMvv4qbTOIhiig7vidImHPpqYT/TCkuVi5w0ZZgkkBeLnxWxH0ldrfzgFBYAxnpTU8Ih/4VhG538Ix1hxPaM6cXds2ic71mBbtbSrk+zjtNPaeYk1O7UpcCw4jjHspU/rVV/DY51D5gSiiuaFPBMucnYPgUxy4FMBFfGrmGLIzTKiLzcz0DiSz1jBeTQOX++1nz+KDLBD8CPdi5k4dq7lLkapRk85qdEvgaG5RlHMSPSS3wDrQ51fD8= user@hostname"
   }
   ' | jq

流程

1. 刷新 API 令牌：

   $ source refresh-token

2. 注册新的基础架构环境。提供名称，最好包含集群名称。本例提供集群 ID，用于将基础架构环境与集群资源关联。以下示例指定了 image_type。您可以指定 full-iso 或 minimal-iso。默认值为 minimal-iso。

   1. 可选： 您可以通过在请求中分片 pull secret 文件来注册新的基础架构环境：

      $ curl https://api.openshift.com/api/assisted-install/v2/infra-envs \
      -H "Authorization: Bearer ${API_TOKEN}" \
      -H "Content-Type: application/json" \
      -d "$(jq --null-input \
        --slurpfile pull_secret ~/Downloads/pull-secret.txt \
        --arg cluster_id ${CLUSTER_ID} '
          {
            "name": "testcluster-infra-env",
            "image_type":"full-iso",
            "cluster_id": $cluster_id,
            "cpu_architecture" : "<architecture_name>" 1
            "pull_secret": $pull_secret[0] | tojson
          }
      ')" | jq '.id'

      注意

      1

      表示有效的值。它们包括：x86_64, arm64, ppc64le, s390x, multi

   2. 可选： 您可以通过将配置写入 JSON 文件并在请求中引用它来注册新的基础架构环境：

      $ cat << EOF > infra-envs.json
      {
       "name": "testcluster-infra-env",
       "image_type": "full-iso",
       "cluster_id": "$CLUSTER_ID",
       "pull_secret": $PULL_SECRET
      }
      EOF

      $ curl -s -X POST "https://api.openshift.com/api/assisted-install/v2/infra-envs" \
       -d @./infra-envs.json \
       -H "Content-Type: application/json" \
       -H "Authorization: Bearer $API_TOKEN" \
       | jq '.id'

3. 为 INFRA_ENV_ID 变量分配返回的 id 并导出它：

   $ export INFRA_ENV_ID=<id>

流程

1. 刷新 API 令牌：

   $ source refresh-token

2. 修改基础架构环境：

   $ curl https://api.openshift.com/api/assisted-install/v2/infra-envs/${INFRA_ENV_ID} \
   -X PATCH \
   -H "Authorization: Bearer ${API_TOKEN}" \
   -H "Content-Type: application/json" \
   -d "$(jq --null-input \
     --slurpfile pull_secret ~/Downloads/pull-secret.txt '
       {
         "image_type":"minimal-iso",
         "pull_secret": $pull_secret[0] | tojson
       }
   ')" | jq

流程

1. 如果需要，配置发现镜像。请参阅使用 iPXE 引导主机

2. 刷新 API 令牌：

   $ source refresh-token

3. 获取下载 URL：

   $ curl -H "Authorization: Bearer ${API_TOKEN}" \
   https://api.openshift.com/api/assisted-install/v2/infra-envs/${INFRA_ENV_ID}/downloads/image-url

4. 下载发现镜像：

   $ wget -O discovery.iso '<url>'

   将 <url> 替换为上一步中的下载 URL。

5. 使用发现镜像引导主机。如果要在平台上安装并希望与平台集成，请查看以下其他资源以了解详情：
6. 为主机分配角色。

流程

1. 刷新 API 令牌：

   $ source refresh-token

2. 获取主机 ID：

   $ curl -s -X GET "https://api.openshift.com/api/assisted-install/v2/clusters/$CLUSTER_ID" \
   --header "Content-Type: application/json" \
     -H "Authorization: Bearer $API_TOKEN" \
   | jq '.host_networks[].host_ids'

3. 对于使用 z/VM 的 IBM Z (s390x)安装，需要额外的内核参数。

   1. 要检索匹配节点的 hostID，请运行以下命令：

      curl https://api.openshift.com/api/assisted-install/v2/infra-envs/$INFRA_ENV_ID/hosts -H "Authorization: Bearer ${API_TOKEN}" | jq '.[]|[.id,.requested_hostname] | join("|")'

   2. 要指定所需的内核参数，请运行以下命令：

      curl https://api.stage.openshift.com/api/assisted-install/v2/infra-envs/${INFRA_ENV_ID}/hosts/$1/installer-args \
      -X PATCH \
      -H "Authorization: Bearer ${API_TOKEN}" \
      -H "Content-Type: application/json" \
      -d '
      {
      "args": [
      "--append-karg", "rd.neednet=1",
      "--append-karg", "ip=10.14.6.3::10.14.6.1:255.255.255.0:master-0.boea3e06.lnxero1.boe:encbdd0:none",
      "--append-karg", "nameserver=10.14.6.1",
      "--append-karg", "ip=[fd00::3]::[fd00::1]:64::encbdd0:none",
      "--append-karg", "nameserver=[fd00::1]",
      "--append-karg", "zfcp.allow_lun_scan=0",
      "--append-karg", "rd.znet=qeth,0.0.bdd0,0.0.bdd1,0.0.bdd2,layer2=1",
      "--append-karg", "rd.dasd=0.0.5235"
      ]
      }
      ' | jq

      注意

      每个主机可能具有特定的内核参数。

      输出示例

      [
        "1062663e-7989-8b2d-7fbb-e6f4d5bb28e5"
      ]

4. 修改主机：

   $ curl https://api.openshift.com/api/assisted-install/v2/infra-envs/${INFRA_ENV_ID}/hosts/<host_id> \ 1
   -X PATCH \
   -H "Authorization: Bearer ${API_TOKEN}" \
   -H "Content-Type: application/json" \
   -d '
       {
         "host_role":"worker"
         "host_name" : "worker-1"
       }
   ' | jq

   1

   将 <host_id> 替换为主机的 ID。

流程

1. 刷新 API 令牌：

   $ source refresh-token

2. 安装集群：

   $ curl -H "Authorization: Bearer $API_TOKEN" \
   -X POST \
   https://api.openshift.com/api/assisted-install/v2/clusters/$CLUSTER_ID/actions/install | jq

3. 完成任何安装后平台集成步骤。

流程

1. 可选： 使用 UI，在用户界面向导的 集群详情 步骤中，选择在 control plane 节点、worker 或这两个节点上启用 TPM v2 加密。

2. 可选：使用 API，请遵循"修改主机"过程。将 disk_encryption.enable_on 设置设置为 all, masters, 或 workers。将 disk_encryption.mode 设置设置为 tpmv2。

   1. 刷新 API 令牌：

      $ source refresh-token

   2. 启用 TPM v2 加密：

      $ curl https://api.openshift.com/api/assisted-install/v2/clusters/${CLUSTER_ID} \
      -X PATCH \
      -H "Authorization: Bearer ${API_TOKEN}" \
      -H "Content-Type: application/json" \
      -d '
      {
        "disk_encryption": {
          "enable_on": "none",
          "mode": "tpmv2"
        }
      }
      ' | jq

      enable_on 的有效设置是 all, master, worker, 或 none。

流程

1. 设置 Tang 服务器或访问现有服务器。具体步骤请查看 网络绑定磁盘加密。您可以设置多个 Tang 服务器，但 Assisted Installer 在安装过程中需要可以连接到所有 Tang 服务器。

2. 在 Tang 服务器上，使用 tang-show-keys 检索 Tang 服务器的 thumbprint：

   $ tang-show-keys <port>

   可选：将 <port> 替换为端口号。默认端口号为 80。

   thumbprint 示例

   1gYTN_LpU9ZMB35yn5IbADY5OQ0

3. 可选：使用 jose 获取 Tang 服务器的 thumbprint。

   1. 确保在 Tang 服务器中安装了 jose ：

      $ sudo dnf install jose

   2. 在 Tang 服务器上，使用 jose 检索 thumbprint:

      $ sudo jose jwk thp -i /var/db/tang/<public_key>.jwk

      将 <public_key> 替换为 Tang 服务器的公共交换密钥。

      thumbprint 示例

      1gYTN_LpU9ZMB35yn5IbADY5OQ0

4. 可选：在用户界面向导的 Cluster details 步骤中，选择在 control plane 节点、worker 或这两个节点上启用 Tang 加密。您需要为 Tang 服务器输入 URL 和 thumbprints。

5. 可选：使用 API，请遵循"修改主机"过程。

   1. 刷新 API 令牌：

      $ source refresh-token

   2. 将 disk_encryption.enable_on 设置设置为 all, masters, 或 workers。将 disk_encryption.mode 设置设置为 tang。设置 disk_encyrption.tang_servers，以提供一个或多个 Tang 服务器的 URL 和 thumbprint 详情：

      $ curl https://api.openshift.com/api/assisted-install/v2/clusters/${CLUSTER_ID} \
      -X PATCH \
      -H "Authorization: Bearer ${API_TOKEN}" \
      -H "Content-Type: application/json" \
      -d '
      {
        "disk_encryption": {
          "enable_on": "all",
          "mode": "tang",
          "tang_servers": "[{\"url\":\"http://tang.example.com:7500\",\"thumbprint\":\"PLjNyRdGw03zlRoGjQYMahSZGu9\"},{\"url\":\"http://tang2.example.com:7500\",\"thumbprint\":\"XYjNyRdGw03zlRoGjQYMahSZGu3\"}]"
        }
      }
      ' | jq

      enable_on 的有效设置是 all, master, worker, 或 none。在 tang_servers 值中，注释掉对象中的引号。

流程

1. 刷新 API 令牌：

   $ source refresh-token

2. 通过列出现有集群来识别 CLUSTER_ID 变量，如下所示：

   $ curl -s https://api.openshift.com/api/assisted-install/v2/clusters -H "Authorization: Bearer ${API_TOKEN}" | jq '[ .[] | { "name": .name, "id": .id } ]'

   输出示例

   [
     {
       "name": "lvmtest",
       "id": "475358f9-ed3a-442f-ab9e-48fd68bc8188" 1
     },
     {
       "name": "mcetest",
       "id": "b5259f97-be09-430e-b5eb-d78420ee509a"
     }
   ]

   注意

   1

   id 值是 < cluster_id>。

3. 将返回的 & lt;cluster_id > 分配给 CLUSTER_ID 变量并导出它：

   $ export CLUSTER_ID=<cluster_id>

4. 使用新 Operator 更新集群：

   $ curl https://api.openshift.com/api/assisted-install/v2/clusters/${CLUSTER_ID} \
   -X PATCH \
   -H "Authorization: Bearer ${API_TOKEN}" \
   -H "Content-Type: application/json" \
   -d '
   {
       "olm_operators": [{"name": "mce"}, {"name": "cnv"}], 1
   }
   ' | jq '.id'

   注意

   1

   指明要安装的 Operator。有效值包括 mce、cnv、lvm 和 odf。要删除之前安装的 Operator，请从值列表中排除它。要删除之前所有安装的 Operator，请键入 "olm_operators": []。

   输出示例

   {
     <various cluster properties>,
     "monitored_operators": [
       {
         "cluster_id": "b5259f97-be09-430e-b5eb-d78420ee509a",
         "name": "console",
         "operator_type": "builtin",
         "status_updated_at": "0001-01-01T00:00:00.000Z",
         "timeout_seconds": 3600
       },
       {
         "cluster_id": "b5259f97-be09-430e-b5eb-d78420ee509a",
         "name": "cvo",
         "operator_type": "builtin",
         "status_updated_at": "0001-01-01T00:00:00.000Z",
         "timeout_seconds": 3600
       },
       {
         "cluster_id": "b5259f97-be09-430e-b5eb-d78420ee509a",
         "name": "mce",
         "namespace": "multicluster-engine",
         "operator_type": "olm",
         "status_updated_at": "0001-01-01T00:00:00.000Z",
         "subscription_name": "multicluster-engine",
         "timeout_seconds": 3600
       },
       {
         "cluster_id": "b5259f97-be09-430e-b5eb-d78420ee509a",
         "name": "cnv",
         "namespace": "openshift-cnv",
         "operator_type": "olm",
         "status_updated_at": "0001-01-01T00:00:00.000Z",
         "subscription_name": "hco-operatorhub",
         "timeout_seconds": 3600
       },
       {
         "cluster_id": "b5259f97-be09-430e-b5eb-d78420ee509a",
         "name": "lvm",
         "namespace": "openshift-local-storage",
         "operator_type": "olm",
         "status_updated_at": "0001-01-01T00:00:00.000Z",
         "subscription_name": "local-storage-operator",
         "timeout_seconds": 4200
       }
     ],
     <more cluster properties>

   注意

   输出是新集群状态的描述。输出中的 monitored_operators 属性包含两个类型的 Operator：

   • "operator_type": "builtin" ：此类型的 Operator 是 OpenShift Container Platform 的一部分。
   • "operator_type": "olm" ：此类型的 Operator 由用户手动添加，或者因为依赖项自动添加。在示例中，自动添加 lso Operator，因为 cnv Operator 需要它。

流程

1. 创建 Ignition 文件并指定配置规格版本：

   $ vim ~/ignition.conf

   {
     "ignition": { "version": "3.1.0" }
   }

2. 将配置数据添加到 Ignition 文件。例如，为 core 用户添加密码。

   1. 生成密码哈希：

      $ openssl passwd -6

   2. 在 core 用户中添加生成的密码哈希：

      {
        "ignition": { "version": "3.1.0" },
        "passwd": {
          "users": [
            {
              "name": "core",
              "passwordHash": "$6$spam$M5LGSMGyVD.9XOboxcwrsnwNdF4irpJdAWy.1Ry55syyUiUssIzIAHaOrUHr2zg6ruD8YNBPW9kW0H8EnKXyc1"
            }
          ]
        }
      }

3. 保存 Ignition 文件并将其导出到 IGNITION_FILE 变量：

   $ export IGNITION_FILE=~/ignition.conf

流程

1. 创建 ignition_config_override JSON 对象并将其重定向到文件中：

   $ jq -n \
     --arg IGNITION "$(jq -c . $IGNITION_FILE)" \
     '{ignition_config_override: $IGNITION}' \
     > discovery_ignition.json

2. 刷新 API 令牌：

   $ source refresh-token

3. 对基础架构环境进行补丁：

   $ curl \
     --header "Authorization: Bearer $API_TOKEN" \
     --header "Content-Type: application/json" \
     -XPATCH \
     -d @discovery_ignition.json \
     https://api.openshift.com/api/assisted-install/v2/infra-envs/$INFRA_ENV_ID | jq

   ignition_config_override 对象引用 Ignition 文件。

4. 下载更新的发现镜像。

流程

1. 在管理主机上，在 USB 端口中插入 USB 驱动器。

2. 将 ISO 镜像复制到 USB 驱动器中，例如：

   # dd if=<path_to_iso> of=<path_to_usb> status=progress

   其中：

   <path_to_iso>

   是下载的发现 ISO 文件的相对路径，如 discovery.iso。

   <path_to_usb>

   是连接的 USB 驱动器的位置，例如 /dev/sdb。

   将 ISO 复制到 USB 驱动器后，您可以使用 USB 驱动器在集群主机上安装辅助安装程序代理。

流程

1. 将 RHCOS 发现 ISO USB 驱动器插入到目标主机中。
2. 在服务器固件设置中配置启动驱动器顺序，以便从附加的发现 ISO 启动，然后重启服务器。

3. 等待主机启动。

   1. 对于 UI 安装，在管理主机上返回浏览器。等待主机出现在已发现的主机列表中。

   2. 对于 API 安装，刷新令牌，检查启用的主机计数，并收集主机 ID：

      $ source refresh-token

      $ curl -s -X GET "https://api.openshift.com/api/assisted-install/v2/clusters/$CLUSTER_ID" \
      --header "Content-Type: application/json" \
        -H "Authorization: Bearer $API_TOKEN" \
      | jq '.enabled_host_count'

      $ curl -s -X GET "https://api.openshift.com/api/assisted-install/v2/clusters/$CLUSTER_ID" \
      --header "Content-Type: application/json" \
        -H "Authorization: Bearer $API_TOKEN" \
      | jq '.host_networks[].host_ids'

      输出示例

      [
        "1062663e-7989-8b2d-7fbb-e6f4d5bb28e5"
      ]

流程

1. 将 ISO 文件复制到网络中的 HTTP 服务器。

2. 从托管 ISO 文件引导主机，例如：

   1. 运行以下命令调用 redfish API，将托管的 ISO 设置为 VirtualMedia 引导介质：

      $ curl -k -u <bmc_username>:<bmc_password> \
      -d '{"Image":"<hosted_iso_file>", "Inserted": true}' \
      -H "Content-Type: application/json" \
      -X POST <host_bmc_address>/redfish/v1/Managers/iDRAC.Embedded.1/VirtualMedia/CD/Actions/VirtualMedia.InsertMedia

      其中：

      <bmc_username>:<bmc_password>

      是目标主机 BMC 的用户名和密码。

      <hosted_iso_file>

      是托管安装 ISO 的 URL，例如：http://webserver.example.com/rhcos-live-minimal.iso。ISO 必须从目标主机机器中访问。

      <host_bmc_address>

      是目标主机计算机的 BMC IP 地址。

   2. 运行以下命令，将主机设置为从 VirtualMedia 设备引导：

      $ curl -k -u <bmc_username>:<bmc_password> \
      -X PATCH -H 'Content-Type: application/json' \
      -d '{"Boot": {"BootSourceOverrideTarget": "Cd", "BootSourceOverrideMode": "UEFI", "BootSourceOverrideEnabled": "Once"}}' \
      <host_bmc_address>/redfish/v1/Systems/System.Embedded.1

   3. 重启主机：

      $ curl -k -u <bmc_username>:<bmc_password> \
      -d '{"ResetType": "ForceRestart"}' \
      -H 'Content-type: application/json' \
      -X POST <host_bmc_address>/redfish/v1/Systems/System.Embedded.1/Actions/ComputerSystem.Reset

   4. 可选： 如果主机已关闭，您可以使用 {"ResetType": "On"} 开关引导它。运行以下命令：

      $ curl -k -u <bmc_username>:<bmc_password> \
      -d '{"ResetType": "On"}' -H 'Content-type: application/json' \
      -X POST <host_bmc_address>/redfish/v1/Systems/System.Embedded.1/Actions/ComputerSystem.Reset

流程

1. 直接从 UI 下载 iPXE 脚本，或者从 Assisted Installer 获取 iPXE 脚本：

   $ curl \
     --silent \
     --header "Authorization: Bearer $API_TOKEN" \
     https://api.openshift.com/api/assisted-install/v2/infra-envs/$INFRA_ENV_ID/downloads/files?file_name=ipxe-script > ipxe-script

   示例

   #!ipxe
   initrd --name initrd http://api.openshift.com/api/assisted-images/images/<infra_env_id>/pxe-initrd?arch=x86_64&image_token=<token_string>&version=4.10
   kernel http://api.openshift.com/api/assisted-images/boot-artifacts/kernel?arch=x86_64&version=4.10 initrd=initrd coreos.live.rootfs_url=http://api.openshift.com/api/assisted-images/boot-artifacts/rootfs?arch=x86_64&version=4.10 random.trust_cpu=on rd.luks.options=discard ignition.firstboot ignition.platform.id=metal console=tty1 console=ttyS1,115200n8 coreos.inst.persistent-kargs="console=tty1 console=ttyS1,115200n8"
   boot

2. 通过从 ipxe-script 中提取 URL 下载所需的工件。

   1. 下载初始 RAM 磁盘：

      $ awk '/^initrd /{print $NF}' ipxe-script | curl -o initrd.img

   2. 下载 linux 内核：

      $ awk '/^kernel /{print $2}' ipxe-script | curl -o kernel

   3. 下载根文件系统：

      $ grep ^kernel ipxe-script | xargs -n1| grep ^coreos.live.rootfs_url | cut -d = -f 2- | curl -o rootfs.img

3. 将 URL 更改为 ipxe-script' 中不同的工件，以匹配本地 HTTP 服务器。例如：

   #!ipxe
   set webserver http://192.168.0.1
   initrd --name initrd $webserver/initrd.img
   kernel $webserver/kernel initrd=initrd coreos.live.rootfs_url=$webserver/rootfs.img random.trust_cpu=on rd.luks.options=discard ignition.firstboot ignition.platform.id=metal console=tty1 console=ttyS1,115200n8 coreos.inst.persistent-kargs="console=tty1 console=ttyS1,115200n8"
   boot

4. 可选：当在 IBM zSystems 上使用 RHEL KVM 安装时，您必须通过指定附加内核参数来引导主机

   random.trust_cpu=on rd.luks.options=discard ignition.firstboot ignition.platform.id=metal console=tty1 console=ttyS1,115200n8 coreos.inst.persistent-kargs="console=tty1 console=ttyS1,115200n8

   注意

   如果您在 RHEL KVM 上使用 iPXE 安装，在一些情况下，虚拟机主机上的虚拟机不会在第一次引导时重启，需要手动启动。

5. 可选：在 IBM Power 上安装时，您必须下载 intramfs、kernel 和 root，如下所示：

   1. 将 initrd.img 和 kernel.img 复制到 PXE 目录 '/var/lib/tftpboot/rhcos '
   2. 将 rootfs.img 复制到 HTTPD 目录 '/var/www/html/install '

   3. 在 '/var/lib/tftpboot/boot/grub2/grub.cfg ' 中添加以下条目：

      if [ ${net_default_mac} == fa:1d:67:35:13:20 ]; then
      default=0
      fallback=1
      timeout=1
      menuentry "CoreOS (BIOS)" {
      echo "Loading kernel"
      linux "/rhcos/kernel.img" ip=dhcp rd.neednet=1 ignition.platform.id=metal ignition.firstboot coreos.live.rootfs_url=http://9.114.98.8:8000/install/rootfs.img
      echo "Loading initrd"
      initrd "/rhcos/initrd.img"
      }
      fi

流程

1. 进入 Host Discovery 选项卡，向下滚动到 Host Inventory 表。

2. 选择所需主机的 Auto-assign 下拉菜单。

   1. 选择 Control plane 节点 来为这个主机分配一个 control plane 角色。
   2. 选择 Worker 为这个主机分配一个 worker 角色。
3. 检查验证状态。

流程

1. 刷新 API 令牌：

   $ source refresh-token

2. 获取主机 ID：

   $ curl -s -X GET "https://api.openshift.com/api/assisted-install/v2/clusters/$CLUSTER_ID" \
   --header "Content-Type: application/json" \
     -H "Authorization: Bearer $API_TOKEN" \
   | jq '.host_networks[].host_ids'

   输出示例

   [
     "1062663e-7989-8b2d-7fbb-e6f4d5bb28e5"
   ]

3. 修改 host_role 设置：

   $ curl https://api.openshift.com/api/assisted-install/v2/infra-envs/${INFRA_ENV_ID}/hosts/<host_id> \
   -X PATCH \
   -H "Authorization: Bearer ${API_TOKEN}" \
   -H "Content-Type: application/json" \
   -d '
       {
         "host_role":"worker"
       }
   ' | jq

   将 <host_id> 替换为主机的 ID。

先决条件

1. 您已使用 API 创建基础架构环境，或者已使用 UI 创建集群。
2. 在 shell 中将您的基础架构环境 ID 导出为 $INFRA_ENV_ID。
3. 您在访问 API 时具有凭证，并在 shell 中将令牌导出为 $API_TOKEN。
4. 您有带有静态网络配置的 YAML 文件，作为 server-a.yaml 和 server-b.yaml。

流程

1. 使用 API 请求创建一个临时文件 /tmp/request-body.txt ：

   ---
   jq -n --arg NMSTATE_YAML1 "$(cat server-a.yaml)" --arg NMSTATE_YAML2 "$(cat server-b.yaml)" \
   '{
     "static_network_config": [
       {
         "network_yaml": $NMSTATE_YAML1,
         "mac_interface_map": [{"mac_address": "02:00:00:2c:23:a5", "logical_nic_name": "eth0"}, {"mac_address": "02:00:00:68:73:dc", "logical_nic_name": "eth1"}]
       },
       {
         "network_yaml": $NMSTATE_YAML2,
         "mac_interface_map": [{"mac_address": "02:00:00:9f:85:eb", "logical_nic_name": "eth1"}, {"mac_address": "02:00:00:c8:be:9b", "logical_nic_name": "eth0"}]
        }
     ]
   }' >> /tmp/request-body.txt
   ---

2. 刷新 API 令牌：

   $ source refresh-token

3. 将请求发送到 Assisted Service API 端点：

   ---
   curl -H "Content-Type: application/json" \
   -X PATCH -d @/tmp/request-body.txt \
   -H "Authorization: Bearer ${API_TOKEN}" \
   https://api.openshift.com/api/assisted-install/v2/infra-envs/$INFRA_ENV_ID
   ---

流程

1. 使用 CLI 登录集群。

2. 检查 architecture 设置：

   $ oc adm release info -o json | jq .metadata.metadata

   确保 architecture 设置设为 'multi'。

   {
     "release.openshift.io/architecture": "multi"
   }

流程

1. 登录 OpenShift Cluster Manager，再点您要扩展的集群。
2. 点 Add hosts 并下载新主机的发现 ISO，添加 SSH 公钥并根据需要配置集群范围的代理设置。
3. 可选：根据需要修改 ignition 文件。
4. 使用发现 ISO 引导目标主机，并等待在控制台中发现主机。
5. 选择主机角色。它可以是 worker 或 control plane 主机。
6. 开始安装。

7. 当安装继续进行时，安装会为主机生成待处理的证书签名请求 (CSR)。出现提示时，批准待处理的 CSR 以完成安装。

   当主机成功安装后，它将在集群 web 控制台中被列为一个主机。

流程

1. 针对 Assisted Installer REST API 进行身份验证，并为会话生成 API 令牌。生成的令牌有效期仅为 15 分钟。

2. 运行以下命令设置 $API_URL 变量：

   $ export API_URL=<api_url> 1

   1

   将 <api_url> 替换为 Assisted Installer API URL，例如 https://api.openshift.com

3. 运行以下命令导入集群：

   1. 设置 $CLUSTER_ID 变量。登录到集群并运行以下命令：

      $ export CLUSTER_ID=$(oc get clusterversion -o jsonpath='{.items[].spec.clusterID}')

   2. 设置用于导入集群的 $CLUSTER_REQUEST 变量：

      $ export CLUSTER_REQUEST=$(jq --null-input --arg openshift_cluster_id "$CLUSTER_ID" '{
        "api_vip_dnsname": "<api_vip>", 1
        "openshift_cluster_id": $CLUSTER_ID,
        "name": "<openshift_cluster_name>" 2
      }')

      1

      将 <api_vip> 替换为集群 API 服务器的主机名。这可以是 API 服务器的 DNS 域，也可以是主机可访问的单一节点的 IP 地址。例如： api.compute-1.example.com。

      2

      将 <openshift_cluster_name> 替换为集群的纯文本名称。集群名称应与在第 1 天集群安装过程中设置的集群名称匹配。

   3. 导入集群并设置 $CLUSTER_ID 变量。运行以下命令：

      $ CLUSTER_ID=$(curl "$API_URL/api/assisted-install/v2/clusters/import" -H "Authorization: Bearer ${API_TOKEN}" -H 'accept: application/json' -H 'Content-Type: application/json' \
        -d "$CLUSTER_REQUEST" | tee /dev/stderr | jq -r '.id')

4. 运行以下命令，为集群生成 InfraEnv 资源并设置 $INFRA_ENV_ID 变量：

   1. 从位于 console.redhat.com 的 Red Hat OpenShift Cluster Manager 下载 pull secret 文件。

   2. 设置 $INFRA_ENV_REQUEST 变量：

      export INFRA_ENV_REQUEST=$(jq --null-input \
          --slurpfile pull_secret <path_to_pull_secret_file> \1
          --arg ssh_pub_key "$(cat <path_to_ssh_pub_key>)" \2
          --arg cluster_id "$CLUSTER_ID" '{
        "name": "<infraenv_name>", 3
        "pull_secret": $pull_secret[0] | tojson,
        "cluster_id": $cluster_id,
        "ssh_authorized_key": $ssh_pub_key,
        "image_type": "<iso_image_type>" 4
      }')

      1

      将 <path_to_pull_secret_file> 替换为在 console.redhat.com 上从 Red Hat OpenShift Cluster Manager 下载的 pull secret 的本地文件的路径。

      2

      将 <path_to_ssh_pub_key> 替换为访问主机所需的公共 SSH 密钥路径。如果没有设置这个值，则无法在发现模式下访问主机。

      3

      将 <infraenv_name> 替换为 InfraEnv 资源的纯文本名称。

      4

      将 <iso_image_type> 替换为 ISO 镜像类型，可以是 full-iso 或 minimal-iso。

   3. 将 $INFRA_ENV_REQUEST 发布到 /v2/infra-envs API，并设置 $INFRA_ENV_ID 变量：

      $ INFRA_ENV_ID=$(curl "$API_URL/api/assisted-install/v2/infra-envs" -H "Authorization: Bearer ${API_TOKEN}" -H 'accept: application/json' -H 'Content-Type: application/json' -d "$INFRA_ENV_REQUEST" | tee /dev/stderr | jq -r '.id')

5. 运行以下命令，获取集群主机的发现 ISO 的 URL：

   $ curl -s "$API_URL/api/assisted-install/v2/infra-envs/$INFRA_ENV_ID" -H "Authorization: Bearer ${API_TOKEN}" | jq -r '.download_url'

   输出示例

   https://api.openshift.com/api/assisted-images/images/41b91e72-c33e-42ee-b80f-b5c5bbf6431a?arch=x86_64&image_token=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE2NTYwMjYzNzEsInN1YiI6IjQxYjkxZTcyLWMzM2UtNDJlZS1iODBmLWI1YzViYmY2NDMxYSJ9.1EX_VGaMNejMhrAvVRBS7PDPIQtbOOc8LtG8OukE1a4&type=minimal-iso&version=4.12

6. 下载 ISO：

   $ curl -L -s '<iso_url>' --output rhcos-live-minimal.iso 1

   1

   将 <iso_url> 替换为上一步中的 ISO URL。

7. 从下载的 rhcos-live-minimal.iso 中引导新的 worker 主机。

8. 获取没有安装的集群中的主机列表。继续运行以下命令，直到新主机显示：

   $ curl -s "$API_URL/api/assisted-install/v2/clusters/$CLUSTER_ID" -H "Authorization: Bearer ${API_TOKEN}" | jq -r '.hosts[] | select(.status != "installed").id'

   输出示例

   2294ba03-c264-4f11-ac08-2f1bb2f8c296

9. 为新主机设置 $HOST_ID 变量，例如：

   $ HOST_ID=<host_id> 1

   1

   将 <host_id> 替换为上一步中的主机 ID。

10. 运行以下命令检查主机是否已就绪：

    注意

    确保复制整个命令，包括完整的 jq 表达式。

    $ curl -s $API_URL/api/assisted-install/v2/clusters/$CLUSTER_ID -H "Authorization: Bearer ${API_TOKEN}" | jq '
    def host_name($host):
        if (.suggested_hostname // "") == "" then
            if (.inventory // "") == "" then
                "Unknown hostname, please wait"
            else
                .inventory | fromjson | .hostname
            end
        else
            .suggested_hostname
        end;
    
    def is_notable($validation):
        ["failure", "pending", "error"] | any(. == $validation.status);
    
    def notable_validations($validations_info):
        [
            $validations_info // "{}"
            | fromjson
            | to_entries[].value[]
            | select(is_notable(.))
        ];
    
    {
        "Hosts validations": {
            "Hosts": [
                .hosts[]
                | select(.status != "installed")
                | {
                    "id": .id,
                    "name": host_name(.),
                    "status": .status,
                    "notable_validations": notable_validations(.validations_info)
                }
            ]
        },
        "Cluster validations info": {
            "notable_validations": notable_validations(.validations_info)
        }
    }
    ' -r

    输出示例

    {
      "Hosts validations": {
        "Hosts": [
          {
            "id": "97ec378c-3568-460c-bc22-df54534ff08f",
            "name": "localhost.localdomain",
            "status": "insufficient",
            "notable_validations": [
              {
                "id": "ntp-synced",
                "status": "failure",
                "message": "Host couldn't synchronize with any NTP server"
              },
              {
                "id": "api-domain-name-resolved-correctly",
                "status": "error",
                "message": "Parse error for domain name resolutions result"
              },
              {
                "id": "api-int-domain-name-resolved-correctly",
                "status": "error",
                "message": "Parse error for domain name resolutions result"
              },
              {
                "id": "apps-domain-name-resolved-correctly",
                "status": "error",
                "message": "Parse error for domain name resolutions result"
              }
            ]
          }
        ]
      },
      "Cluster validations info": {
        "notable_validations": []
      }
    }

11. 当上一个命令显示主机就绪时，通过运行以下命令来使用 /v2/infra-envs/{infra_env_id}/hosts/{host_id}/actions/install API 开始安装：

    $ curl -X POST -s "$API_URL/api/assisted-install/v2/infra-envs/$INFRA_ENV_ID/hosts/$HOST_ID/actions/install"  -H "Authorization: Bearer ${API_TOKEN}"

12. 当安装继续进行时，安装会为主机生成待处理的证书签名请求 (CSR)。

    重要

    您必须批准 CSR 才能完成安装。

    运行以下 API 调用以监控集群安装：

    $ curl -s "$API_URL/api/assisted-install/v2/clusters/$CLUSTER_ID" -H "Authorization: Bearer ${API_TOKEN}" | jq '{
        "Cluster day-2 hosts":
            [
                .hosts[]
                | select(.status != "installed")
                | {id, requested_hostname, status, status_info, progress, status_updated_at, updated_at, infra_env_id, cluster_id, created_at}
            ]
    }'

    输出示例

    {
      "Cluster day-2 hosts": [
        {
          "id": "a1c52dde-3432-4f59-b2ae-0a530c851480",
          "requested_hostname": "control-plane-1",
          "status": "added-to-existing-cluster",
          "status_info": "Host has rebooted and no further updates will be posted. Please check console for progress and to possibly approve pending CSRs",
          "progress": {
            "current_stage": "Done",
            "installation_percentage": 100,
            "stage_started_at": "2022-07-08T10:56:20.476Z",
            "stage_updated_at": "2022-07-08T10:56:20.476Z"
          },
          "status_updated_at": "2022-07-08T10:56:20.476Z",
          "updated_at": "2022-07-08T10:57:15.306369Z",
          "infra_env_id": "b74ec0c3-d5b5-4717-a866-5b6854791bd3",
          "cluster_id": "8f721322-419d-4eed-aa5b-61b50ea586ae",
          "created_at": "2022-07-06T22:54:57.161614Z"
        }
      ]
    }

13. 可选： 运行以下命令以查看集群的所有事件：

    $ curl -s "$API_URL/api/assisted-install/v2/events?cluster_id=$CLUSTER_ID" -H "Authorization: Bearer ${API_TOKEN}" | jq -c '.[] | {severity, message, event_time, host_id}'

    输出示例

    {"severity":"info","message":"Host compute-0: updated status from insufficient to known (Host is ready to be installed)","event_time":"2022-07-08T11:21:46.346Z","host_id":"9d7b3b44-1125-4ad0-9b14-76550087b445"}
    {"severity":"info","message":"Host compute-0: updated status from known to installing (Installation is in progress)","event_time":"2022-07-08T11:28:28.647Z","host_id":"9d7b3b44-1125-4ad0-9b14-76550087b445"}
    {"severity":"info","message":"Host compute-0: updated status from installing to installing-in-progress (Starting installation)","event_time":"2022-07-08T11:28:52.068Z","host_id":"9d7b3b44-1125-4ad0-9b14-76550087b445"}
    {"severity":"info","message":"Uploaded logs for host compute-0 cluster 8f721322-419d-4eed-aa5b-61b50ea586ae","event_time":"2022-07-08T11:29:47.802Z","host_id":"9d7b3b44-1125-4ad0-9b14-76550087b445"}
    {"severity":"info","message":"Host compute-0: updated status from installing-in-progress to added-to-existing-cluster (Host has rebooted and no further updates will be posted. Please check console for progress and to possibly approve pending CSRs)","event_time":"2022-07-08T11:29:48.259Z","host_id":"9d7b3b44-1125-4ad0-9b14-76550087b445"}
    {"severity":"info","message":"Host: compute-0, reached installation stage Rebooting","event_time":"2022-07-08T11:29:48.261Z","host_id":"9d7b3b44-1125-4ad0-9b14-76550087b445"}

14. 登录到集群并批准待处理的 CSR 以完成安装。

流程

1. 检查并批准 CSR

   1. 检查 CertificateSigningRequests (CSR)：

      $ oc get csr | grep Pending

      输出示例

      csr-5sd59   8m19s   kubernetes.io/kube-apiserver-client-kubelet   system:serviceaccount:openshift-machine-config-operator:node-bootstrapper   <none>              Pending
      csr-xzqts   10s     kubernetes.io/kubelet-serving                 system:node:worker-6                                                   <none>              Pending

   2. 批准所有待处理的 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 才能完成安装。

2. 确认主节点处于 Ready 状态：

   $ oc get nodes

   输出示例

   NAME       STATUS   ROLES    AGE     VERSION
   master-0   Ready    master   4h42m   v1.24.0+3882f8f
   worker-1   Ready    worker   4h29m   v1.24.0+3882f8f
   master-2   Ready    master   4h43m   v1.24.0+3882f8f
   master-3   Ready    master   4h27m   v1.24.0+3882f8f
   worker-4   Ready    worker   4h30m   v1.24.0+3882f8f
   master-5   Ready    master   105s    v1.24.0+3882f8f

   注意

   当集群使用功能 Machine API 运行时，etcd-operator 需要机器自定义资源 (CR) 引用新节点。

3. 将 Machine CR 与 BareMetalHost 和 Node 链接：

   1. 使用唯一 .metadata.name 值创建 BareMetalHost CR：

      apiVersion: metal3.io/v1alpha1
      kind: BareMetalHost
      metadata:
        name: custom-master3
        namespace: openshift-machine-api
        annotations:
      spec:
        automatedCleaningMode: metadata
        bootMACAddress: 00:00:00:00:00:02
        bootMode: UEFI
        customDeploy:
          method: install_coreos
        externallyProvisioned: true
        online: true
        userData:
          name: master-user-data-managed
          namespace: openshift-machine-api

      $ oc create -f <filename>

   2. 应用 BareMetalHost CR：

      $ oc apply -f <filename>

   3. 使用唯一的 .machine.name 值创建 Machine CR：

      apiVersion: machine.openshift.io/v1beta1
      kind: Machine
      metadata:
        annotations:
          machine.openshift.io/instance-state: externally provisioned
          metal3.io/BareMetalHost: openshift-machine-api/custom-master3
        finalizers:
        - machine.machine.openshift.io
        generation: 3
        labels:
          machine.openshift.io/cluster-api-cluster: test-day2-1-6qv96
          machine.openshift.io/cluster-api-machine-role: master
          machine.openshift.io/cluster-api-machine-type: master
        name: custom-master3
        namespace: openshift-machine-api
      spec:
        metadata: {}
        providerSpec:
          value:
            apiVersion: baremetal.cluster.k8s.io/v1alpha1
            customDeploy:
              method: install_coreos
            hostSelector: {}
            image:
              checksum: ""
              url: ""
            kind: BareMetalMachineProviderSpec
            metadata:
              creationTimestamp: null
            userData:
              name: master-user-data-managed

      $ oc create -f <filename>

   4. 应用 Machine CR：

      $ oc apply -f <filename>

   5. 使用 link-machine-and-node.sh 脚本链接 BareMetalHost, Machine, 和 Node：

      #!/bin/bash
      
      # Credit goes to https://bugzilla.redhat.com/show_bug.cgi?id=1801238.
      # This script will link Machine object and Node object. This is needed
      # in order to have IP address of the Node present in the status of the Machine.
      
      set -x
      set -e
      
      machine="$1"
      node="$2"
      
      if [ -z "$machine" -o -z "$node" ]; then
          echo "Usage: $0 MACHINE NODE"
          exit 1
      fi
      
      uid=$(echo $node | cut -f1 -d':')
      node_name=$(echo $node | cut -f2 -d':')
      
      oc proxy &
      proxy_pid=$!
      function kill_proxy {
          kill $proxy_pid
      }
      trap kill_proxy EXIT SIGINT
      
      HOST_PROXY_API_PATH="http://localhost:8001/apis/metal3.io/v1alpha1/namespaces/openshift-machine-api/baremetalhosts"
      
      function wait_for_json() {
          local name
          local url
          local curl_opts
          local timeout
      
          local start_time
          local curr_time
          local time_diff
      
          name="$1"
          url="$2"
          timeout="$3"
          shift 3
          curl_opts="$@"
          echo -n "Waiting for $name to respond"
          start_time=$(date +%s)
          until curl -g -X GET "$url" "${curl_opts[@]}" 2> /dev/null | jq '.' 2> /dev/null > /dev/null; do
              echo -n "."
              curr_time=$(date +%s)
              time_diff=$(($curr_time - $start_time))
              if [[ $time_diff -gt $timeout ]]; then
                  echo "\nTimed out waiting for $name"
                  return 1
              fi
              sleep 5
          done
          echo " Success!"
          return 0
      }
      wait_for_json oc_proxy "${HOST_PROXY_API_PATH}" 10 -H "Accept: application/json" -H "Content-Type: application/json"
      
      addresses=$(oc get node -n openshift-machine-api ${node_name} -o json | jq -c '.status.addresses')
      
      machine_data=$(oc get machine -n openshift-machine-api -o json ${machine})
      host=$(echo "$machine_data" | jq '.metadata.annotations["metal3.io/BareMetalHost"]' | cut -f2 -d/ | sed 's/"//g')
      
      if [ -z "$host" ]; then
          echo "Machine $machine is not linked to a host yet." 1>&2
          exit 1
      fi
      
      # The address structure on the host doesn't match the node, so extract
      # the values we want into separate variables so we can build the patch
      # we need.
      hostname=$(echo "${addresses}" | jq '.[] | select(. | .type == "Hostname") | .address' | sed 's/"//g')
      ipaddr=$(echo "${addresses}" | jq '.[] | select(. | .type == "InternalIP") | .address' | sed 's/"//g')
      
      host_patch='
      {
        "status": {
          "hardware": {
            "hostname": "'${hostname}'",
            "nics": [
              {
                "ip": "'${ipaddr}'",
                "mac": "00:00:00:00:00:00",
                "model": "unknown",
                "speedGbps": 10,
                "vlanId": 0,
                "pxe": true,
                "name": "eth1"
              }
            ],
            "systemVendor": {
              "manufacturer": "Red Hat",
              "productName": "product name",
              "serialNumber": ""
            },
            "firmware": {
              "bios": {
                "date": "04/01/2014",
                "vendor": "SeaBIOS",
                "version": "1.11.0-2.el7"
              }
            },
            "ramMebibytes": 0,
            "storage": [],
            "cpu": {
              "arch": "x86_64",
              "model": "Intel(R) Xeon(R) CPU E5-2630 v4 @ 2.20GHz",
              "clockMegahertz": 2199.998,
              "count": 4,
              "flags": []
            }
          }
        }
      }
      '
      
      echo "PATCHING HOST"
      echo "${host_patch}" | jq .
      
      curl -s \
           -X PATCH \
           ${HOST_PROXY_API_PATH}/${host}/status \
           -H "Content-type: application/merge-patch+json" \
           -d "${host_patch}"
      
      oc get baremetalhost -n openshift-machine-api -o yaml "${host}"

      $ bash link-machine-and-node.sh custom-master3 worker-5

4. 确认 etcd 成员：

   $ oc rsh -n openshift-etcd etcd-worker-2
   etcdctl member list -w table

   输出示例

   +--------+---------+--------+--------------+--------------+---------+
   |   ID   |  STATUS |  NAME  |  PEER ADDRS  | CLIENT ADDRS | LEARNER |
   +--------+---------+--------+--------------+--------------+---------+
   |2c18942f| started |worker-3|192.168.111.26|192.168.111.26|  false  |
   |61e2a860| started |worker-2|192.168.111.25|192.168.111.25|  false  |
   |ead4f280| started |worker-5|192.168.111.28|192.168.111.28|  false  |
   +--------+---------+--------+--------------+--------------+---------+

5. 确认 etcd-operator 配置适用于所有节点：

   $ oc get clusteroperator etcd

   输出示例

   NAME   VERSION   AVAILABLE   PROGRESSING   DEGRADED   SINCE   MESSAGE
   etcd   4.11.5    True        False         False      5h54m

6. 确认 etcd-operator 健康状况：

   $ oc rsh -n openshift-etcd etcd-worker-0
   etcdctl endpoint health

   输出示例

   192.168.111.26 is healthy: committed proposal: took = 11.297561ms
   192.168.111.25 is healthy: committed proposal: took = 13.892416ms
   192.168.111.28 is healthy: committed proposal: took = 11.870755ms

7. 确认节点健康状况：

   $ oc get Nodes

   输出示例

   NAME       STATUS   ROLES    AGE     VERSION
   master-0   Ready    master   6h20m   v1.24.0+3882f8f
   worker-1   Ready    worker   6h7m    v1.24.0+3882f8f
   master-2   Ready    master   6h20m   v1.24.0+3882f8f
   master-3   Ready    master   6h4m    v1.24.0+3882f8f
   worker-4   Ready    worker   6h7m    v1.24.0+3882f8f
   master-5   Ready    master   99m     v1.24.0+3882f8f

8. 确认 ClusterOperators 健康状况：

   $ oc get ClusterOperators

   输出示例

   NAME                                      VERSION AVAILABLE PROGRESSING DEGRADED SINCE MSG
   authentication                            4.11.5  True      False       False    5h57m
   baremetal                                 4.11.5  True      False       False    6h19m
   cloud-controller-manager                  4.11.5  True      False       False    6h20m
   cloud-credential                          4.11.5  True      False       False    6h23m
   cluster-autoscaler                        4.11.5  True      False       False    6h18m
   config-operator                           4.11.5  True      False       False    6h19m
   console                                   4.11.5  True      False       False    6h4m
   csi-snapshot-controller                   4.11.5  True      False       False    6h19m
   dns                                       4.11.5  True      False       False    6h18m
   etcd                                      4.11.5  True      False       False    6h17m
   image-registry                            4.11.5  True      False       False    6h7m
   ingress                                   4.11.5  True      False       False    6h6m
   insights                                  4.11.5  True      False       False    6h12m
   kube-apiserver                            4.11.5  True      False       False    6h16m
   kube-controller-manager                   4.11.5  True      False       False    6h16m
   kube-scheduler                            4.11.5  True      False       False    6h16m
   kube-storage-version-migrator             4.11.5  True      False       False    6h19m
   machine-api                               4.11.5  True      False       False    6h15m
   machine-approver                          4.11.5  True      False       False    6h19m
   machine-config                            4.11.5  True      False       False    6h18m
   marketplace                               4.11.5  True      False       False    6h18m
   monitoring                                4.11.5  True      False       False    6h4m
   network                                   4.11.5  True      False       False    6h20m
   node-tuning                               4.11.5  True      False       False    6h18m
   openshift-apiserver                       4.11.5  True      False       False    6h8m
   openshift-controller-manager              4.11.5  True      False       False    6h7m
   openshift-samples                         4.11.5  True      False       False    6h12m
   operator-lifecycle-manager                4.11.5  True      False       False    6h18m
   operator-lifecycle-manager-catalog        4.11.5  True      False       False    6h19m
   operator-lifecycle-manager-pkgsvr         4.11.5  True      False       False    6h12m
   service-ca                                4.11.5  True      False       False    6h19m
   storage                                   4.11.5  True      False       False    6h19m

9. 确认 ClusterVersion ：

   $ oc get ClusterVersion

   输出示例

   NAME      VERSION   AVAILABLE   PROGRESSING   SINCE   STATUS
   version   4.11.5    True        False         5h57m   Cluster version is 4.11.5

10. 删除旧的 control plane 节点：

    1. 删除 BareMetalHost CR：

       $ oc delete bmh -n openshift-machine-api custom-master3

    2. 确认 Machine 不健康：

       $ oc get machine -A

       输出示例

       NAMESPACE              NAME                              PHASE    AGE
       openshift-machine-api  custom-master3                    Running  14h
       openshift-machine-api  test-day2-1-6qv96-master-0        Failed   20h
       openshift-machine-api  test-day2-1-6qv96-master-1        Running  20h
       openshift-machine-api  test-day2-1-6qv96-master-2        Running  20h
       openshift-machine-api  test-day2-1-6qv96-worker-0-8w7vr  Running  19h
       openshift-machine-api  test-day2-1-6qv96-worker-0-rxddj  Running  19h

    3. 删除 Machine CR：

       $ oc delete machine -n openshift-machine-api   test-day2-1-6qv96-master-0
       machine.machine.openshift.io "test-day2-1-6qv96-master-0" deleted

    4. 确认删除 Node CR：

       $ oc get nodes

       输出示例

       NAME       STATUS   ROLES    AGE   VERSION
       worker-1   Ready    worker   19h   v1.24.0+3882f8f
       master-2   Ready    master   20h   v1.24.0+3882f8f
       master-3   Ready    master   19h   v1.24.0+3882f8f
       worker-4   Ready    worker   19h   v1.24.0+3882f8f
       master-5   Ready    master   15h   v1.24.0+3882f8f

11. 检查 etcd-operator 日志以确认 etcd 集群的状态：

    $ oc logs -n openshift-etcd-operator etcd-operator-8668df65d-lvpjf

    输出示例

    E0927 07:53:10.597523       1 base_controller.go:272] ClusterMemberRemovalController reconciliation failed: cannot remove member: 192.168.111.23 because it is reported as healthy but it doesn't have a machine nor a node resource

12. 删除物理机器，以允许 etcd-operator 协调集群成员：

    $ oc rsh -n openshift-etcd etcd-worker-2
    etcdctl member list -w table; etcdctl endpoint health

    输出示例

    +--------+---------+--------+--------------+--------------+---------+
    |   ID   |  STATUS |  NAME  |  PEER ADDRS  | CLIENT ADDRS | LEARNER |
    +--------+---------+--------+--------------+--------------+---------+
    |2c18942f| started |worker-3|192.168.111.26|192.168.111.26|  false  |
    |61e2a860| started |worker-2|192.168.111.25|192.168.111.25|  false  |
    |ead4f280| started |worker-5|192.168.111.28|192.168.111.28|  false  |
    +--------+---------+--------+--------------+--------------+---------+
    192.168.111.26 is healthy: committed proposal: took = 10.458132ms
    192.168.111.25 is healthy: committed proposal: took = 11.047349ms
    192.168.111.28 is healthy: committed proposal: took = 11.414402ms

流程

1. 确认集群的初始状态：

   $ oc get nodes

   输出示例

   NAME       STATUS     ROLES    AGE   VERSION
   worker-1   Ready      worker   20h   v1.24.0+3882f8f
   master-2   NotReady   master   20h   v1.24.0+3882f8f
   master-3   Ready      master   20h   v1.24.0+3882f8f
   worker-4   Ready      worker   20h   v1.24.0+3882f8f
   master-5   Ready      master   15h   v1.24.0+3882f8f

2. 确认 etcd-operator 检测到集群不健康：

   $ oc logs -n openshift-etcd-operator etcd-operator-8668df65d-lvpjf

   输出示例

   E0927 08:24:23.983733       1 base_controller.go:272] DefragController reconciliation failed: cluster is unhealthy: 2 of 3 members are available, worker-2 is unhealthy

3. 确认 etcdctl 成员：

   $ oc rsh -n openshift-etcd etcd-worker-3
   etcdctl member list -w table

   输出示例

   +--------+---------+--------+--------------+--------------+---------+
   |   ID   | STATUS  |  NAME  |  PEER ADDRS  | CLIENT ADDRS | LEARNER |
   +--------+---------+--------+--------------+--------------+---------+
   |2c18942f| started |worker-3|192.168.111.26|192.168.111.26|  false  |
   |61e2a860| started |worker-2|192.168.111.25|192.168.111.25|  false  |
   |ead4f280| started |worker-5|192.168.111.28|192.168.111.28|  false  |
   +--------+---------+--------+--------------+--------------+---------+

4. 确认 etcdctl 报告集群的不健康成员：

   $ etcdctl endpoint health

   输出示例

   {"level":"warn","ts":"2022-09-27T08:25:35.953Z","logger":"client","caller":"v3/retry_interceptor.go:62","msg":"retrying of unary invoker failed","target":"etcd-endpoints://0xc000680380/192.168.111.25","attempt":0,"error":"rpc error: code = DeadlineExceeded desc = latest balancer error: last connection error: connection error: desc = \"transport: Error while dialing dial tcp 192.168.111.25: connect: no route to host\""}
   192.168.111.28 is healthy: committed proposal: took = 12.465641ms
   192.168.111.26 is healthy: committed proposal: took = 12.297059ms
   192.168.111.25 is unhealthy: failed to commit proposal: context deadline exceeded
   Error: unhealthy cluster

5. 通过删除 Machine 自定义资源来删除不健康的 control plane：

   $ oc delete machine -n openshift-machine-api test-day2-1-6qv96-master-2

   注意

   如果不健康的集群无法成功运行，则不会删除 Machine 和 Node 自定义资源 (CR)。

6. 确认 etcd-operator 没有删除不健康的机器：

   $ oc logs -n openshift-etcd-operator etcd-operator-8668df65d-lvpjf -f

   输出示例

   I0927 08:58:41.249222       1 machinedeletionhooks.go:135] skip removing the deletion hook from machine test-day2-1-6qv96-master-2 since its member is still present with any of: [{InternalIP } {InternalIP 192.168.111.26}]

7. 手动删除不健康的 etcdctl 成员：

   $ oc rsh -n openshift-etcd etcd-worker-3\
   etcdctl member list -w table

   输出示例

   +--------+---------+--------+--------------+--------------+---------+
   |   ID   |  STATUS |  NAME  |  PEER ADDRS  | CLIENT ADDRS | LEARNER |
   +--------+---------+--------+--------------+--------------+---------+
   |2c18942f| started |worker-3|192.168.111.26|192.168.111.26|  false  |
   |61e2a860| started |worker-2|192.168.111.25|192.168.111.25|  false  |
   |ead4f280| started |worker-5|192.168.111.28|192.168.111.28|  false  |
   +--------+---------+--------+--------------+--------------+---------+

8. 确认 etcdctl 报告集群的不健康成员：

   $ etcdctl endpoint health

   输出示例

   {"level":"warn","ts":"2022-09-27T10:31:07.227Z","logger":"client","caller":"v3/retry_interceptor.go:62","msg":"retrying of unary invoker failed","target":"etcd-endpoints://0xc0000d6e00/192.168.111.25","attempt":0,"error":"rpc error: code = DeadlineExceeded desc = latest balancer error: last connection error: connection error: desc = \"transport: Error while dialing dial tcp 192.168.111.25: connect: no route to host\""}
   192.168.111.28 is healthy: committed proposal: took = 13.038278ms
   192.168.111.26 is healthy: committed proposal: took = 12.950355ms
   192.168.111.25 is unhealthy: failed to commit proposal: context deadline exceeded
   Error: unhealthy cluster

9. 通过删除 etcdctl 成员自定义资源来删除不健康的集群：

   $ etcdctl member remove 61e2a86084aafa62

   输出示例

   Member 61e2a86084aafa62 removed from cluster 6881c977b97990d7

10. 运行以下命令确认 etcdctl 的成员：

    $ etcdctl member list -w table

    输出示例

    +----------+---------+--------+--------------+--------------+-------+
    |    ID    | STATUS  |  NAME  |  PEER ADDRS  | CLIENT ADDRS |LEARNER|
    +----------+---------+--------+--------------+--------------+-------+
    | 2c18942f | started |worker-3|192.168.111.26|192.168.111.26| false |
    | ead4f280 | started |worker-5|192.168.111.28|192.168.111.28| false |
    +----------+---------+--------+--------------+--------------+-------+

11. 检查并批准证书签名请求

    1. 查看证书签名请求 (CSR)：

       $ oc get csr | grep Pending

       输出示例

       csr-5sd59   8m19s   kubernetes.io/kube-apiserver-client-kubelet   system:serviceaccount:openshift-machine-config-operator:node-bootstrapper   <none>              Pending
       csr-xzqts   10s     kubernetes.io/kubelet-serving                 system:node:worker-6                                                   <none>              Pending

    2. 批准所有待处理的 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 才能完成安装。

12. 确认 control plane 节点就绪状态：

    $ oc get nodes

    输出示例

    NAME       STATUS   ROLES    AGE     VERSION
    worker-1   Ready    worker   22h     v1.24.0+3882f8f
    master-3   Ready    master   22h     v1.24.0+3882f8f
    worker-4   Ready    worker   22h     v1.24.0+3882f8f
    master-5   Ready    master   17h     v1.24.0+3882f8f
    master-6   Ready    master   2m52s   v1.24.0+3882f8f

13. 验证 Machine, Node 和 BareMetalHost 自定义资源。

    如果集群使用功能 Machine API 运行，etcd-operator 需要 Machine CR。存在时，Machine CR 会在 Running 阶段显示。

14. 创建与 BareMetalHost 和 Node 链接的 Machine 自定义资源。

    确保有 Machine CR 引用新添加的节点。

    重要

    boot-it-yourself 将不会创建 BareMetalHost 和 Machine CR，因此您必须创建它们。如果无法创建 BareMetalHost 和 Machine CR，在运行 etcd-operator 时会生成错误。

15. 添加 BareMetalHost 自定义资源：

    $ oc create bmh -n openshift-machine-api custom-master3

16. 添加 Machine 自定义资源：

    $ oc create machine -n openshift-machine-api custom-master3

17. 运行 link-machine-and-node.sh 脚本链接 BareMetalHost, Machine, 和 Node：

    #!/bin/bash
    
    # Credit goes to https://bugzilla.redhat.com/show_bug.cgi?id=1801238.
    # This script will link Machine object and Node object. This is needed
    # in order to have IP address of the Node present in the status of the Machine.
    
    set -x
    set -e
    
    machine="$1"
    node="$2"
    
    if [ -z "$machine" -o -z "$node" ]; then
        echo "Usage: $0 MACHINE NODE"
        exit 1
    fi
    
    uid=$(echo $node | cut -f1 -d':')
    node_name=$(echo $node | cut -f2 -d':')
    
    oc proxy &
    proxy_pid=$!
    function kill_proxy {
        kill $proxy_pid
    }
    trap kill_proxy EXIT SIGINT
    
    HOST_PROXY_API_PATH="http://localhost:8001/apis/metal3.io/v1alpha1/namespaces/openshift-machine-api/baremetalhosts"
    
    function wait_for_json() {
        local name
        local url
        local curl_opts
        local timeout
    
        local start_time
        local curr_time
        local time_diff
    
        name="$1"
        url="$2"
        timeout="$3"
        shift 3
        curl_opts="$@"
        echo -n "Waiting for $name to respond"
        start_time=$(date +%s)
        until curl -g -X GET "$url" "${curl_opts[@]}" 2> /dev/null | jq '.' 2> /dev/null > /dev/null; do
            echo -n "."
            curr_time=$(date +%s)
            time_diff=$(($curr_time - $start_time))
            if [[ $time_diff -gt $timeout ]]; then
                echo "\nTimed out waiting for $name"
                return 1
            fi
            sleep 5
        done
        echo " Success!"
        return 0
    }
    wait_for_json oc_proxy "${HOST_PROXY_API_PATH}" 10 -H "Accept: application/json" -H "Content-Type: application/json"
    
    addresses=$(oc get node -n openshift-machine-api ${node_name} -o json | jq -c '.status.addresses')
    
    machine_data=$(oc get machine -n openshift-machine-api -o json ${machine})
    host=$(echo "$machine_data" | jq '.metadata.annotations["metal3.io/BareMetalHost"]' | cut -f2 -d/ | sed 's/"//g')
    
    if [ -z "$host" ]; then
        echo "Machine $machine is not linked to a host yet." 1>&2
        exit 1
    fi
    
    # The address structure on the host doesn't match the node, so extract
    # the values we want into separate variables so we can build the patch
    # we need.
    hostname=$(echo "${addresses}" | jq '.[] | select(. | .type == "Hostname") | .address' | sed 's/"//g')
    ipaddr=$(echo "${addresses}" | jq '.[] | select(. | .type == "InternalIP") | .address' | sed 's/"//g')
    
    host_patch='
    {
      "status": {
        "hardware": {
          "hostname": "'${hostname}'",
          "nics": [
            {
              "ip": "'${ipaddr}'",
              "mac": "00:00:00:00:00:00",
              "model": "unknown",
              "speedGbps": 10,
              "vlanId": 0,
              "pxe": true,
              "name": "eth1"
            }
          ],
          "systemVendor": {
            "manufacturer": "Red Hat",
            "productName": "product name",
            "serialNumber": ""
          },
          "firmware": {
            "bios": {
              "date": "04/01/2014",
              "vendor": "SeaBIOS",
              "version": "1.11.0-2.el7"
            }
          },
          "ramMebibytes": 0,
          "storage": [],
          "cpu": {
            "arch": "x86_64",
            "model": "Intel(R) Xeon(R) CPU E5-2630 v4 @ 2.20GHz",
            "clockMegahertz": 2199.998,
            "count": 4,
            "flags": []
          }
        }
      }
    }
    '
    
    echo "PATCHING HOST"
    echo "${host_patch}" | jq .
    
    curl -s \
         -X PATCH \
         ${HOST_PROXY_API_PATH}/${host}/status \
         -H "Content-type: application/merge-patch+json" \
         -d "${host_patch}"
    
    oc get baremetalhost -n openshift-machine-api -o yaml "${host}"

    $ bash link-machine-and-node.sh custom-master3 worker-3

18. 运行以下命令确认 etcdctl 的成员：

    $ oc rsh -n openshift-etcd etcd-worker-3
    etcdctl member list -w table

    输出示例

    +---------+-------+--------+--------------+--------------+-------+
    |   ID    | STATUS|  NAME  |   PEER ADDRS | CLIENT ADDRS |LEARNER|
    +---------+-------+--------+--------------+--------------+-------+
    | 2c18942f|started|worker-3|192.168.111.26|192.168.111.26| false |
    | ead4f280|started|worker-5|192.168.111.28|192.168.111.28| false |
    | 79153c5a|started|worker-6|192.168.111.29|192.168.111.29| false |
    +---------+-------+--------+--------------+--------------+-------+

19. 确认 etcd Operator 已配置了所有节点：

    $ oc get clusteroperator etcd

    输出示例

    NAME   VERSION   AVAILABLE   PROGRESSING   DEGRADED   SINCE
    etcd   4.11.5    True        False         False      22h

20. 确认 etcdctl 的健康状况：

    $ oc rsh -n openshift-etcd etcd-worker-3
    etcdctl endpoint health

    输出示例

    192.168.111.26 is healthy: committed proposal: took = 9.105375ms
    192.168.111.28 is healthy: committed proposal: took = 9.15205ms
    192.168.111.29 is healthy: committed proposal: took = 10.277577ms

21. 确认节点的健康状况：

    $ oc get Nodes

    输出示例

    NAME       STATUS   ROLES    AGE   VERSION
    worker-1   Ready    worker   22h   v1.24.0+3882f8f
    master-3   Ready    master   22h   v1.24.0+3882f8f
    worker-4   Ready    worker   22h   v1.24.0+3882f8f
    master-5   Ready    master   18h   v1.24.0+3882f8f
    master-6   Ready    master   40m   v1.24.0+3882f8f

22. 确认 ClusterOperators 的健康状况：

    $ oc get ClusterOperators

    输出示例

    NAME                               VERSION   AVAILABLE   PROGRESSING   DEGRADED   SINCE
    authentication                     4.11.5    True        False         False      150m
    baremetal                          4.11.5    True        False         False      22h
    cloud-controller-manager           4.11.5    True        False         False      22h
    cloud-credential                   4.11.5    True        False         False      22h
    cluster-autoscaler                 4.11.5    True        False         False      22h
    config-operator                    4.11.5    True        False         False      22h
    console                            4.11.5    True        False         False      145m
    csi-snapshot-controller            4.11.5    True        False         False      22h
    dns                                4.11.5    True        False         False      22h
    etcd                               4.11.5    True        False         False      22h
    image-registry                     4.11.5    True        False         False      22h
    ingress                            4.11.5    True        False         False      22h
    insights                           4.11.5    True        False         False      22h
    kube-apiserver                     4.11.5    True        False         False      22h
    kube-controller-manager            4.11.5    True        False         False      22h
    kube-scheduler                     4.11.5    True        False         False      22h
    kube-storage-version-migrator      4.11.5    True        False         False      148m
    machine-api                        4.11.5    True        False         False      22h
    machine-approver                   4.11.5    True        False         False      22h
    machine-config                     4.11.5    True        False         False      110m
    marketplace                        4.11.5    True        False         False      22h
    monitoring                         4.11.5    True        False         False      22h
    network                            4.11.5    True        False         False      22h
    node-tuning                        4.11.5    True        False         False      22h
    openshift-apiserver                4.11.5    True        False         False      163m
    openshift-controller-manager       4.11.5    True        False         False      22h
    openshift-samples                  4.11.5    True        False         False      22h
    operator-lifecycle-manager         4.11.5    True        False         False      22h
    operator-lifecycle-manager-catalog 4.11.5    True        False         False      22h
    operator-lifecycle-manager-pkgsvr  4.11.5    True        False         False      22h
    service-ca                         4.11.5    True        False         False      22h
    storage                            4.11.5    True        False         False      22h

23. 确认 ClusterVersion ：

    $ oc get ClusterVersion

    输出示例

    NAME      VERSION   AVAILABLE   PROGRESSING   SINCE   STATUS
    version   4.11.5    True        False         22h     Cluster version is 4.11.5

流程

1. 在 Host discovery 中，点 Add hosts 按钮并选择安装介质。
2. 选择 Minimal image file: Provision with virtual media 以下载一个较小的镜像，该镜像会获取引导所需的数据。

3. 可选：添加一个 SSH 公钥，以便可以以 core 用户身份连接到 Nutanix 虚拟机。通过登录到集群主机，您可以在安装过程中为您提供调试信息。

   1. 如果您在本地计算机上没有现有的 SSH 密钥对，请按照 为集群节点 SSH 访问生成密钥对 的步骤进行操作。
   2. 在 SSH 公钥 字段中，单击 Browse 以上传包含 SSH 公钥的 id_rsa.pub 文件。或者，将文件拖放到文件管理器的字段中。要查看文件管理器中的文件，请在菜单中选择 Show hidden files。
4. 可选： 如果集群主机位于需要使用代理的防火墙后面，请选择 Configure cluster-wide proxy settings。输入代理服务器的 HTTP 和 HTTPS URL 的用户名、密码、IP 地址和端口。
5. 可选：如果要使用 ignition 文件引导它，请配置发现镜像。如需了解更多详细信息，请参阅配置发现镜像。
6. 点 Generate Discovery ISO。
7. 复制 发现 ISO URL。
8. 在 Nutanix Prism UI 中，按照指示 从 Assisted Installer 中上传发现镜像。

9. 在 Nutanix Prism UI 中，通过 Prism Central 创建 control plane (master) 虚拟机。

   1. 输入 Name。例如，control-plane 或 master。
   2. 输入虚拟机数量。对于 control plane，这应该是 3。
   3. 确保剩余的设置满足 control plane 主机的最低要求。

10. 在 Nutanix Prism UI 中，通过 Prism Central 创建 worker 虚拟机。

    1. 输入 Name。例如，worker。
    2. 输入虚拟机数量。您应该至少创建 2 个 worker 节点。
    3. 确保剩余的设置满足 worker 主机的最低要求。
11. 返回到 Assisted Installer 用户界面，并等待 Assisted Installer 发现主机，每个都处于 Ready 状态。
12. 使用 Integrate with your virtualization platform 滑块启用与 Nutanix 的集成。
13. 继续安装过程。

流程

1. 如果要使用 ignition 文件引导，请配置发现镜像。

2. 创建 Nutanix 集群配置文件来保存环境变量：

   $ touch ~/nutanix-cluster-env.sh

   $ chmod +x ~/nutanix-cluster-env.sh

   如果需要启动新的终端会话，您可以轻松重新加载环境变量。例如：

   $ source ~/nutanix-cluster-env.sh

3. 将 Nutanix 集群的名称分配给配置文件中的 NTX_CLUSTER_NAME 环境变量：

   $ cat << EOF >> ~/nutanix-cluster-env.sh
   export NTX_CLUSTER_NAME=<cluster_name>
   EOF

   将 <cluster_name> 替换为 Nutanix 集群的名称。

4. 将 Nutanix 集群的子网名称分配给配置文件中的 NTX_SUBNET_NAME 环境变量：

   $ cat << EOF >> ~/nutanix-cluster-env.sh
   export NTX_SUBNET_NAME=<subnet_name>
   EOF

   将 <subnet_name> 替换为 Nutanix 集群子网的名称。

5. 刷新 API 令牌：

   $ source refresh-token

6. 获取下载 URL：

   $ curl -H "Authorization: Bearer ${API_TOKEN}" \
   https://api.openshift.com/api/assisted-install/v2/infra-envs/${INFRA_ENV_ID}/downloads/image-url

7. 创建 Nutanix 镜像配置文件：

   $ cat << EOF > create-image.json
   {
     "spec": {
       "name": "ocp_ai_discovery_image.iso",
       "description": "ocp_ai_discovery_image.iso",
       "resources": {
         "architecture": "X86_64",
         "image_type": "ISO_IMAGE",
         "source_uri": "<image_url>",
         "source_options": {
           "allow_insecure_connection": true
         }
       }
     },
     "metadata": {
       "spec_version": 3,
       "kind": "image"
     }
   }
   EOF

   将 <image_url> 替换为从上一步中下载的镜像 URL。

8. 创建 Nutanix 镜像：

   $ curl  -k -u <user>:'<password>' -X 'POST' \
   'https://<domain-or-ip>:<port>/api/nutanix/v3/images \
     -H 'accept: application/json' \
     -H 'Content-Type: application/json' \
     -d @./create-image.json | jq '.metadata.uuid'

   将 <user> 替换为 Nutanix 用户名。将 '<password>' 替换为 Nutanix 密码。将 <domain-or-ip> 替换为 Nutanix plaform 的域名或 IP 地址。将 <port> 替换为 Nutanix 服务器的端口。端口默认为 9440。

9. 将返回的 UUID 分配给配置文件中的 NTX_IMAGE_UUID 环境变量：

   $ cat << EOF >> ~/nutanix-cluster-env.sh
   export NTX_IMAGE_UUID=<uuid>
   EOF

10. 获取 Nutanix 集群 UUID：

    $ curl -k -u <user>:'<password>' -X 'POST' \
      'https://<domain-or-ip>:<port>/api/nutanix/v3/clusters/list' \
      -H 'accept: application/json' \
      -H 'Content-Type: application/json' \
      -d '{
      "kind": "cluster"
    }'  | jq '.entities[] | select(.spec.name=="<nutanix_cluster_name>") | .metadata.uuid'

    将 <user> 替换为 Nutanix 用户名。将 '<password>' 替换为 Nutanix 密码。将 <domain-or-ip> 替换为 Nutanix plaform 的域名或 IP 地址。将 <port> 替换为 Nutanix 服务器的端口。端口默认为 9440。将 <nutanix_cluster_name> 替换为 Nutanix 集群的名称。

11. 将返回的 Nutanix 集群 UUID 分配给配置文件中的 NTX_CLUSTER_UUID 环境变量：

    $ cat << EOF >> ~/nutanix-cluster-env.sh
    export NTX_CLUSTER_UUID=<uuid>
    EOF

    将 <uuid> 替换为 Nutanix 集群的返回 UUID。

12. 获取 Nutanix 集群的子网 UUID：

    $ curl -k -u <user>:'<password>' -X 'POST' \
      'https://<domain-or-ip>:<port>/api/nutanix/v3/subnets/list' \
      -H 'accept: application/json' \
      -H 'Content-Type: application/json' \
      -d '{
      "kind": "subnet",
      "filter": "name==<subnet_name>"
    }' | jq '.entities[].metadata.uuid'

    将 <user> 替换为 Nutanix 用户名。将 '<password>' 替换为 Nutanix 密码。将 <domain-or-ip> 替换为 Nutanix plaform 的域名或 IP 地址。将 <port> 替换为 Nutanix 服务器的端口。端口默认为 9440。将 <subnet_name> 替换为集群子网的名称。

13. 将返回的 Nutanix 子网 UUID 分配给配置文件中的 NTX_CLUSTER_UUID 环境变量：

    $ cat << EOF >> ~/nutanix-cluster-env.sh
    export NTX_SUBNET_UUID=<uuid>
    EOF

    将 <uuid> 替换为集群子网的返回 UUID。

14. 确保设置了 Nutanix 环境变量：

    $ source ~/nutanix-cluster-env.sh

15. 为每个 Nutanix 主机创建一个虚拟机配置文件。创建三个 control plane (master) 虚拟机和至少两个 worker 虚拟机。例如：

    $ touch create-master-0.json

    $ cat << EOF > create-master-0.json
    {
       "spec": {
          "name": "<host_name>",
          "resources": {
             "power_state": "ON",
             "num_vcpus_per_socket": 1,
             "num_sockets": 16,
             "memory_size_mib": 32768,
             "disk_list": [
                {
                   "disk_size_mib": 122880,
                   "device_properties": {
                      "device_type": "DISK"
                   }
                },
                {
                   "device_properties": {
                      "device_type": "CDROM"
                   },
                   "data_source_reference": {
                     "kind": "image",
                     "uuid": "$NTX_IMAGE_UUID"
                  }
                }
             ],
             "nic_list": [
                {
                   "nic_type": "NORMAL_NIC",
                   "is_connected": true,
                   "ip_endpoint_list": [
                      {
                         "ip_type": "DHCP"
                      }
                   ],
                   "subnet_reference": {
                      "kind": "subnet",
                      "name": "$NTX_SUBNET_NAME",
                      "uuid": "$NTX_SUBNET_UUID"
                   }
                }
             ],
             "guest_tools": {
                "nutanix_guest_tools": {
                   "state": "ENABLED",
                   "iso_mount_state": "MOUNTED"
                }
             }
          },
          "cluster_reference": {
             "kind": "cluster",
             "name": "$NTX_CLUSTER_NAME",
             "uuid": "$NTX_CLUSTER_UUID"
          }
       },
       "api_version": "3.1.0",
       "metadata": {
          "kind": "vm"
       }
    }
    EOF

    将 <host_name> 替换为主机的名称。

16. 引导每个 Nutanix 虚拟机：

    $ curl -k -u <user>:'<password>' -X 'POST' \
      'https://<domain-or-ip>:<port>/api/nutanix/v3/vms' \
      -H 'accept: application/json' \
      -H 'Content-Type: application/json' \
      -d @./<vm_config_file_name> | jq '.metadata.uuid'

    将 <user> 替换为 Nutanix 用户名。将 '<password>' 替换为 Nutanix 密码。将 <domain-or-ip> 替换为 Nutanix plaform 的域名或 IP 地址。将 <port> 替换为 Nutanix 服务器的端口。端口默认为 9440。将 <vm_config_file_name> 替换为虚拟机配置文件的名称。

17. 将返回的虚拟机 UUID 分配给配置文件中的唯一环境变量：

    $ cat << EOF >> ~/nutanix-cluster-env.sh
    export NTX_MASTER_0_UUID=<uuid>
    EOF

    将 <uuid> 替换为虚拟机返回的 UUID。

    注意

    环境变量必须具有每个虚拟机的唯一名称。

18. 等待 Assisted Installer 发现每个虚拟机，并已通过验证。

    $ curl -s -X GET "https://api.openshift.com/api/assisted-install/v2/clusters/$CLUSTER_ID"
    --header "Content-Type: application/json"
    -H "Authorization: Bearer $API_TOKEN"
    | jq '.enabled_host_count'

19. 修改集群定义以启用与 Nutanix 集成：

    $ curl https://api.openshift.com/api/assisted-install/v2/clusters/${CLUSTER_ID} \
    -X PATCH \
    -H "Authorization: Bearer ${API_TOKEN}" \
    -H "Content-Type: application/json" \
    -d '
    {
        "platform_type":"nutanix"
    }
    ' | jq

20. 继续安装过程。

流程

1. 如果要使用 ignition 文件引导，请配置发现镜像。

2. 从 Assisted Installer UI 生成并下载 ISO。

   1. 在 Host discovery 中，点 Add hosts 按钮并选择安装介质。
   2. 选择 Minimal image file: Provision with virtual media 以下载一个较小的镜像，该镜像会获取引导所需的数据。

   3. 添加 SSH 公钥，以便您可以以 core 用户身份连接到 vSphere 虚拟机。通过登录到集群主机，您可以在安装过程中为您提供调试信息。

      1. 如果您在本地计算机上没有现有的 SSH 密钥对，请按照 为集群节点 SSH 访问生成密钥对 的步骤进行操作。
      2. 在 SSH 公钥 字段中，单击 Browse 以上传包含 SSH 公钥的 id_rsa.pub 文件。或者，将文件拖放到文件管理器的字段中。要查看文件管理器中的文件，请在菜单中选择 Show hidden files。
   4. 可选： 如果集群主机位于需要使用代理的防火墙后面，请选择 Configure cluster-wide proxy settings。输入代理服务器的 HTTP 和 HTTPS URL 的用户名、密码、IP 地址和端口。
   5. 可选： 如果集群主机位于带有重新加密 man-in-the-middle (MITM) 代理的网络中，或者集群需要信任证书用于容器镜像 registry，请选择 Configure cluster-wide trusted certificate 并添加额外的证书。
   6. 可选：如果要使用 ignition 文件引导它，请配置发现镜像。如需了解更多详细信息，请参阅配置发现镜像。
   7. 点 Generate Discovery ISO。
   8. 复制 发现 ISO URL。

   9. 下载发现 ISO：

      $ wget - O vsphere-discovery-image.iso <discovery_url>

      将 <discovery_url> 替换为上一步中的 URL。

3. 在命令行中，关闭并销毁任何预先存在的虚拟机：

   $ for VM in $(/usr/local/bin/govc ls /<datacenter>/vm/<folder_name>)
   do
    	/usr/local/bin/govc vm.power -off $VM
    	/usr/local/bin/govc vm.destroy $VM
   done

   将 <datacenter> 替换为数据中心的名称。将 <folder_name> 替换为虚拟机清单文件夹的名称。

4. 从数据存储中删除预先存在的 ISO 镜像（如果存在）：

   $ govc datastore.rm -ds <iso_datastore> <image>

   将 <iso_datastore> 替换为数据存储的名称。使用 ISO 镜像的名称替换 image。

5. 上传辅助安装程序发现 ISO：

   $ govc datastore.upload -ds <iso_datastore>  vsphere-discovery-image.iso

   将 <iso_datastore> 替换为数据存储的名称。

   注意

   集群中的所有节点都必须从发现镜像引导。

6. 引导三个 control plane (master) 节点：

   $ govc vm.create -net.adapter <network_adapter_type> \
                    -disk.controller <disk_controller_type> \
                    -pool=<resource_pool> \
                    -c=16 \
                    -m=32768 \
                    -disk=120GB \
                    -disk-datastore=<datastore_file> \
                    -net.address="<nic_mac_address>" \
                    -iso-datastore=<iso_datastore> \
                    -iso="vsphere-discovery-image.iso" \
                    -folder="<inventory_folder>" \
                    <hostname>.<cluster_name>.example.com

   详情请参阅 vm.create。

   注意

   示例中演示了 control plane 节点所需的最小所需资源。

7. 至少引导两个 worker 节点：

   $ govc vm.create -net.adapter <network_adapter_type> \
                    -disk.controller <disk_controller_type> \
                    -pool=<resource_pool> \
                    -c=4 \
                    -m=8192 \
                    -disk=120GB \
                    -disk-datastore=<datastore_file> \
                    -net.address="<nic_mac_address>" \
                    -iso-datastore=<iso_datastore> \
                    -iso="vsphere-discovery-image.iso" \
                    -folder="<inventory_folder>" \
                    <hostname>.<cluster_name>.example.com

   详情请参阅 vm.create。

   注意

   示例中演示了 worker 节点所需的最小所需资源。

8. 确保虚拟机正在运行：

   $  govc ls /<datacenter>/vm/<folder_name>

   将 <datacenter> 替换为数据中心的名称。将 <folder_name> 替换为虚拟机清单文件夹的名称。

9. 2 分钟后，关闭虚拟机：

   $ for VM in $(govc ls /<datacenter>/vm/<folder_name>)
   do
        govc vm.power -s=true $VM
   done

   将 <datacenter> 替换为数据中心的名称。将 <folder_name> 替换为虚拟机清单文件夹的名称。

10. 将 disk.enableUUID 设置为 TRUE ：

    $ for VM in $(govc ls /<datacenter>/vm/<folder_name>)
    do
         govc vm.change -vm $VM -e disk.enableUUID=TRUE
    done

    将 <datacenter> 替换为数据中心的名称。将 <folder_name> 替换为虚拟机清单文件夹的名称。

    注意

    您必须在所有节点上将 disk.enableUUID 设置为 TRUE，才能使用 vSphere 启用自动扩展。

11. 重启虚拟机：

    $  for VM in $(govc ls /<datacenter>/vm/<folder_name>)
    do
         govc vm.power -on=true $VM
    done

    将 <datacenter> 替换为数据中心的名称。将 <folder_name> 替换为虚拟机清单文件夹的名称。

12. 返回到 Assisted Installer 用户界面，并等待 Assisted Installer 发现主机，每个都处于 Ready 状态。
13. 使用 Integrate with your virtualization platform 滑块启用与 vSphere 的集成。
14. 如果需要，选择角色。
15. 在 Networking 中，取消选中 Allocate IPs via DHCP server。
16. 设置 API VIP 地址。
17. 设置 Ingress VIP 地址。
18. 继续安装过程。

流程

1. 为 vCenter 生成 base64 编码的用户名和密码：

   $ echo -n "<vcenter_username>" | base64 -w0

   将 <vcenter_username> 替换为您的 vCenter 用户名。

   $ echo -n "<vcenter_password>" | base64 -w0

   将 <vcenter_password> 替换为您的 vCenter 密码。

2. 备份 vSphere 凭证：

   $ oc get secret vsphere-creds -o yaml -n kube-system > creds_backup.yaml

3. 编辑 vSphere 凭证：

   $ cp creds_backup.yaml vsphere-creds.yaml

   $ vi vsphere-creds.yaml

   apiVersion: v1
   data:
     <vcenter_address>.username: <vcenter_username_encoded>
     <vcenter_address>.password: <vcenter_password_encoded>
   kind: Secret
   metadata:
     annotations:
       cloudcredential.openshift.io/mode: passthrough
     creationTimestamp: "2022-01-25T17:39:50Z"
     name: vsphere-creds
     namespace: kube-system
     resourceVersion: "2437"
     uid: 06971978-e3a5-4741-87f9-2ca3602f2658
   type: Opaque

   将 <vcenter_address> 替换为 vCenter 地址。将 <vcenter_username_encoded> 替换为 vSphere 用户名的 base64 编码版本。将 <vcenter_password_encoded> 替换为 vSphere 密码的 base64 编码版本。

4. 替换 vSphere 凭证：

   $ oc replace -f vsphere-creds.yaml

5. 重新部署 kube-controller-manager pod：

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

6. 备份 vSphere 云供应商配置：

   $ oc get cm cloud-provider-config -o yaml -n openshift-config > cloud-provider-config_backup.yaml

7. 编辑云供应商配置：

   $ cloud-provider-config_backup.yaml cloud-provider-config.yaml

   $ vi cloud-provider-config.yaml

   apiVersion: v1
   data:
     config: |
       [Global]
       secret-name = "vsphere-creds"
       secret-namespace = "kube-system"
       insecure-flag = "1"
   
       [Workspace]
       server = "<vcenter_address>"
       datacenter = "<datacenter>"
       default-datastore = "<datastore>"
       folder = "/<datacenter>/vm/<folder>"
   
       [VirtualCenter "<vcenter_address>"]
       datacenters = "<datacenter>"
   kind: ConfigMap
   metadata:
     creationTimestamp: "2022-01-25T17:40:49Z"
     name: cloud-provider-config
     namespace: openshift-config
     resourceVersion: "2070"
     uid: 80bb8618-bf25-442b-b023-b31311918507

   将 <vcenter_address> 替换为 vCenter 地址。将 <datacenter> 替换为数据中心的名称。将 <datastore> 替换为数据存储的名称。将 <folder> 替换为包含集群虚拟机的文件夹。

8. 应用云供应商配置：

   $ oc apply -f cloud-provider-config.yaml

9. 使用 uninitialized 污点为集群加污点：

   重要

   如果要安装 OpenShift Container Platform 4.13 或更高版本，请执行以下的第 9 步到第 12 步。

   1. 识别要加污点的节点：

      $ oc get nodes

   2. 对每个节点运行以下命令：

      $ oc adm taint node <node_name> node.cloudprovider.kubernetes.io/uninitialized=true:NoSchedule

      将 <node_name> 替换为节点的名称。

   示例

   $ oc get nodes
   NAME                STATUS   ROLES                  AGE   VERSION
   master-0   Ready    control-plane,master   45h   v1.26.3+379cd9f
   master-1   Ready    control-plane,master   45h   v1.26.3+379cd9f
   worker-0   Ready    worker                 45h   v1.26.3+379cd9f
   worker-1   Ready    worker                 45h   v1.26.3+379cd9f
   master-2   Ready    control-plane,master   45h   v1.26.3+379cd9f
   
   $ oc adm taint node master-0 node.cloudprovider.kubernetes.io/uninitialized=true:NoSchedule
   $ oc adm taint node master-1 node.cloudprovider.kubernetes.io/uninitialized=true:NoSchedule
   $ oc adm taint node master-2 node.cloudprovider.kubernetes.io/uninitialized=true:NoSchedule
   $ oc adm taint node worker-0 node.cloudprovider.kubernetes.io/uninitialized=true:NoSchedule
   $ oc adm taint node worker-1 node.cloudprovider.kubernetes.io/uninitialized=true:NoSchedule

10. 备份基础架构配置：

    $ oc get infrastructures.config.openshift.io -o yaml > infrastructures.config.openshift.io.yaml.backup

11. 编辑基础架构配置：

    $ cp infrastructures.config.openshift.io.yaml.backup infrastructures.config.openshift.io.yaml

    $ vi infrastructures.config.openshift.io.yaml

    apiVersion: v1
    items:
    - apiVersion: config.openshift.io/v1
      kind: Infrastructure
      metadata:
        creationTimestamp: "2023-05-07T10:19:55Z"
        generation: 1
        name: cluster
        resourceVersion: "536"
        uid: e8a5742c-6d15-44e6-8a9e-064b26ab347d
      spec:
        cloudConfig:
          key: config
          name: cloud-provider-config
        platformSpec:
          type: VSphere
          vsphere:
            failureDomains:
            - name: assisted-generated-failure-domain
              region: assisted-generated-region
              server: <vcenter_address>
              topology:
                computeCluster: /<data_center>/host/<vcenter_cluster>
                datacenter: <data_center>
                datastore: /<data_center>/datastore/<datastore>
                folder: "/<data_center>/path/to/folder"
                networks:
                - "VM Network"
                resourcePool: /<data_center>/host/<vcenter_cluster>/Resources
              zone: assisted-generated-zone
            nodeNetworking:
              external: {}
              internal: {}
            vcenters:
            - datacenters:
              - <data_center>
              server: <vcenter_address>
    
    kind: List
    metadata:
      resourceVersion: ""

    将 <vcenter_address> 替换为您的 vCenter 地址。将 <datacenter> 替换为 vCenter 数据中心的名称。将 <datastore> 替换为 vCenter 数据存储的名称。将 <folder> 替换为包含集群虚拟机的文件夹。将 <vcenter_cluster> 替换为安装 OpenShift Container Platform 的 vSphere vCenter 集群。

12. 应用基础架构配置：

    $ oc apply -f infrastructures.config.openshift.io.yaml --overwrite=true

流程

1. 在 Administrator 视角中，进入到 Home → Overview。
2. 在 Status 下，点 vSphere connection 打开 vSphere 连接配置。
3. 在 vCenter 字段中，输入 vSphere vCenter 服务器的网络地址。这可以是域名，也可以是 IP 地址。它会出现在 vSphere Web 客户端 URL 中，例如 https://[your_vCenter_address]/ui。

4. 在 vCenter cluster 字段中，输入安装 OpenShift Container Platform 的 vSphere vCenter 集群名称。

   重要

   如果安装了 OpenShift Container Platform 4.13 或更高版本，则此步骤是必需的。

5. 在 Username 字段中，输入 vSphere vCenter 用户名。

6. 在 Password 字段中输入您的 vSphere vCenter 密码。

   警告

   系统将用户名和密码存储在集群的 kube-system 命名空间中的 vsphere-creds secret 中。不正确的 vCenter 用户名或密码使集群节点不可调度。

7. 在 Datacenter 字段中，输入 vSphere 数据中心的名称，其中包含用于托管集群的虚拟机；例如，SDDC-Datacenter。

8. 在 Default data store 字段中，输入存储持久数据卷的 vSphere 数据存储；例如 /SDDC-Datacenter/datastore/datastorename。

   警告

   在保存配置后，更新 vSphere 数据中心或默认数据存储会分离任何活跃的 vSphere PersistentVolume。

9. 在 Virtual Machine Folder 字段中，输入包含集群虚拟机的数据中心文件夹；例如，/SDDC-Datacenter/vm/ci-ln-hjg4vg2-c61657-t2gzr。要使 OpenShift Container Platform 安装成功，组成集群的所有虚拟机都必须位于单个数据中心文件夹中。
10. 点 Save Configuration。这会更新 openshift-config 命名空间中的 cloud-provider-config 文件，并启动配置过程。
11. 重新打开 vSphere 连接配置，再展开 Monitored operators 面板。检查 Operator 的状态是否为 Progressing 或 Healthy。

1. 检查配置过程是否已成功完成：

   1. 在 OpenShift Container Platform Administrator 视角中，进入到 Home → Overview。
   2. 在 Status 下点 Operators。等待所有操作器状态从 Progressing 变为 All succeeded。Failed 状态表示配置失败。
   3. 在 Status 下，点 Control Plane。等待所有 Control Pane 组件的响应率返回到 100%。Failed control plane 组件表示配置失败。

   失败表示至少一个连接设置不正确。更改 vSphere 连接配置中的设置，然后再次保存配置。

2. 通过执行以下步骤来检查您是否可以绑定 PersistentVolumeClaims 对象：

   1. 使用以下 YAML 创建 StorageClass 对象：

      kind: StorageClass
      apiVersion: storage.k8s.io/v1
      metadata:
       name: vsphere-sc
      provisioner: kubernetes.io/vsphere-volume
      parameters:
       datastore: YOURVCENTERDATASTORE
       diskformat: thin
      reclaimPolicy: Delete
      volumeBindingMode: Immediate

   2. 使用以下 YAML 创建 PersistentVolumeClaims 对象：

      kind: PersistentVolumeClaim
      apiVersion: v1
      metadata:
       name: test-pvc
       namespace: openshift-config
       annotations:
         volume.beta.kubernetes.io/storage-provisioner: kubernetes.io/vsphere-volume
       finalizers:
         - kubernetes.io/pvc-protection
      spec:
       accessModes:
         - ReadWriteOnce
       resources:
         requests:
          storage: 10Gi
       storageClassName: vsphere-sc
       volumeMode: Filesystem

   具体步骤请参阅 OpenShift Container Platform 文档中的 动态置备。要排除 PersistentVolumeClaims 对象的问题，请进入到 OpenShift Container Platform UI 的 Administrator 视角中的 Storage → PersistentVolumeClaims。

流程

1. 验证您的主机已开机。
2. 如果您选择了 DHCP 网络，检查 DHCP 服务器是否已启用。
3. 如果您选择了 静态 IP、网桥和绑定网络，请检查您的配置是否正确。

4. 验证您可以使用 SSH、一个控制台（如 BMC）或虚拟机控制台来访问主机机器：

   $ ssh core@<host_ip_address>

   如果没有存储在默认目录中，您可以使用 -i 参数指定私钥文件。

   $ ssh -i <ssh_private_key_file> core@<host_ip_address>

   如果您没有 ssh 到主机，则主机在启动过程中会失败，或者无法配置网络。

   登录后，您应该看到这个信息：

   登录示例

   如果没有看到这个信息，这意味着主机没有使用 assisted-installer ISO 引导。确保正确配置了引导顺序（主机应该从 live-ISO 启动一次）。

5. 检查代理服务日志：

   $ sudo journalctl -u agent.service

   在以下示例中，错误表示存在网络问题：

   代理服务日志的代理服务日志截图示例

   

   如果拉取代理镜像出现错误，请检查代理设置。验证主机是否已连接到网络。您可以使用 nmcli 来获取有关网络配置的额外信息。