支持控制台（Console）开发人员开始试用联系人

1.7. 托管 control plane

使用 multicluster engine operator 集群管理，您可以使用两个不同的 control plane 配置部署 OpenShift Container Platform 集群：独立或托管的 control plane。独立配置使用专用虚拟机或物理机器来托管 OpenShift Container Platform control plane。使用 OpenShift Container Platform 托管 control plane，您可以在托管集群中创建 pod 作为 control plane，而无需为每个 control plane 专用物理机器。

OpenShift Container Platform 托管 control plane 在裸机和 Red Hat OpenShift Virtualization 上提供，并作为 Amazon Web Services (AWS)上的 技术预览功能 提供。您可以在 OpenShift Container Platform 版本 4.14 上托管 control plane。托管的 control plane 功能默认启用。

1.7.1. 要求

下表显示每个平台都支持哪些 OpenShift Container Platform 版本。在表中，Hosting OpenShift Container Platform 版本 指的是启用了 multicluster engine operator 的 OpenShift Container Platform 版本：

平台

托管 OpenShift Container Platform 版本

托管 OpenShift Container Platform 版本

裸机

4.14 - 4.15

4.14 - 4.15 （仅限）

Red Hat OpenShift Virtualization

4.14 - 4.15

4.14 - 4.15 （仅限）

AWS （技术预览）

4.11 - 4.15

4.14 - 4.15 （仅限）

注： 在托管 control plane 的同一平台上运行 hub 集群和 worker。

control plane 作为单一命名空间中包含的 pod 运行，并与托管的 control plane 集群关联。当 OpenShift Container Platform 创建这种类型的托管集群时，它会创建一个独立于 control plane 的 worker 节点。

如果您使用代理，并且希望 pod 到 Kubernetes API 服务器的流量不使用代理，请将默认的 Kubernetes API 服务器地址 172.20.0.1 添加到 no_proxy 列表中。

托管 control plane 集群有几个优点：

  • 通过删除对专用 control plane 节点的需求来降低成本
  • 引入 control plane 和工作负载的隔离，改进了隔离并减少可能需要更改的配置错误
  • 通过删除 control plane 节点 bootstrap 的要求来减少集群创建时间
  • 支持 turn-key 部署或完全自定义的 OpenShift Container Platform 置备

要使用托管的 control plane，请从以下文档开始：

  1. 托管 control plane 大小指导
  2. 安装托管的 control plane 命令行界面
  3. 分发托管集群工作负载

然后，查看与计划使用的平台相关的文档：

要为节点池配置额外网络、保证 CPU 和虚拟机调度，请参阅以下文档：

有关托管 control plane 的其他资源，请参阅以下 OpenShift Container Platform 文档：

1.7.2. 托管 control plane 大小指导

许多因素（包括托管集群工作负载和 worker 节点数）会影响到特定数量的 control-plane 节点中可以容纳多少个托管集群。使用此大小指南来帮助进行托管集群容量规划。这个指南假设高度可用的托管 control plane 拓扑。在裸机集群中测量基于负载的大小示例。基于云的实例可能具有不同的限制因素，如内存大小。有关高可用性托管 control plane 拓扑的更多信息，请参阅 分配托管集群工作负载。

您可以覆盖以下资源利用率大小测量并禁用指标服务监控。如需更多信息，请参阅附加资源部分中的 覆盖资源利用率测量。

请参阅以下高可用性托管的 control plane 要求，这些要求已使用 OpenShift Container Platform 版本 4.12.9 及更新版本进行测试：

  • 78 个 pod
  • etcd 三个 8 GiB PV
  • 最小 vCPU：大约 5.5 个内核
  • 最小内存：大约 19 GiB

1.7.2.1. Pod 限值

每个节点的 maxPods 设置会影响 control-plane 节点可以容纳多少个托管集群。务必要记录所有 control-plane 节点上的 maxPods 值。为每个高可用性托管的 control plane 大约 75 个 pod 计划。

对于裸机节点，默认的 maxPods 设置可能是一个限制因素，因为通常三个托管的 control plane 适合每个节点，即使机器有可备用的资源。通过配置 KubeletConfig 值将 maxPods 值设置为 500，以获得更大的托管 control plane 密度，这有助于利用额外的计算资源。如需更多信息，请参阅 OpenShift Container Platform 文档中的配置每个节点的最大 pod 数量。

1.7.2.2. 基于请求的资源限值

集群可以托管的 control plane CPU 和来自 pod 的内存请求的最大数量。

高可用性托管的 control plane 由请求 5 个 vCPU 和 18 GB 内存的 78 个 pod 组成。这些基准号与集群 worker 节点资源容量进行比较，以估算托管 control plane 的最大数量。

1.7.2.3. 基于负载的限制

当某些工作负载放在托管 control plane Kubernetes API 服务器上时，集群可以托管的 control plane pod CPU 和内存使用率计算集群可以托管的 control plane 的最大 control plane 数量。

以下方法用于在工作负载增加时测量托管的 control plane 资源利用率：

  • 具有 9 个 worker 的托管集群，每个 worker 使用 8 个 vCPU 和 32 GiB，同时使用 KubeVirt 平台

  • 根据以下定义，配置为专注于 API control-plane stress 的工作负载测试配置集：

    • 为每个命名空间创建对象，扩展至 100 个命名空间总数
    • 通过持续删除和创建对象的其他 API 压力
    • 工作负载查询每秒(QPS)和 Burst 设置设置高，以删除任何客户端节流

当负载增加 1000 QPS 时，托管的 control plane 资源使用率会增加 9 个 vCPU 和 2.5 GB 内存。

出于常规大小，请考虑 1000 QPS API 速率，它是 中型 托管集群负载，以及一个 重度 托管的集群负载的 2000 QPS API。

注： 此测试提供了一个估算因素，用于根据预期的 API 负载增加计算资源利用率。确切利用率率可能会因集群工作负载的类型和速度而异。

表 1.7. 载入表
托管 control plane 资源使用率扩展VCPU内存(GiB)

没有负载的资源使用率

2.9

11.1

使用 1000 QPS 的资源利用率

9.0

2.5

当负载增加 1000 QPS 时，托管的 control plane 资源使用率会增加 9 个 vCPU 和 2.5 GB 内存。

出于常规大小，请考虑 1000 QPS API 速率作为中型托管集群负载，以及 2000 QPS API 作为大量托管集群负载。

以下示例显示了工作负载和 API 速率定义的托管 control plane 资源扩展：

表 1.8. API 速率表
QPS (API rate)vCPU 用量内存用量(GiB)

低负载(Less than 50 QPS)

2.9

11.1

中型负载(1000 QPS)

11.9

13.6

高负载(2000 QPS)

20.9

16.1

托管 control plane 大小是 control-plane 负载，以及导致大量 API 活动、etcd 活动或两者的工作负载。侧重于数据平面负载的托管 pod 工作负载（如运行数据库）可能会导致 API 速率高。

1.7.2.4. 大小计算示例

这个示例为以下情况提供了大小调整指导：

  • 三个标记为 hypershift.openshift.io/control-plane 节点的裸机 worker
  • maxPods 值设为 500
  • 根据基于负载的限制，预期的 API 速率为 medium 或大约 1000
表 1.9. 限制输入
限制描述服务器 1服务器 2

worker 节点上的 vCPU 数量

64

128

worker 节点上的内存(GiB)

128

256

每个 worker 的最大 pod

500

500

用于托管 control plane 的 worker 数量

3

3

最大 QPS 目标率（每秒的 API 请求）

1000

1000

表 1.10. 大小计算示例

根据 worker 节点大小和 API 速率计算值

服务器 1

服务器 2

计算备注

根据 vCPU 请求，每个 worker 的最大托管 control plane

12.8

25.6

每个托管的 control plane 的 worker vCPU total 5 个 vCPU 请求数

根据 vCPU 用量，每个 worker 的最大托管 control plane

5.4

10.7

vCPUS HBAC (2.9 测量闲置 vCPU 用量 +（QPS 目标速率 maximum maximum 1000) measured vCPU 用量（每 1000 QPS 测量的 vCPU 使用量）

根据内存请求，每个 worker 的最大托管 control plane

7.1

14.2

worker 内存 GiB 每个托管的 control plane 内存请求总数

根据内存用量，每个 worker 的最大托管 control plane

9.4

18.8

worker 内存 GiB HBAC (11.1 measured idle memory usage +(QPS target rate packagemanifests 1000) measured 2.5 measured memory usage per 1000 QPS increase)

根据每个节点的 pod 限制，每个 worker 的最大托管 control plane

6.7

6.7

每个托管的 control plane 500 maxPods 75 个 pod

前面提到的最大值

5.4

6.7

 
 

vCPU 限制因素

maxPods 限制因素

 

管理集群中托管 control plane 的最大数量

16

20

前面提到的最少 3 个 control-plane worker

表 1.11. 托管 control plane 容量指标

Name

描述

mce_hs_addon_request_based_hcp_capacity_gauge

估算集群可以基于高可用性托管 control plane 资源请求的最大托管 control plane 数量。

mce_hs_addon_low_qps_based_hcp_capacity_gauge

如果所有托管的 control plane 都大约为 50 QPS 到集群 Kube API 服务器，则预测集群可以托管的最大 control plane 数量。

mce_hs_addon_medium_qps_based_hcp_capacity_gauge

如果所有托管的 control plane 都对集群 Kube API 服务器执行超过 1000 QPS，则预测集群可以托管的最大 control plane 数量。

mce_hs_addon_high_qps_based_hcp_capacity_gauge

如果所有托管的 control plane 都围绕 2000 QPS 到集群 Kube API 服务器，则预测集群可以托管的最大 control plane 数量。

mce_hs_addon_average_qps_based_hcp_capacity_gauge

根据托管 control plane 的现有平均 QPS 估算集群可以托管的 control plane 的最大数量。如果您没有活跃的托管 control plane，您可以预期低 QPS。

1.7.2.5. 其他资源

1.7.3. 覆盖资源使用率测量

资源利用率的基准测量集合可能会因每个集群而异。如需更多信息，请参阅 托管 control plane 大小指导。

您可以根据集群工作负载的类型和速度覆盖资源利用率测量。完成以下步骤：

  1. 运行以下命令来创建 ConfigMap 资源： 

    oc create -f <your-config-map-file.yaml>

    将 <your-config-map-file.yaml > 替换为包含 hcp-sizing-baseline 配置映射的 YAML 文件的名称。

  2. 在 local-cluster 命名空间中创建 hcp-sizing-baseline 配置映射，以指定您要覆盖的测量。您的配置映射可能类似以下 YAML 文件： 

    kind: ConfigMap
apiVersion: v1
metadata:
  name: hcp-sizing-baseline
  namespace: local-cluster
data:
  incrementalCPUUsagePer1KQPS: "9.0"
  memoryRequestPerHCP: "18"
  minimumQPSPerHCP: "50.0"

  3. 运行以下命令，删除 hypershift-addon-agent 部署来重启 hypershift-addon-agent pod： 

    oc delete deployment hypershift-addon-agent -n open-cluster-management-agent-addon

  4. 观察 hypershift-addon-agent pod 日志。运行以下命令，验证配置映射中是否已更新覆盖的测量： 

    oc logs hypershift-addon-agent -n open-cluster-management-agent-addon

    您的日志可能类似以下输出： 

    2024-01-05T19:41:05.392Z	INFO	agent.agent-reconciler	agent/agent.go:793	setting cpuRequestPerHCP to 5
2024-01-05T19:41:05.392Z	INFO	agent.agent-reconciler	agent/agent.go:802	setting memoryRequestPerHCP to 18
2024-01-05T19:53:54.070Z	INFO	agent.agent-reconciler	agent/hcp_capacity_calculation.go:141	The worker nodes have 12.000000 vCPUs
2024-01-05T19:53:54.070Z	INFO	agent.agent-reconciler	agent/hcp_capacity_calculation.go:142	The worker nodes have 49.173369 GB memory

    如果没有在 hcp-sizing-baseline 配置映射中正确更新覆盖的测量，您可能会在 hypershift-addon-agent pod 日志中看到以下出错信息： 

    2024-01-05T19:53:54.052Z	ERROR	agent.agent-reconciler	agent/agent.go:788	failed to get configmap from the hub. Setting the HCP sizing baseline with default values.	{"error": "configmaps \"hcp-sizing-baseline\" not found"}

1.7.3.1. 禁用指标服务监控

启用 hypershift-addon 受管集群附加组件后，指标服务监控会被默认配置，以便 OpenShift Container Platform 监控可以从 hypershift-addon 收集指标。您可以通过完成以下步骤来禁用指标服务监控：

  1. 运行以下命令登录到您的 hub 集群： 

    oc login

  2. 运行以下命令，打开 hypershift-addon-deploy-config 附加组件部署配置规格以进行编辑： 

    oc edit addondeploymentconfig hypershift-addon-deploy-config -n multicluster-engine

  3. 在规格中添加 disableMetrics=true 自定义变量，如下例所示： 

    apiVersion: addon.open-cluster-management.io/v1alpha1
kind: AddOnDeploymentConfig
metadata:
  name: hypershift-addon-deploy-config
  namespace: multicluster-engine
spec:
  customizedVariables:
  - name: hcMaxNumber
    value: "80"
  - name: hcThresholdNumber
    value: "60"
  - name: disableMetrics
    value: "true"
  4. 保存更改。disableMetrics=true 自定义变量为新的和现有的 hypershift-addon 受管集群附加组件禁用指标服务监控配置。

1.7.3.2. 其他资源

1.7.4. 安装托管的 control plane 命令行界面

您可以通过完成以下步骤来安装托管的 control plane 命令行界面 hcp ：

  1. 在 OpenShift Container Platform 控制台中点 Help 图标 &gt; Command Line Tools。
  2. 为您的平台点 Download hcp CLI。

  3. 运行以下命令来解包下载的归档： 

    tar xvzf hcp.tar.gz

  4. 运行以下命令使二进制文件可执行： 

    chmod +x hcp

  5. 运行以下命令，将二进制文件移到路径的目录中： 

    sudo mv hcp /usr/local/bin/.

现在，您可以使用 hcp create cluster 命令来创建和管理托管集群。要列出可用的参数，请输入以下命令： 

hcp create cluster <platform> --help 1
1
支持的平台包括 aws、代理 和 kubevirt。

1.7.4.1. 使用 CLI 安装托管的 control plane 命令行界面

您可以通过完成以下步骤，使用 CLI 安装托管的 control plane 命令行界面 hcp ：

  1. 运行以下命令，获取下载 hcp 二进制文件的 URL： 

    oc get ConsoleCLIDownload hcp-cli-download -o json | jq -r ".spec"

  2. 运行以下命令下载 hcp 二进制文件： 

    wget <hcp_cli_download_url> 1
    1
    将 hcp_cli_download_url 替换为您在上一步中获取的 URL。

  3. 运行以下命令来解包下载的归档： 

    tar xvzf hcp.tar.gz

  4. 运行以下命令使二进制文件可执行： 

    chmod +x hcp

  5. 运行以下命令，将二进制文件移到路径的目录中： 

    sudo mv hcp /usr/local/bin/.

1.7.4.2. 使用内容网关安装托管的 control plane 命令行界面

您可以使用内容网关安装托管的 control plane 命令行界面 hcp。完成以下步骤：

  1. 导航到 内容网关 并下载 hcp 二进制文件。

  2. 运行以下命令来解包下载的归档： 

    tar xvzf hcp.tar.gz

  3. 运行以下命令使二进制文件可执行： 

    chmod +x hcp

  4. 运行以下命令，将二进制文件移到路径的目录中： 

    sudo mv hcp /usr/local/bin/.

现在，您可以使用 hcp create cluster 命令来创建和管理托管集群。要列出可用的参数，请输入以下命令： 

hcp create cluster <platform> --help 1
1
支持的平台包括 aws、代理 和 kubevirt。

1.7.5. 分发托管集群工作负载

在开始为 OpenShift Container Platform 托管 control plane 之前，您必须标记节点，将托管的集群 pod 调度到基础架构节点。

节点标签确保以下功能：

  • 高可用性和正确的工作负载部署。例如，您可以设置 node-role.kubernetes.io/infra 标签，以避免将 control-plane 工作负载计数设置为 OpenShift Container Platform 订阅。
  • 使 control plane 工作负载与管理集群中的其他工作负载分开。

重要： 不要为您的工作负载使用管理集群。工作负载不得在 control plane 运行节点上运行。

1.7.5.1. 管理集群节点的标签和污点

作为管理集群管理员，在管理集群节点中使用以下标签和污点来调度 control plane 工作负载：

  • HyperShift.openshift.io/control-plane: true ：使用此标签和污点来专用节点来运行托管的 control plane 工作负载。通过设置 true，您可以避免将 control plane 节点与其他组件共享。
  • HyperShift.openshift.io/cluster: <hosted-control-plane-namespace > : 当您想要将节点专用于单个托管集群时使用此标签和污点。

在主机 control-plane pod 的节点上应用以下标签：

  • node-role.kubernetes.io/infra ：使用此标签以避免将 control-plane 工作负载计数设置为您的订阅。
  • topology.kubernetes.io/zone: 在管理集群节点上使用此标签，在故障域中部署高可用性集群。区域可能是设置该区域的节点的位置、机架名称或主机名。

要将每个机架用作管理集群节点的可用区，请输入以下命令：

+ 

oc label node/<management_node1_name> node/<management_node2_name> topology.kubernetes.io/zone=<rack_name>

托管集群的 Pod 具有容限，调度程序使用关联性规则来调度它们。调度程序将 pod 调度到标记为 hypershift.openshift.io/control-plane 和 hypershift.openshift.io/cluster: <hosted_control_plane_namespace > 的节点。

对于 ControllerAvailabilityPolicy 选项，使用 HighlyAvailable，这是托管 control planes 命令行界面 hcp 的默认值。当使用该选项时，您可以通过将 topology.kubernetes.io/zone 设置为拓扑键，在不同的故障域中为每个部署调度 pod。不支持没有高可用性的 control plane。

1.7.5.2. 为托管集群标记节点

重要： 在部署托管的 control plane 前，您必须将标签添加到节点。

要将在托管集群中运行的 pod 调度到基础架构节点，请在 HostedCluster 自定义资源(CR)中添加 role.kubernetes.io/infra: "" 标签。请参见以下示例： 

  spec:
    nodeSelector:
      role.kubernetes.io/infra: ""

1.7.5.3. 优先级类

四个内置优先级类会影响托管集群 pod 的优先级和抢占。您可以按照从高到低的顺序在管理集群中创建 pod：

  • HyperShift-operator: HyperShift Operator pod。
  • HyperShift-etcd: etcd 的 Pod。
  • HyperShift-api-critical ： API 调用和资源准入所需的 Pod 才能成功。此优先级类包括 kube-apiserver、聚合 API 服务器和 web hook 等 pod。
  • HyperShift-control-plane: control plane 中的 Pod 不是 API-critical，但仍需要提升优先级，如集群版本 Operator。

1.7.5.4. 其他资源

有关托管 control plane 的更多信息，请参阅以下主题：

1.7.6. 在 AWS 上配置托管的 control plane 集群（技术预览）

要配置托管的 control plane，您需要托管集群和一个托管的集群。通过使用 hypershift-addon 受管集群附加组件在现有受管集群上部署 HyperShift Operator，您可以将该集群启用为托管集群，并开始创建托管集群。hypershift-addon 受管集群附加组件默认为 multicluster engine operator 2.5 和 Red Hat Advanced Cluster Management 2.10 hub 集群中的 local-cluster 受管集群启用。

托管的集群 是一个 OpenShift Container Platform 集群，其 API 端点和托管在托管集群中的 control plane。托管的集群包括控制平面和它的对应的数据平面。您可以使用 multicluster engine operator 控制台或托管的 control plane 命令行界面 hcp 创建托管集群。托管的集群自动导入为受管集群。如果要禁用此自动导入功能，请参阅禁用将托管集群的自动导入到 multicluster engine operator。

重要：

  • 每个托管集群都必须具有集群范围的唯一名称。托管的集群名称不能与任何现有受管集群相同，以便 multicluster engine operator 管理它。
  • 不要使用 集群 作为托管的集群名称。
  • 在托管 control plane 的同一平台上运行 hub 集群和 worker。
  • 无法在 multicluster engine operator 受管集群的命名空间中创建托管集群。

1.7.6.1. 先决条件

您必须具有以下先决条件才能配置托管集群：

  • Kubernetes operator 2.5 及更新版本的多集群引擎安装在 OpenShift Container Platform 集群中。安装 Red Hat Advanced Cluster Management 时会自动安装 multicluster engine operator。在没有 Red Hat Advanced Cluster Management 作为来自 OpenShift Container Platform OperatorHub 的 Operator 的情况下，也可以安装 multicluster engine operator。

  • multicluster engine operator 必须至少有一个受管 OpenShift Container Platform 集群。local-cluster 在 multicluster engine operator 2.5 及更新的版本中自动导入。有关 local-cluster 的更多信息，请参阅高级配置。您可以运行以下命令来检查 hub 集群的状态： 

    oc get managedclusters local-cluster
  • AWS 命令行界面
  • 托管 control plane 命令行界面

有关托管 control plane 的其他资源，请参阅以下文档：

1.7.6.2. 创建 Amazon Web Services S3 存储桶和 S3 OIDC secret

如果您计划在 AWS 上创建和管理托管集群，请完成以下步骤：

  1. 创建一个 S3 存储桶，其具有集群托管 OIDC 发现文档的公共访问权限。

    • 要在 us-east-1 区域中创建存储桶，请输入以下代码： 

      aws s3api create-bucket --bucket <your-bucket-name>
aws s3api delete-public-access-block --bucket <your-bucket-name>
echo '{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": "*",
            "Action": "s3:GetObject",
            "Resource": "arn:aws:s3:::<your-bucket-name>/*"
        }
    ]
}' | envsubst > policy.json
aws s3api put-bucket-policy --bucket <your-bucket-name> --policy file://policy.json
    • 要在 us-east-1 区域以外的区域中创建存储桶，请输入以下代码： 
    aws s3api create-bucket --bucket <your-bucket-name> \
  --create-bucket-configuration LocationConstraint=<region> \
  --region <region>
aws s3api delete-public-access-block --bucket <your-bucket-name>
echo '{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": "*",
            "Action": "s3:GetObject",
            "Resource": "arn:aws:s3:::<your-bucket-name>/*"
        }
    ]
}' | envsubst > policy.json
aws s3api put-bucket-policy --bucket <your-bucket-name> --policy file://policy.json
  2. 为 HyperShift Operator 创建名为 hypershift-operator-oidc-provider-s3-credentials 的 OIDC S3 secret。
  3. 将 secret 保存到 local-cluster 命名空间中。

  4. 请参阅下表来验证 secret 是否包含以下字段：

    字段名称描述

    bucket

    包含对托管集群的主机 OIDC 发现文档的公共访问权限的 S3 存储桶。

    credentials

    对包含可以访问存储桶的 default 配置集凭证的文件的引用。默认情况下，HyperShift 仅使用 default 配置集来运行 bucket。

    region

    指定 S3 存储桶的区域。

    以下示例显示了 AWS secret 模板示例： 

    oc create secret generic hypershift-operator-oidc-provider-s3-credentials --from-file=credentials=<path>/.aws/credentials --from-literal=bucket=<s3-bucket-for-hypershift> --from-literal=region=<region> -n local-cluster

    注：不会自动启用 secret 的恢复备份。运行以下命令添加启用 hypershift-operator-oidc-provider-s3-credentials secret 的标签，以便为灾难恢复进行备份： 

    oc label secret hypershift-operator-oidc-provider-s3-credentials -n local-cluster cluster.open-cluster-management.io/backup=true

1.7.6.3. 创建可路由的公共区

要访问客户机集群中的应用程序，必须路由公共区。如果 public 区域存在，请跳过这一步。否则，公共区将影响现有功能。

运行以下命令为集群 DNS 记录创建一个公共区： 

aws route53 create-hosted-zone --name <your-basedomain> --caller-reference $(whoami)-$(date --rfc-3339=date)

将 your-basedomain 替换为您的基域，例如 www.example.com。

1.7.6.4. 启用外部 DNS

control plane 和数据平面在托管的 control plane 中分离。您可以在两个独立区域中配置 DNS：

  • 托管集群中工作负载的 Ingress，如以下域：.. apps.service-consumer-domain.com
  • 管理集群中的服务端点的 Ingress，如 API 或 OAUTH 端点，通过服务供应商域：... service-provider-domain.com

hostedCluster.spec.dns 的输入管理托管集群中工作负载的入口。hostedCluster.spec.services.servicePublishingStrategy.route.hostname 的输入管理管理集群中服务端点的入口。

外部 DNS 为托管的集群服务创建名称记录，用于指定 LoadBalancer 或 Route 的发布类型，并为该发布类型提供主机名。对于使用 Private 或 PublicAndPrivate 端点访问类型的托管集群，只有 APIServer 和 OAuth 服务支持主机名。对于私有集群，DNS 记录解析为 VPC 中 Virtual Private Cloud (VPC)端点的专用 IP 地址。

托管的 control plane 会公开以下服务：

  • APIServer
  • OAuthServer
  • Konnectivity
  • Ignition
  • OVNSbDb
  • OIDC

您可以使用 HostedCluster 规格中的 servicePublishingStrategy 字段公开这些服务。默认情况下，对于 LoadBalancer 和 Route 类型的 servicePublishingStrategy，您可以使用以下方法之一发布该服务：

  • 使用处于 LoadBalancer 类型的 Service 状态的负载均衡器的主机名
  • 使用 Route 资源的 status.host 字段

但是，当您在受管服务上下文中部署托管的 control plane 时，这些方法可以公开底层管理集群的 ingress 子域，以及管理集群生命周期和灾难恢复的限制选项。

当在 LoadBalancer 和 Route 发布类型上分层 DNS 间接时，受管服务操作员可以使用服务级别域发布所有公共托管的集群服务。此架构允许在 DNS 名称上重新映射到新的 LoadBalancer 或 Route，且不会公开管理集群的 ingress 域。托管 control plane 使用外部 DNS 实现该间接层。

您可以在管理集群的 hypershift 命名空间中部署 external-dns 和 HyperShift Operator。外部 DNS 监视具有 external-dns.alpha.kubernetes.io/hostname 注解的服务或路由。 该注解用于创建指向服务的 DNS 记录，如一个记录，或路由，如一个 CNAME 记录。

您只能在云环境中使用外部 DNS。对于其他环境，您需要手动配置 DNS 和服务。

有关外部 DNS 的更多信息，请参阅 外部 DNS。

1.7.6.4.1. 先决条件

在为托管的 control plane 设置外部 DNS 前，您必须满足以下先决条件：

  • 您创建了外部公共域
  • 您可以访问 AWS Route53 管理控制台
1.7.6.4.2. 为托管的 control plane 设置外部 DNS

要使用服务级别 DNS （外部 DNS）置备托管的 control plane 集群，请完成以下步骤：

  1. 为 HyperShift Operator 创建一个 AWS 凭证 secret，并在 local-cluster 命名空间中将其命名为 hypershift-operator-external-dns-credentials。

  2. 请参阅下表来验证 secret 是否具有所需字段：

    字段名称描述可选或必需的

    provider

    管理服务级别 DNS 区的 DNS 提供程序。

    必需

    domain-filter

    服务级别域。

    必需

    credentials

    支持所有外部 DNS 类型的凭据文件。

    当使用 AWS 密钥时可选

    aws-access-key-id

    凭证访问密钥 id。

    使用 AWS DNS 服务时的可选

    aws-secret-access-key

    凭证访问密钥 secret。

    使用 AWS DNS 服务时的可选

    以下示例显示了 hypershift-operator-external-dns-credentials secret 模板示例： 

    oc create secret generic hypershift-operator-external-dns-credentials --from-literal=provider=aws --from-literal=domain-filter=<domain_name> --from-file=credentials=<path_to_aws_credentials_file> -n local-cluster

    注：不会自动启用 secret 的恢复备份。要备份灾难恢复的 secret，请输入以下命令添加 hypershift-operator-external-dns-credentials ： 

    oc label secret hypershift-operator-external-dns-credentials -n local-cluster cluster.open-cluster-management.io/backup=""
1.7.6.4.3. 创建公共 DNS 托管区

External DNS Operator 使用公共 DNS 托管区来创建公共托管集群。

您可以创建公共 DNS 托管区，以用作外部 DNS domain-filter。在 AWS Route 53 管理控制台中完成以下步骤：

  1. 在 Route 53 管理控制台中，单击 Create hosted zone。
  2. 在 Hosted zone configuration 页面上，输入域名，验证 Publish 托管区域 是否选为类型，然后单击 Create hosted zone。
  3. 创建区域后，在 Records 选项卡上，记录 Value/Route 流量到 列中的值。
  4. 在主域中，创建一个 NS 记录，将 DNS 请求重定向到委派的区域。在 Value 字段中，输入您在上一步中记下的值。
  5. 点 Create records。

  6. 通过在新的子区中创建测试条目并使用类似以下示例的 dig 命令测试 DNS 托管区来验证 DNS 托管区是否正常工作： 

    dig +short test.user-dest-public.aws.kerberos.com
192.168.1.1

  7. 要创建为 LoadBalancer 和 Route 服务设置主机名的托管集群，请输入以下命令： 

    hcp create cluster aws --name=<hosted_cluster_name> --endpoint-access=PublicAndPrivate --external-dns-domain=<public_hosted_zone> ...

    将 <public_hosted_zone > 替换为您创建的公共托管区。

本例显示了为托管集群生成的 服务 块： 

  platform:
    aws:
      endpointAccess: PublicAndPrivate
...
  services:
  - service: APIServer
    servicePublishingStrategy:
      route:
        hostname: api-example.service-provider-domain.com
      type: Route
  - service: OAuthServer
    servicePublishingStrategy:
      route:
        hostname: oauth-example.service-provider-domain.com
      type: Route
  - service: Konnectivity
    servicePublishingStrategy:
      type: Route
  - service: Ignition
    servicePublishingStrategy:
      type: Route

Control Plane Operator 创建 Services 和 Routes 资源，并使用 external-dns.alpha.kubernetes.io/hostname 注解为它们添加注解。对于 Services 和 Routes，Control Plane Operator 在服务端点的 servicePublishingStrategy 字段中使用 hostname 参数的值。要创建 DNS 记录，您可以使用一个机制，如 external-dns 部署。

您只能为公共服务配置服务级别 DNS 间接。您无法为私有服务设置主机名，因为它们使用 hypershift.local 私有区。

下表包括在什么时候它可以用来对于服务和端点组合设置主机名：

服务公开PublicAndPrivate私有

APIServer

Y

Y

N

OAuthServer

Y

Y

N

Konnectivity

Y

N

N

Ignition

Y

N

N

1.7.6.4.4. 使用命令行界面和外部 DNS 部署集群

要使用 PublicAndPrivate 或 Public publish 策略创建托管集群，您必须在管理集群中配置以下工件：

  • 公共 DNS 托管区
  • External DNS Operator
  • HyperShift Operator

要使用命令行界面部署托管集群，请完成以下步骤：

  1. 要访问您的管理集群，请输入以下命令： 

    export KUBECONFIG=<path_to_management_cluster_kubeconfig>

  2. 输入以下命令验证外部 DNS Operator 是否正在运行： 

    oc get pod -n hypershift -lapp=external-dns

    请参见以下示例输出： 

    NAME                            READY   STATUS    RESTARTS   AGE
external-dns-7c89788c69-rn8gp   1/1     Running   0          40s

  3. 要使用外部 DNS 创建托管集群，请输入以下命令： 

    hypershift create cluster aws \
    --aws-creds <path_to_aws_credentials_file> \ 1
    --instance-type <instance_type> \ 2
    --region <region> \ 3
    --auto-repair \
    --generate-ssh \
    --name <hosted_cluster_name> \ 4
    --namespace clusters \
    --base-domain <service_consumer_domain> \ 5
    --node-pool-replicas <node_replica_count> \ 6
    --pull-secret <path_to_your_pull_secret> \ 7
    --release-image quay.io/openshift-release-dev/ocp-release:<ocp_release_image> \ 8
    --external-dns-domain=<service_provider_domain> \ 9
    --endpoint-access=PublicAndPrivate 10
    1
    指定 AWS 凭证文件的路径，例如 /user/name/.aws/credentials。
    2
    指定实例类型，如 m6i.xlarge。
    3
    指定 AWS 区域，如 us-east-1。
    4
    指定托管的集群名称，如 my-external-aws。
    5
    指定服务消费者拥有的公共托管区，如 service-consumer-domain.com。
    6
    指定节点副本数，例如 2。
    7
    指定 pull secret 文件的路径。
    8
    指定您要使用的 OpenShift Container Platform 版本，如 4.14.0-x86_64。
    9
    指定服务提供商拥有的公共托管区，如 service-provider-domain.com。
    10
    将 设置为 PublicAndPrivate。您只能在公共或 公共 配置中使用外部 DNS 和 PublicAndPrivate 配置。

1.7.6.6. 托管集群的灾难恢复

托管 control plane 在 multicluster engine operator hub 集群上运行。data plane 在您选择的独立平台上运行。当从灾难中恢复多集群引擎 operator hub 集群时，您可能还想恢复托管的 control plane。

请参阅 AWS 区域托管的集群的灾难恢复，以了解如何备份托管的 control plane 集群并在不同的集群中恢复它。

重要： 托管集群的灾难恢复只在 AWS 上可用。

1.7.6.7. 在 AWS 上部署托管集群

设置托管的 control plane 命令行界面后，hcp 并启用 local-cluster 作为托管集群，您可以通过完成以下步骤在 AWS 上部署托管集群。要部署私有集群，请参阅在 AWS 上部署私有集群。

  1. 要查看每个变量的描述，请运行以下命令： 

    hcp create cluster aws --help
  2. 验证您是否已登录到 hub 集群。

  3. 运行以下命令来创建托管集群： 

    hcp create cluster aws \
    --name <hosted_cluster_name> \ 1
    --infra-id <infra_id> \ 2
    --base-domain <basedomain> \ 3
    --aws-creds <path_to_aws_creds> \ 4
    --pull-secret <path_to_pull_secret> \ 5
    --region <region> \ 6
    --generate-ssh \
    --node-pool-replicas <node_pool_replica_count> \ 7
    --namespace <hosted_cluster_namespace> 8
1
指定托管集群的名称，例如。验证 & lt;hosted_cluster_name & gt; 和 <infra_id > 的值是否相同，否则集群可能无法在 Kubernetes operator 控制台的多集群引擎中正确显示。
2
指定基础架构的名称，例如 clc-name-hs1。
3
指定您的基域，如 dev09.red-chesterfield.com。
4
指定 AWS 凭证文件的路径，例如 /user/name/.aws/credentials。
5
指定 pull secret 的路径，例如 /user/name/pullsecret。
6
指定 AWS 区域名称，如 us-east-1。
7
指定节点池副本数，例如 2。
8
指定托管集群的命名空间，例如 clusters。

注： 默认情况下，所有 HostedCluster 和 NodePool 自定义资源都是在 集群 命名空间中创建的。如果指定了 --namespace <namespace& gt; 参数，则会在您选择的命名空间中创建 HostedCluster 和 NodePool 自定义资源。

  1. 您可以运行以下命令来检查托管集群的状态： 

    oc get hostedclusters -n <hosted_cluster_namespace>
  2. 您可以运行以下命令来检查节点池： 
oc get nodepools --namespace <hosted_cluster_namespace>

1.7.6.8. 在 AWS 的多个区中创建托管集群

输入以下命令创建集群，指定公共区的基域： 

hcp create cluster aws \
--name <hosted-cluster-name> \ 1
--node-pool-replicas=<node-pool-replica-count> \ 2
--base-domain <basedomain> \ 3
--pull-secret <path-to-pull-secret> \ 4
--aws-creds <path-to-aws-credentials> \ 5
--region <region> \ 6
--zones <zones> 7
1
指定托管集群的名称，例如。
2
指定节点池副本数，例如 2。
3
指定您的基域，如 example.com。
4
指定 pull secret 的路径，例如 /user/name/pullsecret。
5
指定 AWS 凭证文件的路径，例如 /user/name/.aws/credentials。
6
指定 AWS 区域名称，如 us-east-1。
7
指定 AWS 区域中的可用区，如 us-east-1a 和 us-east-1b。

对于每个指定区，会创建以下基础架构：

  • 公共子网
  • 专用子网
  • NAT 网关
  • 专用路由表（公共路由表在公共子网之间共享）

为每个区创建一个 NodePool 资源。节点池名称按区域名称后缀。区的专用子网在 spec.platform.aws.subnet.id 中设置。

1.7.6.8.1. 提供用于在 AWS 上创建托管集群的凭证

当使用 hcp create cluster aws 命令创建托管集群时，您需要提供具有为集群创建基础架构资源的 AWS 帐户凭证。基础架构资源示例包括 VPC、子网和 NAT 网关。您可以通过两种方式提供 AWS 凭证： 使用 --aws-creds 标志或使用 multicluster engine operator 中的 AWS 云供应商 secret。

1.7.6.8.1.1. 使用 --aws-creds 标志提供凭证

如果使用 --aws-creds 标志提供凭证，请将该标志与 AWS 凭证文件路径的值一起使用。

请参见以下示例： 

hcp create cluster aws \
--name <hosted-cluster-name> \ 1
--node-pool-replicas=<node-pool-replica-count> \ 2
--base-domain <basedomain> \ 3
--pull-secret <path-to-pull-secret> \ 4
--aws-creds <path-to-aws-credentials> \ 5
--region <region> 6
1
指定托管集群的名称，例如。
2
指定节点池副本数，例如 2。
3
指定您的基域，如 example.com。
4
指定 pull secret 的路径，例如 /user/name/pullsecret。
5
指定 AWS 凭证文件的路径，例如 /user/name/.aws/credentials。
6
指定 AWS 区域名称，如 us-east-1。
1.7.6.8.1.2. 使用 AWS 云供应商 secret 提供凭证

secret 包含 SSH 密钥、pull secret、基域和 AWS 凭证。因此，您可以使用 hcp create cluster aws 命令及 --secret-creds 标志来提供 AWS 凭证。请参见以下示例： 

hcp create cluster aws \
--name <hosted-cluster-name> \ 1
--region <region> \ 2
--namespace <hosted-cluster-namespace> \ 3
--secret-creds <my-aws-cred> 4
1
指定托管集群的名称，例如。
2
指定 AWS 区域名称，如 us-east-1。
3
如果 secret 不在 default 集群 命名空间中，请指定托管集群命名空间。
4
指定 AWS secret 名称，如 my-aws-cred。

使用此 secret 时，以下标记变为可选。如果您使用 --secret-creds 标志指定这些标记，则这些标志优先于云供应商 secret 中的值：

  • --aws-creds
  • --base-domain
  • --pull-secret
  • --ssh-key
  1. 要使用 {mce-shortF} 控制台创建 secret，从导航菜单中选择 Credentials 并按照控制台中的凭证创建步骤进行操作。

  2. 要在命令行中创建 secret，请输入以下命令： 

    $ oc create secret generic <my-secret> -n <namespace> --from-literal=baseDomain=<your-basedomain> --from-literal=aws_access_key_id=<your-aws-access-key> --from-literal=aws_secret_access_key=<your-aws-secret-key> --from-literal=pullSecret='{"auths":{"cloud.openshift.com":{"auth":"<auth>", "email":"<your-email>"}, "quay.io":{"auth":"<auth>", "email":"<your-email>"} } }' --from-literal=ssh-publickey=<your-ssh-publickey> --from-literal=ssh-privatekey=<your-ssh-privatekey>

    secret 具有以下格式： 

    apiVersion: v1
metadata:
  name: my-aws-cred 1
  namespace: clusters 2
type: Opaque
kind: Secret
stringData:
  ssh-publickey:          # Value
  ssh-privatekey:         # Value
  pullSecret:             # Value, required
  baseDomain:             # Value, required
  aws_secret_access_key:  # Value, required
  aws_access_key_id:      # Value, required
1.7.6.8.2. 其他资源

有关在托管集群中安装 AWS Elastic File Service (EFS) CSI Driver Operator 的说明，请参阅使用安全令牌服务配置 AWS EFS CSI Driver Operator。

1.7.6.9. 在 ARM64 OpenShift Container Platform 集群上启用托管的 control plane （技术预览）

您可以启用 ARM64-hosted control plane，以便在管理集群环境中使用 OpenShift Container Platform ARM64 data plane。此功能仅适用于 AWS 上的托管 control plane。

1.7.6.9.1. 先决条件

您必须在 64 位 ARM 基础架构上安装 OpenShift Container Platform 集群。如需更多信息，请参阅创建 OpenShift 集群：AWS (ARM)。

1.7.6.9.2. 在 ARM64 OpenShift Container Platform 集群上运行托管集群

要在 ARM64 OpenShift Container Platform 集群上运行托管集群，请完成以下步骤：

  1. 创建一个托管集群，以使用多架构发行镜像覆盖默认发行镜像。

    例如，通过托管的 control plane 命令行界面 hcp，输入以下命令，并将集群名称、节点池副本、基域、pull secret、AWS 凭证和区域替换为您的信息： 

    hcp create cluster aws \
--name $CLUSTER_NAME \
--node-pool-replicas=$NODEPOOL_REPLICAS \
--base-domain $BASE_DOMAIN \
--pull-secret $PULL_SECRET \
--aws-creds $AWS_CREDS \
--region $REGION \
--release-image quay.io/openshift-release-dev/ocp-release:4.13.0-rc.0-multi

    本例通过 --node-pool-replicas 标志添加默认的 NodePool 对象。

  2. 将 64 位 x_86 NodePool 对象添加到托管集群。

    例如，通过托管的 control plane 命令行界面 hcp，输入以下命令，将集群名称、节点池名称和节点池副本替换为您的信息： 

    hcp create nodepool aws \
--cluster-name $CLUSTER_NAME \
--name $NODEPOOL_NAME \
--node-count=$NODEPOOL_REPLICAS
1.7.6.9.3. 在 AWS 托管的集群中创建 ARM NodePool 对象

您可以在同一托管的 control plane 的 64 位 ARM 和 AMD64 上调度应用程序工作负载(NodePool 对象)。为此，您可以在 NodePool 规格中定义 arch 字段，以设置 NodePool 对象所需的处理器架构。arch 字段的有效值如下：

  • arm64
  • amd64

如果没有为 arch 字段指定值，则默认使用 amd64 值。

要在 AWS 上的托管集群上创建 ARM NodePool 对象，请完成以下步骤：

  1. 确保具有要使用的 HostedCluster 自定义资源的多架构镜像。您可以在每晚访问多架构 https://multi.ocp.releases.ci.openshift.org/。

    一个多架构镜像类似以下示例： 

    % oc image info quay.io/openshift-release-dev/ocp-release-nightly@sha256:9b992c71f77501678c091e3dc77c7be066816562efe3d352be18128b8e8fce94 -a ~/pull-secrets.json

error: the image is a manifest list and contains multiple images - use --filter-by-os to select from:

  OS            DIGEST
  linux/amd64   sha256:c9dc4d07788ebc384a3d399a0e17f80b62a282b2513062a13ea702a811794a60
  linux/ppc64le sha256:c59c99d6ff1fe7b85790e24166cfc448a3c2ac3ef3422fce3c7259e48d2c9aab
  linux/s390x   sha256:07fcd16d5bee95196479b1e6b5b3b8064dd5359dac75e3d81f0bd4be6b8fe208
  linux/arm64   sha256:1d93a6beccc83e2a4c56ecfc37e921fe73d8964247c1a3ec34c4d66f175d9b3d

  2. 通过在托管 control plane 命令行界面( hcp )上输入以下命令来呈现 NodePool 对象： 

    hcp create nodepool aws --cluster-name $CLUSTER_NAME --name $ARM64_NODEPOOL_NAME --node-count=$NODEPOOL_REPLICAS --render > arm_nodepool_spec.yml

    该命令创建一个 YAML 文件，用于指定 NodePool 对象的 CPU 架构，如下例所示： 

    apiVersion: hypershift.openshift.io/v1beta1
kind: NodePool
metadata:
  creationTimestamp: null
  name: hypershift-arm-us-east-1a
  namespace: clusters
spec:
  arch: amd64
  clusterName: hypershift-arm
  management:
    autoRepair: false
    upgradeType: Replace
  nodeDrainTimeout: 0s
  platform:
    aws:
      instanceProfile: hypershift-arm-2m289-worker
      instanceType: m5.large
      rootVolume:
        size: 120
        type: gp3
      securityGroups:
      - id: sg-064ea63968d258493
      subnet:
        id: subnet-02c74cf1cf1e7413f
    type: AWS
  release:
    image: quay.io/openshift-release-dev/ocp-release-nightly@sha256:390a33cebc940912a201a35ca03927ae5b058fbdae9626f7f4679786cab4fb1c
  replicas: 3
status:
  replicas: 0

  3. 输入以下命令修改 YAML 文件中的 arch 和 instanceType 值。在命令中，ARM 实例类型为 m6g.large，但任何 ARM 实例类型都可以正常工作： 

    sed 's/arch: amd64/arch: arm64/g; s/instanceType: m5.large/instanceType: m6g.large/g' arm_nodepool_spec.yml > temp.yml && mv temp.yml arm_nodepool_spec.yml

  4. 输入以下命令将渲染的 YAML 文件应用到托管集群： 

    oc apply -f arm_nodepool_spec.yml

1.7.6.10. 访问托管集群

您可以通过直接从资源获取 kubeconfig 文件和 kubeadmin 凭证，或使用 hcp 命令行界面生成 kubeconfig 文件来访问托管集群。

  • 要通过直接从资源获取 kubeconfig 文件和凭证来访问托管集群，您需要熟悉托管 control plane 集群的访问 secret。secret 存储在托管的集群（托管）命名空间中。托管的集群（托管） 命名空间包含托管的集群资源，托管的 control plane 命名空间是托管的 control plane 运行的位置。

    secret 名称格式如下：

    • kubeconfig secret: & lt;hosted-cluster-namespace>-<name>-admin-kubeconfig (clusters-hypershift-demo-admin-kubeconfig)

    • kubeadmin password secret: & lt;hosted-cluster-namespace>-<name>-kubeadmin-password (clusters-hypershift-demo-kubeadmin-password)

      kubeconfig secret 包含 Base64 编码的 kubeconfig 字段，您可以使用以下命令解码并保存到文件中： 

      oc --kubeconfig <hosted-cluster-name>.kubeconfig get nodes

    kubeadmin 密码 secret 也采用 Base64 编码。您可以解码它，并使用密码登录到托管的集群的 API 服务器或控制台。

  • 要使用 hcp CLI 访问托管集群来生成 kubeconfig 文件，请执行以下步骤：

    1. 输入以下命令生成 kubeconfig 文件： 

      hcp create kubeconfig --namespace <hosted-cluster-namespace> --name <hosted-cluster-name> > <hosted-cluster-name>.kubeconfig

    2. 保存 kubeconfig 文件后，您可以输入以下示例命令来访问托管集群： 

      oc --kubeconfig <hosted-cluster-name>.kubeconfig get nodes
1.7.6.10.1. 其他资源

访问托管集群后，您可以扩展节点池或为托管集群启用节点自动扩展。如需更多信息，请阅读以下主题：

要为托管集群配置节点性能优化，请查看以下主题：

1.7.6.11. 在 AWS 上部署私有集群（技术预览）

设置托管的 control plane 命令行界面后，hcp 并启用 local-cluster 作为托管集群，您可以在 AWS 上部署托管集群或私有托管集群。要在 AWS 上部署公共托管集群，请参阅在 AWS 上部署托管集群。

默认情况下，托管的 control plane 客户机集群可以通过公共 DNS 和管理集群的默认路由器进行公开访问。

对于 AWS 上的私有集群，所有与客户机集群的通信都通过 AWS PrivateLink 进行。要为 AWS 上的私有集群配置托管的 control plane，请执行以下步骤。

重要： 虽然公共集群可以在任何区域中创建，但只能在 --aws-private-region 指定的区域中创建私有集群。

1.7.6.11.1. 先决条件

要为 AWS 启用私有托管集群，您必须首先启用 AWS PrivateLink。如需更多信息，请参阅启用 AWS PrivateLink。

1.7.6.11.2. 在 AWS 上创建私有集群

  1. 输入以下命令来创建私有集群 IAM 策略文档： 

    cat << EOF >> policy.json
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "ec2:CreateVpcEndpointServiceConfiguration",
        "ec2:DescribeVpcEndpointServiceConfigurations",
        "ec2:DeleteVpcEndpointServiceConfigurations",
        "ec2:DescribeVpcEndpointServicePermissions",
        "ec2:ModifyVpcEndpointServicePermissions",
        "ec2:CreateTags",
        "elasticloadbalancing:DescribeLoadBalancers"
      ],
      "Resource": "\*"
    }
  ]
}

  2. 输入以下命令在 AWS 中创建 IAM 策略： 

    aws iam create-policy --policy-name=hypershift-operator-policy --policy-document=file://policy.json

  3. 输入以下命令来创建 hypershift-operator IAM 用户： 

    aws iam create-user --user-name=hypershift-operator

  4. 输入以下命令将策略附加到 hypershift-operator 用户，将 &lt ;policy-arn > 替换为您创建的策略的 ARN： 

    aws iam attach-user-policy --user-name=hypershift-operator --policy-arn=<policy-arn>

  5. 输入以下命令为用户创建 IAM 访问密钥： 

    aws iam create-access-key --user-name=hypershift-operator

  6. 输入以下命令创建私有集群，根据需要将变量替换为您的值： 

    hcp create cluster aws \
--name <hosted-cluster-name> \ 1
--node-pool-replicas=<node-pool-replica-count> \ 2
--base-domain <basedomain> \ 3
--pull-secret <path-to-pull-secret> \ 4
--aws-creds <path-to-aws-credentials> \ 5
--region <region> \ 6
--endpoint-access Private 7
    1 1
    指定托管集群的名称，例如。
    2 2
    指定节点池副本数，例如 3。
    3
    指定您的基域，如 example.com。
    4
    指定 pull secret 的路径，例如 /user/name/pullsecret。
    5
    指定 AWS 凭证文件的路径，例如 /user/name/.aws/credentials。
    6
    指定 AWS 区域名称，如 us-east-1。
    7
    定义集群是公共还是私有。

    集群的 API 端点可以通过私有 DNS 区域访问：

    • api.<hosted-cluster-name>.hypershift.local
    • *.apps.<hosted-cluster-name>.hypershift.local
1.7.6.11.3. 访问 AWS 上的私有托管集群

您可以使用堡垒实例访问私有集群。

  1. 输入以下命令启动堡垒实例： 

    hypershift create bastion aws --aws-creds=<aws-creds> --infra-id=<infra-id> --region=<region> --ssh-key-file=<ssh-key>

    将 <ssh-key > 替换为连接到堡垒的 SSH 公钥文件。SSH 公钥文件的默认位置为 ~/.ssh/id_rsa.pub。将 <aws-creds > 替换为 AWS 凭证文件的路径，例如 /user/name/.aws/credentials。

注： hypershift CLI 不适用于下载。使用以下命令，使用 hypershift 命名空间中存在的 HyperShift Operator pod 来提取它。将 <hypershift-operator-pod-name& gt; 替换为您的 HyperShift Operator pod 名称。 

oc project hypershift
oc rsync <hypershift-operator-pod-name>:/usr/bin/hypershift-no-cgo .
mv hypershift-no-cgo hypershift

  1. 输入以下命令在集群节点池中查找节点的专用 IP： 

    aws ec2 describe-instances --filter="Name=tag:kubernetes.io/cluster/<infra-id>,Values=owned" | jq '.Reservations[] | .Instances[] | select(.PublicDnsName=="") | .PrivateIpAddress'

  2. 输入以下命令为集群创建 kubeconfig 文件，它可以复制到节点： 

    hcp create kubeconfig > <cluster-kubeconfig>

  3. 输入以下命令使用 create bastion 命令打印的 IP 通过堡垒 SSH 到其中一个节点： 

    ssh -o ProxyCommand="ssh ec2-user@<bastion-ip> -W %h:%p" core@<node-ip>

  4. 在 SSH shell 中，输入以下命令将 kubeconfig 文件内容复制到节点上的文件中： 

    mv <path-to-kubeconfig-file> <new-file-name>

  5. 输入以下命令导出 kubeconfig 文件： 

    export KUBECONFIG=<path-to-kubeconfig-file>

  6. 输入以下命令观察客户机集群状态： 

    oc get clusteroperators clusterversion
1.7.6.11.4. 其他资源

有关在 AWS 上部署公共托管集群的更多信息，请参阅在 AWS 上部署托管集群。

1.7.6.12. 为托管 control plane 管理 AWS 基础架构和 IAM 权限（技术预览）

当您在 AWS 上为 Red Hat OpenShift Container Platform 使用托管的 control plane 时，基础架构要求会因您的设置而异。

1.7.6.12.1. 先决条件

您必须先配置托管的 control plane，然后才能创建托管的 control plane 集群。如需更多信息，请参阅在 AWS 上配置托管的 control plane 集群（技术预览）。

1.7.6.12.2. AWS 基础架构要求

当您在 AWS 上使用托管的 control plane 时，基础架构要求适合以下类别：

  • 在任意 AWS 帐户中为 HyperShift Operator 预必需和非受管基础架构
  • 托管的集群 AWS 帐户中的 Prerequired 和 unmanaged 基础架构
  • 在管理 AWS 帐户中托管 control planes 管理的基础架构
  • 在托管的集群 AWS 帐户中托管 control plane 管理的基础架构
  • 托管集群 AWS 帐户中的 Kubernetes 管理的基础架构

Prerequired 表示托管 control plane 需要 AWS 基础架构才能正常工作。Unmanaged 意味着没有 Operator 或控制器为您创建基础架构。以下小节包含有关创建 AWS 资源的详细信息。

1.7.6.12.2.1. 在任意 AWS 帐户中为 HyperShift Operator 预必需和非受管基础架构

任意 AWS 帐户取决于托管的 control plane 服务的供应商。

在自我管理的托管 control plane 中，集群服务提供商控制 AWS 帐户。集群服务提供商 是托管集群 control plane 的管理员，它负责正常运行时间。在托管的托管 control plane 中，AWS 帐户属于红帽。

在 HyperShift Operator 的预必需且非受管基础架构中，以下基础架构要求适用于管理集群 AWS 帐户：

  • 一个 S3 Bucket

    • OpenID Connect(OIDC)

  • 路由 53 托管区域

    • 托管托管集群的专用和公共条目的域
1.7.6.12.2.2. 托管的集群 AWS 帐户中的 Prerequired 和 unmanaged 基础架构

当您的基础架构在托管集群 AWS 帐户中预必需且非受管时，所有访问模式的基础架构要求如下：

  • 一个 VPC
  • 一个 DHCP 选项

  • 两个子网

    • 是内部数据平面子网的专用子网
    • 允许从数据平面访问互联网的公共子网
  • 一个互联网网关
  • 一个弹性 IP
  • 一个 NAT 网关
  • 一个安全组(worker 节点)
  • 两个路由表（一个私有和一个公共）
  • 两个 Route 53 托管区域

  • 有足够的配额用于以下项目：

    • 公共托管集群的一个 Ingress 服务负载均衡器
    • 私有托管集群的一个私有链接端点

注： 要使私有链路网络正常工作，托管集群 AWS 帐户中的端点区域必须与管理集群 AWS 帐户中的服务端点解析的实例区匹配。在 AWS 中，区域名称是别名，如 us-east-2b，它们不一定映射到不同帐户中的同一区域。因此，为了使私有链接正常工作，管理集群必须在其区域的所有区域中都有子网或 worker。

1.7.6.12.2.3. 在管理 AWS 帐户中托管 control planes 管理的基础架构

当您的基础架构由管理 AWS 帐户中的托管 control plane 管理时，基础架构要求因您的集群是公共、私有还是组合而不同。

对于具有公共集群的帐户，基础架构要求如下：

  • 网络负载均衡器：负载均衡器 Kube API 服务器

    • Kubernetes 创建一个安全组

  • 卷

    • 对于 etcd （取决于高可用性，一个或多个三个）
    • 对于 OVN-Kube

对于带有私有集群的帐户，基础架构要求如下：

  • 网络负载均衡器：负载均衡器私有路由器
  • 端点服务（专用链接）

对于具有公共和私有集群的帐户，基础架构要求如下：

  • 网络负载均衡器：负载均衡器公共路由器
  • 网络负载均衡器：负载均衡器私有路由器
  • 端点服务（专用链接）

  • 卷：

    • 对于 etcd （取决于高可用性，一个或多个三个）
    • 对于 OVN-Kube
1.7.6.12.2.4. 在托管的集群 AWS 帐户中托管 control plane 管理的基础架构

当您的基础架构由托管的集群 AWS 帐户中的托管 control plane 管理时，基础架构要求会有所不同，具体取决于您的集群是公共、私有还是组合。

对于具有公共集群的帐户，基础架构要求如下：

  • 节点池必须具有定义 Role 和 RolePolicy 的 EC2 实例。

对于带有私有集群的帐户，基础架构要求如下：

  • 每个可用区的一个私有链接端点
  • 用于节点池的 EC2 实例

对于具有公共和私有集群的帐户，基础架构要求如下：

  • 每个可用区的一个私有链接端点
  • 用于节点池的 EC2 实例
1.7.6.12.2.5. 托管集群 AWS 帐户中的 Kubernetes 管理的基础架构

当 Kubernetes 在托管集群 AWS 帐户中管理您的基础架构时，基础架构要求如下：

  • 默认入口的网络负载均衡器
  • registry 的 S3 存储桶
1.7.6.12.3. Identity and Access Management (IAM)权限

在托管 control plane 的上下文中，使用者负责创建 Amazon 资源名称(ARN)角色。使用者 是生成权限文件的自动过程。消费者可能是命令行界面或 OpenShift Cluster Manager。托管 control plane 尝试使粒度遵守最低特权组件的原则，这意味着每个组件都使用自己的角色来运行或创建 AWS 对象，并且角色仅限于产品正常正常工作所需的角色。

有关命令行界面如何创建 ARN 角色的示例，请参阅"单独创建 AWS 基础架构和 IAM 资源"。

托管的集群作为输入接收 ARN 角色，消费者为每个组件创建一个 AWS 权限配置。因此，组件可以通过 STS 和预配置的 OIDC IDP 进行身份验证。

以下角色由 control plane 上运行的托管 control plane 的一些组件使用，并在 data plane 上运行：

  • controlPlaneOperatorARN
  • imageRegistryARN
  • ingressARN
  • kubeCloudControllerARN
  • nodePoolManagementARN
  • storageARN
  • networkARN

以下示例显示了对来自托管集群的 IAM 角色的引用： 

...
endpointAccess: Public
  region: us-east-2
  resourceTags:
  - key: kubernetes.io/cluster/example-cluster-bz4j5
    value: owned
rolesRef:
    controlPlaneOperatorARN: arn:aws:iam::820196288204:role/example-cluster-bz4j5-control-plane-operator
    imageRegistryARN: arn:aws:iam::820196288204:role/example-cluster-bz4j5-openshift-image-registry
    ingressARN: arn:aws:iam::820196288204:role/example-cluster-bz4j5-openshift-ingress
    kubeCloudControllerARN: arn:aws:iam::820196288204:role/example-cluster-bz4j5-cloud-controller
    networkARN: arn:aws:iam::820196288204:role/example-cluster-bz4j5-cloud-network-config-controller
    nodePoolManagementARN: arn:aws:iam::820196288204:role/example-cluster-bz4j5-node-pool
    storageARN: arn:aws:iam::820196288204:role/example-cluster-bz4j5-aws-ebs-csi-driver-controller
type: AWS
...

托管 control plane 使用的角色在以下示例中显示：

  • ingressARN 

    {
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "elasticloadbalancing:DescribeLoadBalancers",
                "tag:GetResources",
                "route53:ListHostedZones"
            ],
            "Resource": "\*"
        },
        {
            "Effect": "Allow",
            "Action": [
                "route53:ChangeResourceRecordSets"
            ],
            "Resource": [
                "arn:aws:route53:::PUBLIC_ZONE_ID",
                "arn:aws:route53:::PRIVATE_ZONE_ID"
            ]
        }
    ]
}

  • imageRegistryARN 

    {
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "s3:CreateBucket",
                "s3:DeleteBucket",
                "s3:PutBucketTagging",
                "s3:GetBucketTagging",
                "s3:PutBucketPublicAccessBlock",
                "s3:GetBucketPublicAccessBlock",
                "s3:PutEncryptionConfiguration",
                "s3:GetEncryptionConfiguration",
                "s3:PutLifecycleConfiguration",
                "s3:GetLifecycleConfiguration",
                "s3:GetBucketLocation",
                "s3:ListBucket",
                "s3:GetObject",
                "s3:PutObject",
                "s3:DeleteObject",
                "s3:ListBucketMultipartUploads",
                "s3:AbortMultipartUpload",
                "s3:ListMultipartUploadParts"
            ],
            "Resource": "\*"
        }
    ]
}

  • storageARN 

    {
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "ec2:AttachVolume",
                "ec2:CreateSnapshot",
                "ec2:CreateTags",
                "ec2:CreateVolume",
                "ec2:DeleteSnapshot",
                "ec2:DeleteTags",
                "ec2:DeleteVolume",
                "ec2:DescribeInstances",
                "ec2:DescribeSnapshots",
                "ec2:DescribeTags",
                "ec2:DescribeVolumes",
                "ec2:DescribeVolumesModifications",
                "ec2:DetachVolume",
                "ec2:ModifyVolume"
            ],
            "Resource": "\*"
        }
    ]
}

  • networkARN 

    {
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "ec2:DescribeInstances",
                "ec2:DescribeInstanceStatus",
                "ec2:DescribeInstanceTypes",
                "ec2:UnassignPrivateIpAddresses",
                "ec2:AssignPrivateIpAddresses",
                "ec2:UnassignIpv6Addresses",
                "ec2:AssignIpv6Addresses",
                "ec2:DescribeSubnets",
                "ec2:DescribeNetworkInterfaces"
            ],
            "Resource": "\*"
        }
    ]
}

  • kubeCloudControllerARN 

    {
    "Version": "2012-10-17",
    "Statement": [
        {
            "Action": [
                "ec2:DescribeInstances",
                "ec2:DescribeImages",
                "ec2:DescribeRegions",
                "ec2:DescribeRouteTables",
                "ec2:DescribeSecurityGroups",
                "ec2:DescribeSubnets",
                "ec2:DescribeVolumes",
                "ec2:CreateSecurityGroup",
                "ec2:CreateTags",
                "ec2:CreateVolume",
                "ec2:ModifyInstanceAttribute",
                "ec2:ModifyVolume",
                "ec2:AttachVolume",
                "ec2:AuthorizeSecurityGroupIngress",
                "ec2:CreateRoute",
                "ec2:DeleteRoute",
                "ec2:DeleteSecurityGroup",
                "ec2:DeleteVolume",
                "ec2:DetachVolume",
                "ec2:RevokeSecurityGroupIngress",
                "ec2:DescribeVpcs",
                "elasticloadbalancing:AddTags",
                "elasticloadbalancing:AttachLoadBalancerToSubnets",
                "elasticloadbalancing:ApplySecurityGroupsToLoadBalancer",
                "elasticloadbalancing:CreateLoadBalancer",
                "elasticloadbalancing:CreateLoadBalancerPolicy",
                "elasticloadbalancing:CreateLoadBalancerListeners",
                "elasticloadbalancing:ConfigureHealthCheck",
                "elasticloadbalancing:DeleteLoadBalancer",
                "elasticloadbalancing:DeleteLoadBalancerListeners",
                "elasticloadbalancing:DescribeLoadBalancers",
                "elasticloadbalancing:DescribeLoadBalancerAttributes",
                "elasticloadbalancing:DetachLoadBalancerFromSubnets",
                "elasticloadbalancing:DeregisterInstancesFromLoadBalancer",
                "elasticloadbalancing:ModifyLoadBalancerAttributes",
                "elasticloadbalancing:RegisterInstancesWithLoadBalancer",
                "elasticloadbalancing:SetLoadBalancerPoliciesForBackendServer",
                "elasticloadbalancing:AddTags",
                "elasticloadbalancing:CreateListener",
                "elasticloadbalancing:CreateTargetGroup",
                "elasticloadbalancing:DeleteListener",
                "elasticloadbalancing:DeleteTargetGroup",
                "elasticloadbalancing:DescribeListeners",
                "elasticloadbalancing:DescribeLoadBalancerPolicies",
                "elasticloadbalancing:DescribeTargetGroups",
                "elasticloadbalancing:DescribeTargetHealth",
                "elasticloadbalancing:ModifyListener",
                "elasticloadbalancing:ModifyTargetGroup",
                "elasticloadbalancing:RegisterTargets",
                "elasticloadbalancing:SetLoadBalancerPoliciesOfListener",
                "iam:CreateServiceLinkedRole",
                "kms:DescribeKey"
            ],
            "Resource": [
                "\*"
            ],
            "Effect": "Allow"
        }
    ]
}

  • nodePoolManagementARN 

    {
    "Version": "2012-10-17",
    "Statement": [
        {
            "Action": [
                "ec2:AllocateAddress",
                "ec2:AssociateRouteTable",
                "ec2:AttachInternetGateway",
                "ec2:AuthorizeSecurityGroupIngress",
                "ec2:CreateInternetGateway",
                "ec2:CreateNatGateway",
                "ec2:CreateRoute",
                "ec2:CreateRouteTable",
                "ec2:CreateSecurityGroup",
                "ec2:CreateSubnet",
                "ec2:CreateTags",
                "ec2:DeleteInternetGateway",
                "ec2:DeleteNatGateway",
                "ec2:DeleteRouteTable",
                "ec2:DeleteSecurityGroup",
                "ec2:DeleteSubnet",
                "ec2:DeleteTags",
                "ec2:DescribeAccountAttributes",
                "ec2:DescribeAddresses",
                "ec2:DescribeAvailabilityZones",
                "ec2:DescribeImages",
                "ec2:DescribeInstances",
                "ec2:DescribeInternetGateways",
                "ec2:DescribeNatGateways",
                "ec2:DescribeNetworkInterfaces",
                "ec2:DescribeNetworkInterfaceAttribute",
                "ec2:DescribeRouteTables",
                "ec2:DescribeSecurityGroups",
                "ec2:DescribeSubnets",
                "ec2:DescribeVpcs",
                "ec2:DescribeVpcAttribute",
                "ec2:DescribeVolumes",
                "ec2:DetachInternetGateway",
                "ec2:DisassociateRouteTable",
                "ec2:DisassociateAddress",
                "ec2:ModifyInstanceAttribute",
                "ec2:ModifyNetworkInterfaceAttribute",
                "ec2:ModifySubnetAttribute",
                "ec2:ReleaseAddress",
                "ec2:RevokeSecurityGroupIngress",
                "ec2:RunInstances",
                "ec2:TerminateInstances",
                "tag:GetResources",
                "ec2:CreateLaunchTemplate",
                "ec2:CreateLaunchTemplateVersion",
                "ec2:DescribeLaunchTemplates",
                "ec2:DescribeLaunchTemplateVersions",
                "ec2:DeleteLaunchTemplate",
                "ec2:DeleteLaunchTemplateVersions"
            ],
            "Resource": [
                "\*"
            ],
            "Effect": "Allow"
        },
        {
            "Condition": {
                "StringLike": {
                    "iam:AWSServiceName": "elasticloadbalancing.amazonaws.com"
                }
            },
            "Action": [
                "iam:CreateServiceLinkedRole"
            ],
            "Resource": [
                "arn:*:iam::*:role/aws-service-role/elasticloadbalancing.amazonaws.com/AWSServiceRoleForElasticLoadBalancing"
            ],
            "Effect": "Allow"
        },
        {
            "Action": [
                "iam:PassRole"
            ],
            "Resource": [
                "arn:*:iam::*:role/*-worker-role"
            ],
            "Effect": "Allow"
        }
    ]
}

  • controlPlaneOperatorARN 

    {
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "ec2:CreateVpcEndpoint",
                "ec2:DescribeVpcEndpoints",
                "ec2:ModifyVpcEndpoint",
                "ec2:DeleteVpcEndpoints",
                "ec2:CreateTags",
                "route53:ListHostedZones"
            ],
            "Resource": "\*"
        },
        {
            "Effect": "Allow",
            "Action": [
                "route53:ChangeResourceRecordSets",
                "route53:ListResourceRecordSets"
            ],
            "Resource": "arn:aws:route53:::%s"
        }
    ]
}
1.7.6.12.4. 单独创建 AWS 基础架构和 IAM 资源

默认情况下，hcp create cluster aws 命令创建带有托管集群的云基础架构并应用它。您可以单独创建云基础架构部分，以便 hcp create cluster aws 命令只能用于创建集群，或者呈现它，以便在应用它前修改它。

要单独创建云基础架构部分，您需要创建 AWS 基础架构，创建 AWS Identity and Access (IAM)资源，并创建集群。

1.7.6.12.4.1. 创建 AWS 基础架构

运行以下命令来创建 AWS 基础架构： 

hypershift create infra aws --name CLUSTER_NAME \ 1
    --aws-creds AWS_CREDENTIALS_FILE \ 2
    --base-domain BASEDOMAIN \ 3
    --infra-id INFRA_ID \ 4
    --region REGION \ 5
    --output-file OUTPUT_INFRA_FILE 6
1
将 CLUSTER_NAME 替换为您要创建的托管集群的名称。这个值用于为集群创建 Route 53 私有托管区。
2
将 AWS_CREDENTIALS_FILE 替换为 AWS 凭证文件的名称，该文件具有为集群创建基础架构资源的权限，如 VPC、子网和 NAT 网关。这个值必须与 worker 所在的客户机集群的 AWS 帐户对应。
3
将 BASEDOMAIN 替换为您计划用于托管集群 Ingress 的基域的名称。这个值必须与您可以在其中创建记录的 Route 53 公共区对应。
4
将 INFRA_ID 替换为使用标签标识基础架构的唯一名称。这个值供 Kubernetes 中的云控制器管理器和集群 API 管理器使用，以识别集群的基础架构。通常，这个值是集群的名称(CLUSTER_NAME)，后缀附加到其中。
5
使用您要为集群创建基础架构的区域替换 REGION。
6
将 OUTPUT_INFRA_FILE 替换为您要以 JSON 格式存储基础架构的 ID 的文件名称。您可以使用此文件作为 hcp create cluster aws 命令的输入，来填充 HostedCluster 和 NodePool resouces 中的字段。

注： hypershift CLI 不适用于下载。使用以下命令，使用 hypershift 命名空间中存在的 HyperShift Operator pod 来提取它。将 <hypershift-operator-pod-name& gt; 替换为您的 HyperShift Operator pod 名称。

+ 

oc project hypershift
oc rsync <hypershift-operator-pod-name>:/usr/bin/hypershift-no-cgo .
mv hypershift-no-cgo hypershift

输入以下命令后，会创建以下资源：

  • 一个 VPC
  • 一个 DHCP 选项
  • 一个专用子网
  • 一个公共子网
  • 一个互联网网关
  • 一个 NAT 网关
  • 一个用于 worker 节点的安全组
  • 两个路由表：1 个私有和 1 个公共
  • 两个私有托管区：1 用于集群 Ingress，1 代表 PrivateLink，如果您创建一个私有集群

所有这些资源都包含 kubernetes.io/cluster/INFRA_ID=owned 标签，其中 INFRA_ID 是您在命令中指定的值。

1.7.6.12.4.2. 创建 AWS IAM 资源

运行以下命令来创建 AWS IAM 资源： 

hypershift create iam aws --infra-id INFRA_ID \ 1
    --aws-creds AWS_CREDENTIALS_FILE \ 2
    --oidc-storage-provider-s3-bucket-name OIDC_BUCKET_NAME \ 3
    --oidc-storage-provider-s3-region OIDC_BUCKET_REGION \ 4
    --region REGION \ 5
    --public-zone-id PUBLIC_ZONE_ID \ 6
    --private-zone-id PRIVATE_ZONE_ID \ 7
    --local-zone-id LOCAL_ZONE_ID \ 8
    --output-file OUTPUT_IAM_FILE 9
1
将 INFRA_ID 替换为您在 create infra aws 命令中指定的相同 ID。这个值标识与托管集群关联的 IAM 资源。
2
将 AWS_CREDENTIALS_FILE 替换为具有创建 IAM 资源权限的 AWS 凭证文件的名称，如角色。此文件不需要是您为创建基础架构指定的相同凭据文件，但它必须与相同的 AWS 帐户对应。
3
将 OIDC_BUCKET_NAME 替换为存储 OIDC 文档的存储桶的名称。此存储桶是作为安装托管 control plane 的先决条件创建的。bucket 的名称用于为这个命令创建的 OIDC 供应商构建 URL。
4
将 OIDC_BUCKET_REGION 替换为 OIDC 存储桶所在的区域。
5
将 REGION 替换为集群基础架构所在的区域。这个值用于为属于托管集群的机器创建 worker 实例配置集。
6
将 PUBLIC_ZONE_ID 替换为客户机集群公共区的 ID。这个值用于为 Ingress Operator 创建策略。您可以在 create infra aws 命令生成的 OUTPUT_INFRA_FILE 中找到这个值。
7
将 PRIVATE_ZONE_ID 替换为客户机集群的私有区 ID。这个值用于为 Ingress Operator 创建策略。您可以在 create infra aws 命令生成的 OUTPUT_INFRA_FILE 中找到这个值。
8
在创建私有集群时，将 LOCAL_ZONE_ID 替换为客户机集群的本地区 ID。这个值用于为 Control Plane Operator 创建策略，以便它可以管理 PrivateLink 端点的记录。您可以在 create infra aws 命令生成的 OUTPUT_INFRA_FILE 中找到这个值。
9
将 OUTPUT_IAM_FILE 替换为计划以 JSON 格式存储 IAM 资源的 ID 的文件名称。然后，您可以使用此文件作为 hcp create cluster aws 命令的输入，来填充 HostedCluster 和 NodePool 资源中的字段。

输入以下命令后，会创建以下资源：

  • 一个 OIDC 供应商，需要启用 STS 验证
  • 七家角色，每个组件都分开与提供程序交互，如 Kubernetes 控制器管理器、集群 API 供应商和 registry
  • 一个实例配置集，它是分配给集群中的所有 worker 实例的配置集
1.7.6.12.4.3. 创建集群

运行以下命令来创建集群： 

hcp create cluster aws \
    --infra-id INFRA_ID \ 1
    --name CLUSTER_NAME \ 2
    --aws-creds AWS_CREDENTIALS \ 3
    --pull-secret PULL_SECRET_FILE \ 4
    --generate-ssh \ 5
    --node-pool-replicas 3
1
将 INFRA_ID 替换为您在 create infra aws 命令中指定的相同 ID。这个值标识与托管集群关联的 IAM 资源。
2
将 CLUSTER_NAME 替换为您在 create infra aws 命令中指定的相同名称。
3
将 AWS_CREDENTIALS 替换为您在 create infra aws 命令中指定的相同值。
4
将 PULL_SECRET_FILE 替换为包含有效 OpenShift Container Platform pull secret 的文件的名称。
5
--generate-ssh 标志是可选的，但在您需要 SSH 到 worker 时包括。为您生成 SSH 密钥，并作为 secret 存储在与托管集群相同的命名空间中。

您还可以在命令中添加 --render 标志，并将输出重定向到可编辑资源的文件，然后再将它们应用到集群。

运行命令后，以下资源会应用到集群：

  • 一个命名空间
  • 带有 pull secret 的 secret
  • A HostedCluster
  • A NodePool
  • control plane 组件的三个 AWS STS secret
  • 如果您指定了 --generate-ssh 标志，则一个 SSH 密钥 secret。

1.7.6.13. 销毁 AWS 上的托管集群

要销毁托管的集群及其受管集群资源，请完成以下步骤：

  1. 运行以下命令，删除 multicluster engine operator 上的受管集群资源： 

    oc delete managedcluster <managed_cluster_name>

    其中 <managed_cluster_name > 是受管集群的名称。

  2. 运行以下命令来删除托管集群及其后端资源： 

    hcp destroy cluster aws --name <hosted_cluster_name> --infra-id <infra_id> --aws-creds <path_to_aws_creds> --base-domain <basedomain>

    根据需要替换名称。

1.7.7. 在裸机上配置托管的 control plane 集群

您可以通过将集群配置为充当托管集群来部署托管 control plane。托管的集群是托管 control plane 的 OpenShift Container Platform 集群。托管集群也称为 管理集群。

注： 管理集群 与受管集群 不同。受管集群是一个 hub 集群管理的集群。

托管的 control plane 功能默认启用。

multicluster engine operator 2.5 仅支持默认的 local-cluster，它是一个托管的 hub 集群，以及 hub 集群作为托管集群。在 Red Hat Advanced Cluster Management 2.10 中，您可以使用受管 hub 集群（也称为 local-cluster ），作为托管集群。

托管的集群 是一个 OpenShift Container Platform 集群，其 API 端点和托管在托管集群中的 control plane。托管的集群包括控制平面和它的对应的数据平面。您可以使用 multicluster engine operator 控制台或托管的 control plane 命令行界面 hcp 创建托管集群。托管的集群自动导入为受管集群。如果要禁用此自动导入功能，请参阅禁用将托管集群的自动导入到 multicluster engine operator。

重要：

  • 在托管 control plane 的同一平台上运行 hub 集群和 worker。
  • 每个托管集群都必须具有集群范围的唯一名称。托管的集群名称不能与任何现有受管集群相同，以便 multicluster engine operator 管理它。
  • 不要使用 集群 作为托管的集群名称。
  • 无法在 multicluster engine operator 受管集群的命名空间中创建托管集群。
  • 要在裸机上置备托管的 control plane，您可以使用 Agent 平台。Agent 平台使用中央基础架构管理服务将 worker 节点添加到托管集群。有关中央基础架构管理服务简介，请参阅 启用中央基础架构管理服务。
  • 所有裸机主机都需要使用中央基础架构管理提供的发现镜像 ISO 手动引导。您可以使用 Cluster-Baremetal-Operator 手动启动主机或通过自动化启动主机。每个主机启动后，它运行一个 Agent 进程来发现主机详情并完成安装。Agent 自定义资源代表每个主机。
  • 当使用 Agent 平台创建托管集群时，HyperShift 在托管的 control plane 命名空间中安装 Agent Cluster API 供应商。
  • 当您根据节点池扩展副本时，会创建一个机器。对于每台机器，Cluster API 供应商找到并安装满足节点池规格中指定的要求的 Agent。您可以通过检查其状态和条件来监控代理的安装。
  • 当您缩减节点池时，代理会从对应的集群中绑定。在重复使用代理前，您必须使用 Discovery 镜像重启它们。
  • 当您为托管 control plane 配置存储时，请考虑推荐的 etcd 实践。要确保您满足延迟要求，请将快速存储设备专用于每个 control-plane 节点上运行的所有托管的 control plane etcd 实例。您可以使用 LVM 存储为托管 etcd pod 配置本地存储类。如需更多信息，请参阅 OpenShift Container Platform 文档中的使用逻辑卷管理器存储 的建议 etcd 实践 和持久性存储。

1.7.7.1. 先决条件

您必须具有以下先决条件才能配置托管集群：

  • 您需要 multicluster engine for Kubernetes operator 2.2 及之后的版本安装在 OpenShift Container Platform 集群中。安装 Red Hat Advanced Cluster Management 时会自动安装 multicluster engine operator。您还可以在没有 Red Hat Advanced Cluster Management 作为 OpenShift Container Platform OperatorHub 的 Operator 的情况下安装 multicluster engine operator。

  • multicluster engine operator 必须至少有一个受管 OpenShift Container Platform 集群。local-cluster 在多集群引擎 operator 2.2 及更新的版本中自动导入。有关 local-cluster 的更多信息，请参阅高级配置。您可以运行以下命令来检查 hub 集群的状态： 

    oc get managedclusters local-cluster
  • 您必须将 topology.kubernetes.io/zone 标签添加到管理集群中的裸机主机。否则，所有托管的 control plane pod 都会调度到单个节点上，从而导致单点故障。
  • 您需要启用中央基础架构管理。如需更多信息 ，请参阅启用中央基础架构管理服务。
  • 您需要安装托管的 control plane 命令行界面。
  • 对于具有访问托管集群 API 端点的 hub 集群，请将所有托管集群 API 端点添加到 Proxy 对象的 noProxy 字段中。如需更多信息，请参阅 配置集群范围代理。

1.7.7.2. 裸机防火墙、端口和服务要求

您必须满足防火墙、端口和服务要求，以便端口可以在管理集群、control plane 和托管的集群间进行通信。

注： 服务在其默认端口上运行。但是，如果您使用 NodePort 发布策略，服务在由 NodePort 服务分配的端口上运行。

使用防火墙规则、安全组或其他访问控制来限制对所需源的访问。除非必要，否则请避免公开端口。对于生产环境部署，请使用负载均衡器通过单个 IP 地址简化访问。

托管的 control plane 在裸机上公开以下服务：

  • APIServer

    • APIServer 服务默认在端口 6443 上运行，并且需要入口访问才能在 control plane 组件之间的通信。
    • 如果使用 MetalLB 负载均衡，允许对用于负载均衡器 IP 地址的 IP 范围进行入口访问。

  • OAuthServer

    • 当您使用路由和入口来公开服务时，OAuthServer 服务默认在端口 443 上运行。
    • 如果使用 NodePort 发布策略，请为 OAuthServer 服务使用防火墙规则。

  • Konnectivity

    • 当您使用路由和入口来公开服务时，Konnectivity 服务默认在端口 443 上运行。
    • Konnectivity 代理（建立反向隧道来允许托管的集群中的双向通信）需要在端口 6443 上出口访问集群 API 服务器地址。通过该出口访问，代理可以访问 APIServer 服务。
    • 如果集群 API 服务器地址是一个内部 IP 地址，允许从工作负载子网访问端口 6443 上的 IP 地址。
    • 如果地址是一个外部 IP 地址，允许将端口 6443 上的出口从节点传输到该外部 IP 地址。

  • Ignition

    • 当使用路由和入口来公开服务时，Ignition 服务默认在端口 443 上运行。
    • 如果使用 NodePort 发布策略，请为 Ignition 服务使用防火墙规则。

在裸机上不需要以下服务：

  • OVNSbDb
  • OIDC

1.7.7.3. 裸机基础架构要求

Agent 平台不创建任何基础架构，但它对基础架构有以下要求：

  • Agent ：代理代表使用发现镜像引导的主机，并准备好作为 OpenShift Container Platform 节点置备。
  • DNS ：API 和入口端点必须可以被路由。

有关裸机上托管 control plane 的其他资源，请参阅以下文档：

1.7.7.4. 在裸机上配置 DNS

托管集群的 API 服务器作为 NodePort 服务公开。必须存在 api.${HOSTED_CLUSTER_NAME}.${BASEDOMAIN} 的 DNS 条目，指向可访问 API 服务器的目的地。

DNS 条目可以像一个记录一样简单，指向运行托管 control plane 的受管集群中的一个节点。该条目也可以指向部署的负载均衡器，以将传入的流量重定向到入口 pod。

  • 请参见以下 DNS 配置示例： 

    api.example.krnl.es.    IN A 192.168.122.20
api.example.krnl.es.    IN A 192.168.122.21
api.example.krnl.es.    IN A 192.168.122.22
api-int.example.krnl.es.    IN A 192.168.122.20
api-int.example.krnl.es.    IN A 192.168.122.21
api-int.example.krnl.es.    IN A 192.168.122.22
`*`.apps.example.krnl.es. IN A 192.168.122.23

  • 如果您要为 IPv6 网络上的断开连接的环境配置 DNS，请查看以下 DNS 配置示例： 

    api.example.krnl.es.    IN A 2620:52:0:1306::5
api.example.krnl.es.    IN A 2620:52:0:1306::6
api.example.krnl.es.    IN A 2620:52:0:1306::7
api-int.example.krnl.es.    IN A 2620:52:0:1306::5
api-int.example.krnl.es.    IN A 2620:52:0:1306::6
api-int.example.krnl.es.    IN A 2620:52:0:1306::7
`*`.apps.example.krnl.es. IN A 2620:52:0:1306::10

  • 如果您要为双栈网络上的断开连接的环境配置 DNS，请确保同时包含 IPv4 和 IPv6 的 DNS 条目。请参见以下 DNS 配置示例： 

    host-record=api-int.hub-dual.dns.base.domain.name,192.168.126.10
host-record=api.hub-dual.dns.base.domain.name,192.168.126.10
address=/apps.hub-dual.dns.base.domain.name/192.168.126.11
dhcp-host=aa:aa:aa:aa:10:01,ocp-master-0,192.168.126.20
dhcp-host=aa:aa:aa:aa:10:02,ocp-master-1,192.168.126.21
dhcp-host=aa:aa:aa:aa:10:03,ocp-master-2,192.168.126.22
dhcp-host=aa:aa:aa:aa:10:06,ocp-installer,192.168.126.25
dhcp-host=aa:aa:aa:aa:10:07,ocp-bootstrap,192.168.126.26

host-record=api-int.hub-dual.dns.base.domain.name,2620:52:0:1306::2
host-record=api.hub-dual.dns.base.domain.name,2620:52:0:1306::2
address=/apps.hub-dual.dns.base.domain.name/2620:52:0:1306::3
dhcp-host=aa:aa:aa:aa:10:01,ocp-master-0,[2620:52:0:1306::5]
dhcp-host=aa:aa:aa:aa:10:02,ocp-master-1,[2620:52:0:1306::6]
dhcp-host=aa:aa:aa:aa:10:03,ocp-master-2,[2620:52:0:1306::7]
dhcp-host=aa:aa:aa:aa:10:06,ocp-installer,[2620:52:0:1306::8]
dhcp-host=aa:aa:aa:aa:10:07,ocp-bootstrap,[2620:52:0:1306::9]

接下来，在裸机上托管 control plane 创建主机清单。

1.7.7.5. 在裸机上创建托管集群

您可以在裸机上创建托管集群，或导入一个集群。有关导入托管集群的步骤，请参阅 导入托管集群。

  1. 输入以下命令来创建托管的 control plane 命名空间： 

    oc create ns <hosted_cluster_namespace>-<hosted_cluster_name>

    将 <hosted_cluster_namespace > 替换为托管的集群命名空间名称，例如 集群。将 <hosted_cluster_name > 替换为您的托管的集群名称。

  2. 验证您是否为集群配置了默认存储类。否则，您可能会看到待处理的 PVC。运行以下命令: 

    hcp create cluster agent \
    --name=<hosted_cluster_name> \ 1
    --pull-secret=<path_to_pull_secret> \ 2
    --agent-namespace=<hosted_control_plane_namespace> \ 3
    --base-domain=<basedomain> \ 4
    --api-server-address=api.<hosted_cluster_name>.<basedomain> \
    --etcd-storage-class=<etcd_storage_class> \ 5
    --ssh-key  <path_to_ssh_public_key> \ 6
    --namespace <hosted_cluster_namespace> \ 7
    --control-plane-availability-policy SingleReplica \
    --release-image=quay.io/openshift-release-dev/ocp-release:<ocp_release_image> 8
    1
    指定托管集群的名称，例如。
    2
    指定 pull secret 的路径，例如 /user/name/pullsecret。
    3
    指定托管的 control plane 命名空间，如 cluster -example。使用 oc get agent -n <hosted_control_plane_namespace> 命令确保代理在这个命名空间中 可用。
    4
    指定您的基域，如 krnl.es。
    5
    指定 etcd 存储类名称，例如 lvm-storageclass。
    6
    指定 SSH 公钥的路径。默认文件路径为 ~/.ssh/id_rsa.pub。
    7
    指定托管集群的命名空间。
    8
    指定您要使用的 OpenShift Container Platform 版本，如 4.14.0-x86_64。如果您使用断开连接的环境，将 < ocp_release_image&gt; 替换为摘要镜像。要提取 OpenShift Container Platform 发行镜像摘要，请参阅 提取 OpenShift Container Platform 发行镜像摘要。

  3. 片刻后，输入以下命令验证托管的 control plane pod 是否正在运行： 

    oc -n <hosted_control_plane_namespace> get pods

    请参见以下示例输出： 

    NAME                                             READY   STATUS    RESTARTS   AGE
capi-provider-7dcf5fc4c4-nr9sq                   1/1     Running   0          4m32s
catalog-operator-6cd867cc7-phb2q                 2/2     Running   0          2m50s
certified-operators-catalog-884c756c4-zdt64      1/1     Running   0          2m51s
cluster-api-f75d86f8c-56wfz                      1/1     Running   0          4m32s
1.7.7.5.1. 使用控制台在裸机上创建托管集群
  1. 打开 OpenShift Container Platform Web 控制台，并通过输入管理员凭证登录。有关打开控制台的说明，请参阅 OpenShift Container Platform 文档中的 访问 Web 控制台。
  2. 在控制台标头中，确保选择了 All Clusters。
  3. 点 Infrastructure > Clusters。

  4. 点 Create cluster > Host inventory > Hosted control plane。

    此时会显示 Create cluster 页面。

  5. 在 Create cluster 页面中，按照提示输入集群、节点池、网络和自动化的详情。

    注： 当您输入集群详情时，您可能会发现以下有用提示：

    • 如果要使用预定义的值来自动填充控制台中的字段，您可以创建主机清单凭证。如需更多信息，请参阅 为内部环境创建凭证。
    • 在 Cluster details 页面中，pull secret 是用于访问 OpenShift Container Platform 资源的 OpenShift Container Platform pull secret。如果选择了主机清单凭证，则会自动填充 pull secret。
    • 在 Node pool 页面中，命名空间包含节点池的主机。如果使用控制台创建主机清单，控制台会创建一个专用命名空间。
    • 在 Networking 页面中，您可以选择 API 服务器发布策略。托管集群的 API 服务器可以通过使用现有的负载均衡器或 NodePort 类型的服务公开。必须存在 api.${HOSTED_CLUSTER_NAME}.${BASEDOMAIN} 设置的 DNS 条目，该设置指向可访问 API 服务器的目的地。此条目可以是指向管理集群中的一个节点的记录，或指向将传入的流量重定向到 Ingress pod 的负载均衡器的记录。

  6. 检查您的条目并点 Create。

    此时会显示 Hosted 集群 视图。

  7. 在 Hosted 集群 视图中监控托管集群的部署。
  8. 如果没有看到有关托管集群的信息，请确保选择了 All Clusters，然后点集群名称。
  9. 等待 control plane 组件就绪。这个过程可能需要几分钟时间。
  10. 要查看节点池状态，可滚动到 NodePool 部分。安装节点的过程大约需要 10 分钟。您还可以单击 Nodes 来确认节点是否加入托管集群。
1.7.7.5.2. 使用镜像 registry 在裸机上创建托管集群

您可以通过在 hcp create cluster 命令中指定 --image-content-sources 标志，使用镜像 registry 在裸机上创建托管集群。完成以下步骤：

  1. 创建 YAML 文件以定义镜像内容源策略(ICSP)。请参见以下示例： 

    - mirrors:
  - brew.registry.redhat.io
  source: registry.redhat.io
- mirrors:
  - brew.registry.redhat.io
  source: registry.stage.redhat.io
- mirrors:
  - brew.registry.redhat.io
  source: registry-proxy.engineering.redhat.com
  2. 将文件保存为 icsp.yaml。此文件包含您的镜像 registry。

  3. 要使用您的镜像 registry 创建托管集群，请运行以下命令： 

    hcp create cluster agent \
    --name=<hosted_cluster_name> \ 1
    --pull-secret=<path_to_pull_secret> \ 2
    --agent-namespace=<hosted_control_plane_namespace> \ 3
    --base-domain=<basedomain> \ 4
    --api-server-address=api.<hosted_cluster_name>.<basedomain> \
    --image-content-sources icsp.yaml  \ 5
    --ssh-key  <path_to_ssh_key> \ 6
    --namespace <hosted_cluster_namespace> \ 7
    --release-image=quay.io/openshift-release-dev/ocp-release:<ocp_release_image> 8
    1
    指定托管集群的名称，例如。
    2
    指定 pull secret 的路径，例如 /user/name/pullsecret。
    3
    指定托管的 control plane 命名空间，如 cluster -example。使用 oc get agent -n <hosted-control-plane-namespace> 命令来确保代理在此命名空间中 可用。
    4
    指定您的基域，如 krnl.es。
    5
    指定定义 ICSP 和您的镜像 registry 的 icsp.yaml 文件。
    6
    指定 SSH 公钥的路径。默认文件路径为 ~/.ssh/id_rsa.pub。
    7
    指定托管集群的命名空间。
    8
    指定您要使用的 OpenShift Container Platform 版本，如 4.14.0-x86_64。如果您使用断开连接的环境，将 < ocp_release_image&gt; 替换为摘要镜像。要提取 OpenShift Container Platform 发行镜像摘要，请参阅 提取 OpenShift Container Platform 发行镜像摘要。
1.7.7.5.3. 其他资源

1.7.7.6. 验证托管集群创建

部署过程完成后，您可以验证托管集群是否已成功创建。在创建托管集群后，按照以下步骤操作。

  1. 输入 extract 命令获取新托管集群的 kubeconfig ： 

    oc extract -n <hosted-control-plane-namespace> secret/admin-kubeconfig --to=- > kubeconfig-<hosted-cluster-name>

  2. 使用 kubeconfig 查看托管集群的集群 Operator。输入以下命令： 

    oc get co --kubeconfig=kubeconfig-<hosted-cluster-name>

    请参见以下示例输出： 

    NAME                                       VERSION   AVAILABLE   PROGRESSING   DEGRADED   SINCE   MESSAGE
console                                    4.10.26   True        False         False      2m38s
dns                                        4.10.26   True        False         False      2m52s
image-registry                             4.10.26   True        False         False      2m8s
ingress                                    4.10.26   True        False         False      22m

  3. 您还可以输入以下命令查看托管集群中运行的 pod： 

    oc get pods -A --kubeconfig=kubeconfig-<hosted-cluster-name>

    请参见以下示例输出： 

    NAMESPACE                                          NAME                                                      READY   STATUS             RESTARTS        AGE
kube-system                                        konnectivity-agent-khlqv                                  0/1     Running            0               3m52s
openshift-cluster-node-tuning-operator             tuned-dhw5p                                               1/1     Running            0               109s
openshift-cluster-storage-operator                 cluster-storage-operator-5f784969f5-vwzgz                 1/1     Running            1 (113s ago)    20m
openshift-cluster-storage-operator                 csi-snapshot-controller-6b7687b7d9-7nrfw                  1/1     Running            0               3m8s
openshift-console                                  console-5cbf6c7969-6gk6z                                  1/1     Running            0               119s
openshift-console                                  downloads-7bcd756565-6wj5j                                1/1     Running            0               4m3s
openshift-dns-operator                             dns-operator-77d755cd8c-xjfbn                             2/2     Running            0               21m
openshift-dns                                      dns-default-kfqnh                                         2/2     Running            0               113s

1.7.7.7. 为托管集群扩展 NodePool 对象

您可以通过将节点添加到托管集群来扩展 NodePool 对象。

  1. 将 NodePool 对象扩展到两个节点： 

    oc -n <hosted-cluster-namespace> scale nodepool <nodepool-name> --replicas 2

    Cluster API 代理供应商随机选择两个代理，然后分配给托管集群。这些代理通过不同的状态，最后将托管集群作为 OpenShift Container Platform 节点加入。代理按以下顺序传递状态：

    • binding
    • 发现
    • insufficient
    • 安装
    • installing-in-progress
    • added-to-existing-cluster

  2. 输入以下命令： 

    oc -n <hosted-control-plane-namespace> get agent

    请参见以下示例输出： 

    NAME                                   CLUSTER         APPROVED   ROLE          STAGE
4dac1ab2-7dd5-4894-a220-6a3473b67ee6   hypercluster1   true       auto-assign
d9198891-39f4-4930-a679-65fb142b108b                   true       auto-assign
da503cf1-a347-44f2-875c-4960ddb04091   hypercluster1   true       auto-assign

  3. 输入以下命令： 

    oc -n <hosted-control-plane-namespace> get agent -o jsonpath='{range .items[*]}BMH: {@.metadata.labels.agent-install\.openshift\.io/bmh} Agent: {@.metadata.name} State: {@.status.debugInfo.state}{"\n"}{end}'

    请参见以下示例输出： 

    BMH: ocp-worker-2 Agent: 4dac1ab2-7dd5-4894-a220-6a3473b67ee6 State: binding
BMH: ocp-worker-0 Agent: d9198891-39f4-4930-a679-65fb142b108b State: known-unbound
BMH: ocp-worker-1 Agent: da503cf1-a347-44f2-875c-4960ddb04091 State: insufficient

  4. 输入 extract 命令获取新托管集群的 kubeconfig ： 

    oc extract -n <hosted-cluster-namespace> secret/<hosted-cluster-name>-admin-kubeconfig --to=- > kubeconfig-<hosted-cluster-name>

  5. 在代理到达 add-to-existing-cluster 状态后，输入以下命令验证您可以在托管集群中看到 OpenShift Container Platform 节点： 

    oc --kubeconfig kubeconfig-<hosted-cluster-name> get nodes

    请参见以下示例输出： 

    NAME           STATUS   ROLES    AGE     VERSION
ocp-worker-1   Ready    worker   5m41s   v1.24.0+3882f8f
ocp-worker-2   Ready    worker   6m3s    v1.24.0+3882f8f

    集群 Operator 首先通过将工作负载添加到节点来协调。

  6. 输入以下命令验证在扩展 NodePool 对象时是否创建了两台机器： 

    oc -n <hosted-control-plane-namespace> get machines

    请参见以下示例输出： 

    NAME                            CLUSTER               NODENAME       PROVIDERID                                     PHASE     AGE   VERSION
hypercluster1-c96b6f675-m5vch   hypercluster1-b2qhl   ocp-worker-1   agent://da503cf1-a347-44f2-875c-4960ddb04091   Running   15m   4.13z
hypercluster1-c96b6f675-tl42p   hypercluster1-b2qhl   ocp-worker-2   agent://4dac1ab2-7dd5-4894-a220-6a3473b67ee6   Running   15m   4.13z

    clusterversion 协调过程最终到达缺少 Ingress 和 Console 集群 Operator 的点。

  7. 输入以下命令： 

    oc --kubeconfig kubeconfig-<hosted-cluster-name> get clusterversion,co

    请参见以下示例输出： 

    NAME                                         VERSION   AVAILABLE   PROGRESSING   SINCE   STATUS
clusterversion.config.openshift.io/version             False       True          40m     Unable to apply 4.13z: the cluster operator console has not yet successfully rolled out

NAME                                                                           VERSION   AVAILABLE   PROGRESSING   DEGRADED   SINCE   MESSAGE
clusteroperator.config.openshift.io/console                                    4.12z    False       False         False      11m     RouteHealthAvailable: failed to GET route (https://console-openshift-console.apps.hypercluster1.domain.com): Get "https://console-openshift-console.apps.hypercluster1.domain.com": dial tcp 10.19.3.29:443: connect: connection refused
clusteroperator.config.openshift.io/csi-snapshot-controller                    4.12z    True        False         False      10m
clusteroperator.config.openshift.io/dns                                        4.12z    True        False         False      9m16s
1.7.7.7.1. 添加节点池

您可以通过指定名称、副本数和任何其他信息（如代理标签选择器），为托管集群创建节点池。

  1. 要创建节点池，请输入以下信息： 

    export NODEPOOL_NAME=${CLUSTER_NAME}-extra-cpu
export WORKER_COUNT="2"

hcp create nodepool agent \
  --cluster-name $CLUSTER_NAME \
  --name $NODEPOOL_NAME \
  --node-count $WORKER_COUNT \
  --agentLabelSelector '{"matchLabels": {"size": "medium"}}' 1
    1
    --agentLabelSelector 是可选的。节点池使用带有 "size" 标签的代理。

  2. 通过列出 cluster 命名空间中的 nodepool 资源来检查节点池的状态： 

    oc get nodepools --namespace clusters

  3. 输入以下命令提取 admin-kubeconfig secret： 

    oc extract -n <hosted-control-plane-namespace> secret/admin-kubeconfig --to=./hostedcluster-secrets --confirm

    请参见以下示例输出： 

    hostedcluster-secrets/kubeconfig

  4. 一段时间后，您可以输入以下命令检查节点池的状态： 

    oc --kubeconfig ./hostedcluster-secrets get nodes

  5. 输入以下命令验证可用节点池的数量是否与预期的节点池数量匹配： 

    oc get nodepools --namespace clusters
1.7.7.7.2. 其他资源

1.7.7.8. 处理裸机上托管的集群中的入口

每个 OpenShift Container Platform 集群都有一个默认的应用程序 Ingress Controller，它通常关联有外部 DNS 记录。例如，如果您创建一个名为 example 的托管集群，其基域为 krnl.es，您可以预期通配符 domain. apps.example.krnl.es 可以被路由。

要为 If apps 域设置负载均衡器和通配符 DNS 记录，请在客户机集群中执行以下操作：

  1. 通过创建包含 MetalLB Operator 配置的 YAML 文件来部署 MetalLB： 

    apiVersion: v1
kind: Namespace
metadata:
  name: metallb
  labels:
    openshift.io/cluster-monitoring: "true"
  annotations:
    workload.openshift.io/allowed: management
---
apiVersion: operators.coreos.com/v1
kind: OperatorGroup
metadata:
  name: metallb-operator-operatorgroup
  namespace: metallb
---
apiVersion: operators.coreos.com/v1alpha1
kind: Subscription
metadata:
  name: metallb-operator
  namespace: metallb
spec:
  channel: "stable"
  name: metallb-operator
  source: redhat-operators
  sourceNamespace: openshift-marketplace
  2. 将文件保存为 metallb-operator-config.yaml。

  3. 输入以下命令应用配置： 

    oc apply -f metallb-operator-config.yaml

  4. Operator 运行后，创建 MetalLB 实例：

    1. 创建包含 MetalLB 实例配置的 YAML 文件： 

      apiVersion: metallb.io/v1beta1
kind: MetalLB
metadata:
  name: metallb
  namespace: metallb
    2. 将文件保存为 metallb-instance-config.yaml。
    3. 输入以下命令来创建 MetalLB 实例： 
    oc apply -f metallb-instance-config.yaml

  5. 通过创建两个资源来配置 MetalLB Operator：

    • 具有单个 IP 地址的 IPAddressPool 资源。此 IP 地址必须与集群节点使用的网络位于同一个子网中。

    • 一个 BGPAdvertisement 资源，用于公告 IPAddressPool 资源通过 BGP 协议提供的负载均衡器 IP 地址。

      1. 创建 YAML 文件使其包含配置： 
    apiVersion: metallb.io/v1beta1
kind: IPAddressPool
metadata:
  name: <ip_address_pool_name> 1
  namespace: metallb
spec:
  protocol: layer2
  autoAssign: false
  addresses:
    - <ingress_ip>-<ingress_ip> 2
---
apiVersion: metallb.io/v1beta1
kind: BGPAdvertisement
metadata:
  name: <bgp_advertisement_name> 3
  namespace: metallb
spec:
  ipAddressPools:
    - <ip_address_pool_name> 4
1 4
指定 IPAddressPool 资源名称。
2
指定环境的 IP 地址，例如 192.168.122.23。
3
指定 BGPAdvertisement 资源名称。
  1. 将文件保存为 ipaddresspool-bgpadvertisement-config.yaml。

  2. 运行以下命令来创建资源： 

    oc apply -f ipaddresspool-bgpadvertisement-config.yaml
    1. 创建 LoadBalancer 类型的服务后，MetalLB 为该服务添加一个外部 IP 地址。

  3. 通过创建名为 metallb-loadbalancer-service.yaml 的 YAML 文件，配置将入口流量路由到 ingress 部署的新负载均衡器服务： 

    kind: Service
apiVersion: v1
metadata:
  annotations:
    metallb.universe.tf/address-pool: ingress-public-ip
  name: metallb-ingress
  namespace: openshift-ingress
spec:
  ports:
    - name: http
      protocol: TCP
      port: 80
      targetPort: 80
    - name: https
      protocol: TCP
      port: 443
      targetPort: 443
  selector:
    ingresscontroller.operator.openshift.io/deployment-ingresscontroller: default
  type: LoadBalancer
  4. 保存 metallb-loadbalancer-service.yaml 文件。

  5. 输入以下命令应用 YAML 配置： 

    oc apply -f metallb-loadbalancer-service.yaml

  6. 输入以下命令访问 OpenShift Container Platform 控制台： 

    curl -kI https://console-openshift-console.apps.example.krnl.es

HTTP/1.1 200 OK

  7. 检查 clusterversion 和 clusteroperator 值，以验证一切是否正在运行。输入以下命令： 

    oc --kubeconfig <hosted_cluster_name>.kubeconfig get clusterversion,co

    请参见以下示例输出： 

NAME                                         VERSION   AVAILABLE   PROGRESSING   SINCE   STATUS
clusterversion.config.openshift.io/version   4.x.y      True        False         3m32s   Cluster version is 4.x.y

NAME                                                                           VERSION   AVAILABLE   PROGRESSING   DEGRADED   SINCE   MESSAGE
clusteroperator.config.openshift.io/console                                    4.x.y     True        False         False      3m50s
clusteroperator.config.openshift.io/ingress                                    4.x.y     True        False         False      53m

+ 将 4.x.y 替换为您要使用的 OpenShift Container Platform 版本，如 4.14.0-x86_64。

1.7.7.8.1. 其他资源

1.7.7.9. 为托管集群启用节点自动扩展

当托管集群和备用代理中需要更多容量时，您可以启用自动扩展来安装新的 worker 节点。

  1. 要启用自动扩展，请输入以下命令： 

    oc -n <hosted-cluster-namespace> patch nodepool <hosted-cluster-name> --type=json -p '[{"op": "remove", "path": "/spec/replicas"},{"op":"add", "path": "/spec/autoScaling", "value": { "max": 5, "min": 2 }}]'

注意： 在示例中，最少的节点数量为 2，最大为 5。您可以添加的最大节点数可能会受您的平台绑定。例如，如果您使用 Agent 平台，则最大节点数由可用代理数量绑定。

  1. 创建需要新节点的工作负载。

    1. 使用以下示例创建一个包含工作负载配置的 YAML 文件： 

      apiVersion: apps/v1
kind: Deployment
metadata:
  creationTimestamp: null
  labels:
    app: reversewords
  name: reversewords
  namespace: default
spec:
  replicas: 40
  selector:
    matchLabels:
      app: reversewords
  strategy: {}
  template:
    metadata:
      creationTimestamp: null
      labels:
        app: reversewords
  spec:
    containers:
    - image: quay.io/mavazque/reversewords:latest
      name: reversewords
      resources:
        requests:
          memory: 2Gi
status: {}
    2. 将文件保存为 workload-config.yaml。
    3. 输入以下命令应用 YAML： 
    oc apply -f workload-config.yaml

  2. 输入以下命令提取 admin-kubeconfig secret： 

    oc extract -n <hosted-cluster-namespace> secret/<hosted-cluster-name>-admin-kubeconfig --to=./hostedcluster-secrets --confirm

    请参见以下示例输出： 

    hostedcluster-secrets/kubeconfig

  3. 您可以输入以下命令来检查新节点是否处于 Ready 状态： 

    oc --kubeconfig ./hostedcluster-secrets get nodes

  4. 要删除节点，请输入以下命令删除工作负载： 

    oc --kubeconfig ./hostedcluster-secrets -n default delete deployment reversewords

  5. 等待几分钟通过，无需额外容量。在 Agent 平台上，代理将停用，并可重复使用。您可以输入以下命令确认节点已被删除： 

    oc --kubeconfig ./hostedcluster-secrets get nodes
1.7.7.9.1. 为托管集群禁用节点自动扩展

要禁用节点自动扩展，请输入以下命令： 

oc -n <hosted-cluster-namespace> patch nodepool <hosted-cluster-name> --type=json -p '[\{"op":"remove", "path": "/spec/autoScaling"}, \{"op": "add", "path": "/spec/replicas", "value": <specify-value-to-scale-replicas>]'

命令从 YAML 文件中删除 "spec.autoScaling"，添加 "spec.replicas"，并将 "spec.replicas" 设置为您指定的整数值。

1.7.7.10. 在裸机上销毁托管集群

您可以使用控制台销毁裸机托管集群。完成以下步骤以在裸机上销毁托管集群：

  1. 在控制台中，进入到 Infrastructure > Clusters。
  2. 在 Clusters 页面中，选择要销毁的集群。
  3. 在 Actions 菜单中，选择 Destroy 集群 来删除集群。
1.7.7.10.1. 使用命令行销毁裸机上的托管集群

要销毁托管集群，请完成以下步骤：

  • 运行以下命令来删除托管集群及其后端资源： 

    hcp destroy cluster agent --name <hosted_cluster_name>

    将 <hosted_cluster_name > 替换为托管集群的名称。

1.7.8. 使用非裸机代理机器配置托管的 control plane 集群（技术预览）

您可以通过将集群配置为充当托管集群来部署托管 control plane。托管的集群是托管 control plane 的 OpenShift Container Platform 集群。托管集群也称为 管理集群。

注： 管理集群 与受管集群 不同。受管集群是一个 hub 集群管理的集群。

托管的 control plane 功能默认启用。

multicluster engine operator 2.5 仅支持默认的 local-cluster，它是一个托管的 hub 集群，以及 hub 集群作为托管集群。在 Red Hat Advanced Cluster Management 2.10 中，您可以使用受管 hub 集群（也称为 local-cluster ），作为托管集群。

托管的集群 是一个 OpenShift Container Platform 集群，其 API 端点和托管在托管集群中的 control plane。托管的集群包括控制平面和它的对应的数据平面。您可以使用 multicluster engine operator 控制台或托管的 control plane 命令行界面 hcp 创建托管集群。托管的集群自动导入为受管集群。如果要禁用此自动导入功能，请参阅禁用将托管集群的自动导入到 multicluster engine operator。

重要：

  • 每个托管集群都必须具有集群范围的唯一名称。托管的集群名称不能与任何现有受管集群相同，以便 multicluster engine operator 管理它。
  • 不要使用 集群 作为托管的集群名称。
  • 在托管 control plane 的同一平台上运行 hub 集群和 worker。
  • 无法在 multicluster engine operator 受管集群的命名空间中创建托管集群。
  • 您可以使用 Agent 平台将代理机器作为 worker 节点添加到托管集群。代理机器代表使用 Discovery Image 引导的主机，并准备好作为 OpenShift Container Platform 节点置备。Agent 平台是中央基础架构管理服务的一部分。如需更多信息 ，请参阅启用中央基础架构管理服务。
  • 不是裸机的所有主机都需要使用中央基础架构管理提供的发现镜像 ISO 手动引导。
  • 当使用 Agent 平台创建托管集群时，HyperShift 在托管的 control plane 命名空间中安装 Agent Cluster API 供应商。
  • 当您扩展节点池时，会为每个副本创建一个机器。对于每台机器，Cluster API 供应商找到并安装一个经过批准的代理（通过验证）当前没有被使用，并满足节点池规格中指定的要求。您可以通过检查其状态和条件来监控代理的安装。
  • 当您缩减节点池时，代理会从对应的集群中绑定。在重复使用代理前，您必须使用 Discovery 镜像重启它们。
  • 当您为托管 control plane 配置存储时，请考虑推荐的 etcd 实践。要确保您满足延迟要求，请将快速存储设备专用于每个 control-plane 节点上运行的所有托管的 control plane etcd 实例。您可以使用 LVM 存储为托管 etcd pod 配置本地存储类。如需更多信息，请参阅 OpenShift Container Platform 文档中的使用逻辑卷管理器存储 的建议 etcd 实践 和持久性存储。

1.7.8.1. 先决条件

您必须具有以下先决条件才能配置托管集群：

  • 您需要 multicluster engine for Kubernetes operator 2.5 及更新的版本，并在 OpenShift Container Platform 集群上安装。安装 Red Hat Advanced Cluster Management 时会自动安装 multicluster engine operator。您还可以在没有 Red Hat Advanced Cluster Management 作为 OpenShift Container Platform OperatorHub 的 Operator 的情况下安装 multicluster engine operator。

  • multicluster engine operator 必须至少有一个受管 OpenShift Container Platform 集群。local-cluster 会自动导入。有关 local-cluster 的更多信息，请参阅高级配置。您可以运行以下命令来检查 hub 集群的状态： 

    oc get managedclusters local-cluster
  • 您需要启用中央基础架构管理。如需更多信息 ，请参阅启用中央基础架构管理服务。
  • 您需要安装托管的 control plane 命令行界面。

1.7.8.2. 非裸机代理机器的防火墙和端口要求

确保满足防火墙和端口要求，以便端口可以在管理集群、control plane 和托管的集群间进行通信：

  • kube-apiserver 服务默认在端口 6443 上运行，需要 ingress 访问 control plane 组件之间的通信。

    • 如果使用 NodePort 发布策略，请确保公开给 kube-apiserver 服务的节点端口。
    • 如果使用 MetalLB 负载均衡，允许对用于负载均衡器 IP 地址的 IP 范围进行入口访问。
  • 如果使用 NodePort 发布策略，请为 ignition-server 和 Oauth-server 设置使用防火墙规则。

  • konnectivity 代理建立反向隧道，以允许托管集群上的双向通信，需要在端口 6443 上出口访问集群 API 服务器地址。通过该出口访问，代理可以访问 kube-apiserver 服务。

    • 如果集群 API 服务器地址是一个内部 IP 地址，允许从工作负载子网访问端口 6443 上的 IP 地址。
    • 如果地址是一个外部 IP 地址，允许将端口 6443 上的出口从节点传输到该外部 IP 地址。
  • 如果您更改了 6443 的默认端口，请调整规则以反映该更改。
  • 确保打开在集群中运行的工作负载所需的任何端口。
  • 使用防火墙规则、安全组或其他访问控制来限制对所需源的访问。除非必要，否则请避免公开端口。
  • 对于生产环境部署，请使用负载均衡器通过单个 IP 地址简化访问。

1.7.8.3. 非裸机代理机器的基础架构要求

Agent 平台不创建任何基础架构，但它对基础架构有以下要求：

  • Agent ：代理代表使用发现镜像引导的主机，并准备好作为 OpenShift Container Platform 节点置备。
  • DNS ：API 和入口端点必须可以被路由。

1.7.8.4. 在非裸机代理机器上配置 DNS

托管集群的 API 服务器作为 NodePort 服务公开。api.<hosted-cluster-name>.<basedomain&gt; 必须存在 DNS 条目，指向可访问 API 服务器的目的地。

DNS 条目可以像一个记录一样简单，指向运行托管 control plane 的受管集群中的一个节点。该条目也可以指向部署的负载均衡器，以将传入的流量重定向到入口 pod。

  • 请参见以下 DNS 配置示例： 

    api-int.example.krnl.es.    IN A 192.168.122.22
`*`.apps.example.krnl.es. IN A 192.168.122.23

  • 如果您要为 IPv6 网络上的断开连接的环境配置 DNS，请查看以下 DNS 配置示例： 

    api-int.example.krnl.es.    IN A 2620:52:0:1306::7
`*`.apps.example.krnl.es. IN A 2620:52:0:1306::10

  • 如果您要为双栈网络上的断开连接的环境配置 DNS，请确保同时包含 IPv4 和 IPv6 的 DNS 条目。请参见以下 DNS 配置示例： 

    host-record=api-int.hub-dual.dns.base.domain.name,2620:52:0:1306::2
address=/apps.hub-dual.dns.base.domain.name/2620:52:0:1306::3
dhcp-host=aa:aa:aa:aa:10:01,ocp-master-0,[2620:52:0:1306::5]

1.7.8.5. 在非裸机代理机器上创建托管集群

您可以创建托管集群或导入一个。有关导入托管集群的步骤，请参阅 导入托管集群。

  1. 输入以下命令来创建托管的 control plane 命名空间： 

    oc create ns <hosted-cluster-namespace>-<hosted-cluster-name>

    将 <hosted-cluster-namespace > 替换为托管的集群命名空间名称，例如 集群。将 <hosted-cluster-name > 替换为您的托管的集群名称。

  2. 验证您是否为集群配置了默认存储类。否则，可能会以待处理的 PVC 结束。输入以下命令，将任何示例变量替换为您的信息： 

    hcp create cluster agent \
    --name=<hosted-cluster-name> \ 1
    --pull-secret=<path-to-pull-secret> \ 2
    --agent-namespace=<hosted-control-plane-namespace> \ 3
    --base-domain=<basedomain> \ 4
    --api-server-address=api.<hosted-cluster-name>.<basedomain> \
    --etcd-storage-class=<etcd-storage-class> \ 5
    --ssh-key  <path-to-ssh-key> \ 6
    --namespace <hosted-cluster-namespace> \ 7
    --control-plane-availability-policy SingleReplica \
    --release-image=quay.io/openshift-release-dev/ocp-release:<ocp-release> 8
    1
    指定托管集群的名称，例如。
    2
    指定 pull secret 的路径，例如 /user/name/pullsecret。
    3
    指定托管的 control plane 命名空间，如 cluster -example。使用 oc get agent -n <hosted-control-plane-namespace> 命令来确保代理在此命名空间中 可用。
    4
    指定您的基域，如 krnl.es。
    5
    指定 etcd 存储类名称，例如 lvm-storageclass。
    6
    指定 SSH 公钥的路径。默认文件路径为 ~/.ssh/id_rsa.pub。
    7
    指定托管集群的命名空间。
    8
    指定您要使用的 OpenShift Container Platform 版本，如 4.14.0-x86_64。

  3. 片刻后，输入以下命令验证托管的 control plane pod 是否正在运行： 

    oc -n <hosted-control-plane-namespace> get pods

    请参见以下示例输出： 

    NAME                                             READY   STATUS    RESTARTS   AGE
catalog-operator-6cd867cc7-phb2q                 2/2     Running   0          2m50s
control-plane-operator-f6b4c8465-4k5dh           1/1     Running   0          4m32s
1.7.8.5.1. 使用控制台在非裸机代理机器上创建托管集群
  1. 打开 OpenShift Container Platform Web 控制台，并通过输入管理员凭证登录。有关打开控制台的说明，请参阅 OpenShift Container Platform 文档中的 访问 Web 控制台。
  2. 在控制台标头中，确保选择了 All Clusters。
  3. 点 Infrastructure > Clusters。

  4. 点 Create cluster Host inventory > Hosted control plane。

    此时会显示 Create cluster 页面。

  5. 在 Create cluster 页面中，按照提示输入集群、节点池、网络和自动化的详情。

    注： 当您输入集群详情时，您可能会发现以下有用提示：

    • 如果要使用预定义的值来自动填充控制台中的字段，您可以创建主机清单凭证。如需更多信息，请参阅 为内部环境创建凭证。
    • 在 Cluster details 页面中，pull secret 是用于访问 OpenShift Container Platform 资源的 OpenShift Container Platform pull secret。如果选择了主机清单凭证，则会自动填充 pull secret。
    • 在 Node pool 页面中，命名空间包含节点池的主机。如果使用控制台创建主机清单，控制台会创建一个专用命名空间。
    • 在 Networking 页面中，您可以选择 API 服务器发布策略。托管集群的 API 服务器可以通过使用现有的负载均衡器或 NodePort 类型的服务公开。必须存在 api.${HOSTED_CLUSTER_NAME}.${BASEDOMAIN} 设置的 DNS 条目，该设置指向可访问 API 服务器的目的地。此条目可以是指向管理集群中的一个节点的记录，或指向将传入的流量重定向到 Ingress pod 的负载均衡器的记录。

  6. 检查您的条目并点 Create。

    此时会显示 Hosted 集群 视图。

  7. 在 Hosted 集群 视图中监控托管集群的部署。如果没有看到有关托管集群的信息，请确保选择了 All Clusters，然后点集群名称。等待 control plane 组件就绪。这个过程可能需要几分钟时间。
  8. 要查看节点池状态，可滚动到 NodePool 部分。安装节点的过程大约需要 10 分钟。您还可以单击 Nodes 来确认节点是否加入托管集群。
1.7.8.5.2. 其他资源

1.7.8.6. 验证托管集群创建

部署过程完成后，您可以验证托管集群是否已成功创建。在创建托管集群后，按照以下步骤操作。

  1. 输入 extract 命令获取新托管集群的 kubeconfig ： 

    oc extract -n <hosted-cluster-namespace> secret/<hosted-cluster-name>-admin-kubeconfig --to=- > kubeconfig-<hosted-cluster-name>

  2. 使用 kubeconfig 查看托管集群的集群 Operator。输入以下命令： 

    oc get co --kubeconfig=kubeconfig-<hosted_cluster_name>

    请参见以下示例输出： 

    NAME                                       VERSION   AVAILABLE   PROGRESSING   DEGRADED   SINCE   MESSAGE
console                                    4.10.26   True        False         False      2m38s
csi-snapshot-controller                    4.10.26   True        False         False      4m3s
dns                                        4.10.26   True        False         False      2m52s

  3. 您还可以输入以下命令查看托管集群中运行的 pod： 

    oc get pods -A --kubeconfig=kubeconfig-<hosted-cluster-name>

    请参见以下示例输出： 

    NAMESPACE                                          NAME                                                      READY   STATUS             RESTARTS        AGE
kube-system                                        konnectivity-agent-khlqv                                  0/1     Running            0               3m52s
openshift-cluster-samples-operator                 cluster-samples-operator-6b5bcb9dff-kpnbc                 2/2     Running            0               20m
openshift-monitoring                               alertmanager-main-0                                       6/6     Running            0               100s
openshift-monitoring                               openshift-state-metrics-677b9fb74f-qqp6g                  3/3     Running            0               104s

1.7.8.7. 为托管集群扩展 NodePool 对象

您可以通过扩展 NodePool 对象将节点添加到托管集群。

  1. 将 NodePool 对象扩展到两个节点： 

    oc -n <hosted-cluster-namespace> scale nodepool <nodepool-name> --replicas 2

    Cluster API 代理供应商随机选择两个代理，然后分配给托管集群。这些代理通过不同的状态，最后将托管集群作为 OpenShift Container Platform 节点加入。代理按以下顺序传递状态：

    • binding
    • 发现
    • insufficient
    • 安装
    • installing-in-progress
    • added-to-existing-cluster

  2. 输入以下命令： 

    oc -n <hosted-control-plane-namespace> get agent

    请参见以下示例输出： 

    NAME                                   CLUSTER         APPROVED   ROLE          STAGE
4dac1ab2-7dd5-4894-a220-6a3473b67ee6   hypercluster1   true       auto-assign

  3. 输入以下命令： 

    oc -n <hosted-control-plane-namespace> get agent -o jsonpath='{range .items[*]}BMH: {@.metadata.labels.agent-install\.openshift\.io/bmh} Agent: {@.metadata.name} State: {@.status.debugInfo.state}{"\n"}{end}'

    请参见以下示例输出： 

    BMH: ocp-worker-2 Agent: 4dac1ab2-7dd5-4894-a220-6a3473b67ee6 State: binding
BMH: ocp-worker-1 Agent: da503cf1-a347-44f2-875c-4960ddb04091 State: insufficient

  4. 输入 extract 命令获取新托管集群的 kubeconfig ： 

    oc extract -n <hosted-cluster-namespace> secret/<hosted-cluster-name>-admin-kubeconfig --to=- > kubeconfig-<hosted-cluster-name>

  5. 在代理到达 add-to-existing-cluster 状态后，输入以下命令验证您可以在托管集群中看到 OpenShift Container Platform 节点： 

    oc --kubeconfig kubeconfig-<hosted-cluster-name> get nodes

    请参见以下示例输出： 

    NAME           STATUS   ROLES    AGE     VERSION
ocp-worker-1   Ready    worker   5m41s   v1.24.0+3882f8f

    集群 Operator 首先通过将工作负载添加到节点来协调。

  6. 输入以下命令验证在扩展 NodePool 对象时是否创建了两台机器： 

    oc -n <hosted-control-plane-namespace> get machines

    请参见以下示例输出： 

    NAME                            CLUSTER               NODENAME       PROVIDERID                                     PHASE     AGE   VERSION
hypercluster1-c96b6f675-m5vch   hypercluster1-b2qhl   ocp-worker-1   agent://da503cf1-a347-44f2-875c-4960ddb04091   Running   15m   4.13z

    clusterversion 协调过程最终到达缺少 Ingress 和 Console 集群 Operator 的点。

  7. 输入以下命令： 

    oc --kubeconfig kubeconfig-<hosted-cluster-name> get clusterversion,co

    请参见以下示例输出： 

    NAME                                         VERSION   AVAILABLE   PROGRESSING   SINCE   STATUS
clusterversion.config.openshift.io/version             False       True          40m     Unable to apply 4.13z: the cluster operator console has not yet successfully rolled out

NAME                                                                           VERSION   AVAILABLE   PROGRESSING   DEGRADED   SINCE   MESSAGE
clusteroperator.config.openshift.io/console                                    4.13z    False       False         False      11m     RouteHealthAvailable: failed to GET route (https://console-openshift-console.apps.hypercluster1.domain.com): Get "https://console-openshift-console.apps.hypercluster1.domain.com": dial tcp 10.19.3.29:443: connect: connection refused
clusteroperator.config.openshift.io/csi-snapshot-controller                    4.13z    True        False         False      10m
clusteroperator.config.openshift.io/dns                                        4.13z    True        False         False      9m16s
1.7.8.7.1. 添加节点池

您可以通过指定名称、副本数和任何其他信息（如代理标签选择器），为托管集群创建节点池。

  1. 要创建节点池，请输入以下信息： 

    export NODEPOOL_NAME=${CLUSTER_NAME}-extra-cpu
export WORKER_COUNT="2"

hcp create nodepool agent \
  --cluster-name $CLUSTER_NAME \
  --name $NODEPOOL_NAME \
  --node-count $WORKER_COUNT \
  --agentLabelSelector '{"matchLabels": {"size": "medium"}}' 1
    1
    --agentLabelSelector 是可选的。节点池使用带有 "size" 标签的代理。

  2. 通过列出 cluster 命名空间中的 nodepool 资源来检查节点池的状态： 

    oc get nodepools --namespace clusters

  3. 输入以下命令提取 admin-kubeconfig secret： 

    oc extract -n <hosted-cluster-namespace> secret/<hosted-cluster-name>-admin-kubeconfig --to=./hostedcluster-secrets --confirm

    请参见以下示例输出： 

    hostedcluster-secrets/kubeconfig

  4. 一段时间后，您可以输入以下命令检查节点池的状态： 

    oc --kubeconfig ./hostedcluster-secrets get nodes

  5. 输入以下命令验证可用节点池的数量是否与预期的节点池数量匹配： 

    oc get nodepools --namespace clusters
1.7.8.7.2. 其他资源

1.7.8.8. 在非裸机代理机器上处理托管的集群中的入口

每个 OpenShift Container Platform 集群都有一个默认的应用程序 Ingress Controller，它通常关联有外部 DNS 记录。例如，如果您创建一个名为 example 的托管集群，其基域为 krnl.es，您可以预期通配符 domain. apps.example.krnl.es 可以被路由。

要为 If apps 域设置负载均衡器和通配符 DNS 记录，请在客户机集群中执行以下操作：

  1. 通过创建包含 MetalLB Operator 配置的 YAML 文件来部署 MetalLB： 

    apiVersion: v1
kind: Namespace
metadata:
  name: metallb
  labels:
    openshift.io/cluster-monitoring: "true"
  annotations:
    workload.openshift.io/allowed: management
---
apiVersion: operators.coreos.com/v1
kind: OperatorGroup
metadata:
  name: metallb-operator-operatorgroup
  namespace: metallb
---
apiVersion: operators.coreos.com/v1alpha1
kind: Subscription
metadata:
  name: metallb-operator
  namespace: metallb
spec:
  channel: "stable"
  name: metallb-operator
  source: redhat-operators
  sourceNamespace: openshift-marketplace
  2. 将文件保存为 metallb-operator-config.yaml。

  3. 输入以下命令应用配置： 

    oc apply -f metallb-operator-config.yaml

  4. Operator 运行后，创建 MetalLB 实例：

    1. 创建包含 MetalLB 实例配置的 YAML 文件： 

      apiVersion: metallb.io/v1beta1
kind: MetalLB
metadata:
  name: metallb
  namespace: metallb
    2. 将文件保存为 metallb-instance-config.yaml。
    3. 输入以下命令来创建 MetalLB 实例： 
    oc apply -f metallb-instance-config.yaml

  5. 通过创建两个资源来配置 MetalLB Operator：

    • 具有单个 IP 地址的 IPAddressPool 资源。此 IP 地址必须与集群节点使用的网络位于同一个子网中。

    • 一个 BGPAdvertisement 资源，用于公告 IPAddressPool 资源通过 BGP 协议提供的负载均衡器 IP 地址。

      1. 创建 YAML 文件使其包含配置： 
    apiVersion: metallb.io/v1beta1
kind: IPAddressPool
metadata:
  name: <ip_address_pool_name> 1
  namespace: metallb
spec:
  protocol: layer2
  autoAssign: false
  addresses:
    - <ingress_ip>-<ingress_ip> 2
---
apiVersion: metallb.io/v1beta1
kind: BGPAdvertisement
metadata:
  name: <bgp_advertisement_name> 3
  namespace: metallb
spec:
  ipAddressPools:
    - <ip_address_pool_name> 4
1 4
指定 IPAddressPool 资源名称。
2
指定环境的 IP 地址，例如 192.168.122.23。
3
指定 BGPAdvertisement 资源名称。
  1. 将文件保存为 ipaddresspool-bgpadvertisement-config.yaml。

  2. 运行以下命令来创建资源： 

    oc apply -f ipaddresspool-bgpadvertisement-config.yaml
    1. 创建 LoadBalancer 类型的服务后，MetalLB 为该服务添加一个外部 IP 地址。

  3. 通过创建名为 metallb-loadbalancer-service.yaml 的 YAML 文件，配置将入口流量路由到 ingress 部署的新负载均衡器服务： 

    kind: Service
apiVersion: v1
metadata:
  annotations:
    metallb.universe.tf/address-pool: ingress-public-ip
  name: metallb-ingress
  namespace: openshift-ingress
spec:
  ports:
    - name: http
      protocol: TCP
      port: 80
      targetPort: 80
    - name: https
      protocol: TCP
      port: 443
      targetPort: 443
  selector:
    ingresscontroller.operator.openshift.io/deployment-ingresscontroller: default
  type: LoadBalancer
  4. 将文件保存为 metallb-loadbalancer-service.yaml。

  5. 输入以下命令应用 YAML 配置： 

    oc apply -f metallb-loadbalancer-service.yaml

  6. 输入以下命令访问 OpenShift Container Platform 控制台： 

    curl -kI https://console-openshift-console.apps.example.krnl.es

HTTP/1.1 200 OK

  7. 检查 clusterversion 和 clusteroperator 值，以验证一切是否正在运行。输入以下命令： 

    oc --kubeconfig <hosted_cluster_name>.kubeconfig get clusterversion,co

    请参见以下示例输出： 

NAME                                         VERSION           AVAILABLE   PROGRESSING   SINCE   STATUS
clusterversion.config.openshift.io/version   4.x.y             True        False         3m32s   Cluster version is 4.x.y

NAME                                                                           VERSION           AVAILABLE   PROGRESSING   DEGRADED   SINCE   MESSAGE
clusteroperator.config.openshift.io/console                                    4.x.y             True        False         False      3m50s
clusteroperator.config.openshift.io/ingress                                    4.x.y             True        False         False      53m

+ 将 4.x.y 替换为您要使用的 OpenShift Container Platform 版本，如 4.14.0-x86_64。

1.7.8.8.1. 其他资源

1.7.8.9. 为托管集群启用节点自动扩展

当托管集群和备用代理中需要更多容量时，您可以启用自动扩展来安装新的 worker 节点。

  1. 要启用自动扩展，请输入以下命令。在本例中，最少的节点数量为 2，最大为 5。您可以添加的最大节点数可能会受您的平台绑定。例如，如果您使用 Agent 平台，则最大节点数由可用代理数量绑定： 

    oc -n <hosted-cluster-namespace> patch nodepool <hosted-cluster-name> --type=json -p '[{"op": "remove", "path": "/spec/replicas"},{"op":"add", "path": "/spec/autoScaling", "value": { "max": 5, "min": 2 }}]'

  2. 创建需要新节点的工作负载。

    1. 使用以下示例创建一个包含工作负载配置的 YAML 文件： 

      apiVersion: apps/v1
kind: Deployment
metadata:
  creationTimestamp: null
  labels:
    app: reversewords
  name: reversewords
  namespace: default
spec:
  replicas: 40
  selector:
    matchLabels:
      app: reversewords
  strategy: {}
  template:
    metadata:
      creationTimestamp: null
      labels:
        app: reversewords
  spec:
    containers:
    - image: quay.io/mavazque/reversewords:latest
      name: reversewords
      resources:
        requests:
          memory: 2Gi
status: {}
    2. 将文件保存为 workload-config.yaml。
    3. 输入以下命令应用 YAML： 
    oc apply -f workload-config.yaml

  3. 输入以下命令提取 admin-kubeconfig secret： 

    oc extract -n <hosted-cluster-namespace> secret/<hosted-cluster-name>admin-kubeconfig --to=./hostedcluster-secrets --confirm

    请参见以下示例输出： 

    hostedcluster-secrets/kubeconfig

  4. 您可以输入以下命令来检查新节点是否处于 Ready 状态： 

    oc --kubeconfig <hosted-cluster-name>.kubeconfig get nodes

  5. 要删除节点，请输入以下命令删除工作负载： 

    oc --kubeconfig <hosted-cluster-name>.kubeconfig -n default delete deployment reversewords

  6. 等待几分钟通过，无需额外容量。在 Agent 平台上，代理将停用，并可重复使用。您可以输入以下命令确认节点已被删除： 

    oc --kubeconfig <hosted-cluster-name>.kubeconfig get nodes
1.7.8.9.1. 为托管集群禁用节点自动扩展

要禁用节点自动扩展，请输入以下命令： 

oc -n <hosted-cluster-namespace> patch nodepool <hosted-cluster-name> --type=json -p '[\{"op":"remove", "path": "/spec/autoScaling"}, \{"op": "add", "path": "/spec/replicas", "value": <specify-value-to-scale-replicas>]'

命令从 YAML 文件中删除 "spec.autoScaling"，添加 "spec.replicas"，并将 "spec.replicas" 设置为您指定的整数值。

1.7.8.10. 在非裸机代理机器上销毁托管集群

您可以使用控制台销毁非裸机托管集群。完成以下步骤，在非裸机代理机器上销毁托管集群：

  1. 在控制台中，进入到 Infrastructure > Clusters。
  2. 在 Clusters 页面中，选择要销毁的集群。
  3. 在 Actions 菜单中，选择 Destroy 集群 来删除集群。
1.7.8.10.1. 使用命令行销毁非裸机代理机器上的托管集群

要销毁托管集群，请完成以下步骤：

  • 运行以下命令来删除托管集群及其后端资源： 

    hcp destroy cluster agent --name <hosted_cluster_name>

    将 <hosted_cluster_name > 替换为托管集群的名称。

1.7.9. 在 64 位 x86 OpenShift Container Platform 集群上配置托管集群，为 IBM Power 计算节点创建托管的 control plane （技术预览）

技术预览： 在 64 位 x86 裸机中为 IBM Power (ppc64le)计算节点配置托管集群有有限的支持。

您可以通过将集群配置为充当托管集群来部署托管 control plane。托管的集群是托管 control plane 的 OpenShift Container Platform 集群。托管集群也称为 管理集群。

注： 管理集群 不是 受管集群。受管集群是一个 hub 集群管理的集群。

multicluster engine operator 2.5 仅支持默认的 local-cluster，它是一个托管的 hub 集群，以及 hub 集群作为托管集群。

重要：

  • 要在裸机上置备托管的 control plane，您可以使用 Agent 平台。Agent 平台使用中央基础架构管理服务将 worker 节点添加到托管集群。有关中央基础架构管理服务简介，请参阅创建主机清单。
  • 每个 IBM Power 系统主机都必须使用中央基础架构管理提供的发现镜像启动。每个主机启动后，它运行一个 Agent 进程来发现主机的详细信息并完成安装。Agent 自定义资源代表每个主机。
  • 当使用 Agent 平台创建托管集群时，HyperShift 在托管的 control plane 命名空间中安装 Agent Cluster API 供应商。
  • 当您扩展节点池时，会创建一个机器。Cluster API 供应商找到一个经过批准的代理，正在传递验证，当前没有被使用，并满足节点池规格中指定的要求。您可以通过检查其状态和条件来监控代理的安装。
  • 当您缩减节点池时，代理会从对应的集群中绑定。在重复使用集群前，您必须使用 Discovery 镜像更新节点数量来重启它们。

1.7.9.1. 先决条件

您必须具有以下先决条件才能配置托管集群：

  • Kubernetes operator 2.5 及更新版本的多集群引擎安装在 OpenShift Container Platform 集群中。安装 Red Hat Advanced Cluster Management 时会自动安装 multicluster engine operator。您还可以在没有 Red Hat Advanced Cluster Management 作为 OpenShift Container Platform OperatorHub 的 Operator 的情况下安装 multicluster engine operator。

  • multicluster engine operator 必须至少有一个受管 OpenShift Container Platform 集群。local-cluster 在 multicluster engine operator 2.5 及更新的版本中自动导入。有关 local-cluster 的更多信息，请参阅高级配置。您可以运行以下命令来检查 hub 集群的状态： 

    oc get managedclusters local-cluster
  • 您需要至少 3 个 worker 节点的托管集群来运行 HyperShift Operator。
  • 您需要启用中央基础架构管理服务。如需更多信息 ，请参阅启用中央基础架构管理服务。
  • 您需要安装托管的 control plane 命令行界面。请参阅 安装托管的 control plane 命令行界面。

1.7.9.2. IBM Power 基础架构要求

Agent 平台不创建任何基础架构，但对于基础架构需要以下内容：

  • Agent ：代理代表使用发现镜像引导的主机，并准备好作为 OpenShift Container Platform 节点置备。
  • DNS ：API 和入口端点必须可以被路由。

1.7.9.3. IBM Power 配置文档

满足先决条件后，请查看以下主题来在裸机上配置托管的 control plane：

  1. 在 InfraEnv 资源中添加代理
  2. 为 IBM Power 上托管的 control plane 配置 DNS
  3. 在裸机上创建托管集群
  4. 为 IBM Power 计算节点在 64 位 x86 裸机上托管 control plane 创建 InfraEnv 资源
  5. 为 IBM Power 上托管集群扩展 NodePool 对象。

1.7.9.4. 在 InfraEnv 资源中添加代理

您可以通过手动将机器配置为使用 live ISO 来添加代理。

  1. 下载 live ISO，并使用它来启动主机（裸机或虚拟机）。live ISO 的 URL 可以在 InfraEnv 资源（在 status.isoDownloadURL 字段中）中找到。在启动时，主机与 Assisted Service 通信，并注册为与 InfraEnv 资源相同的命名空间中的代理。

  2. 要列出代理及其某些属性，请输入以下命令： 

    oc -n <hosted-control-plane-namespace> get agents

    请参见以下示例输出： 

    NAME                                   CLUSTER   APPROVED   ROLE          STAGE
86f7ac75-4fc4-4b36-8130-40fa12602218                        auto-assign
e57a637f-745b-496e-971d-1abbf03341ba                        auto-assign

  3. 创建每个代理后，您可以选择在规格中设置 installation_disk_id 和 hostname，并输入以下命令批准代理： 

    oc -n <hosted-control-plane-namespace> patch agent 86f7ac75-4fc4-4b36-8130-40fa12602218 -p '{"spec":{"installation_disk_id":"/dev/sda","approved":true,"hostname":"worker-0.example.krnl.es"}}' --type merge

oc -n <hosted-control-plane-namespace> patch agent 23d0c614-2caa-43f5-b7d3-0b3564688baa -p '{"spec":{"installation_disk_id":"/dev/sda","approved":true,"hostname":"worker-1.example.krnl.es"}}' --type merge

  4. 要验证代理是否已批准使用，请输入以下命令并检查输出： 

    oc -n <hosted-control-plane-namespace> get agents

    请参见以下示例输出： 

    NAME                                   CLUSTER   APPROVED   ROLE          STAGE
86f7ac75-4fc4-4b36-8130-40fa12602218             true       auto-assign
e57a637f-745b-496e-971d-1abbf03341ba             true       auto-assign

1.7.9.5. 为 IBM Power 上托管的 control plane 配置 DNS

托管集群的 API 服务器公开。api.<hosted-cluster-name>.<base-domain> 条目必须存在 DNS 条目，该条目指向可访问 API 服务器的目的地。

DNS 条目可以像一个记录一样简单，指向运行托管 control plane 的受管集群中的一个节点。

该条目也可以指向部署的负载均衡器，以将传入的流量重定向到入口 pod。

请参阅以下 DNS 配置示例： 

$ cat /var/named/<example.krnl.es.zone>

请参见以下示例输出： 

$ TTL 900
@ IN  SOA bastion.example.krnl.es.com. hostmaster.example.krnl.es.com. (
      2019062002
      1D 1H 1W 3H )
  IN NS bastion.example.krnl.es.com.
;
;
api                   IN A 1xx.2x.2xx.1xx 1
api-int               IN A 1xx.2x.2xx.1xx
;
;
*.apps.<hosted-cluster-name>.<basedomain>           IN A 1xx.2x.2xx.1xx
;
;EOF
1
记录指的是 API 负载均衡器的 IP 地址，它处理托管的 control plane 的入口和出口流量。

对于 IBM Power，添加与代理 IP 地址对应的 IP 地址。 

compute-0              IN A 1xx.2x.2xx.1yy
compute-1              IN A 1xx.2x.2xx.1yy

1.7.9.6. 为 IBM Power 计算节点在 64 位 x86 裸机上托管 control plane 创建 InfraEnv 资源

InfraEnv 是启动实时 ISO 的主机可以加入为代理的环境。在这种情况下，代理会在与您托管的 control plane 相同的命名空间中创建。

要创建 InfraEnv 资源，请完成以下步骤：

  1. 创建包含配置的 YAML 文件。请参见以下示例： 

    apiVersion: agent-install.openshift.io/v1beta1
kind: InfraEnv
metadata:
  name: <hosted-cluster-name>
  namespace: <hosted-control-plane-namespace>
spec:
  cpuArchitecture: ppc64le
  pullSecretRef:
    name: pull-secret
  sshAuthorizedKey: <ssh-public-key>
  2. 将文件保存为 infraenv-config.yaml。

  3. 输入以下命令应用配置： 

    oc apply -f infraenv-config.yaml

  4. 要获取用于下载 live ISO 的 URL，它允许 IBM Power 机器加入代理，请输入以下命令： 

    oc -n <hosted-control-plane-namespace> get InfraEnv <hosted-cluster-name> -o json

1.7.9.7. 为 IBM Power 上托管集群扩展 NodePool 对象

在创建托管集群时，会创建 NodePool 对象。通过扩展 NodePool 对象，您可以将更多计算节点添加到托管的 control plane 中。

  1. 运行以下命令来将 NodePool 对象扩展到两个节点： 

    oc -n <clusters_namespace> scale nodepool <nodepool_name> --replicas 2

    Cluster API 代理供应商随机选择两个代理，然后分配给托管集群。这些代理通过不同的状态，最后将托管集群作为 OpenShift Container Platform 节点加入。代理按以下顺序传递转换阶段：

    • binding
    • 发现
    • insufficient
    • 安装
    • installing-in-progress
    • added-to-existing-cluster

  2. 运行以下命令查看特定扩展代理的状态： 

    oc -n <hosted_control_plane_namespace> get agent -o jsonpath='{range .items[*]}BMH: {@.metadata.labels.agent-install\.openshift\.io/bmh} Agent: {@.metadata.name} State: {@.status.debugInfo.state}{"\n"}{end}'

    请参见以下输出： 

    BMH: Agent: 50c23cda-cedc-9bbd-bcf1-9b3a5c75804d State: known-unbound
BMH: Agent: 5e498cd3-542c-e54f-0c58-ed43e28b568a State: insufficient

  3. 运行以下命令查看转换阶段： 

    oc -n <hosted_control_plane_namespace> get agent

    请参见以下输出： 

    NAME                                   CLUSTER           APPROVED       ROLE        STAGE
50c23cda-cedc-9bbd-bcf1-9b3a5c75804d   hosted-forwarder   true          auto-assign
5e498cd3-542c-e54f-0c58-ed43e28b568a                      true          auto-assign
da503cf1-a347-44f2-875c-4960ddb04091   hosted-forwarder   true          auto-assign

  4. 运行以下命令以生成 kubeconfig 文件来访问托管集群： 

    hcp create kubeconfig --namespace <clusters_namespace> --name <hosted_cluster_namespace> > <hosted_cluster_name>.kubeconfig

  5. 在代理到达 add-to-existing-cluster 状态后，输入以下命令验证您可以看到 OpenShift Container Platform 节点： 

    oc --kubeconfig <hosted_cluster_name>.kubeconfig get nodes

    请参见以下输出： 

    NAME                             STATUS   ROLES    AGE      VERSION
worker-zvm-0.hostedn.example.com Ready    worker   5m41s    v1.24.0+3882f8f
worker-zvm-1.hostedn.example.com Ready    worker   6m3s     v1.24.0+3882f8f

  6. 输入以下命令验证在扩展 NodePool 对象时是否创建了两台机器： 

    oc -n <hosted_control_plane_namespace> get machine.cluster.x-k8s.io

    请参见以下输出： 

    NAME                                CLUSTER  NODENAME PROVIDERID     PHASE     AGE   VERSION
hosted-forwarder-79558597ff-5tbqp   hosted-forwarder-crqq5   worker-zvm-0.hostedn.example.com   agent://50c23cda-cedc-9bbd-bcf1-9b3a5c75804d   Running   41h   4.15.0
hosted-forwarder-79558597ff-lfjfk   hosted-forwarder-crqq5   worker-zvm-1.hostedn.example.com   agent://5e498cd3-542c-e54f-0c58-ed43e28b568a   Running   41h   4.15.0

  7. 运行以下命令检查集群版本和集群 Operator 状态： 

    oc --kubeconfig <hosted_cluster_name>.kubeconfig get clusterversion

    请参见以下输出： 

    NAME                                         VERSION       AVAILABLE   PROGRESSING   SINCE   STATUS
clusterversion.config.openshift.io/version   4.15.0   True        False         40h     Cluster version is 4.15.0

  8. 运行以下命令来检查集群 Operator 状态： 

    oc --kubeconfig <hosted_cluster_name>.kubeconfig get clusteroperators

对于集群中的每个组件，输出显示以下集群 operator 状态： NAME,VERSION, AVAILABLE ,AVAILABLE,PROGRESSING,DEGRADED,SINCE, 和 MESSAGE。

如需输出示例，请参阅 OpenShift Container Platform 文档中的 Initial Operator 配置部分。

1.7.9.7.1. 其他资源

1.7.10. 为 IBM Z 计算节点在 x86 裸机上配置托管集群（技术预览）

技术预览： 在 IBM Z (s390x)计算节点的 x86 裸机中配置托管集群处于技术预览状态，且支持有限的。

您可以通过将集群配置为充当托管集群来部署托管 control plane。托管的集群是托管 control plane 的 OpenShift Container Platform 集群。托管集群也称为 管理集群。

注： 管理集群 不是 受管集群。受管集群是一个 hub 集群管理的集群。

您可以使用 hypershift 附加组件将受管集群转换为托管集群，以在该集群中部署 HyperShift Operator。然后，您可以开始创建托管集群。

multicluster engine operator 2.5 仅支持默认的 local-cluster，它是一个托管的 hub 集群，以及 hub 集群作为托管集群。

重要：

  • 要在裸机上置备托管的 control plane，您可以使用 Agent 平台。Agent 平台使用中央基础架构管理服务将 worker 节点添加到托管集群。有关中央基础架构管理服务简介，请参阅 Kube API - 入门指南。
  • 每个 IBM Z 系统主机都必须使用中央基础架构管理提供的 PXE 镜像启动。每个主机启动后，它运行一个 Agent 进程来发现主机的详细信息并完成安装。Agent 自定义资源代表每个主机。
  • 当使用 Agent 平台创建托管集群时，Hy HyperShift Operator 会在托管的 control plane 命名空间中安装 Agent Cluster API 供应商。
  • 当您扩展节点池时，会创建一个机器。Cluster API 供应商找到一个经过批准的代理，正在传递验证，当前没有被使用，并满足节点池规格中指定的要求。您可以通过检查其状态和条件来监控代理的安装。
  • 当您缩减节点池时，代理会从对应的集群中绑定。在重复使用集群前，您必须使用 PXE 镜像引导集群，以更新节点的数量。

1.7.10.1. 先决条件

  • Kubernetes operator 版本 2.5 或更高版本的多集群引擎必须安装在 OpenShift Container Platform 集群中。在安装 Red Hat Advanced Cluster Management 时，多集群引擎 operator 会被自动安装。您还可以在没有 Red Hat Advanced Cluster Management 作为 OpenShift Container Platform OperatorHub 的 Operator 的情况下安装 multicluster engine operator。

  • multicluster engine operator 必须至少有一个受管 OpenShift Container Platform 集群。local-cluster 在 multicluster engine operator 2.5 及更新的版本中自动导入。有关 local-cluster 的更多信息，请参阅高级配置。您可以运行以下命令来检查 hub 集群的状态： 

    oc get managedclusters local-cluster
  • 您需要至少具有三个 worker 节点的托管集群来运行 HyperShift Operator。
  • 您需要启用中央基础架构管理服务。如需更多信息 ，请参阅启用中央基础架构管理服务。
  • 您需要安装托管的 control plane 命令行界面。请参阅 安装托管的 control plane 命令行界面。

1.7.10.2. IBM Z 基础架构要求

Agent 平台不创建任何基础架构，但对于基础架构需要以下内容：

  • Agent ：代理代表使用发现镜像或 PXE 镜像引导的主机，并可置备为 OpenShift Container Platform 节点。
  • DNS ：API 和 Ingress 端点必须可以被路由。

托管的 control plane 功能默认启用。如果您禁用了这个功能并希望手动启用它，或者需要禁用这个功能，请参阅启用或禁用 托管的 control plane 功能。

1.7.10.3. IBM Z 配置文档

满足先决条件后，请查看以下主题来在裸机上配置托管的 control plane：

  1. 使用 IBM Z 为托管的 control plane 配置 DNS
  2. 在裸机上创建托管集群
  3. 为 IBM Z 计算节点在 64 位 x86 裸机上托管 control plane 创建 InfraEnv 资源
  4. 在 InfraEnv 资源中添加 IBM Z 代理（技术预览）
  5. 为 IBM Z 上托管集群扩展 NodePool 对象

1.7.10.4. 在 InfraEnv 资源中添加 IBM Z 代理（技术预览）

在 IBM Z 环境中添加代理需要额外的步骤，本节中详细介绍。

注： 除非另有说明，这些步骤适用于 IBM Z 和 IBM LinuxONE 上的 z/VM 和 RHEL KVM 安装。

1.7.10.4.1. 使用 KVM 为 IBM Z 添加代理

对于带有 KVM 的 IBM Z，运行以下命令，使用从 InfraEnv 资源下载的 PXE 镜像启动 IBM Z 环境。创建代理后，主机与 Assisted Service 通信，并注册到与管理集群上的 InfraEnv 资源相同的命名空间中。 

virt-install \
   --name "<vm_name>" \
   --autostart \
   --ram=16384 \
   --cpu host \
   --vcpus=4 \
   --location "<path_to_kernel_initrd_image>,kernel=kernel.img,initrd=initrd.img" \
   --disk <qcow_image_path> \
   --network network:macvtap-net,mac=<mac_address> \
   --graphics none \
   --noautoconsole \
   --wait=-1 \
   --extra-args "rd.neednet=1 nameserver=<nameserver>   coreos.live.rootfs_url=http://<http_server>/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"

对于 ISO 引导，从 InfraEnv 资源下载 ISO，并运行以下命令来引导节点： 

virt-install \
  --name "<vm_name>" \
  --autostart \
  --memory=16384 \
  --cpu host \
  --vcpus=4 \
  --network network:macvtap-net,mac=<mac_address> \
  --cdrom "<path_to_image.iso>" \
  --disk <qcow_image_path> \
  --graphics none \
  --noautoconsole \
  --os-variant <os_version> \
  --wait=-1 \
1.7.10.4.2. 使用 z/VM 为 IBM 添加代理

注： 如果要为 z/VM 客户机使用静态 IP，您必须为 z/VM 代理配置 NMStateConfig 属性，以便 IP 参数在第二次引导中保留。

完成以下步骤，使用从 InfraEnv 资源下载的 PXE 镜像启动 IBM Z 环境。创建代理后，主机与 Assisted Service 通信，并注册到与管理集群上的 InfraEnv 资源相同的命名空间中。

  1. 更新参数文件，以添加 rootfs_url、network_adaptor 和 disk_type 值。

    请参见以下示例参数文件： 

    rd.neednet=1 \
console=ttysclp0  \
coreos.live.rootfs_url=<rootfs_url> \
ip=<IP_guest_vm>::<nameserver>:255.255.255.0::<network_adaptor>:none \
nameserver=<nameserver> \
zfcp.allow_lun_scan=0 \ 1
rd.znet=qeth,<network_adaptor_range>,layer2=1 \
rd.<disk_type>=<storage> random.trust_cpu=on \ 2
rd.luks.options=discard \
ignition.firstboot ignition.platform.id=metal \
console=tty1 console=ttyS1,115200n8 \
coreos.inst.persistent-kargs="console=tty1 console=ttyS1,115200n8
    1
    对于使用 VSwitch 的安装，请添加 zfcp.allow_lun_scan=0。使用 OSA、Hipersockets 和 RoCE 安装省略此条目。
    2
    对于在 DASD 类型磁盘中安装，请使用 rd.dasd= 指定安装磁盘。对于在 FCP 类型磁盘中安装，请使用 rd.zfcp=。

  2. 运行以下命令，将 initrd、内核镜像和参数文件移到客户机虚拟机中： 

    vmur pun -r -u -N kernel.img $INSTALLERKERNELLOCATION/<image name>
    vmur pun -r -u -N generic.parm $PARMFILELOCATION/paramfilename
    vmur pun -r -u -N initrd.img $INSTALLERINITRAMFSLOCATION/<image name>

  3. 在客户机虚拟机控制台中运行以下命令： 

    cp ipl c

  4. 要列出代理及其属性，请输入以下命令： 

    oc -n <hosted_control_plane_namespace> get agents

    请参见以下示例输出： 

    NAME    CLUSTER APPROVED    ROLE    STAGE
50c23cda-cedc-9bbd-bcf1-9b3a5c75804d    auto-assign
5e498cd3-542c-e54f-0c58-ed43e28b568a    auto-assign

  5. 运行以下命令来批准代理。可选： 您可以在规格中设置代理 ID < installation_disk_id> 和 <hostname > ： 

    oc -n <hosted_control_plane_namespace> patch agent 50c23cda-cedc-9bbd-bcf1-9b3a5c75804d -p '{"spec":{"installation_disk_id":"/dev/sda","approved":true,"hostname":"worker-zvm-0.hostedn.example.com"}}' --type merge

  6. 运行以下命令验证代理是否已批准： 

    oc -n <hosted_control_plane_namespace> get agents

    请参见以下示例输出： 

    NAME                                            CLUSTER     APPROVED   ROLE          STAGE
50c23cda-cedc-9bbd-bcf1-9b3a5c75804d             true       auto-assign
5e498cd3-542c-e54f-0c58-ed43e28b568a             true       auto-assign

1.7.10.5. 为使用 IBM Z 托管 control plane 配置 DNS

托管集群的 API 服务器作为 'NodePort' 服务公开。api.<hosted-cluster-name>.<base-domain&gt; 必须存在 DNS 条目，指向可访问 API 服务器的目的地。

DNS 条目可以像一个记录一样简单，指向运行托管 control plane 的受管集群中的一个节点。

该条目也可以指向部署的负载均衡器，以将传入的流量重定向到 Ingress pod。

请参阅以下 DNS 配置示例： 

$ cat /var/named/<example.krnl.es.zone>

请参见以下示例输出： 

$ TTL 900
@ IN  SOA bastion.example.krnl.es.com. hostmaster.example.krnl.es.com. (
      2019062002
      1D 1H 1W 3H )
  IN NS bastion.example.krnl.es.com.
;
;
api                   IN A 1xx.2x.2xx.1xx 1
api-int               IN A 1xx.2x.2xx.1xx
;
;
*.apps        IN A 1xx.2x.2xx.1xx
;
;EOF
1
记录指的是 API 负载均衡器的 IP 地址，它处理托管的 control plane 的入口和出口流量。

对于 IBM z/VM，添加与代理 IP 地址对应的 IP 地址。 

compute-0              IN A 1xx.2x.2xx.1yy
compute-1              IN A 1xx.2x.2xx.1yy

1.7.10.6. 为 IBM Z 计算节点的 x86 裸机上托管 control plane 创建 InfraEnv 资源

InfraEnv 是一个环境，使用 PXE 镜像引导的主机可以作为代理加入。在这种情况下，代理会在与您托管的 control plane 相同的命名空间中创建。

请参阅以下流程来创建 InfraEnv 资源：

  1. 创建包含配置的 YAML 文件。请参见以下示例： 

    apiVersion: agent-install.openshift.io/v1beta1
kind: InfraEnv
metadata:
  name: <hosted-cluster-name>
  namespace: <hosted-control-plane-namespace>
spec:
  cpuArchitecture: s390x
  pullSecretRef:
    name: pull-secret
  sshAuthorizedKey: <ssh-public-key>
  2. 将文件保存为 infraenv-config.yaml。

  3. 输入以下命令应用配置： 

    oc apply -f infraenv-config.yaml

  4. 要获取用于下载 PXE 镜像的 URL，如 initrd.img、kernel.img 或 rootfs.img，它允许 IBM Z 机器作为代理加入，请输入以下命令： 

    oc -n <hosted-control-plane-namespace> get InfraEnv <hosted-cluster-name> -o json

1.7.10.7. 为 IBM Z 上托管集群扩展 NodePool 对象

在创建托管集群时，会创建 NodePool 对象。通过扩展 NodePool 对象，您可以将更多计算节点添加到托管的 control plane 中。

  1. 运行以下命令来将 NodePool 对象扩展到两个节点： 

    oc -n <clusters_namespace> scale nodepool <nodepool_name> --replicas 2

    Cluster API 代理供应商随机选择两个代理，然后分配给托管集群。这些代理通过不同的状态，最后将托管集群作为 OpenShift Container Platform 节点加入。代理按以下顺序传递转换阶段：

    • binding
    • 发现
    • insufficient
    • 安装
    • installing-in-progress
    • added-to-existing-cluster

  2. 运行以下命令查看特定扩展代理的状态： 

    oc -n <hosted_control_plane_namespace> get agent -o jsonpath='{range .items[*]}BMH: {@.metadata.labels.agent-install\.openshift\.io/bmh} Agent: {@.metadata.name} State: {@.status.debugInfo.state}{"\n"}{end}'

    请参见以下输出： 

    BMH: Agent: 50c23cda-cedc-9bbd-bcf1-9b3a5c75804d State: known-unbound
BMH: Agent: 5e498cd3-542c-e54f-0c58-ed43e28b568a State: insufficient

  3. 运行以下命令查看转换阶段： 

    oc -n <hosted_control_plane_namespace> get agent

    请参见以下输出： 

    NAME                                   CLUSTER           APPROVED       ROLE        STAGE
50c23cda-cedc-9bbd-bcf1-9b3a5c75804d   hosted-forwarder   true          auto-assign
5e498cd3-542c-e54f-0c58-ed43e28b568a                      true          auto-assign
da503cf1-a347-44f2-875c-4960ddb04091   hosted-forwarder   true          auto-assign

  4. 运行以下命令以生成 kubeconfig 文件来访问托管集群： 

    hcp create kubeconfig --namespace <clusters_namespace> --name <hosted_cluster_namespace> > <hosted_cluster_name>.kubeconfig

  5. 在代理到达 add-to-existing-cluster 状态后，输入以下命令验证您可以看到 OpenShift Container Platform 节点： 

    oc --kubeconfig <hosted_cluster_name>.kubeconfig get nodes

    请参见以下输出： 

    NAME                             STATUS   ROLES    AGE      VERSION
worker-zvm-0.hostedn.example.com Ready    worker   5m41s    v1.24.0+3882f8f
worker-zvm-1.hostedn.example.com Ready    worker   6m3s     v1.24.0+3882f8f

    集群 Operator 首先通过将工作负载添加到节点来协调。

  6. 输入以下命令验证在扩展 NodePool 对象时是否创建了两台机器： 

    oc -n <hosted_control_plane_namespace> get machine.cluster.x-k8s.io

    请参见以下输出： 

    NAME                                CLUSTER  NODENAME PROVIDERID     PHASE     AGE   VERSION
hosted-forwarder-79558597ff-5tbqp   hosted-forwarder-crqq5   worker-zvm-0.hostedn.example.com   agent://50c23cda-cedc-9bbd-bcf1-9b3a5c75804d   Running   41h   4.15.0
hosted-forwarder-79558597ff-lfjfk   hosted-forwarder-crqq5   worker-zvm-1.hostedn.example.com   agent://5e498cd3-542c-e54f-0c58-ed43e28b568a   Running   41h   4.15.0

  7. 运行以下命令来检查集群版本： 

    oc --kubeconfig <hosted_cluster_name>.kubeconfig get clusterversion,co

    请参见以下输出： 

    NAME                                         VERSION       AVAILABLE   PROGRESSING   SINCE   STATUS
clusterversion.config.openshift.io/version   4.15.0-ec.2   True        False         40h     Cluster version is 4.15.0-ec.2

  8. 运行以下命令来检查集群 Operator 状态： 

    oc --kubeconfig <hosted_cluster_name>.kubeconfig get clusteroperators

对于集群中的每个组件，输出显示以下集群 operator 状态： NAME,VERSION, AVAILABLE ,AVAILABLE,PROGRESSING,DEGRADED,SINCE, 和 MESSAGE。

如需输出示例，请参阅 OpenShift Container Platform 文档中的 Initial Operator 配置部分。

1.7.10.7.1. 其他资源

1.7.11. 在 OpenShift Virtualization 中管理托管的 control plane 集群

使用托管的 control plane 和 Red Hat OpenShift Virtualization，您可以创建带有由 KubeVirt 虚拟机托管的 worker 节点的 OpenShift Container Platform 集群。在 OpenShift Virtualization 上托管的 control plane 提供了几个优点：

  • 通过在相同的底层裸机基础架构中打包托管的 control plane 和托管集群来提高资源使用量
  • 分隔托管的 control plane 和托管集群，以提供强大的隔离
  • 通过消除裸机节点 bootstrap 过程来减少集群置备时间
  • 管理同一基本 OpenShift Container Platform 集群下的多个发行版本

托管的 control plane 功能默认启用。

您可以使用托管的 control plane 命令行界面 hcp 创建 OpenShift Container Platform 托管的集群。托管的集群自动导入为受管集群。如果要禁用此自动导入功能，请参阅禁用将托管集群的自动导入到 multicluster engine operator。

重要：

  • 在托管 control plane 的同一平台上运行 hub 集群和 worker。
  • 每个托管集群都必须具有集群范围的唯一名称。托管的集群名称不能与任何现有受管集群相同，以便 multicluster engine operator 管理它。
  • 不要使用 集群 作为托管的集群名称。
  • 无法在 multicluster engine operator 受管集群的命名空间中创建托管集群。
  • 当您为托管 control plane 配置存储时，请考虑推荐的 etcd 实践。要确保您满足延迟要求，请将快速存储设备专用于每个 control-plane 节点上运行的所有托管的 control plane etcd 实例。您可以使用 LVM 存储为托管 etcd pod 配置本地存储类。如需更多信息，请参阅 OpenShift Container Platform 文档中的使用逻辑卷管理器存储 的建议 etcd 实践 和持久性存储。

1.7.11.1. 先决条件

您必须满足以下先决条件才能在 OpenShift Virtualization 上创建 OpenShift Container Platform 集群：

  • 您需要管理员访问由 KUBECONFIG 环境变量指定的 OpenShift Container Platform 集群，版本 4.14 或更高版本。

  • OpenShift Container Platform 托管集群必须启用通配符 DNS 路由，如下所示： 

    oc patch ingresscontroller -n openshift-ingress-operator default --type=json -p '[{ "op": "add", "path": "/spec/routeAdmission", "value": {wildcardPolicy: "WildcardsAllowed"}}]'
  • OpenShift Container Platform 托管集群必须安装有 OpenShift Virtualization 版本 4.14 或更高版本。如需更多信息，请参阅使用 Web 控制台安装 OpenShift Virtualization。
  • OpenShift Container Platform 托管集群必须使用 OVNKubernetes 配置为默认 pod 网络 CNI。

  • OpenShift Container Platform 托管集群必须具有默认存储类。如需更多信息，请参阅 安装后存储配置。以下示例演示了如何设置默认存储类： 

    oc patch storageclass ocs-storagecluster-ceph-rbd -p '{"metadata": {"annotations":{"storageclass.kubernetes.io/is-default-class":"true"}}}'
  • 您需要 quay.io/openshift-release-dev 存储库的有效的 pull secret 文件。如需更多信息，请参阅使用用户置备的基础架构在任何 x86_64 平台上安装 OpenShift。
  • 您需要安装托管的 control plane 命令行界面。
  • 在置备集群前，您需要配置负载均衡器。如需更多信息，请参阅 可选：配置 MetalLB。
  • 为获得最佳网络性能，请在托管 KubeVirt 虚拟机的 OpenShift Container Platform 集群上使用网络最大传输单元(MTU) 9000 或更高。如果您使用较低的 MTU 设置，则影响托管 pod 的网络延迟和吞吐量。仅在 MTU 为 9000 或更高版本时，在节点池中启用多队列。

  • multicluster engine operator 必须至少有一个受管 OpenShift Container Platform 集群。local-cluster 会自动导入。有关 local-cluster 的更多信息，请参阅高级配置。您可以运行以下命令来检查 hub 集群的状态： 

    oc get managedclusters local-cluster

1.7.11.2. 防火墙和端口要求

确保满足防火墙和端口要求，以便端口可以在管理集群、control plane 和托管的集群间进行通信：

  • kube-apiserver 服务默认在端口 6443 上运行，需要 ingress 访问 control plane 组件之间的通信。

    • 如果使用 NodePort 发布策略，请确保公开给 kube-apiserver 服务的节点端口。
    • 如果使用 MetalLB 负载均衡，允许对用于负载均衡器 IP 地址的 IP 范围进行入口访问。
  • 如果使用 NodePort 发布策略，请为 ignition-server 和 Oauth-server 设置使用防火墙规则。

  • konnectivity 代理建立反向隧道，以允许托管集群上的双向通信，需要在端口 6443 上出口访问集群 API 服务器地址。通过该出口访问，代理可以访问 kube-apiserver 服务。

    • 如果集群 API 服务器地址是一个内部 IP 地址，允许从工作负载子网访问端口 6443 上的 IP 地址。
    • 如果地址是一个外部 IP 地址，允许将端口 6443 上的出口从节点传输到该外部 IP 地址。
  • 如果您更改了 6443 的默认端口，请调整规则以反映该更改。
  • 确保打开在集群中运行的工作负载所需的任何端口。
  • 使用防火墙规则、安全组或其他访问控制来限制对所需源的访问。除非必要，否则请避免公开端口。
  • 对于生产环境部署，请使用负载均衡器通过单个 IP 地址简化访问。

有关 Red Hat OpenShift Virtualization 上托管 control plane 的其他资源，请参阅以下文档：

1.7.11.3. 使用 KubeVirt 平台创建托管集群

在 OpenShift Container Platform 4.14 及更新的版本中，您可以创建一个具有 KubeVirt 的集群，使其包含使用外部基础架构创建。了解更多有关使用 KubeVirt 创建的进程的信息：

1.7.11.3.1. 创建托管集群

  1. 要创建托管集群，请使用托管的 control plane 命令行界面 hcp ： 

    hcp create cluster kubevirt \
--name <hosted-cluster-name> \ 1
--node-pool-replicas <worker-count> \ 2
--pull-secret <path-to-pull-secret> \ 3
--memory <value-for-memory> \ 4
--cores <value-for-cpu> \ 5
--etcd-storage-class=<etcd-storage-class> 6
    1
    指定托管集群的名称，例如。
    2
    指定 worker 数量，如 2。
    3
    指定 pull secret 的路径，例如 /user/name/pullsecret。
    4
    为 memory 指定一个值，例如 6Gi。
    5
    为 CPU 指定一个值，例如 2。
    6
    指定 etcd 存储类名称，例如 lvm-storageclass。

    注： 您可以使用 --release-image 标志使用特定的 OpenShift Container Platform 发行版本设置托管集群。

    根据 --node-pool-replicas 标志，为集群创建一个默认节点池，它有两个虚拟机 worker 副本。

  2. 片刻后，输入以下命令验证托管的 control plane pod 是否正在运行： 

    oc -n clusters-<hosted-cluster-name> get pods

    请参见以下示例输出： 

    NAME                                                  READY   STATUS    RESTARTS   AGE
capi-provider-5cc7b74f47-n5gkr                        1/1     Running   0          3m
catalog-operator-5f799567b7-fd6jw                     2/2     Running   0          69s
certified-operators-catalog-784b9899f9-mrp6p          1/1     Running   0          66s
cluster-api-6bbc867966-l4dwl                          1/1     Running   0          66s
.
.
.
redhat-operators-catalog-9d5fd4d44-z8qqk              1/1     Running   0          66s

    具有 KubeVirt 虚拟机支持的 worker 节点的托管集群通常需要 10-15 分钟才能被完全置备。

  3. 要检查托管集群的状态，请输入以下命令来查看对应的 HostedCluster 资源： 

    oc get --namespace clusters hostedclusters

    请参阅以下示例输出，它演示了一个完全置备的 HostedCluster 对象： 

    NAMESPACE   NAME      VERSION   KUBECONFIG                 PROGRESS    AVAILABLE   PROGRESSING   MESSAGE
clusters    example   4.x.0     example-admin-kubeconfig   Completed   True        False         The hosted control plane is available

    将 4.x.0 替换为您要使用的 OpenShift Container Platform 版本。

  4. 按照访问托管集群中的说明 访问托管集群。
1.7.11.3.2. 使用外部基础架构创建托管集群

默认情况下，HyperShift Operator 同时托管托管集群的 control plane pod 和同一集群中的 KubeVirt worker 虚拟机。使用外部基础架构功能，您可以将 worker 节点虚拟机放在与 control plane pod 独立的集群中。

  • 管理集群 是运行 HyperShift Operator 的 OpenShift Container Platform 集群，并为托管集群托管 control plane pod。
  • 基础架构集群是 为托管集群运行 KubeVirt worker 虚拟机的 OpenShift Container Platform 集群。
  • 默认情况下，管理集群也充当托管虚拟机的基础架构集群。但是，对于外部基础架构，管理和基础架构集群会有所不同。
1.7.11.3.2.1. 外部基础架构的先决条件
  • 您必须在外部基础架构集群中有一个命名空间，才能托管 KubeVirt 节点。
  • 您必须具有外部基础架构集群的 kubeconfig 文件。
1.7.11.3.2.2. 使用 hcp 命令行界面创建托管集群

您可以使用 hcp 命令行界面创建托管集群。

  1. 要将 KubeVirt worker 虚拟机放在基础架构集群中，请使用 --infra-kubeconfig-file 和 --infra-namespace 参数，如下例所示： 

    hcp create cluster kubevirt \
--name <hosted-cluster-name> \ 1
--node-pool-replicas <worker-count> \ 2
--pull-secret <path-to-pull-secret> \ 3
--memory <value-for-memory> \ 4
--cores <value-for-cpu> \ 5
--infra-namespace=<hosted-cluster-namespace>-<hosted-cluster-name> \ 6
--infra-kubeconfig-file=<path-to-external-infra-kubeconfig> 7
    1
    指定托管集群的名称，例如。
    2
    指定 worker 数量，如 2。
    3
    指定 pull secret 的路径，例如 /user/name/pullsecret。
    4
    为 memory 指定一个值，例如 6Gi。
    5
    为 CPU 指定一个值，例如 2。
    6
    指定基础架构命名空间，如 cluster -example。
    7
    为基础架构集群指定 kubeconfig 文件的路径，如 /user/name/external-infra-kubeconfig。

    输入该命令后，control plane pod 托管在 HyperShift Operator 上运行的管理集群上，并且 KubeVirt 虚拟机托管在一个单独的基础架构集群中。

  2. 按照访问托管集群中的说明 访问托管集群。
1.7.11.3.3. 使用控制台创建托管集群

要使用控制台创建带有 KubeVirt 平台的托管集群，请完成以下步骤：

  1. 打开 OpenShift Container Platform Web 控制台，并通过输入管理员凭证登录。有关打开控制台的说明，请参阅 OpenShift Container Platform 文档中的 访问 Web 控制台。
  2. 在控制台标头中，确保选择了 All Clusters。
  3. 点 Infrastructure > Clusters。
  4. 点 Create cluster > Red Hat OpenShift Virtualization > Hosted。

  5. 在 Create cluster 页面中，按照提示输入集群和节点池的详情。

    备注：

    • 如果要使用预定义的值来自动填充控制台中的字段，您可以创建 Red Hat OpenShift Virtualization 凭证。如需更多信息，请参阅 为内部环境创建凭证。
    • 在 Cluster details 页面中，pull secret 是用于访问 OpenShift Container Platform 资源的 OpenShift Container Platform pull secret。如果您选择了 Red Hat OpenShift Virtualization 凭证，pull secret 会自动填充。

  6. 检查您的条目并点 Create。

    此时会显示 Hosted 集群 视图。

  7. 在 Hosted 集群 视图中监控托管集群的部署。如果没有看到有关托管集群的信息，请确保选择了 All Clusters，然后点集群名称。
  8. 等待 control plane 组件就绪。这个过程可能需要几分钟时间。
  9. 要查看节点池状态，可滚动到 NodePool 部分。安装节点的过程大约需要 10 分钟。您还可以单击 Nodes 来确认节点是否加入托管集群。
1.7.11.3.4. 其他资源

1.7.11.4. 默认入口和 DNS 行为

每个 OpenShift Container Platform 集群都包括一个默认的应用程序 Ingress Controller，它必须关联有通配符 DNS 记录。默认情况下，使用 HyperShift KubeVirt 供应商创建的托管集群会自动成为 KubeVirt 虚拟机上运行的 OpenShift Container Platform 集群的子域。

例如，OpenShift Container Platform 集群可能有以下默认入口 DNS 条目： 

*.apps.mgmt-cluster.example.com

因此，名为 guest 的 KubeVirt 托管集群，并在该底层 OpenShift Container Platform 集群上运行有以下默认入口： 

*.apps.guest.apps.mgmt-cluster.example.com

要使默认入口 DNS 正常工作，托管 KubeVirt 虚拟机的集群必须允许通配符 DNS 路由。您可以输入以下命令来配置此行为： 

oc patch ingresscontroller -n openshift-ingress-operator default --type=json -p '[{ "op": "add", "path": "/spec/routeAdmission", "value": {wildcardPolicy: "WildcardsAllowed"}}]'

注： 当您使用默认托管集群入口时，连接会被限制为通过端口 443 进行 HTTPS 流量。通过端口 80 的普通 HTTP 流量将被拒绝。这个限制只适用于默认的入口行为。

1.7.11.4.1. 自定义入口和 DNS 行为

如果您不想使用默认入口和 DNS 行为，您可以在创建时配置带有唯一基域的 KubeVirt 托管集群。这个选项需要创建过程中手动配置步骤，并涉及三个主要步骤：集群创建、负载均衡器创建和通配符 DNS 配置。

1.7.11.4.1.1. 部署指定基域的托管集群

  1. 要创建指定基域的托管集群，请输入以下命令： 

    hcp create cluster kubevirt \
--name <hosted-cluster-name> \ 1
--node-pool-replicas <worker-count> \ 2
--pull-secret <path-to-pull-secret> \ 3
--memory <value-for-memory> \ 4
--cores <value-for-cpu> \ 5
--base-domain <basedomain> 6
1
指定托管集群的名称，例如。
2
指定 worker 数量，如 2。
3
指定 pull secret 的路径，例如 /user/name/pullsecret。
4
为 memory 指定一个值，例如 6Gi。
5
为 CPU 指定一个值，例如 2。
6
指定基域，如 hypershift.lab。

因此，托管集群有一个入口通配符，它为集群名称和基域配置，如 .apps.example.hypershift.lab。托管的集群处于 Partial 状态。因为在使用唯一基域创建托管集群后，您必须配置所需的 DNS 记录和负载均衡器。

  1. 输入以下命令来查看托管集群的状态： 

    oc get --namespace clusters hostedclusters

    请参见以下示例输出： 

    NAME            VERSION   KUBECONFIG                       PROGRESS   AVAILABLE   PROGRESSING   MESSAGE
example                   example-admin-kubeconfig         Partial    True        False         The hosted control plane is available

  2. 输入以下命令访问集群： 

    hcp create kubeconfig --name <hosted-cluster-name> > <hosted-cluster-name>-kubeconfig
    oc --kubeconfig <hosted-cluster-name>-kubeconfig get co

    请参见以下示例输出： 

    NAME                                       VERSION   AVAILABLE   PROGRESSING   DEGRADED   SINCE   MESSAGE
console                                    4.x.0     False       False         False      30m     RouteHealthAvailable: failed to GET route (https://console-openshift-console.apps.example.hypershift.lab): Get "https://console-openshift-console.apps.example.hypershift.lab": dial tcp: lookup console-openshift-console.apps.example.hypershift.lab on 172.31.0.10:53: no such host
ingress                                    4.x.0     True        False         True       28m     The "default" ingress controller reports Degraded=True: DegradedConditions: One or more other status conditions indicate a degraded state: CanaryChecksSucceeding=False (CanaryChecksRepetitiveFailures: Canary route checks for the default ingress controller are failing)

    将 4.x.0 替换为您要使用的 OpenShift Container Platform 版本。

    后续步骤修复了输出中的错误。

    注： 如果托管集群位于裸机上，您可能需要 MetalLB 来设置负载均衡器服务。如需更多信息，请参阅 可选：配置 MetalLB。

1.7.11.4.1.2. 设置负载均衡器

设置将入口流量路由到 KubeVirt 虚拟机的负载均衡器服务，并为负载均衡器 IP 地址分配通配符 DNS 条目。

  1. 公开托管集群入口的 NodePort 服务已存在。您可以导出节点端口并创建以这些端口为目标的负载均衡器服务。

    1. 输入以下命令来获取 HTTP 节点端口： 

      oc --kubeconfig <hosted-cluster-name>-kubeconfig get services -n openshift-ingress router-nodeport-default -o jsonpath='{.spec.ports[?(@.name=="http")].nodePort}'

      注意下一步中使用的 HTTP 节点端口值。

    2. 输入以下命令来获取 HTTPS 节点端口： 

      oc --kubeconfig <hosted-cluster-name>-kubeconfig get services -n openshift-ingress router-nodeport-default -o jsonpath='{.spec.ports[?(@.name=="https")].nodePort}'

    请注意下一步中使用的 HTTPS 节点端口值。

  2. 运行以下命令来创建负载均衡器服务： 

    oc apply -f -
apiVersion: v1
kind: Service
metadata:
  labels:
    app: <hosted-cluster-name>
  name: <hosted-cluster-name>-apps
  namespace: clusters-<hosted-cluster-name>
spec:
  ports:
  - name: https-443
    port: 443
    protocol: TCP
    targetPort: <https-node-port> 1
  - name: http-80
    port: 80
    protocol: TCP
    targetPort: <http-node-port> 2
  selector:
    kubevirt.io: virt-launcher
  type: LoadBalancer
    1
    指定您在上一步中记录的 HTTPS 节点端口值。
    2
    指定您在上一步中记录的 HTTP 节点端口值。
1.7.11.4.1.3. 设置通配符 DNS

设置引用负载均衡器服务外部 IP 的通配符 DNS 记录或 CNAME。

  1. 输入以下命令来获取外部 IP 地址： 

    oc -n clusters-<hosted-cluster-name> get service <hosted-cluster-name>-apps -o jsonpath='{.status.loadBalancer.ingress[0].ip}'

    请参见以下示例输出： 

    192.168.20.30

  2. 配置引用外部 IP 地址的通配符 DNS 条目。查看以下 DNS 条目示例： 

    *.apps.<hosted-cluster-name\>.<base-domain\>.

    DNS 条目必须能够在集群内部和外部路由。请参阅以下 DNS 解析示例： 

    dig +short test.apps.example.hypershift.lab

192.168.20.30

  3. 输入以下命令检查托管的集群状态已从 Partial 移到 Completed ： 

    oc get --namespace clusters hostedclusters

    请参见以下示例输出： 

    NAME            VERSION   KUBECONFIG                       PROGRESS    AVAILABLE   PROGRESSING   MESSAGE
example         4.x.0     example-admin-kubeconfig         Completed   True        False         The hosted control plane is available

    将 4.x.0 替换为您要使用的 OpenShift Container Platform 版本。

1.7.11.4.1.4. 其他资源

1.7.11.5. 可选：配置 MetalLB

您必须先安装 MetalLB Operator，然后才能配置 MetalLB。如需更多信息，请参阅 OpenShift Container Platform 文档中的安装 MetalLB Operator。

执行以下步骤在客户机集群中配置 MetalLB：

  1. 通过在 configure-metallb.yaml 文件中保存以下示例 YAML 内容来创建 MetalLB 资源： 

    apiVersion: metallb.io/v1beta1
kind: MetalLB
metadata:
  name: metallb
  namespace: metallb-system

  2. 输入以下命令应用 YAML 内容： 

    oc apply -f configure-metallb.yaml

    请参见以下示例输出： 

    metallb.metallb.io/metallb created

  3. 通过在 create-ip-address-pool.yaml 文件中保存以下示例 YAML 内容来创建 IPAddressPool 资源： 

    apiVersion: metallb.io/v1beta1
kind: IPAddressPool
metadata:
  name: metallb
  namespace: metallb-system
spec:
  addresses:
  - 192.168.216.32-192.168.216.122 1
    1
    创建在节点网络中可用 IP 地址范围的地址池。将 IP 地址范围替换为网络中的可用 IP 地址池。

  4. 输入以下命令应用 YAML 内容： 

    oc apply -f create-ip-address-pool.yaml

    请参见以下示例输出： 

    ipaddresspool.metallb.io/metallb created

  5. 通过在 l2advertisement.yaml 文件中保存以下示例 YAML 内容来创建 L2Advertisement 资源： 

    apiVersion: metallb.io/v1beta1
kind: L2Advertisement
metadata:
  name: l2advertisement
  namespace: metallb-system
spec:
  ipAddressPools:
   - metallb

  6. 输入以下命令应用 YAML 内容： 

    oc apply -f l2advertisement.yaml

    请参见以下示例输出： 

    l2advertisement.metallb.io/metallb created
1.7.11.5.1. 其他资源

1.7.11.6. 为节点池配置额外网络、保证 CPU 和虚拟机调度

如果您需要为节点池配置额外网络，请对虚拟机(VM)请求保证 CPU 访问或管理 KubeVirt 虚拟机的调度，请参阅以下步骤。

1.7.11.6.1. 将多个网络添加到节点池

默认情况下，节点池生成的节点附加到 pod 网络。您可以使用 Multus 和 NetworkAttachmentDefinition 将额外网络附加到节点。

要将多个网络添加到节点，请运行以下命令来使用 --additional-network 参数： 

hcp create cluster kubevirt \
--name <hosted_cluster_name> \ 1
--node-pool-replicas <worker_node_count> \ 2
--pull-secret <path_to_pull_secret> \ 3
--memory <memory> \ 4
--cores <cpu> \ 5
--additional-network name:<namespace/name> \ 6
–-additional-network name:<namespace/name>
1
指定托管集群的名称，例如。
2
指定 worker 节点数，例如 2。
3
指定 pull secret 的路径，例如 /user/name/pullsecret。
4
指定内存值，例如 8Gi。
5
指定 CPU 值，例如 2。
6
将 -additional-network 参数的值设置为 name:<namespace/name>。将 <namespace/name > 替换为 NetworkAttachmentDefinition 的命名空间和名称。
1.7.11.6.2. 请求保证 CPU 资源

默认情况下，KubeVirt 虚拟机可能会与节点上的其他工作负载共享其 CPU。这会影响虚拟机的性能。为了避免性能影响，您可以请求虚拟机的 CPU 访问。

要请求保证的 CPU 资源，请运行以下命令将 --qos-class 参数设置为 Guaranteed ： 

hcp create cluster kubevirt \
--name <hosted_cluster_name> \ 1
--node-pool-replicas <worker_node_count> \ 2
--pull-secret <path_to_pull_secret> \ 3
--memory <memory> \ 4
--cores <cpu> \ 5
--qos-class Guaranteed 6
1
指定托管集群的名称，例如。
2
指定 worker 节点数，例如 2。
3
指定 pull secret 的路径，例如 /user/name/pullsecret。
4
指定内存值，例如 8Gi。
5
指定 CPU 值，例如 2。
6
--qos-class Guaranteed 参数保证指定数量的 CPU 资源被分配给虚拟机。
1.7.11.6.3. 在一组节点上调度 KubeVirt VM

默认情况下，节点池创建的 KubeVirt 虚拟机被调度到任何可用的节点。您可以将 KubeVirt VM 调度到具有足够容量以运行虚拟机的特定节点。

要在特定节点池中调度 KubeVirt 虚拟机，请运行以下命令来使用 --vm-node-selector 参数： 

hcp create cluster kubevirt \
--name <hosted_cluster_name> \ 1
--node-pool-replicas <worker_node_count> \ 2
--pull-secret <path_to_pull_secret> \ 3
--memory <memory> \ 4
--cores <cpu> \ 5
--vm-node-selector <label_key>=<label_value>,<label_key>=<label_value> 6
1
指定托管集群的名称，例如。
2
指定 worker 节点数，例如 2。
3
指定 pull secret 的路径，例如 /user/name/pullsecret。
4
指定内存值，例如 8Gi。
5
指定 CPU 值，例如 2。
6
--vm-node-selector 标志定义包含键值对的特定节点集合。将 <label_key & gt; 和 <label_ value> 替换为标签的键和值。

1.7.11.7. 扩展节点池

  1. 您可以使用 oc scale 命令手动扩展节点池： 

    NODEPOOL_NAME=${CLUSTER_NAME}-work
NODEPOOL_REPLICAS=5

oc scale nodepool/$NODEPOOL_NAME --namespace clusters --replicas=$NODEPOOL_REPLICAS

  2. 片刻后，输入以下命令查看节点池的状态： 

    oc --kubeconfig $CLUSTER_NAME-kubeconfig get nodes

    请参见以下示例输出： 

    NAME                  STATUS   ROLES    AGE     VERSION
example-9jvnf         Ready    worker   97s     v1.27.4+18eadca
example-n6prw         Ready    worker   116m    v1.27.4+18eadca
example-nc6g4         Ready    worker   117m    v1.27.4+18eadca
example-thp29         Ready    worker   4m17s   v1.27.4+18eadca
example-twxns         Ready    worker   88s     v1.27.4+18eadca
1.7.11.7.1. 添加节点池

您可以通过指定名称、副本数和任何其他信息（如内存和 CPU 要求）来为托管集群创建节点池。

  1. 要创建节点池，请输入以下信息：在本例中，节点池分配有更多 CPU: 

    export NODEPOOL_NAME=${CLUSTER_NAME}-extra-cpu
export WORKER_COUNT="2"
export MEM="6Gi"
export CPU="4"
export DISK="16"

hcp create nodepool kubevirt \
  --cluster-name $CLUSTER_NAME \
  --name $NODEPOOL_NAME \
  --node-count $WORKER_COUNT \
  --memory $MEM \
  --cores $CPU \
  --root-volume-size $DISK

  2. 通过列出 cluster 命名空间中的 nodepool 资源来检查节点池的状态： 

    oc get nodepools --namespace clusters

    请参见以下示例输出： 

    NAME                      CLUSTER         DESIRED NODES   CURRENT NODES   AUTOSCALING   AUTOREPAIR   VERSION   UPDATINGVERSION   UPDATINGCONFIG   MESSAGE
example                   example         5               5               False         False        4.x.0
example-extra-cpu         example         2                               False         False                  True              True             Minimum availability requires 2 replicas, current 0 available

    将 4.x.0 替换为您要使用的 OpenShift Container Platform 版本。

  3. 一段时间后，您可以输入以下命令检查节点池的状态： 

    oc --kubeconfig $CLUSTER_NAME-kubeconfig get nodes

    请参见以下示例输出： 

    NAME                      STATUS   ROLES    AGE     VERSION
example-9jvnf             Ready    worker   97s     v1.27.4+18eadca
example-n6prw             Ready    worker   116m    v1.27.4+18eadca
example-nc6g4             Ready    worker   117m    v1.27.4+18eadca
example-thp29             Ready    worker   4m17s   v1.27.4+18eadca
example-twxns             Ready    worker   88s     v1.27.4+18eadca
example-extra-cpu-zh9l5   Ready    worker   2m6s    v1.27.4+18eadca
example-extra-cpu-zr8mj   Ready    worker   102s    v1.27.4+18eadca

  4. 输入以下命令验证节点池是否处于您所期望的状态： 

    oc get nodepools --namespace clusters

    请参见以下示例输出： 

    NAME                      CLUSTER         DESIRED NODES   CURRENT NODES   AUTOSCALING   AUTOREPAIR   VERSION   UPDATINGVERSION   UPDATINGCONFIG   MESSAGE
example                   example         5               5               False         False        4.x.0
example-extra-cpu         example         2               2               False         False        4.x.0

    将 4.x.0 替换为您要使用的 OpenShift Container Platform 版本。

1.7.11.7.1.1. 其他资源

1.7.11.8. 在 OpenShift Virtualization 上验证托管集群创建

要验证托管集群是否已成功创建，请完成以下步骤。

  1. 输入以下命令验证 HostedCluster 资源是否过渡到 completed 状态： 

    oc get --namespace clusters hostedclusters ${CLUSTER_NAME}

    请参见以下示例输出： 

    NAMESPACE   NAME      VERSION   KUBECONFIG                 PROGRESS    AVAILABLE   PROGRESSING   MESSAGE
clusters    example   4.12.2    example-admin-kubeconfig   Completed   True        False         The hosted control plane is available

  2. 输入以下命令验证托管的集群中的所有集群 Operator 是否在线： 

    hcp create kubeconfig --name $CLUSTER_NAME > $CLUSTER_NAME-kubeconfig
    oc get co --kubeconfig=$CLUSTER_NAME-kubeconfig

    请参见以下示例输出： 

    NAME                                       VERSION   AVAILABLE   PROGRESSING   DEGRADED   SINCE   MESSAGE
console                                    4.12.2   True        False         False      2m38s
csi-snapshot-controller                    4.12.2   True        False         False      4m3s
dns                                        4.12.2   True        False         False      2m52s
image-registry                             4.12.2   True        False         False      2m8s
ingress                                    4.12.2   True        False         False      22m
kube-apiserver                             4.12.2   True        False         False      23m
kube-controller-manager                    4.12.2   True        False         False      23m
kube-scheduler                             4.12.2   True        False         False      23m
kube-storage-version-migrator              4.12.2   True        False         False      4m52s
monitoring                                 4.12.2   True        False         False      69s
network                                    4.12.2   True        False         False      4m3s
node-tuning                                4.12.2   True        False         False      2m22s
openshift-apiserver                        4.12.2   True        False         False      23m
openshift-controller-manager               4.12.2   True        False         False      23m
openshift-samples                          4.12.2   True        False         False      2m15s
operator-lifecycle-manager                 4.12.2   True        False         False      22m
operator-lifecycle-manager-catalog         4.12.2   True        False         False      23m
operator-lifecycle-manager-packageserver   4.12.2   True        False         False      23m
service-ca                                 4.12.2   True        False         False      4m41s
storage                                    4.12.2   True        False         False      4m43s

1.7.11.9. 为 OpenShift Virtualization 上托管的 control plane 配置存储

如果没有提供高级配置，则默认存储类用于 KubeVirt 虚拟机(VM)镜像、KubeVirt CSI 映射和 etcd 卷。

1.7.11.9.1. 映射 KubeVirt CSI 存储类

kubevirt CSI 允许任何具有 ReadWriteMany 访问模式的基础架构存储类公开给托管集群。您可以使用 --infra-storage-class-mapping 参数在集群创建过程中将基础架构集群存储类的这个映射配置为托管集群的存储类。

要将基础架构存储类映射到托管存储类，请参阅以下示例： 

hcp create cluster kubevirt \
--name <hosted-cluster-name> \ 1
--node-pool-replicas <worker-count> \ 2
--pull-secret <path-to-pull-secret> \ 3
--memory <value-for-memory> \ 4
--cores <value-for-cpu> \ 5
--infra-storage-class-mapping=<storage-class>/<hosted-storage-class> \ 6
1
指定托管集群的名称，例如。
2
指定 worker 数量，如 2。
3
指定 pull secret 的路径，例如 /user/name/pullsecret。
4
为 memory 指定一个值，例如 6Gi。
5
为 CPU 指定一个值，例如 2。
6
将 <storage-class > 替换为基础架构存储类名称，将 < hosted-storage-class > 替换为托管的集群存储类名称。您可以在 create 命令中多次使用 --infra-storage-class-mapping 参数。

创建托管集群后，基础架构存储类会在托管集群中可见。当您在使用其中一个存储类的托管集群中创建 PVC 时，KubeVirt CSI 会使用您在集群创建过程中配置的基础架构存储类映射来置备卷。

注： KubeVirt CSI 仅支持映射能够 ReadWriteMany (RWX)访问的基础架构存储类。

1.7.11.9.2. 配置 KubeVirt VM root 卷

在集群创建时，您可以使用 --root-volume-storage-class 参数配置用于托管 KubeVirt VM root 卷的存储类。

要为 KubeVirt 虚拟机设置自定义存储类和卷大小，请参阅以下示例： 

hcp create cluster kubevirt \
--name <hosted-cluster-name> \ 1
--node-pool-replicas <worker-count> \ 2
--pull-secret <path-to-pull-secret> \ 3
--memory <value-for-memory> \ 4
--cores <value-for-cpu> \ 5
--root-volume-storage-class <root-volume-storage-class> \ 6
--root-volume-size <volume-size> 7
1
指定托管集群的名称，例如。
2
指定 worker 数量，如 2。
3
指定 pull secret 的路径，例如 /user/name/pullsecret。
4
为 memory 指定一个值，例如 6Gi。
5
为 CPU 指定一个值，例如 2。
6
指定用于托管 KubeVirt VM root 卷的存储类的名称，如 ocs-storagecluster-ceph-rbd。
7
指定卷大小，例如 64。

结果是一个托管的、由 ocs-storagecluster-ceph-rdb 存储类托管的 PVC 上的虚拟机。

1.7.11.9.3. 启用 KubeVirt 虚拟机镜像缓存

kubevirt 镜像缓存是一个高级功能，可用于优化集群启动时间和存储利用率。此功能需要使用能够智能克隆和 ReadWriteMany 访问模式的存储类。有关智能克隆的更多信息 ，请参阅使用智能克隆克隆数据卷。

镜像缓存按如下方式工作：

  1. 虚拟机镜像导入到与托管集群关联的 PVC 中。
  2. 为添加到集群的每个 KubeVirt 虚拟机创建一个 PVC 的唯一克隆。

镜像缓存只需要单个镜像导入来减少虚拟机启动时间。当存储类支持写时复制克隆时，它可以进一步减少集群存储使用。

要启用镜像缓存，在集群创建过程中使用 --root-volume-cache-strategy=PVC 参数，如下例所示： 

hcp create cluster kubevirt \
--name <hosted-cluster-name> \ 1
--node-pool-replicas <worker-count> \ 2
--pull-secret <path-to-pull-secret> \ 3
--memory <value-for-memory> \ 4
--cores <value-for-cpu> \ 5
--root-volume-cache-strategy=PVC 6
1
指定托管集群的名称，例如。
2
指定 worker 数量，如 2。
3
指定 pull secret 的路径，例如 /user/name/pullsecret。
4
为 memory 指定一个值，例如 6Gi。
5
为 CPU 指定一个值，例如 2。
6
为镜像缓存指定一个策略，如 PVC。
1.7.11.9.4. 配置 etcd 存储

在集群创建时，您可以使用 --etcd-storage-class 参数配置用于托管 etcd 数据的存储类。

要为 etcd 配置存储类，请参阅以下示例： 

hcp create cluster kubevirt \
--name <hosted-cluster-name> \ 1
--node-pool-replicas <worker-count> \ 2
--pull-secret <path-to-pull-secret> \ 3
--memory <value-for-memory> \ 4
--cores <value-for-cpu> \ 5
--etcd-storage-class=<etcd-storage-class-name> 6
1
指定托管集群的名称，例如。
2
指定 worker 数量，如 2。
3
指定 pull secret 的路径，例如 /user/name/pullsecret。
4
为 memory 指定一个值，例如 6Gi。
5
为 CPU 指定一个值，例如 2。
6
指定 etcd 存储类名称，例如 lvm-storageclass。如果没有提供 --etcd-storage-class 参数，则会使用默认存储类。
1.7.11.9.4.1. 其他资源

1.7.11.10. 在 OpenShift Virtualization 上销毁托管集群

要销毁托管的集群及其受管集群资源，请完成以下步骤：

  1. 运行以下命令，删除 multicluster engine operator 上的受管集群资源： 

    oc delete managedcluster <managed_cluster_name>

    其中 <managed_cluster_name > 是受管集群的名称。

  2. 运行以下命令来删除托管集群及其后端资源： 

    hcp destroy cluster kubevirt --name <hosted_cluster_name>

    将 <hosted_cluster_name > 替换为您的托管的集群名称。

1.7.12. 在断开连接的环境中配置托管的 control plane

断开连接的环境是没有连接到互联网的 OpenShift Container Platform 集群，它使用托管的 control plane 作为基础。

技术预览： 您可以使用 IPv4 或 IPv6 网络在裸机平台上在断开连接的环境中部署托管的 control plane。另外，在断开连接的环境中托管的 control plane 作为一个技术预览功能在双栈网络中提供。如果您使用 Red Hat OpenShift Virtualization 平台，则在断开连接的环境中托管的 control plane 仅作为技术预览功能提供。

1.7.12.1. 断开连接的环境架构

您可以使用 Agent 平台在裸机上置备托管的 control plane。Agent 平台使用中央基础架构管理服务将 worker 节点添加到托管集群。有关中央基础架构管理服务简介，请参阅 启用中央基础架构管理服务。

请参阅以下断开连接的环境架构图：

Disconnected architecture diagram

  1. 配置基础架构服务，包括带有 TLS 支持、Web 服务器和 DNS 的 registry 证书部署，以确保断开连接的部署正常工作。

  2. 在 openshift-config 命名空间中创建配置映射。配置映射的内容是 Registry CA 证书。配置映射的 data 字段必须包含以下键和值：

    • Key: & lt;registry_dns_domain_name>..<port >，例如 registry.hypershiftdomain.lab..5000:。在指定端口时， 请确保将 .. 放在 registry DNS 域名后。
    • Value ：证书内容

    有关创建配置映射的更多信息，请参阅为 IPv4 网络配置 TLS 证书。

  3. 在 images.config.openshift.io 自定义资源(CR)中添加 additionalTrustedCA 字段，值设为 name: registry-config。

  4. 在 multicluster-engine 命名空间中创建配置映射。请参见以下示例配置： 

    apiVersion: v1
kind: ConfigMap
metadata:
  name: custom-registries
  namespace: multicluster-engine
  labels:
    app: assisted-service
data:
  ca-bundle.crt: | 1
    -----BEGIN CERTIFICATE-----
    ...
    ...
    ...
    -----END CERTIFICATE-----
  registries.conf: | 2
    unqualified-search-registries = ["registry.access.redhat.com", "docker.io"]

    [[registry]]
    prefix = ""
    location = "registry.redhat.io/openshift4"
    mirror-by-digest-only = true

    [[registry.mirror]]
      location = "registry.ocp-edge-cluster-0.qe.lab.redhat.com:5000/openshift4"

    [[registry]]
    prefix = ""
    location = "registry.redhat.io/rhacm2"
    mirror-by-digest-only = true
...
...
1
包含 registry 的 CA 证书。
2
包含 RAW 格式的 registry.conf 文件内容。
  1. 在 multicluster engine operator 命名空间中，您可以创建 multiclusterengine CR，它将同时启用 Agent 和 hypershift-addon 附加组件。multicluster engine operator 命名空间必须包含配置映射，才能修改断开连接的部署中的行为。命名空间还包含 multicluster-engine、assisted-service 和 hypershift-addon-manager pod。

  2. 为以下组件创建对象来部署托管集群：

    • secret： Secret 包含 pull secret、SSH 密钥和 etcd 加密密钥。
    • 配置映射 ：配置映射包含私有 registry 的 CA 证书。
    • HostedCluster ： HostedCluster 资源定义托管集群的配置。
    • NodePool: NodePool 资源标识引用用于数据平面的机器的节点池。
  3. 创建托管集群对象后，HyperShift Operator 在 HostedControlPlane 命名空间中创建 control plane pod。HostedControlPlane 命名空间还托管代理、裸机主机和 InfraEnv 资源等组件。
  4. 创建 InfraEnv 资源。生成 ISO 镜像后，创建裸机主机及其包含基板管理控制器(BMC)凭证的 secret。
  5. openshift-machine-api 命名空间中的 Metal3 Operator 会检查新的裸机主机。
  6. Metal3 Operator 会尝试使用 LiveISO 和 RootFS 值连接并启动 BMC。您可以通过 multicluster engine operator 命名空间中的 AgentServiceConfig CR 指定 LiveISO 和 RootFS 值。
  7. 启动 HostedCluster 资源的 worker 节点后，会启动 Agent 容器。
  8. 将 NodePool 资源扩展到 HostedCluster 资源的 worker 节点数量。
  9. 等待部署过程完成。

1.7.12.2. 先决条件

要在断开连接的环境中配置托管的 control plane，您必须满足以下条件：

  • CPU：提供的 CPU 数量决定了可以同时运行多少个托管集群。通常，每个节点为 3 个节点使用 16 个 CPU。对于最小开发，您可以对 3 个节点使用 12 个 CPU。
  • memory： RAM 量会影响您可以托管的托管集群的数量。每个节点使用 48 GB RAM。对于最小开发，18 GB RAM 可能已经足够。

  • Storage ：将 SSD 存储用于多集群引擎 operator。

    • 管理集群： 250 GB.
    • registry：所需的 registry 存储取决于托管的发行版本、Operator 和镜像的数量。您可能需要 500 GB，最好与托管集群的磁盘分开。
    • Web 服务器：所需的 Web 服务器存储取决于托管的 ISO 和镜像的数量。您可能需要 500 GB。

  • 生产环境：对于生产环境，将管理集群、registry 和 Web 服务器分隔在不同的磁盘上。请参阅以下用于生产环境的示例配置：

    • Registry: 2 TB
    • 管理集群：500 GB
    • Web 服务器：2 TB

1.7.12.3. 提取 OpenShift Container Platform 发行镜像摘要

您可以使用标记的镜像提取 OpenShift Container Platform 发行镜像摘要。完成以下步骤：

  1. 运行以下命令来获取镜像摘要： 

    oc adm release info <tagged_openshift_release_image> | grep "Pull From"

    将 <tagged_openshift_release_image > 替换为支持的 OpenShift Container Platform 版本标记的镜像，例如 quay.io/openshift-release-dev/ocp-release:4.14.0-x8_64。

    请参见以下示例输出： 

    Pull From: quay.io/openshift-release-dev/ocp-release@sha256:69d1292f64a2b67227c5592c1a7d499c7d00376e498634ff8e1946bc9ccdddfe

    要了解更多有关镜像标签和摘要的信息，请参阅 OpenShift Container Platform 文档中的镜像流中的 镜像。

1.7.12.3.1. 其他资源

1.7.12.4. 在断开连接的环境中监控用户工作负载

hypershift-addon 受管集群附加组件在 HyperShift Operator 中启用 --enable-uwm-telemetry-remote-write 选项。通过启用该选项，您可以确保启用了用户工作负载监控，并确保可以从 control plane 远程编写遥测指标。

如果您在没有连接到互联网的 OpenShift Container Platform 集群中安装 multicluster engine operator，当尝试通过输入以下命令来运行 HyperShift Operator 的用户工作负载监控功能时，该功能会失败并显示错误： 

oc get events -n hypershift

这个错误可能类似以下示例： 

LAST SEEN   TYPE      REASON           OBJECT                MESSAGE
4m46s       Warning   ReconcileError   deployment/operator   Failed to ensure UWM telemetry remote write: cannot get telemeter client secret: Secret "telemeter-client" not found

要避免这个错误，您必须在 local-cluster 命名空间中创建配置映射来禁用用户工作负载监控选项。您可以在启用附加组件之前或之后创建配置映射。附加组件代理重新配置 HyperShift Operator。

创建以下配置映射： 

kind: ConfigMap
apiVersion: v1
metadata:
  name: hypershift-operator-install-flags
  namespace: local-cluster
data:
  installFlagsToAdd: ""
  installFlagsToRemove: "--enable-uwm-telemetry-remote-write"
1.7.12.4.1. 验证托管 control plane 功能的状态

托管的 control plane 功能默认启用。

  1. 如果禁用了这个功能，且您要启用它，请输入以下命令。将 multiclusterengine 替换为 multicluster engine operator 实例的名称： 

    oc patch mce <multiclusterengine> --type=merge -p '{"spec":{"overrides":{"components":[{"name":"hypershift","enabled": true}]}}}'

    当您启用这个功能时，hypershift-addon 受管集群附加组件安装在 local-cluster 受管集群中，附加组件代理会在 multicluster engine operator hub 集群上安装 HyperShift Operator。

  2. 输入以下命令确认已安装 hypershift-addon 受管集群附加组件： 

    oc get managedclusteraddons -n local-cluster hypershift-addon

  3. 查看生成的输出： 

    NAME               AVAILABLE   DEGRADED   PROGRESSING
hypershift-addon   True        False

  4. 要避免这个过程出现超时，请输入以下命令： 

    oc wait --for=condition=Degraded=True managedclusteraddons/hypershift-addon -n local-cluster --timeout=5m
    oc wait --for=condition=Available=True managedclusteraddons/hypershift-addon -n local-cluster --timeout=5m

    过程完成后，hypershift-addon 受管集群附加组件和 HyperShift Operator 会被安装，local-cluster 受管集群可用于托管和管理托管集群。

1.7.12.4.2. 配置 hypershift-addon 受管集群附加组件以便在基础架构节点上运行

默认情况下，未为 hypershift-addon 受管集群附加组件指定节点放置首选项。考虑在基础架构节点上运行附加组件，因为这样做可以防止因订阅计数和单独的维护和管理任务造成计费成本。

  1. 登录到 hub 集群。

  2. 输入以下命令打开 hypershift-addon-deploy-config 附加组件部署配置规格以进行编辑： 

    oc edit addondeploymentconfig hypershift-addon-deploy-config -n multicluster-engine

  3. 在规格中添加 nodePlacement 字段，如下例所示： 

    apiVersion: addon.open-cluster-management.io/v1alpha1
kind: AddOnDeploymentConfig
metadata:
  name: hypershift-addon-deploy-config
  namespace: multicluster-engine
spec:
  nodePlacement:
    nodeSelector:
      node-role.kubernetes.io/infra: ""
    tolerations:
    - effect: NoSchedule
      key: node-role.kubernetes.io/infra
      operator: Exists
  4. 保存更改。hypershift-addon 受管集群附加组件部署在用于新和现有受管集群的基础架构节点上。

1.7.12.5. 使用 IPv4 在断开连接的环境中配置托管的 control plane

您可以使用 IPv4 网络在断开连接的环境中配置托管的 control plane。IPv4 范围需要比 IPv6 或双栈设置更少的外部组件。

查看以下步骤在 IPv4 网络上配置托管的 control plane：

  1. 为 IPv4 网络配置虚拟机监控程序
  2. 为 IPv4 网络配置 DNS
  3. 为 IPv4 网络部署 registry
  4. 为 IPv4 网络设置管理集群
  5. 为 IPv4 网络配置 Web 服务器
  6. 为 IPv4 网络配置镜像镜像
  7. 为 IPv4 网络部署多集群引擎 operator
  8. 为 IPv4 网络配置 TLS 证书
  9. 为 IPv4 网络部署托管集群
  10. 完成 IPv4 网络的部署
1.7.12.5.1. 为 IPv4 网络配置 hypervisor

以下信息仅适用于虚拟机环境。

1.7.12.5.1.1. 访问和部署虚拟 OpenShift Container Platform 集群的软件包

  1. 要部署虚拟 OpenShift Container Platform 管理集群，请输入以下命令来访问所需的软件包： 

    sudo dnf install dnsmasq radvd vim golang podman bind-utils net-tools httpd-tools tree htop strace tmux -y

  2. 输入以下命令启用并启动 Podman 服务： 

    systemctl enable --now podman

  3. 要使用 kcli 部署 OpenShift Container Platform 管理集群和其他虚拟组件，请输入以下命令安装和配置 hypervisor： 

    sudo yum -y install libvirt libvirt-daemon-driver-qemu qemu-kvm
    sudo usermod -aG qemu,libvirt $(id -un)
    sudo newgrp libvirt
    sudo systemctl enable --now libvirtd
    sudo dnf -y copr enable karmab/kcli
    sudo dnf -y install kcli
    sudo kcli create pool -p /var/lib/libvirt/images default
    kcli create host kvm -H 127.0.0.1 local
    sudo setfacl -m u:$(id -un):rwx /var/lib/libvirt/images
    kcli create network  -c 192.168.122.0/24 default
1.7.12.5.1.2. 启用网络管理器分配程序

  1. 启用网络管理器分配程序，以确保虚拟机可以解析所需的域、路由和 registry。要启用网络管理器分配程序，在 /etc/NetworkManager/dispatcher.d/ 目录中，创建一个名为 forcedns 的脚本，其中包含以下内容，根据需要替换与您的环境匹配的值： 

    #!/bin/bash

export IP="192.168.126.1" 1
export BASE_RESOLV_CONF="/run/NetworkManager/resolv.conf"

if ! [[ `grep -q "$IP" /etc/resolv.conf` ]]; then
export TMP_FILE=$(mktemp /etc/forcedns_resolv.conf.XXXXXX)
cp $BASE_RESOLV_CONF $TMP_FILE
chmod --reference=$BASE_RESOLV_CONF $TMP_FILE
sed -i -e "s/dns.base.domain.name//" -e "s/search /& dns.base.domain.name /" -e "0,/nameserver/s/nameserver/& $IP\n&/" $TMP_FILE 2
mv $TMP_FILE /etc/resolv.conf
fi
echo "ok"
    1
    修改 IP 变量，以指向托管 OpenShift Container Platform 管理集群的虚拟机监控程序接口的 IP 地址。
    2
    将 dns.base.domain.name 替换为 DNS 基域名称。

  2. 创建该文件后，输入以下命令添加权限： 

    chmod 755 /etc/NetworkManager/dispatcher.d/forcedns
  3. 运行脚本，并验证输出是否返回 ok。
1.7.12.5.1.3. 配置 BMC 访问

  1. 配置 ksushy 以模拟虚拟机的基板管理控制器(BMC)。输入以下命令： 

    sudo dnf install python3-pyOpenSSL.noarch python3-cherrypy -y
    kcli create sushy-service --ssl --port 9000
    sudo systemctl daemon-reload
    systemctl enable --now ksushy

  2. 输入以下命令测试该服务是否正常工作： 

    systemctl status ksushy
1.7.12.5.1.4. 配置 hypervisor 系统以允许连接

如果您在开发环境中工作，请将 hypervisor 系统配置为允许通过环境中不同虚拟网络进行各种连接。

注： 如果您在生产环境中工作，您必须为 firewalld 服务建立正确的规则，并配置 SELinux 策略以维护安全环境。

  • 对于 SELinux，输入以下命令： 

    sed -i s/^SELINUX=.*$/SELINUX=permissive/ /etc/selinux/config; setenforce 0

  • 对于 firewalld，输入以下命令： 

    systemctl disable --now firewalld

  • 对于 libvirtd，输入以下命令： 

    systemctl restart libvirtd
    systemctl enable --now libvirtd

接下来，为您的环境配置 DNS。

1.7.12.5.1.5. 其他资源
1.7.12.5.2. 为 IPv4 网络配置 DNS

对于虚拟和裸机环境中断开连接和连接的环境，此步骤是必需的。虚拟和裸机环境之间的主要区别在于配置资源的位置。在裸机环境中，使用 Bind 等解决方案，而不是 dnsmasq 等轻量级解决方案。

接下来，部署 registry。

1.7.12.5.3. 为 IPv4 网络部署 registry

对于开发环境，使用 Podman 容器部署小型自托管注册表。对于生产环境，请使用企业托管的 registry，如 Red Hat Quay、Nexus 或 Artifactory。

要使用 Podman 部署小 registry，请完成以下步骤：

  1. 以特权用户身份，访问 ${HOME} 目录并创建以下脚本： 

    #!/usr/bin/env bash

set -euo pipefail

PRIMARY_NIC=$(ls -1 /sys/class/net | grep -v podman | head -1)
export PATH=/root/bin:$PATH
export PULL_SECRET="/root/baremetal/hub/openshift_pull.json" 1

if [[ ! -f $PULL_SECRET ]];then
  echo "Pull Secret not found, exiting..."
  exit 1
fi

dnf -y install podman httpd httpd-tools jq skopeo libseccomp-devel
export IP=$(ip -o addr show $PRIMARY_NIC | head -1 | awk '{print $4}' | cut -d'/' -f1)
REGISTRY_NAME=registry.$(hostname --long)
REGISTRY_USER=dummy
REGISTRY_PASSWORD=dummy
KEY=$(echo -n $REGISTRY_USER:$REGISTRY_PASSWORD | base64)
echo "{\"auths\": {\"$REGISTRY_NAME:5000\": {\"auth\": \"$KEY\", \"email\": \"sample-email@domain.ltd\"}}}" > /root/disconnected_pull.json
mv ${PULL_SECRET} /root/openshift_pull.json.old
jq ".auths += {\"$REGISTRY_NAME:5000\": {\"auth\": \"$KEY\",\"email\": \"sample-email@domain.ltd\"}}" < /root/openshift_pull.json.old > $PULL_SECRET
mkdir -p /opt/registry/{auth,certs,data,conf}
cat <<EOF > /opt/registry/conf/config.yml
version: 0.1
log:
  fields:
    service: registry
storage:
  cache:
    blobdescriptor: inmemory
  filesystem:
    rootdirectory: /var/lib/registry
  delete:
    enabled: true
http:
  addr: :5000
  headers:
    X-Content-Type-Options: [nosniff]
health:
  storagedriver:
    enabled: true
    interval: 10s
    threshold: 3
compatibility:
  schema1:
    enabled: true
EOF
openssl req -newkey rsa:4096 -nodes -sha256 -keyout /opt/registry/certs/domain.key -x509 -days 3650 -out /opt/registry/certs/domain.crt -subj "/C=US/ST=Madrid/L=San Bernardo/O=Karmalabs/OU=Guitar/CN=$REGISTRY_NAME" -addext "subjectAltName=DNS:$REGISTRY_NAME"
cp /opt/registry/certs/domain.crt /etc/pki/ca-trust/source/anchors/
update-ca-trust extract
htpasswd -bBc /opt/registry/auth/htpasswd $REGISTRY_USER $REGISTRY_PASSWORD
podman create --name registry --net host --security-opt label=disable --replace -v /opt/registry/data:/var/lib/registry:z -v /opt/registry/auth:/auth:z -v /opt/registry/conf/config.yml:/etc/docker/registry/config.yml -e "REGISTRY_AUTH=htpasswd" -e "REGISTRY_AUTH_HTPASSWD_REALM=Registry" -e "REGISTRY_HTTP_SECRET=ALongRandomSecretForRegistry" -e REGISTRY_AUTH_HTPASSWD_PATH=/auth/htpasswd -v /opt/registry/certs:/certs:z -e REGISTRY_HTTP_TLS_CERTIFICATE=/certs/domain.crt -e REGISTRY_HTTP_TLS_KEY=/certs/domain.key docker.io/library/registry:latest
[ "$?" == "0" ] || !!
systemctl enable --now registry
    1
    将 PULL_SECRET 的位置替换为您的设置的适当位置。

  2. 命名脚本文件 registry.sh 并保存它。运行脚本时，它会拉取以下信息：

    • registry 名称，基于虚拟机监控程序主机名
    • 所需的凭证和用户访问详情

  3. 通过添加执行标记来调整权限，如下所示： 

    chmod u+x ${HOME}/registry.sh

  4. 要在没有任何参数的情况下运行脚本，请输入以下命令： 

    ${HOME}/registry.sh

    该脚本启动服务器。

  5. 该脚本使用 systemd 服务来管理目的。如果需要管理脚本，您可以使用以下命令： 

    systemctl status
    systemctl start
    systemctl stop

registry 的根文件夹位于 /opt/registry 目录中，包含以下子目录：

  • certs 包含 TLS 证书。
  • auth 包含凭据。
  • 数据 包含 registry 镜像。
  • conf 包含 registry 配置。
1.7.12.5.4. 为 IPv4 网络设置管理集群

要设置 OpenShift Container Platform 管理集群，您可以使用 dev-scripts，或者基于虚拟机，您可以使用 kcli 工具。以下说明特定于 kcli 工具。

  1. 确保正确的网络已准备好在 hypervisor 中使用。网络将托管管理和托管集群。输入以下 kcli 命令： 

    kcli create network -c 192.168.125.0/24 -P dhcp=false -P dns=false --domain dns.base.domain.name ipv4

    其中：

    • -c 指定网络的 CIDR。
    • -p dhcp=false 将网络配置为禁用 DHCP，该 DHCP 由您配置的 dnsmasq 处理。
    • -p dns=false 将网络配置为禁用 DNS，这也由您配置的 dnsmasq 处理。
    • --domain 设置要搜索的域。
    • dns.base.domain.name 是 DNS 基础域名。
    • ipv4 是您要创建的网络的名称。

  2. 创建网络后，查看以下输出： 

    [root@hypershiftbm ~]# kcli list network
Listing Networks...
+---------+--------+---------------------+-------+------------------+------+
| Network |  Type  |         Cidr        |  Dhcp |      Domain      | Mode |
+---------+--------+---------------------+-------+------------------+------+
| default | routed |   192.168.122.0/24  |  True |     default      | nat  |
| ipv4    | routed |   192.168.125.0/24  | False | dns.base.domain.name | nat  |
| ipv6    | routed | 2620:52:0:1306::/64 | False | dns.base.domain.name | nat  |
+---------+--------+---------------------+-------+------------------+------+
    [root@hypershiftbm ~]# kcli info network ipv4
Providing information about network ipv4...
cidr: 192.168.125.0/24
dhcp: false
domain: dns.base.domain.name
mode: nat
plan: kvirt
type: routed

  3. 确保 pull secret 和 kcli 计划文件已就位，以便您可以部署 OpenShift Container Platform 管理集群：

    1. 确认 pull secret 与 kcli 计划位于同一个文件夹中，并且 pull secret 文件名为 openshift_pull.json。

    2. 在 mgmt-compact-hub-ipv4.yaml 文件中添加 kcli 计划，其中包含 OpenShift Container Platform 定义。确保更新文件内容以匹配您的环境： 

      plan: hub-ipv4
force: true
version: nightly
tag: "4.x.y-x86_64" 1
cluster: "hub-ipv4"
domain: dns.base.domain.name
api_ip: 192.168.125.10
ingress_ip: 192.168.125.11
disconnected_url: registry.dns.base.domain.name:5000
disconnected_update: true
disconnected_user: dummy
disconnected_password: dummy
disconnected_operators_version: v4.14
disconnected_operators:
- name: metallb-operator
- name: lvms-operator
  channels:
  - name: stable-4.13
disconnected_extra_images:
- quay.io/user-name/trbsht:latest
- quay.io/user-name/hypershift:BMSelfManage-v4.14-rc-v3
- registry.redhat.io/openshift4/ose-kube-rbac-proxy:v4.10
dualstack: false
disk_size: 200
extra_disks: [200]
memory: 48000
numcpus: 16
ctlplanes: 3
workers: 0
manifests: extra-manifests
metal3: true
network: ipv4
users_dev: developer
users_devpassword: developer
users_admin: admin
users_adminpassword: admin
metallb_pool: ipv4-virtual-network
metallb_ranges:
- 192.168.125.150-192.168.125.190
metallb_autoassign: true
apps:
- users
- lvms-operator
- metallb-operator
vmrules:
- hub-bootstrap:
    nets:
    - name: ipv4
      mac: aa:aa:aa:aa:02:10
- hub-ctlplane-0:
    nets:
    - name: ipv4
      mac: aa:aa:aa:aa:02:01
- hub-ctlplane-1:
    nets:
    - name: ipv4
      mac: aa:aa:aa:aa:02:02
- hub-ctlplane-2:
    nets:
    - name: ipv4
      mac: aa:aa:aa:aa:02:03
    1
    将 4.x.y 替换为您要使用的 OpenShift Container Platform 版本。

  4. 要置备管理集群，请输入以下命令： 

    kcli create cluster openshift --pf mgmt-compact-hub-ipv4.yaml
1.7.12.5.4.1. 其他资源
1.7.12.5.5. 为 IPv4 网络配置 Web 服务器

您需要配置一个额外的 Web 服务器来托管与您要部署为托管集群的 OpenShift Container Platform 发行版本关联的 Red Hat Enterprise Linux CoreOS (RHCOS)镜像。

要配置 web 服务器，请完成以下步骤：

  1. 输入以下命令从您要使用的 OpenShift Container Platform 发行版本中提取 openshift-install 二进制文件： 

    oc adm -a ${LOCAL_SECRET_JSON} release extract --command=openshift-install "${LOCAL_REGISTRY}/${LOCAL_REPOSITORY}:${OCP_RELEASE}-${ARCHITECTURE}"

  2. 运行以下脚本：该脚本在 /opt/srv 目录中创建文件夹。文件夹包含用于置备 worker 节点的 RHCOS 镜像。 

    #!/bin/bash

WEBSRV_FOLDER=/opt/srv
ROOTFS_IMG_URL="$(./openshift-install coreos print-stream-json | jq -r '.architectures.x86_64.artifacts.metal.formats.pxe.rootfs.location')" 1
LIVE_ISO_URL="$(./openshift-install coreos print-stream-json | jq -r '.architectures.x86_64.artifacts.metal.formats.iso.disk.location')" 2

mkdir -p ${WEBSRV_FOLDER}/images
curl -Lk ${ROOTFS_IMG_URL} -o ${WEBSRV_FOLDER}/images/${ROOTFS_IMG_URL##*/}
curl -Lk ${LIVE_ISO_URL} -o ${WEBSRV_FOLDER}/images/${LIVE_ISO_URL##*/}
chmod -R 755 ${WEBSRV_FOLDER}/*

## Run Webserver
podman ps --noheading | grep -q websrv-ai
if [[ $? == 0 ]];then
    echo "Launching Registry pod..."
    /usr/bin/podman run --name websrv-ai --net host -v /opt/srv:/usr/local/apache2/htdocs:z quay.io/alosadag/httpd:p8080
fi
    1
    您可以在 OpenShift CI Release 页面上找到 ROOTFS_IMG_URL 值。
    2
    您可以在 OpenShift CI Release 页面上找到 LIVE_ISO_URL 值。

下载完成后，容器将运行，以托管 Web 服务器上的镜像。容器使用官方 HTTPd 镜像的一种变体，这使得它能够使用 IPv6 网络。

1.7.12.5.6. 为 IPv4 网络配置镜像镜像

镜像镜像是从外部 registry 获取镜像的过程，如 registry.redhat.com 或 quay.io，并将它们存储在私有 registry 中。

1.7.12.5.6.1. 完成镜像过程

注： 在 registry 服务器运行后启动镜像过程。

在以下步骤中，使用 oc-mirror 工具，它是一个使用 ImageSetConfiguration 对象的二进制文件。在文件中，您可以指定以下信息：

  • 要镜像的 OpenShift Container Platform 版本。版本位于 quay.io 中。
  • 要镜像的额外 Operator。单独选择软件包。
  • 要添加到存储库的额外镜像。

要配置镜像镜像，请完成以下步骤：

  1. 确保 ${HOME}/.docker/config.json 文件已更新为您要从中镜像 registry 以及您要将镜像推送到的私有 registry。

  2. 通过使用以下示例，创建一个 ImageSetConfiguration 对象以用于镜像。根据需要替换与您的环境匹配的值： 

    apiVersion: mirror.openshift.io/v1alpha2
kind: ImageSetConfiguration
storageConfig:
  registry:
    imageURL: registry.dns.base.domain.name:5000/openshift/release/metadata:latest 1
mirror:
  platform:
    channels:
    - name: candidate-4.14
      minVersion: 4.x.y-x86_64 2
      maxVersion: 4.x.y-x86_64
      type: ocp
    graph: true
  additionalImages:
  - name: quay.io/karmab/origin-keepalived-ipfailover:latest
  - name: quay.io/karmab/kubectl:latest
  - name: quay.io/karmab/haproxy:latest
  - name: quay.io/karmab/mdns-publisher:latest
  - name: quay.io/karmab/origin-coredns:latest
  - name: quay.io/karmab/curl:latest
  - name: quay.io/karmab/kcli:latest
  - name: quay.io/user-name/trbsht:latest
  - name: quay.io/user-name/hypershift:BMSelfManage-v4.14-rc-v3
  - name: registry.redhat.io/openshift4/ose-kube-rbac-proxy:v4.10
  operators:
  - catalog: registry.redhat.io/redhat/redhat-operator-index:v4.14
    packages:
    - name: lvms-operator
    - name: local-storage-operator
    - name: odf-csi-addons-operator
    - name: odf-operator
    - name: mcg-operator
    - name: ocs-operator
    - name: metallb-operator
    - name: kubevirt-hyperconverged
    1
    将 dns.base.domain.name 替换为 DNS 基域名称。
    2
    将 4.x.y 替换为您要使用的 OpenShift Container Platform 版本。

  3. 输入以下命令启动镜像过程： 

    oc-mirror --source-skip-tls --config imagesetconfig.yaml docker://${REGISTRY}

    镜像过程完成后，您有一个名为 oc-mirror-workspace/results-XXXXXX/ 的新文件夹，其中包含 ICSP 和要应用到托管的集群的目录源。

  4. 使用 oc adm release mirror 命令镜像 OpenShift Container Platform 的 nightly 或 CI 版本。输入以下命令： 

    REGISTRY=registry.$(hostname --long):5000

oc adm release mirror \
  --from=registry.ci.openshift.org/ocp/release:4.x.y-x86_64 \
  --to=${REGISTRY}/openshift/release \
  --to-release-image=${REGISTRY}/openshift/release-images:4.x.y-x86_64

    将 4.x.y 替换为您要使用的 OpenShift Container Platform 版本。

  5. 按照在 断开连接的网络 上安装 中的步骤镜像最新的多集群引擎 operator 镜像。
1.7.12.5.6.2. 在管理集群中应用对象

镜像过程完成后，您需要在管理集群中应用两个对象：

  • 镜像内容源策略(ICSP)或镜像 Digest 镜像集(IDMS)
  • 目录源

当使用 oc-mirror 工具时，输出工件位于名为 oc-mirror-workspace/results-XXXXXX/ 的目录中。

ICSP 或 IDMS 会启动一个 MachineConfig 更改，它不会重启节点，而是在每个节点上重启 kubelet。节点标记为 READY 后，您需要应用新生成的目录源。

目录源在 openshift-marketplace Operator 中启动操作，如下载目录镜像并处理它来检索该镜像中包含的所有 PackageManifests。

  1. 要检查新源，请使用新的 CatalogSource 作为源运行以下命令： 

    oc get packagemanifest

  2. 要应用工件，请完成以下步骤：

    1. 输入以下命令来创建 ImageContentSourcePolicy (ICSP)或 IDMS 工件： 

      oc apply -f oc-mirror-workspace/results-XXXXXX/imageContentSourcePolicy.yaml
    2. 等待节点就绪，然后输入以下命令： 
    oc apply -f catalogSource-XXXXXXXX-index.yaml

  3. 镜像 OLM 目录并配置 hosed 集群以指向镜像。

    当您使用 management （默认）OLMCatalogPlacement 模式时，用于 OLM 目录的镜像流不会自动通过管理集群上的 ICSP 的信息覆盖信息。

    1. 如果 OLM 目录使用原始名称和标签正确镜像到内部 registry，请将 hypershift.openshift.io/olm-catalogs-is-registry-overrides 注解添加到 HostedCluster 资源。格式为 "sr1=dr1,sr2=dr2"，其中源 registry 字符串是一个键，目标 registry 是一个值。

    2. 要绕过 OLM 目录镜像流机制，请在 HostedCluster 资源上使用以下四个注解来直接指定用于 OLM operator 目录的四个镜像的地址：

      • hypershift.openshift.io/certified-operators-catalog-image
      • hypershift.openshift.io/community-operators-catalog-image
      • hypershift.openshift.io/redhat-marketplace-catalog-image
      • hypershift.openshift.io/redhat-operators-catalog-image

      在这种情况下，镜像流不会被创建，当刷新内部镜像以拉取 Operator 更新时，您必须更新注解的值。

    注： 如果需要覆盖机制，则需要四个默认目录源的所有四个值。

1.7.12.5.6.3. 其他资源
1.7.12.5.7. 为 IPv4 网络部署多集群引擎 operator

multicluster engine operator 在供应商间部署集群时扮演了关键角色。如果已安装 Red Hat Advanced Cluster Management，则不需要安装 multicluster engine operator，因为它会被自动安装。

如果您没有安装 multicluster engine operator，请参阅以下文档以了解安装它的先决条件和步骤：

1.7.12.5.7.1. 部署 AgentServiceConfig 资源

AgentServiceConfig 自定义资源是 Assisted Service add-on 的基本组件，它是 multicluster engine operator 的一部分。它负责裸机集群部署。启用附加组件后，您要部署 AgentServiceConfig 资源来配置附加组件。

除了配置 AgentServiceConfig 资源外，还需要包含额外的配置映射，以确保多集群引擎 Operator 在断开连接的环境中正常工作。

  1. 通过添加以下配置映射来配置自定义 registry，其中包含用于自定义部署的断开连接的详情： 

    ---
apiVersion: v1
kind: ConfigMap
metadata:
  name: custom-registries
  namespace: multicluster-engine
  labels:
    app: assisted-service
data:
  ca-bundle.crt: |
    -----BEGIN CERTIFICATE-----
    -----END CERTIFICATE-----
  registries.conf: |
    unqualified-search-registries = ["registry.access.redhat.com", "docker.io"]

    [[registry]]
    prefix = ""
    location = "registry.redhat.io/openshift4"
    mirror-by-digest-only = true

    [[registry.mirror]]
      location = "registry.dns.base.domain.name:5000/openshift4" 1

    [[registry]]
    prefix = ""
    location = "registry.redhat.io/rhacm2"
    mirror-by-digest-only = true
    ...
    ...
    1
    将 dns.base.domain.name 替换为 DNS 基域名称。

    对象包含两个字段：

    • 自定义 CA：此字段包含加载到部署各种进程的证书颁发机构(CA)。
    • Registry: Registries.conf 字段包含有关需要从镜像 registry 而不是原始源 registry 中消耗的镜像和命名空间的信息。

  2. 通过添加 AssistedServiceConfig 对象来配置 Assisted Service，如下例所示： 

    ---
apiVersion: agent-install.openshift.io/v1beta1
kind: AgentServiceConfig
metadata:
  annotations:
    unsupported.agent-install.openshift.io/assisted-service-configmap: assisted-service-config 1
  name: agent
  namespace: multicluster-engine
spec:
  mirrorRegistryRef:
    name: custom-registries 2
  databaseStorage:
    storageClassName: lvms-vg1
    accessModes:
    - ReadWriteOnce
    resources:
      requests:
        storage: 10Gi
  filesystemStorage:
    storageClassName: lvms-vg1
    accessModes:
    - ReadWriteOnce
    resources:
      requests:
        storage: 20Gi
  osImages: 3
  - cpuArchitecture: x86_64
    openshiftVersion: "4.14"
    rootFSUrl: http://registry.dns.base.domain.name:8080/images/rhcos-414.92.202308281054-0-live-rootfs.x86_64.img 4
    url: http://registry.dns.base.domain.name:8080/images/rhcos-414.92.202308281054-0-live.x86_64.iso
    version: 414.92.202308281054-0
    1
    metadata.annotations["unsupported.agent-install.openshift.io/assisted-service-configmap"] 注解引用 Operator 用来自定义行为的配置映射名称。
    2
    spec.mirrorRegistryRef.name 注解指向包含 Assisted Service Operator 使用断开连接的 registry 信息的配置映射。此配置映射在部署过程中添加这些资源。
    3
    spec.osImages 字段包含可供此 Operator 部署的不同版本。这个字段是必须的。本例假定您已下载了 RootFS 和 LiveISO 文件。
    4
    在 rootFSUrl 和 url 字段中，将 dns.base.domain.name 替换为 DNS 基域名称。

  3. 通过将所有对象串联到一个文件中，并将它们应用到管理集群，以此部署所有对象。要做到这一点，请输入以下命令： 

    oc apply -f agentServiceConfig.yaml

    该命令会触发两个 pod，如本示例输出所示： 

    assisted-image-service-0                               1/1     Running   2             11d 1
assisted-service-668b49548-9m7xw                       2/2     Running   5             11d 2
    1
    assisted-image-service pod 负责创建 Red Hat Enterprise Linux CoreOS (RHCOS)引导镜像模板，该模板针对您部署的每个集群自定义。
    2
    assisted-service 指的是 Operator。
1.7.12.5.8. 为 IPv4 网络配置 TLS 证书

涉及几个 TLS 证书，以便在断开连接的环境中配置托管的 control plane。要将证书颁发机构(CA)添加到管理集群中，您需要修改 OpenShift Container Platform control plane 和 worker 节点上的以下文件的内容：

  • /etc/pki/ca-trust/extracted/pem/
  • /etc/pki/ca-trust/source/anchors
  • /etc/pki/tls/certs/

要在管理集群中添加 CA，请完成以下步骤：

  1. 完成官方 OpenShift Container Platform 文档中的 更新 CA 捆绑包 中的步骤。该方法涉及使用 image-registry-operator，它将 CA 部署到 OpenShift Container Platform 节点。

  2. 如果该方法不适用于您的情况，请检查管理集群中的 openshift-config 命名空间是否包含名为 user-ca-bundle 的配置映射。

    • 如果命名空间包含该配置映射，请输入以下命令： 

      ## REGISTRY_CERT_PATH=<PATH/TO/YOUR/CERTIFICATE/FILE>
export REGISTRY_CERT_PATH=/opt/registry/certs/domain.crt

oc create configmap user-ca-bundle -n openshift-config --from-file=ca-bundle.crt=${REGISTRY_CERT_PATH}

    • 如果命名空间不包含该配置映射，请输入以下命令： 

      ## REGISTRY_CERT_PATH=<PATH/TO/YOUR/CERTIFICATE/FILE>
export REGISTRY_CERT_PATH=/opt/registry/certs/domain.crt
export TMP_FILE=$(mktemp)

oc get cm -n openshift-config user-ca-bundle -ojsonpath='{.data.ca-bundle\.crt}' > ${TMP_FILE}
echo >> ${TMP_FILE}
echo \#registry.$(hostname --long) >> ${TMP_FILE}
cat ${REGISTRY_CERT_PATH} >> ${TMP_FILE}
oc create configmap user-ca-bundle -n openshift-config --from-file=ca-bundle.crt=${TMP_FILE} --dry-run=client -o yaml | kubectl apply -f -
1.7.12.5.9. 为 IPv4 网络部署托管集群

托管的集群是一个 OpenShift Container Platform 集群，它带有托管在管理集群上的 control plane 和 API 端点。托管的集群包括控制平面和它的对应的数据平面。

虽然您可以使用 Red Hat Advanced Cluster Management 中的控制台创建托管集群，但以下步骤使用清单，这提供了修改相关工件的灵活性。

1.7.12.5.9.1. 部署托管集群对象

对于此过程，使用以下值：

  • HostedCluster name: hosted-ipv4
  • HostedCluster 命名空间： 集群
  • disconnected: true
  • 网络堆栈： IPv4

通常，HyperShift Operator 会创建 HostedControlPlane 命名空间。但是，在这种情况下，您想要在 HyperShift Operator 开始协调 HostedCluster 对象前包含所有对象。然后，当 Operator 启动协调过程时，它可以找到所有对象。

  1. 使用有关命名空间的以下信息创建 YAML 文件： 

    ---
apiVersion: v1
kind: Namespace
metadata:
  creationTimestamp: null
  name: clusters-hosted-ipv4
spec: {}
status: {}
---
apiVersion: v1
kind: Namespace
metadata:
  creationTimestamp: null
  name: clusters
spec: {}
status: {}

  2. 创建一个 YAML 文件，其中包含有关配置映射和 secret 的信息，以便在 HostedCluster 部署中包括： 

    ---
apiVersion: v1
data:
  ca-bundle.crt: |
    -----BEGIN CERTIFICATE-----
    -----END CERTIFICATE-----
kind: ConfigMap
metadata:
  name: user-ca-bundle
  namespace: clusters
---
apiVersion: v1
data:
  .dockerconfigjson: xxxxxxxxx
kind: Secret
metadata:
  creationTimestamp: null
  name: hosted-ipv4-pull-secret
  namespace: clusters
---
apiVersion: v1
kind: Secret
metadata:
  name: sshkey-cluster-hosted-ipv4
  namespace: clusters
stringData:
  id_rsa.pub: ssh-rsa xxxxxxxxx
---
apiVersion: v1
data:
  key: nTPtVBEt03owkrKhIdmSW8jrWRxU57KO/fnZa8oaG0Y=
kind: Secret
metadata:
  creationTimestamp: null
  name: hosted-ipv4-etcd-encryption-key
  namespace: clusters
type: Opaque

  3. 创建一个包含 RBAC 角色的 YAML 文件，以便辅助服务代理可以与托管 control plane 位于同一个 HostedControlPlane 命名空间中，仍由集群 API 管理： 

    apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  creationTimestamp: null
  name: capi-provider-role
  namespace: clusters-hosted-ipv4
rules:
- apiGroups:
  - agent-install.openshift.io
  resources:
  - agents
  verbs:
  - '*'

  4. 使用 HostedCluster 对象的信息创建 YAML 文件，根据需要替换值： 

    apiVersion: hypershift.openshift.io/v1beta1
kind: HostedCluster
metadata:
  name: hosted-ipv4
  namespace: clusters
spec:
  additionalTrustBundle:
    name: "user-ca-bundle"
  olmCatalogPlacement: guest
  imageContentSources: 1
  - source: quay.io/openshift-release-dev/ocp-v4.0-art-dev
    mirrors:
    - registry.dns.base.domain.name:5000/openshift/release
  - source: quay.io/openshift-release-dev/ocp-release
    mirrors:
    - registry.dns.base.domain.name:5000/openshift/release-images
  - mirrors:
  ...
  ...
  autoscaling: {}
  controllerAvailabilityPolicy: SingleReplica
  dns:
    baseDomain: dns.base.domain.name
  etcd:
    managed:
      storage:
        persistentVolume:
          size: 8Gi
        restoreSnapshotURL: null
        type: PersistentVolume
    managementType: Managed
  fips: false
  networking:
    clusterNetwork:
    - cidr: 10.132.0.0/14
    networkType: OVNKubernetes
    serviceNetwork:
    - cidr: 172.31.0.0/16
  platform:
    agent:
      agentNamespace: clusters-hosted-ipv4
    type: Agent
  pullSecret:
    name: hosted-ipv4-pull-secret
  release:
    image: registry.dns.base.domain.name:5000/openshift/release-images:4.x.y-x86_64
  secretEncryption:
    aescbc:
      activeKey:
        name: hosted-ipv4-etcd-encryption-key
    type: aescbc
  services:
  - service: APIServer
    servicePublishingStrategy:
      nodePort:
        address: api.hosted-ipv4.dns.base.domain.name
      type: NodePort
  - service: OAuthServer
    servicePublishingStrategy:
      nodePort:
        address: api.hosted-ipv4.dns.base.domain.name
      type: NodePort
  - service: OIDC
    servicePublishingStrategy:
      nodePort:
        address: api.hosted-ipv4.dns.base.domain.name
      type: NodePort
  - service: Konnectivity
    servicePublishingStrategy:
      nodePort:
        address: api.hosted-ipv4.dns.base.domain.name
      type: NodePort
  - service: Ignition
    servicePublishingStrategy:
      nodePort:
        address: api.hosted-ipv4.dns.base.domain.name
      type: NodePort
  sshKey:
    name: sshkey-cluster-hosted-ipv4
status:
  controlPlaneEndpoint:
    host: ""
    port: 0

    其中 dns.base.domain.name 是 DNS 基础域名，而 4.x.y 是您要使用的 OpenShift Container Platform 版本。

    1
    imageContentSources 部分包含托管集群中用户工作负载的镜像引用。

  5. 在 HostedCluster 对象中添加指向 OpenShift Container Platform 发行版本中 HyperShift Operator 发行版本的注解：

    1. 输入以下命令来获取镜像有效负载： 

      oc adm release info registry.dns.base.domain.name:5000/openshift-release-dev/ocp-release:4.x.y-x86_64 | grep hypershift

      其中 dns.base.domain.name 是 DNS 基础域名，而 4.x.y 是您要使用的 OpenShift Container Platform 版本。

    2. 请参见以下输出： 

      hypershift                                     sha256:31149e3e5f8c5e5b5b100ff2d89975cf5f7a73801b2c06c639bf6648766117f8

    3. 使用 OpenShift Container Platform Images 命名空间，输入以下命令检查摘要： 

      podman pull registry.dns.base.domain.name:5000/openshift-release-dev/ocp-v4.0-art-dev@sha256:31149e3e5f8c5e5b5b100ff2d89975cf5f7a73801b2c06c639bf6648766117f8

      其中 dns.base.domain.name 是 DNS 基础域名。

    4. 请参见以下输出： 

      podman pull registry.dns.base.domain.name:5000/openshift/release@sha256:31149e3e5f8c5e5b5b100ff2d89975cf5f7a73801b2c06c639bf6648766117f8
Trying to pull registry.dns.base.domain.name:5000/openshift/release@sha256:31149e3e5f8c5e5b5b100ff2d89975cf5f7a73801b2c06c639bf6648766117f8...
Getting image source signatures
Copying blob d8190195889e skipped: already exists
Copying blob c71d2589fba7 skipped: already exists
Copying blob d4dc6e74b6ce skipped: already exists
Copying blob 97da74cc6d8f skipped: already exists
Copying blob b70007a560c9 done
Copying config 3a62961e6e done
Writing manifest to image destination
Storing signatures
3a62961e6ed6edab46d5ec8429ff1f41d6bb68de51271f037c6cb8941a007fde

    注： HostedCluster 对象中设置的发行镜像必须使用摘要而不是标签；例如，quay.io/openshift-release-dev/ocp-release-dev/ocp-release@sha256:e3ba11bd1e5e8ea5a0b36a75791c90f29afb0fdbe4125be4e48f69c76a5c47a0。

  6. 通过将 YAML 文件中定义的所有对象串联成文件并根据管理集群应用，以创建您在 YAML 文件中定义的所有对象。要做到这一点，请输入以下命令： 

    oc apply -f 01-4.14-hosted_cluster-nodeport.yaml

  7. 查看托管 control plane 的输出： 

    NAME                                                  READY   STATUS    RESTARTS   AGE
capi-provider-5b57dbd6d5-pxlqc                        1/1     Running   0          3m57s
catalog-operator-9694884dd-m7zzv                      2/2     Running   0          93s
cluster-api-f98b9467c-9hfrq                           1/1     Running   0          3m57s
cluster-autoscaler-d7f95dd5-d8m5d                     1/1     Running   0          93s
cluster-image-registry-operator-5ff5944b4b-648ht      1/2     Running   0          93s
cluster-network-operator-77b896ddc-wpkq8              1/1     Running   0          94s
cluster-node-tuning-operator-84956cd484-4hfgf         1/1     Running   0          94s
cluster-policy-controller-5fd8595d97-rhbwf            1/1     Running   0          95s
cluster-storage-operator-54dcf584b5-xrnts             1/1     Running   0          93s
cluster-version-operator-9c554b999-l22s7              1/1     Running   0          95s
control-plane-operator-6fdc9c569-t7hr4                1/1     Running   0          3m57s
csi-snapshot-controller-785c6dc77c-8ljmr              1/1     Running   0          77s
csi-snapshot-controller-operator-7c6674bc5b-d9dtp     1/1     Running   0          93s
csi-snapshot-webhook-5b8584875f-2492j                 1/1     Running   0          77s
dns-operator-6874b577f-9tc6b                          1/1     Running   0          94s
etcd-0                                                3/3     Running   0          3m39s
hosted-cluster-config-operator-f5cf5c464-4nmbh        1/1     Running   0          93s
ignition-server-6b689748fc-zdqzk                      1/1     Running   0          95s
ignition-server-proxy-54d4bb9b9b-6zkg7                1/1     Running   0          95s
ingress-operator-6548dc758b-f9gtg                     1/2     Running   0          94s
konnectivity-agent-7767cdc6f5-tw782                   1/1     Running   0          95s
kube-apiserver-7b5799b6c8-9f5bp                       4/4     Running   0          3m7s
kube-controller-manager-5465bc4dd6-zpdlk              1/1     Running   0          44s
kube-scheduler-5dd5f78b94-bbbck                       1/1     Running   0          2m36s
machine-approver-846c69f56-jxvfr                      1/1     Running   0          92s
oauth-openshift-79c7bf44bf-j975g                      2/2     Running   0          62s
olm-operator-767f9584c-4lcl2                          2/2     Running   0          93s
openshift-apiserver-5d469778c6-pl8tj                  3/3     Running   0          2m36s
openshift-controller-manager-6475fdff58-hl4f7         1/1     Running   0          95s
openshift-oauth-apiserver-dbbc5cc5f-98574             2/2     Running   0          95s
openshift-route-controller-manager-5f6997b48f-s9vdc   1/1     Running   0          95s
packageserver-67c87d4d4f-kl7qh                        2/2     Running   0          93s

  8. 查看托管集群的输出： 

    NAMESPACE   NAME         VERSION   KUBECONFIG                PROGRESS   AVAILABLE   PROGRESSING   MESSAGE
clusters    hosted-ipv4            hosted-admin-kubeconfig   Partial    True          False         The hosted control plane is available

接下来，创建 NodePool 对象。

1.7.12.5.9.2. 为托管集群创建 NodePool 对象

NodePool 是与托管集群关联的一组可扩展的 worker 节点。NodePool 机器架构在特定池中保持一致，独立于 control plane 的机器架构。

  1. 使用有关 NodePool 对象的以下信息创建 YAML 文件，根据需要替换值： 

    apiVersion: hypershift.openshift.io/v1beta1
kind: NodePool
metadata:
  creationTimestamp: null
  name: hosted-ipv4
  namespace: clusters
spec:
  arch: amd64
  clusterName: hosted-ipv4
  management:
    autoRepair: false 1
    upgradeType: InPlace 2
  nodeDrainTimeout: 0s
  platform:
    type: Agent
  release:
    image: registry.dns.base.domain.name:5000/openshift/release-images:4.x.y-x86_64 3
  replicas: 0
status:
  replicas: 0 4
    1
    autoRepair 字段被设置为 false，因为如果删除了该节点，则不会重新创建该节点。
    2
    upgradeType 设置为 InPlace，这表示升级过程中会重复使用相同的裸机节点。
    3
    此 NodePool 中包含的所有节点都基于以下 OpenShift Container Platform 版本： 4.x.y-x86_64。将 dns.base.domain.name 替换为 DNS 基础域名，将 4.x.y 替换为您要使用的 OpenShift Container Platform 版本。
    4
    replicas 值设为 0， 以便在需要时可以扩展它们。务必要将 NodePool 副本保持为 0，直到所有步骤都完成为止。

  2. 运行以下命令来创建 NodePool 对象： 

    oc apply -f 02-nodepool.yaml

  3. 查看输出： 

    NAMESPACE   NAME          CLUSTER   DESIRED NODES   CURRENT NODES   AUTOSCALING   AUTOREPAIR   VERSION                              UPDATINGVERSION   UPDATINGCONFIG   MESSAGE
clusters    hosted-ipv4   hosted    0                               False         False        4.x.y-x86_64

    将 4.x.y 替换为您要使用的 OpenShift Container Platform 版本。

接下来，创建一个 InfraEnv 资源。

1.7.12.5.9.3. 为托管集群创建 InfraEnv 资源

InfraEnv 资源是一个 Assisted Service 对象，其中包含基本详情，如 pullSecretRef 和 sshAuthorizedKey。这些详情用于创建为托管集群自定义的 Red Hat Enterprise Linux CoreOS (RHCOS)引导镜像。

  1. 使用以下有关 InfraEnv 资源的信息创建 YAML 文件，根据需要替换值： 

    ---
apiVersion: agent-install.openshift.io/v1beta1
kind: InfraEnv
metadata:
  name: hosted-ipv4
  namespace: clusters-hosted-ipv4
spec:
  pullSecretRef: 1
    name: pull-secret
  sshAuthorizedKey: ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQDk7ICaUE+/k4zTpxLk4+xFdHi4ZuDi5qjeF52afsNkw0w/glILHhwpL5gnp5WkRuL8GwJuZ1VqLC9EKrdmegn4MrmUlq7WTsP0VFOZFBfq2XRUxo1wrRdor2z0Bbh93ytR+ZsDbbLlGngXaMa0Vbt+z74FqlcajbHTZ6zBmTpBVq5RHtDPgKITdpE1fongp7+ZXQNBlkaavaqv8bnyrP4BWahLP4iO9/xJF9lQYboYwEEDzmnKLMW1VtCE6nJzEgWCufACTbxpNS7GvKtoHT/OVzw8ArEXhZXQUS1UY8zKsX2iXwmyhw5Sj6YboA8WICs4z+TrFP89LmxXY0j6536TQFyRz1iB4WWvCbH5n6W+ABV2e8ssJB1AmEy8QYNwpJQJNpSxzoKBjI73XxvPYYC/IjPFMySwZqrSZCkJYqQ023ySkaQxWZT7in4KeMu7eS2tC+Kn4deJ7KwwUycx8n6RHMeD8Qg9flTHCv3gmab8JKZJqN3hW1D378JuvmIX4V0= 2
    1
    pullSecretRef 引用与 InfraEnv 相同的命名空间中的配置映射引用，其中使用 pull secret。
    2
    sshAuthorizedKey 代表放在引导镜像中的 SSH 公钥。SSH 密钥允许以 core 用户身份访问 worker 节点。

  2. 运行以下命令来创建 InfraEnv 资源： 

    oc apply -f 03-infraenv.yaml

  3. 请参见以下输出： 

    NAMESPACE              NAME     ISO CREATED AT
clusters-hosted-ipv4   hosted   2023-09-11T15:14:10Z

接下来，创建 worker 节点。

1.7.12.5.9.4. 为托管集群创建 worker 节点

如果您在裸机平台上工作，创建 worker 节点对于确保正确配置了 BareMetalHost 的详情至关重要。

如果使用虚拟机，您可以完成以下步骤来创建 Metal3 Operator 消耗的空 worker 节点。为此，您可以使用 kcli。

  1. 如果这不是您首次尝试创建 worker 节点，您必须首先删除之前的设置。要做到这一点，请输入以下命令删除计划： 

    kcli delete plan hosted-ipv4
    1. 当系统提示您确认是否要删除计划时，键入 y。
    2. 确认您看到一条消息，表示计划已被删除。

  2. 输入以下命令来创建虚拟机： 

    kcli create vm -P start=False -P uefi_legacy=true -P plan=hosted-ipv4 -P memory=8192 -P numcpus=16 -P disks=[200,200] -P nets=["{\"name\": \"ipv4\", \"mac\": \"aa:aa:aa:aa:02:11\"}"] -P uuid=aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaa0211 -P name=hosted-ipv4-worker0
    kcli create vm -P start=False -P uefi_legacy=true -P plan=hosted-ipv4 -P memory=8192 -P numcpus=16 -P disks=[200,200] -P nets=["{\"name\": \"ipv4\", \"mac\": \"aa:aa:aa:aa:02:12\"}"] -P uuid=aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaa0212 -P name=hosted-ipv4-worker1
    kcli create vm -P start=False -P uefi_legacy=true -P plan=hosted-ipv4 -P memory=8192 -P numcpus=16 -P disks=[200,200] -P nets=["{\"name\": \"ipv4\", \"mac\": \"aa:aa:aa:aa:02:13\"}"] -P uuid=aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaa0213 -P name=hosted-ipv4-worker2
    systemctl restart ksushy

    其中：

    • start=False 表示虚拟机(VM)不会在创建时自动启动。
    • uefi_legacy=true 表示您将使用 UEFI 传统引导来确保与之前的 UEFI 实现兼容。
    • plan=hosted-dual 表示计划名称，将一组机器标识为集群。
    • memory=8192 和 numcpus=16 是指定虚拟机资源的参数，包括 RAM 和 CPU。
    • disks=[200,200] 表示您要在虚拟机中创建两个精简置备磁盘。
    • nets=[{"name": "dual", "mac": "aa:aa:aa:02:13"}] 是网络详情，包括要连接到的网络详情以及主接口的 MAC 地址。
    • 重启 ksushy 重启 ksushy 工具，以确保工具检测到您添加的虚拟机。

  3. 查看生成的输出： 

    +---------------------+--------+-------------------+----------------------------------------------------+-------------+---------+
|         Name        | Status |         Ip        |                       Source                       |     Plan    | Profile |
+---------------------+--------+-------------------+----------------------------------------------------+-------------+---------+
|    hosted-worker0   |  down  |                   |                                                    | hosted-ipv4 |  kvirt  |
|    hosted-worker1   |  down  |                   |                                                    | hosted-ipv4 |  kvirt  |
|    hosted-worker2   |  down  |                   |                                                    | hosted-ipv4 |  kvirt  |
+---------------------+--------+-------------------+----------------------------------------------------+-------------+---------+

接下来，为托管集群创建裸机主机。

1.7.12.5.9.5. 为托管集群创建裸机主机

裸机主机 是一个 openshift-machine-api 对象，其中包含物理和虚拟详情，以便可以通过 Metal3 Operator 识别它。这些详细信息与其他辅助服务对象关联，称为 代理。

重要： 在创建裸机主机和目标节点前，您必须创建虚拟机。

要创建裸机主机，请完成以下步骤：

  1. 使用以下信息创建 YAML 文件：

    注： 因为至少有一个 secret 包含裸机主机凭证，所以您需要为每个 worker 节点至少创建两个对象。 

    ---
apiVersion: v1
kind: Secret
metadata:
  name: hosted-ipv4-worker0-bmc-secret
  namespace: clusters-hosted-ipv4
data:
  password: YWRtaW4=
  username: YWRtaW4=
type: Opaque
---
apiVersion: metal3.io/v1alpha1
kind: BareMetalHost
metadata:
  name: hosted-ipv4-worker0
  namespace: clusters-hosted-ipv4
  labels:
    infraenvs.agent-install.openshift.io: hosted-ipv4 1
  annotations:
    inspect.metal3.io: disabled
    bmac.agent-install.openshift.io/hostname: hosted-ipv4-worker0 2
spec:
  automatedCleaningMode: disabled 3
  bmc:
    disableCertificateVerification: true 4
    address: redfish-virtualmedia://[192.168.125.1]:9000/redfish/v1/Systems/local/hosted-ipv4-worker0 5
    credentialsName: hosted-ipv4-worker0-bmc-secret 6
  bootMACAddress: aa:aa:aa:aa:02:11 7
  online: true 8
    1
    infraenvs.agent-install.openshift.io 作为 Assisted Installer 和 BareMetalHost 对象之间的链接。
    2
    bmac.agent-install.openshift.io/hostname 代表部署期间采用的节点名称。
    3
    automatedCleaningMode 可防止节点被 Metal3 Operator 擦除。
    4
    disableCertificateVerification 设置为 true，以从客户端绕过证书验证。
    5
    address 表示 worker 节点的基板管理控制器(BMC)地址。
    6
    credentialsName 指向存储了用户和密码凭证的 secret。
    7
    bootMACAddress 表示节点从其启动的接口 MACAddress。
    8
    Online 定义 BareMetalHost 对象创建后节点的状态。

  2. 输入以下命令部署 BareMetalHost 对象： 

    oc apply -f 04-bmh.yaml

    在此过程中，您可以查看以下输出：

    • 这个输出表示进程正在尝试访问节点： 

      NAMESPACE         NAME             STATE         CONSUMER   ONLINE   ERROR   AGE
clusters-hosted   hosted-worker0   registering              true             2s
clusters-hosted   hosted-worker1   registering              true             2s
clusters-hosted   hosted-worker2   registering              true             2s

    • 此输出显示节点已启动： 

      NAMESPACE         NAME             STATE          CONSUMER   ONLINE   ERROR   AGE
clusters-hosted   hosted-worker0   provisioning              true             16s
clusters-hosted   hosted-worker1   provisioning              true             16s
clusters-hosted   hosted-worker2   provisioning              true             16s
    • 此输出显示节点成功启动： 
    NAMESPACE         NAME             STATE         CONSUMER   ONLINE   ERROR   AGE
clusters-hosted   hosted-worker0   provisioned              true             67s
clusters-hosted   hosted-worker1   provisioned              true             67s
clusters-hosted   hosted-worker2   provisioned              true             67s

  3. 节点启动后，请注意命名空间中的代理，如下例所示： 

    NAMESPACE         NAME                                   CLUSTER   APPROVED   ROLE          STAGE
clusters-hosted   aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaa0411             true       auto-assign
clusters-hosted   aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaa0412             true       auto-assign
clusters-hosted   aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaa0413             true       auto-assign

    代理代表可用于安装的节点。要将节点分配到托管集群，请扩展节点池。

1.7.12.5.9.6. 扩展节点池

创建裸机主机后，其状态将从 Registering 变为 Provisioning 。节点以代理的 LiveISO 开头，以及名为 agent 的默认 pod。该代理负责从 Assisted Service Operator 接收安装 OpenShift Container Platform 有效负载的说明。

  1. 要扩展节点池，请输入以下命令： 

    oc -n clusters scale nodepool hosted-ipv4 --replicas 3

  2. 扩展过程完成后，请注意代理被分配给一个托管的集群： 

    NAMESPACE         NAME                                   CLUSTER   APPROVED   ROLE          STAGE
clusters-hosted   aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaa0411   hosted    true       auto-assign
clusters-hosted   aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaa0412   hosted    true       auto-assign
clusters-hosted   aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaa0413   hosted    true       auto-assign

  3. 另请注意设置了节点池副本： 

    NAMESPACE   NAME     CLUSTER   DESIRED NODES   CURRENT NODES   AUTOSCALING   AUTOREPAIR   VERSION                              UPDATINGVERSION   UPDATINGCONFIG   MESSAGE
clusters    hosted   hosted    3                               False         False        4.x.y-x86_64                                      Minimum availability requires 3 replicas, current 0 available

    将 4.x.y 替换为您要使用的 OpenShift Container Platform 版本。

  4. 等待节点加入集群。在此过程中，代理在其阶段和状态上提供更新。

接下来，监控托管集群的部署。

1.7.12.5.10. 为 IPv4 网络完成托管集群部署

您可以从两个视角监控托管集群的部署：control plane 和 data plane。

1.7.12.5.10.1. 监控 control plane

在托管集群部署时，您可以输入以下命令来监控 control plane： 

export KUBECONFIG=/root/.kcli/clusters/hub-ipv4/auth/kubeconfig
watch "oc get pod -n hypershift;echo;echo;oc get pod -n clusters-hosted-ipv4;echo;echo;oc get bmh -A;echo;echo;oc get agent -A;echo;echo;oc get infraenv -A;echo;echo;oc get hostedcluster -A;echo;echo;oc get nodepool -A;echo;echo;"

这些命令提供有关以下工件的信息：

  • HyperShift Operator
  • HostedControlPlane pod
  • 裸机主机
  • 代理
  • InfraEnv 资源
  • HostedCluster 和 NodePool 资源
1.7.12.5.10.2. 监控数据平面

要监控 Operator 在部署过程中如何进行，请输入以下命令： 

oc get secret -n clusters-hosted-ipv4 admin-kubeconfig -o jsonpath='{.data.kubeconfig}' |base64 -d > /root/hc_admin_kubeconfig.yaml
export KUBECONFIG=/root/hc_admin_kubeconfig.yaml
watch "oc get clusterversion,nodes,co"

这些命令提供有关以下工件的信息：

  • 集群版本
  • 节点，特别是有关节点是否加入集群
  • 集群 Operator

1.7.12.6. 在 IPv6 网络中配置托管的 control plane

IPv6 网络配置目前被指定为 disconnected。此设计的主要原因是远程 registry 不适用于 IPv6。

查看以下步骤在 IPv6 网络上配置托管的 control plane：

  1. 为 IPv6 网络配置虚拟机监控程序
  2. 为 IPv6 网络配置 DNS
  3. 为 IPv6 网络部署 registry
  4. 为 IPv6 网络设置管理集群
  5. 为 IPv6 网络配置 Web 服务器
  6. 为 IPv6 网络配置镜像
  7. 为 IPv6 网络部署多集群引擎 operator
  8. 为 IPv6 网络配置 TLS 证书
  9. 为 IPv6 网络部署托管集群
  10. 完成 IPv6 网络的部署
1.7.12.6.1. 为 IPv6 网络配置 hypervisor

以下信息仅适用于虚拟机环境。

1.7.12.6.1.1. 访问和部署虚拟 OpenShift Container Platform 集群的软件包

  1. 要部署虚拟 OpenShift Container Platform 管理集群，请输入以下命令来访问所需的软件包： 

    sudo dnf install dnsmasq radvd vim golang podman bind-utils net-tools httpd-tools tree htop strace tmux -y

  2. 输入以下命令启用并启动 Podman 服务： 

    systemctl enable --now podman

  3. 要使用 kcli 部署 OpenShift Container Platform 管理集群和其他虚拟组件，请输入以下命令安装和配置 hypervisor： 

    sudo yum -y install libvirt libvirt-daemon-driver-qemu qemu-kvm
    sudo usermod -aG qemu,libvirt $(id -un)
    sudo newgrp libvirt
    sudo systemctl enable --now libvirtd
    sudo dnf -y copr enable karmab/kcli
    sudo dnf -y install kcli
    sudo kcli create pool -p /var/lib/libvirt/images default
    kcli create host kvm -H 127.0.0.1 local
    sudo setfacl -m u:$(id -un):rwx /var/lib/libvirt/images
    kcli create network  -c 192.168.122.0/24 default
1.7.12.6.1.2. 启用网络管理器分配程序

  1. 启用网络管理器分配程序，以确保虚拟机可以解析所需的域、路由和 registry。要启用网络管理器分配程序，在 /etc/NetworkManager/dispatcher.d/ 目录中，创建一个名为 forcedns 的脚本，其中包含以下内容，根据需要替换与您的环境匹配的值： 

    #!/bin/bash

export IP="2620:52:0:1306::1" 1
export BASE_RESOLV_CONF="/run/NetworkManager/resolv.conf"

if ! [[ `grep -q "$IP" /etc/resolv.conf` ]]; then
export TMP_FILE=$(mktemp /etc/forcedns_resolv.conf.XXXXXX)
cp $BASE_RESOLV_CONF $TMP_FILE
chmod --reference=$BASE_RESOLV_CONF $TMP_FILE
sed -i -e "s/dns.base.domain.name//" -e "s/search /& dns.base.domain.name /" -e "0,/nameserver/s/nameserver/& $IP\n&/" $TMP_FILE 2
mv $TMP_FILE /etc/resolv.conf
fi
echo "ok"
    1
    修改 IP 变量，以指向托管 OpenShift Container Platform 管理集群的虚拟机监控程序接口的 IP 地址。
    2
    将 dns.base.domain.name 替换为 DNS 基域名称。

  2. 创建该文件后，输入以下命令添加权限： 

    chmod 755 /etc/NetworkManager/dispatcher.d/forcedns
  3. 运行脚本，并验证输出是否返回 ok。
1.7.12.6.1.3. 配置 BMC 访问

  1. 配置 ksushy 以模拟虚拟机的基板管理控制器(BMC)。输入以下命令： 

    sudo dnf install python3-pyOpenSSL.noarch python3-cherrypy -y
    kcli create sushy-service --ssl --ipv6 --port 9000
    sudo systemctl daemon-reload
    systemctl enable --now ksushy

  2. 输入以下命令测试该服务是否正常工作： 

    systemctl status ksushy
1.7.12.6.1.4. 配置 hypervisor 系统以允许连接

如果您在开发环境中工作，请将 hypervisor 系统配置为允许通过环境中不同虚拟网络进行各种连接。

注： 如果您在生产环境中工作，您必须为 firewalld 服务建立正确的规则，并配置 SELinux 策略以维护安全环境。

  • 对于 SELinux，输入以下命令： 

    sed -i s/^SELINUX=.*$/SELINUX=permissive/ /etc/selinux/config; setenforce 0

  • 对于 firewalld，输入以下命令： 

    systemctl disable --now firewalld

  • 对于 libvirtd，输入以下命令： 

    systemctl restart libvirtd
    systemctl enable --now libvirtd

接下来，为您的环境配置 DNS。

1.7.12.6.1.5. 其他资源
1.7.12.6.2. 为 IPv6 网络配置 DNS

对于虚拟和裸机环境中断开连接和连接的环境，此步骤是必需的。虚拟和裸机环境之间的主要区别在于配置资源的位置。在裸机环境中，使用 Bind 等解决方案，而不是 dnsmasq 等轻量级解决方案。

接下来，部署 registry。

1.7.12.6.3. 为 IPv6 网络部署 registry

对于开发环境，使用 Podman 容器部署小型自托管注册表。对于生产环境，请使用企业托管的 registry，如 Red Hat Quay、Nexus 或 Artifactory。

要使用 Podman 部署小 registry，请完成以下步骤：

  1. 以特权用户身份，访问 ${HOME} 目录并创建以下脚本： 

    #!/usr/bin/env bash

set -euo pipefail

PRIMARY_NIC=$(ls -1 /sys/class/net | grep -v podman | head -1)
export PATH=/root/bin:$PATH
export PULL_SECRET="/root/baremetal/hub/openshift_pull.json" 1

if [[ ! -f $PULL_SECRET ]];then
  echo "Pull Secret not found, exiting..."
  exit 1
fi

dnf -y install podman httpd httpd-tools jq skopeo libseccomp-devel
export IP=$(ip -o addr show $PRIMARY_NIC | head -1 | awk '{print $4}' | cut -d'/' -f1)
REGISTRY_NAME=registry.$(hostname --long)
REGISTRY_USER=dummy
REGISTRY_PASSWORD=dummy
KEY=$(echo -n $REGISTRY_USER:$REGISTRY_PASSWORD | base64)
echo "{\"auths\": {\"$REGISTRY_NAME:5000\": {\"auth\": \"$KEY\", \"email\": \"sample-email@domain.ltd\"}}}" > /root/disconnected_pull.json
mv ${PULL_SECRET} /root/openshift_pull.json.old
jq ".auths += {\"$REGISTRY_NAME:5000\": {\"auth\": \"$KEY\",\"email\": \"sample-email@domain.ltd\"}}" < /root/openshift_pull.json.old > $PULL_SECRET
mkdir -p /opt/registry/{auth,certs,data,conf}
cat <<EOF > /opt/registry/conf/config.yml
version: 0.1
log:
  fields:
    service: registry
storage:
  cache:
    blobdescriptor: inmemory
  filesystem:
    rootdirectory: /var/lib/registry
  delete:
    enabled: true
http:
  addr: :5000
  headers:
    X-Content-Type-Options: [nosniff]
health:
  storagedriver:
    enabled: true
    interval: 10s
    threshold: 3
compatibility:
  schema1:
    enabled: true
EOF
openssl req -newkey rsa:4096 -nodes -sha256 -keyout /opt/registry/certs/domain.key -x509 -days 3650 -out /opt/registry/certs/domain.crt -subj "/C=US/ST=Madrid/L=San Bernardo/O=Karmalabs/OU=Guitar/CN=$REGISTRY_NAME" -addext "subjectAltName=DNS:$REGISTRY_NAME"
cp /opt/registry/certs/domain.crt /etc/pki/ca-trust/source/anchors/
update-ca-trust extract
htpasswd -bBc /opt/registry/auth/htpasswd $REGISTRY_USER $REGISTRY_PASSWORD
podman create --name registry --net host --security-opt label=disable --replace -v /opt/registry/data:/var/lib/registry:z -v /opt/registry/auth:/auth:z -v /opt/registry/conf/config.yml:/etc/docker/registry/config.yml -e "REGISTRY_AUTH=htpasswd" -e "REGISTRY_AUTH_HTPASSWD_REALM=Registry" -e "REGISTRY_HTTP_SECRET=ALongRandomSecretForRegistry" -e REGISTRY_AUTH_HTPASSWD_PATH=/auth/htpasswd -v /opt/registry/certs:/certs:z -e REGISTRY_HTTP_TLS_CERTIFICATE=/certs/domain.crt -e REGISTRY_HTTP_TLS_KEY=/certs/domain.key docker.io/library/registry:latest
[ "$?" == "0" ] || !!
systemctl enable --now registry
    1
    将 PULL_SECRET 的位置替换为您的设置的适当位置。

  2. 命名脚本文件 registry.sh 并保存它。运行脚本时，它会拉取以下信息：

    • registry 名称，基于虚拟机监控程序主机名
    • 所需的凭证和用户访问详情

  3. 通过添加执行标记来调整权限，如下所示： 

    chmod u+x ${HOME}/registry.sh

  4. 要在没有任何参数的情况下运行脚本，请输入以下命令： 

    ${HOME}/registry.sh

    该脚本启动服务器。

  5. 该脚本使用 systemd 服务来管理目的。如果需要管理脚本，您可以使用以下命令： 

    systemctl status
    systemctl start
    systemctl stop

registry 的根文件夹位于 /opt/registry 目录中，包含以下子目录：

  • certs 包含 TLS 证书。
  • auth 包含凭据。
  • 数据 包含 registry 镜像。
  • conf 包含 registry 配置。
1.7.12.6.4. 为 IPv6 网络设置管理集群

要设置 OpenShift Container Platform 管理集群，您可以使用 dev-scripts，或者基于虚拟机，您可以使用 kcli 工具。以下说明特定于 kcli 工具。

  1. 确保正确的网络已准备好在 hypervisor 中使用。网络将托管管理和托管集群。输入以下 kcli 命令： 

    kcli create network -c 2620:52:0:1305::0/64 -P dhcp=false -P dns=false --domain dns.base.domain.name --nodhcp ipv6

    其中：

    • -c 指定网络的 CIDR。
    • -p dhcp=false 将网络配置为禁用 DHCP，该 DHCP 由您配置的 dnsmasq 处理。
    • -p dns=false 将网络配置为禁用 DNS，这也由您配置的 dnsmasq 处理。
    • --domain 设置要搜索的域。
    • dns.base.domain.name 是 DNS 基础域名。
    • ipv6 是您要创建的网络的名称。

  2. 创建网络后，查看以下输出： 

    [root@hypershiftbm ~]# kcli list network
Listing Networks...
+---------+--------+---------------------+-------+------------------+------+
| Network |  Type  |         Cidr        |  Dhcp |      Domain      | Mode |
+---------+--------+---------------------+-------+------------------+------+
| default | routed |   192.168.122.0/24  |  True |     default      | nat  |
| ipv4    | routed |   192.168.125.0/24  | False | dns.base.domain.name | nat  |
| ipv4    | routed | 2620:52:0:1305::/64 | False | dns.base.domain.name | nat  |
+---------+--------+---------------------+-------+------------------+------+
    [root@hypershiftbm ~]# kcli info network ipv6
Providing information about network ipv6...
cidr: 2620:52:0:1305::/64
dhcp: false
domain: dns.base.domain.name
mode: nat
plan: kvirt
type: routed

  3. 确保 pull secret 和 kcli 计划文件已就位，以便您可以部署 OpenShift Container Platform 管理集群：

    1. 确认 pull secret 与 kcli 计划位于同一个文件夹中，并且 pull secret 文件名为 openshift_pull.json。
    2. 在 mgmt-compact-hub-ipv6.yaml 文件中添加 kcli 计划，其中包含 OpenShift Container Platform 定义。确保更新文件内容以匹配您的环境： 
    plan: hub-ipv6
force: true
version: nightly
tag: "4.x.y-x86_64"
cluster: "hub-ipv6"
ipv6: true
domain: dns.base.domain.name
api_ip: 2620:52:0:1305::2
ingress_ip: 2620:52:0:1305::3
disconnected_url: registry.dns.base.domain.name:5000
disconnected_update: true
disconnected_user: dummy
disconnected_password: dummy
disconnected_operators_version: v4.14
disconnected_operators:
- name: metallb-operator
- name: lvms-operator
  channels:
  - name: stable-4.13
disconnected_extra_images:
- quay.io/user-name/trbsht:latest
- quay.io/user-name/hypershift:BMSelfManage-v4.14-rc-v3
- registry.redhat.io/openshift4/ose-kube-rbac-proxy:v4.10
dualstack: false
disk_size: 200
extra_disks: [200]
memory: 48000
numcpus: 16
ctlplanes: 3
workers: 0
manifests: extra-manifests
metal3: true
network: ipv6
users_dev: developer
users_devpassword: developer
users_admin: admin
users_adminpassword: admin
metallb_pool: ipv6-virtual-network
metallb_ranges:
- 2620:52:0:1305::150-2620:52:0:1305::190
metallb_autoassign: true
apps:
- users
- lvms-operator
- metallb-operator
vmrules:
- hub-bootstrap:
    nets:
    - name: ipv6
      mac: aa:aa:aa:aa:03:10
- hub-ctlplane-0:
    nets:
    - name: ipv6
      mac: aa:aa:aa:aa:03:01
- hub-ctlplane-1:
    nets:
    - name: ipv6
      mac: aa:aa:aa:aa:03:02
- hub-ctlplane-2:
    nets:
    - name: ipv6
      mac: aa:aa:aa:aa:03:03

  4. 要置备管理集群，请输入以下命令： 

    kcli create cluster openshift --pf mgmt-compact-hub-ipv6.yaml
1.7.12.6.4.1. 其他资源
1.7.12.6.5. 为 IPv6 网络配置 Web 服务器

您需要配置一个额外的 Web 服务器来托管与您要部署为托管集群的 OpenShift Container Platform 发行版本关联的 Red Hat Enterprise Linux CoreOS (RHCOS)镜像。

要配置 web 服务器，请完成以下步骤：

  1. 输入以下命令从您要使用的 OpenShift Container Platform 发行版本中提取 openshift-install 二进制文件： 

    oc adm -a ${LOCAL_SECRET_JSON} release extract --command=openshift-install "${LOCAL_REGISTRY}/${LOCAL_REPOSITORY}:${OCP_RELEASE}-${ARCHITECTURE}"

  2. 运行以下脚本：该脚本在 /opt/srv 目录中创建文件夹。文件夹包含用于置备 worker 节点的 RHCOS 镜像。 

    #!/bin/bash

WEBSRV_FOLDER=/opt/srv
ROOTFS_IMG_URL="$(./openshift-install coreos print-stream-json | jq -r '.architectures.x86_64.artifacts.metal.formats.pxe.rootfs.location')" 1
LIVE_ISO_URL="$(./openshift-install coreos print-stream-json | jq -r '.architectures.x86_64.artifacts.metal.formats.iso.disk.location')" 2

mkdir -p ${WEBSRV_FOLDER}/images
curl -Lk ${ROOTFS_IMG_URL} -o ${WEBSRV_FOLDER}/images/${ROOTFS_IMG_URL##*/}
curl -Lk ${LIVE_ISO_URL} -o ${WEBSRV_FOLDER}/images/${LIVE_ISO_URL##*/}
chmod -R 755 ${WEBSRV_FOLDER}/*

## Run Webserver
podman ps --noheading | grep -q websrv-ai
if [[ $? == 0 ]];then
    echo "Launching Registry pod..."
    /usr/bin/podman run --name websrv-ai --net host -v /opt/srv:/usr/local/apache2/htdocs:z quay.io/alosadag/httpd:p8080
fi
    1
    您可以在 OpenShift CI Release 页面上找到 ROOTFS_IMG_URL 值。
    2
    您可以在 OpenShift CI Release 页面上找到 LIVE_ISO_URL 值。

下载完成后，容器将运行，以托管 Web 服务器上的镜像。容器使用官方 HTTPd 镜像的一种变体，这使得它能够使用 IPv6 网络。

1.7.12.6.6. 为 IPv6 网络配置镜像

镜像镜像是从外部 registry 获取镜像的过程，如 registry.redhat.com 或 quay.io，并将它们存储在私有 registry 中。

1.7.12.6.6.1. 完成镜像过程

注： 在 registry 服务器运行后启动镜像过程。

在以下步骤中，使用 oc-mirror 工具，它是一个使用 ImageSetConfiguration 对象的二进制文件。在文件中，您可以指定以下信息：

  • 要镜像的 OpenShift Container Platform 版本。版本位于 quay.io 中。
  • 要镜像的额外 Operator。单独选择软件包。
  • 要添加到存储库的额外镜像。

要配置镜像镜像，请完成以下步骤：

  1. 确保 ${HOME}/.docker/config.json 文件已更新为您要从中镜像 registry 以及您要将镜像推送到的私有 registry。

  2. 通过使用以下示例，创建一个 ImageSetConfiguration 对象以用于镜像。根据需要替换与您的环境匹配的值： 

    apiVersion: mirror.openshift.io/v1alpha2
kind: ImageSetConfiguration
storageConfig:
  registry:
    imageURL: registry.dns.base.domain.name:5000/openshift/release/metadata:latest 1
mirror:
  platform:
    channels:
    - name: candidate-4.14
      minVersion: 4.x.y-x86_64
      maxVersion: 4.x.y-x86_64
      type: ocp
    graph: true
  additionalImages:
  - name: quay.io/karmab/origin-keepalived-ipfailover:latest
  - name: quay.io/karmab/kubectl:latest
  - name: quay.io/karmab/haproxy:latest
  - name: quay.io/karmab/mdns-publisher:latest
  - name: quay.io/karmab/origin-coredns:latest
  - name: quay.io/karmab/curl:latest
  - name: quay.io/karmab/kcli:latest
  - name: quay.io/user-name/trbsht:latest
  - name: quay.io/user-name/hypershift:BMSelfManage-v4.14-rc-v3
  - name: registry.redhat.io/openshift4/ose-kube-rbac-proxy:v4.10
  operators:
  - catalog: registry.redhat.io/redhat/redhat-operator-index:v4.14
    packages:
    - name: lvms-operator
    - name: local-storage-operator
    - name: odf-csi-addons-operator
    - name: odf-operator
    - name: mcg-operator
    - name: ocs-operator
    - name: metallb-operator
    1
    将 dns.base.domain.name 替换为 DNS 基础域名，将 4.x.y 替换为您要使用的 OpenShift Container Platform 版本。

  3. 输入以下命令启动镜像过程： 

    oc-mirror --source-skip-tls --config imagesetconfig.yaml docker://${REGISTRY}

    镜像过程完成后，您有一个名为 oc-mirror-workspace/results-XXXXXX/ 的新文件夹，其中包含 ICSP 和要应用到托管的集群的目录源。

  4. 使用 oc adm release mirror 命令镜像 OpenShift Container Platform 的 nightly 或 CI 版本。输入以下命令： 

    REGISTRY=registry.$(hostname --long):5000

oc adm release mirror \
  --from=registry.ci.openshift.org/ocp/release:4.x.y-x86_64 \
  --to=${REGISTRY}/openshift/release \
  --to-release-image=${REGISTRY}/openshift/release-images:4.x.y-x86_64

    将 4.x.y 替换为您要使用的 OpenShift Container Platform 版本。

  5. 按照在 断开连接的网络 上安装 中的步骤镜像最新的多集群引擎 operator 镜像。
1.7.12.6.6.2. 在管理集群中应用对象

镜像过程完成后，您需要在管理集群中应用两个对象：

  • 镜像内容源策略(ICSP)或镜像 Digest 镜像集(IDMS)
  • 目录源

当使用 oc-mirror 工具时，输出工件位于名为 oc-mirror-workspace/results-XXXXXX/ 的目录中。

ICSP 或 IDMS 会启动一个 MachineConfig 更改，它不会重启节点，而是在每个节点上重启 kubelet。节点标记为 READY 后，您需要应用新生成的目录源。

目录源在 openshift-marketplace Operator 中启动操作，如下载目录镜像并处理它来检索该镜像中包含的所有 PackageManifests。

  1. 要检查新源，请使用新的 CatalogSource 作为源运行以下命令： 

    oc get packagemanifest

  2. 要应用工件，请完成以下步骤：

    1. 输入以下命令来创建 ICSP 或 IDMS 工件： 

      oc apply -f oc-mirror-workspace/results-XXXXXX/imageContentSourcePolicy.yaml
    2. 等待节点就绪，然后输入以下命令： 
    oc apply -f catalogSource-XXXXXXXX-index.yaml
1.7.12.6.6.3. 其他资源
1.7.12.6.7. 为 IPv6 网络部署多集群引擎 operator

multicluster engine operator 在供应商间部署集群时扮演了关键角色。如果已安装 Red Hat Advanced Cluster Management，则不需要安装 multicluster engine operator，因为它会被自动安装。

如果您没有安装 multicluster engine operator，请参阅以下文档以了解安装它的先决条件和步骤：

1.7.12.6.7.1. 部署 AgentServiceConfig 资源

AgentServiceConfig 自定义资源是 Assisted Service add-on 的基本组件，它是 multicluster engine operator 的一部分。它负责裸机集群部署。启用附加组件后，您要部署 AgentServiceConfig 资源来配置附加组件。

除了配置 AgentServiceConfig 资源外，还需要包含额外的配置映射，以确保多集群引擎 Operator 在断开连接的环境中正常工作。

  1. 通过添加以下配置映射来配置自定义 registry，其中包含用于自定义部署的断开连接的详情： 

    ---
apiVersion: v1
kind: ConfigMap
metadata:
  name: custom-registries
  namespace: multicluster-engine
  labels:
    app: assisted-service
data:
  ca-bundle.crt: |
    -----BEGIN CERTIFICATE-----
    -----END CERTIFICATE-----
  registries.conf: |
    unqualified-search-registries = ["registry.access.redhat.com", "docker.io"]

    [[registry]]
    prefix = ""
    location = "registry.redhat.io/openshift4"
    mirror-by-digest-only = true

    [[registry.mirror]]
      location = "registry.dns.base.domain.name:5000/openshift4" 1

    [[registry]]
    prefix = ""
    location = "registry.redhat.io/rhacm2"
    mirror-by-digest-only = true
    ...
    ...
    1
    将 dns.base.domain.name 替换为 DNS 基域名称。

    对象包含两个字段：

    • 自定义 CA：此字段包含加载到部署各种进程的证书颁发机构(CA)。
    • Registry: Registries.conf 字段包含有关需要从镜像 registry 而不是原始源 registry 中消耗的镜像和命名空间的信息。

  2. 通过添加 AssistedServiceConfig 对象来配置 Assisted Service，如下例所示： 

    ---
apiVersion: agent-install.openshift.io/v1beta1
kind: AgentServiceConfig
metadata:
  annotations:
    unsupported.agent-install.openshift.io/assisted-service-configmap: assisted-service-config 1
  name: agent
  namespace: multicluster-engine
spec:
  mirrorRegistryRef:
    name: custom-registries 2
  databaseStorage:
    storageClassName: lvms-vg1
    accessModes:
    - ReadWriteOnce
    resources:
      requests:
        storage: 10Gi
  filesystemStorage:
    storageClassName: lvms-vg1
    accessModes:
    - ReadWriteOnce
    resources:
      requests:
        storage: 20Gi
  osImages: 3
  - cpuArchitecture: x86_64
    openshiftVersion: "4.14"
    rootFSUrl: http://registry.dns.base.domain.name:8080/images/rhcos-414.92.202308281054-0-live-rootfs.x86_64.img 4
    url: http://registry.dns.base.domain.name:8080/images/rhcos-414.92.202308281054-0-live.x86_64.iso
    version: 414.92.202308281054-0
    1
    metadata.annotations["unsupported.agent-install.openshift.io/assisted-service-configmap"] 注解引用 Operator 用来自定义行为的配置映射名称。
    2
    spec.mirrorRegistryRef.name 注解指向包含 Assisted Service Operator 使用断开连接的 registry 信息的配置映射。此配置映射在部署过程中添加这些资源。
    3
    spec.osImages 字段包含可供此 Operator 部署的不同版本。这个字段是必须的。本例假定您已下载了 RootFS 和 LiveISO 文件。
    4
    在 rootFSUrl 和 url 字段中，将 dns.base.domain.name 替换为 DNS 基域名称。

  3. 通过将所有对象串联到一个文件中，并将它们应用到管理集群，以此部署所有对象。要做到这一点，请输入以下命令： 

    oc apply -f agentServiceConfig.yaml

    该命令会触发两个 pod，如本示例输出所示： 

    assisted-image-service-0                               1/1     Running   2             11d 1
assisted-service-668b49548-9m7xw                       2/2     Running   5             11d 2
    1
    assisted-image-service pod 负责创建 Red Hat Enterprise Linux CoreOS (RHCOS)引导镜像模板，该模板针对您部署的每个集群自定义。
    2
    assisted-service 指的是 Operator。
1.7.12.6.8. 为 IPv6 网络配置 TLS 证书

涉及几个 TLS 证书，以便在断开连接的环境中配置托管的 control plane。要将证书颁发机构(CA)添加到管理集群中，您需要修改 OpenShift Container Platform control plane 和 worker 节点上的以下文件的内容：

  • /etc/pki/ca-trust/extracted/pem/
  • /etc/pki/ca-trust/source/anchors
  • /etc/pki/tls/certs/

要在管理集群中添加 CA，请完成以下步骤：

  1. 完成官方 OpenShift Container Platform 文档中的 更新 CA 捆绑包 中的步骤。该方法涉及使用 image-registry-operator，它将 CA 部署到 OpenShift Container Platform 节点。

  2. 如果该方法不适用于您的情况，请检查管理集群中的 openshift-config 命名空间是否包含名为 user-ca-bundle 的配置映射。

    • 如果命名空间包含该配置映射，请输入以下命令： 

      ## REGISTRY_CERT_PATH=<PATH/TO/YOUR/CERTIFICATE/FILE>
export REGISTRY_CERT_PATH=/opt/registry/certs/domain.crt

oc create configmap user-ca-bundle -n openshift-config --from-file=ca-bundle.crt=${REGISTRY_CERT_PATH}

    • 如果命名空间不包含该配置映射，请输入以下命令： 

      ## REGISTRY_CERT_PATH=<PATH/TO/YOUR/CERTIFICATE/FILE>
export REGISTRY_CERT_PATH=/opt/registry/certs/domain.crt
export TMP_FILE=$(mktemp)

oc get cm -n openshift-config user-ca-bundle -ojsonpath='{.data.ca-bundle\.crt}' > ${TMP_FILE}
echo >> ${TMP_FILE}
echo \#registry.$(hostname --long) >> ${TMP_FILE}
cat ${REGISTRY_CERT_PATH} >> ${TMP_FILE}
oc create configmap user-ca-bundle -n openshift-config --from-file=ca-bundle.crt=${TMP_FILE} --dry-run=client -o yaml | kubectl apply -f -
1.7.12.6.9. 为 IPv6 网络部署托管集群

托管的集群是一个 OpenShift Container Platform 集群，它带有托管在管理集群上的 control plane 和 API 端点。托管的集群包括控制平面和它的对应的数据平面。

虽然您可以使用 Red Hat Advanced Cluster Management 中的控制台创建托管集群，但以下步骤使用清单，这提供了修改相关工件的灵活性。

1.7.12.6.9.1. 部署托管集群对象

对于此过程，使用以下值：

  • HostedCluster name: hosted-ipv6
  • HostedCluster 命名空间： 集群
  • disconnected: true
  • 网络堆栈： IPv6

通常，HyperShift Operator 会创建 HostedControlPlane 命名空间。但是，在这种情况下，您想要在 HyperShift Operator 开始协调 HostedCluster 对象前包含所有对象。然后，当 Operator 启动协调过程时，它可以找到所有对象。

  1. 使用有关命名空间的以下信息创建 YAML 文件： 

    ---
apiVersion: v1
kind: Namespace
metadata:
  creationTimestamp: null
  name: clusters-hosted-ipv6
spec: {}
status: {}
---
apiVersion: v1
kind: Namespace
metadata:
  creationTimestamp: null
  name: clusters
spec: {}
status: {}

  2. 创建一个 YAML 文件，其中包含有关配置映射和 secret 的信息，以便在 HostedCluster 部署中包括： 

    ---
apiVersion: v1
data:
  ca-bundle.crt: |
    -----BEGIN CERTIFICATE-----
    -----END CERTIFICATE-----
kind: ConfigMap
metadata:
  name: user-ca-bundle
  namespace: clusters
---
apiVersion: v1
data:
  .dockerconfigjson: xxxxxxxxx
kind: Secret
metadata:
  creationTimestamp: null
  name: hosted-ipv6-pull-secret
  namespace: clusters
---
apiVersion: v1
kind: Secret
metadata:
  name: sshkey-cluster-hosted-ipv6
  namespace: clusters
stringData:
  id_rsa.pub: ssh-rsa xxxxxxxxx
---
apiVersion: v1
data:
  key: nTPtVBEt03owkrKhIdmSW8jrWRxU57KO/fnZa8oaG0Y=
kind: Secret
metadata:
  creationTimestamp: null
  name: hosted-ipv6-etcd-encryption-key
  namespace: clusters
type: Opaque

  3. 创建一个包含 RBAC 角色的 YAML 文件，以便辅助服务代理可以与托管 control plane 位于同一个 HostedControlPlane 命名空间中，仍由集群 API 管理： 

    apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  creationTimestamp: null
  name: capi-provider-role
  namespace: clusters-hosted-ipv6
rules:
- apiGroups:
  - agent-install.openshift.io
  resources:
  - agents
  verbs:
  - '*'

  4. 使用 HostedCluster 对象的信息创建 YAML 文件，根据需要替换值： 

    apiVersion: hypershift.openshift.io/v1beta1
kind: HostedCluster
metadata:
  name: hosted-ipv6
  namespace: clusters
  annotations:
    hypershift.openshift.io/control-plane-operator-image: registry.ocp-edge-cluster-0.qe.lab.redhat.com:5005/openshift/release@sha256:31149e3e5f8c5e5b5b100ff2d89975cf5f7a73801b2c06c639bf6648766117f8
spec:
  additionalTrustBundle:
    name: "user-ca-bundle"
  olmCatalogPlacement: guest
  imageContentSources: 1
  - source: quay.io/openshift-release-dev/ocp-v4.0-art-dev
    mirrors:
    - registry.dns.base.domain.name:5000/openshift/release
  - source: quay.io/openshift-release-dev/ocp-release
    mirrors:
    - registry.dns.base.domain.name:5000/openshift/release-images
  - mirrors:
  ...
  ...
  autoscaling: {}
  controllerAvailabilityPolicy: SingleReplica
  dns:
    baseDomain: dns.base.domain.name
  etcd:
    managed:
      storage:
        persistentVolume:
          size: 8Gi
        restoreSnapshotURL: null
        type: PersistentVolume
    managementType: Managed
  fips: false
  networking:
    clusterNetwork:
    - cidr: 10.132.0.0/14
    networkType: OVNKubernetes
    serviceNetwork:
    - cidr: 172.31.0.0/16
  platform:
    agent:
      agentNamespace: clusters-hosted-ipv6
    type: Agent
  pullSecret:
    name: hosted-ipv6-pull-secret
  release:
    image: registry.dns.base.domain.name:5000/openshift/release-images:4.x.y-x86_64
  secretEncryption:
    aescbc:
      activeKey:
        name: hosted-ipv6-etcd-encryption-key
    type: aescbc
  services:
  - service: APIServer
    servicePublishingStrategy:
      nodePort:
        address: api.hosted-ipv6.dns.base.domain.name
      type: NodePort
  - service: OAuthServer
    servicePublishingStrategy:
      nodePort:
        address: api.hosted-ipv6.dns.base.domain.name
      type: NodePort
  - service: OIDC
    servicePublishingStrategy:
      nodePort:
        address: api.hosted-ipv6.dns.base.domain.name
      type: NodePort
  - service: Konnectivity
    servicePublishingStrategy:
      nodePort:
        address: api.hosted-ipv6.dns.base.domain.name
      type: NodePort
  - service: Ignition
    servicePublishingStrategy:
      nodePort:
        address: api.hosted-ipv6.dns.base.domain.name
      type: NodePort
  sshKey:
    name: sshkey-cluster-hosted-ipv6
status:
  controlPlaneEndpoint:
    host: ""
    port: 0

    其中 dns.base.domain.name 是 DNS 基础域名，而 4.x.y 是您要使用的 OpenShift Container Platform 版本。

    1
    imageContentSources 部分包含托管集群中用户工作负载的镜像引用。

  5. 在 HostedCluster 对象中添加指向 OpenShift Container Platform 发行版本中 HyperShift Operator 发行版本的注解：

    1. 输入以下命令来获取镜像有效负载： 

      oc adm release info registry.dns.base.domain.name:5000/openshift-release-dev/ocp-release:4.x.y-x86_64 | grep hypershift

      其中 dns.base.domain.name 是 DNS 基础域名，而 4.x.y 是您要使用的 OpenShift Container Platform 版本。

    2. 请参见以下输出： 

      hypershift                                     sha256:31149e3e5f8c5e5b5b100ff2d89975cf5f7a73801b2c06c639bf6648766117f8

    3. 使用 OpenShift Container Platform Images 命名空间，输入以下命令检查摘要： 

      podman pull registry.dns.base.domain.name:5000/openshift-release-dev/ocp-v4.0-art-dev@sha256:31149e3e5f8c5e5b5b100ff2d89975cf5f7a73801b2c06c639bf6648766117f8

      其中 dns.base.domain.name 是 DNS 基础域名。

    4. 请参见以下输出： 

      podman pull registry.dns.base.domain.name:5000/openshift/release@sha256:31149e3e5f8c5e5b5b100ff2d89975cf5f7a73801b2c06c639bf6648766117f8
Trying to pull registry.dns.base.domain.name:5000/openshift/release@sha256:31149e3e5f8c5e5b5b100ff2d89975cf5f7a73801b2c06c639bf6648766117f8...
Getting image source signatures
Copying blob d8190195889e skipped: already exists
Copying blob c71d2589fba7 skipped: already exists
Copying blob d4dc6e74b6ce skipped: already exists
Copying blob 97da74cc6d8f skipped: already exists
Copying blob b70007a560c9 done
Copying config 3a62961e6e done
Writing manifest to image destination
Storing signatures
3a62961e6ed6edab46d5ec8429ff1f41d6bb68de51271f037c6cb8941a007fde

    注： HostedCluster 对象中设置的发行镜像必须使用摘要而不是标签；例如，quay.io/openshift-release-dev/ocp-release-dev/ocp-release@sha256:e3ba11bd1e5e8ea5a0b36a75791c90f29afb0fdbe4125be4e48f69c76a5c47a0。

  6. 通过将 YAML 文件中定义的所有对象串联成文件并根据管理集群应用，以创建您在 YAML 文件中定义的所有对象。要做到这一点，请输入以下命令： 

    oc apply -f 01-4.14-hosted_cluster-nodeport.yaml

  7. 查看托管 control plane 的输出： 

    NAME                                                  READY   STATUS    RESTARTS   AGE
capi-provider-5b57dbd6d5-pxlqc                        1/1     Running   0          3m57s
catalog-operator-9694884dd-m7zzv                      2/2     Running   0          93s
cluster-api-f98b9467c-9hfrq                           1/1     Running   0          3m57s
cluster-autoscaler-d7f95dd5-d8m5d                     1/1     Running   0          93s
cluster-image-registry-operator-5ff5944b4b-648ht      1/2     Running   0          93s
cluster-network-operator-77b896ddc-wpkq8              1/1     Running   0          94s
cluster-node-tuning-operator-84956cd484-4hfgf         1/1     Running   0          94s
cluster-policy-controller-5fd8595d97-rhbwf            1/1     Running   0          95s
cluster-storage-operator-54dcf584b5-xrnts             1/1     Running   0          93s
cluster-version-operator-9c554b999-l22s7              1/1     Running   0          95s
control-plane-operator-6fdc9c569-t7hr4                1/1     Running   0          3m57s
csi-snapshot-controller-785c6dc77c-8ljmr              1/1     Running   0          77s
csi-snapshot-controller-operator-7c6674bc5b-d9dtp     1/1     Running   0          93s
csi-snapshot-webhook-5b8584875f-2492j                 1/1     Running   0          77s
dns-operator-6874b577f-9tc6b                          1/1     Running   0          94s
etcd-0                                                3/3     Running   0          3m39s
hosted-cluster-config-operator-f5cf5c464-4nmbh        1/1     Running   0          93s
ignition-server-6b689748fc-zdqzk                      1/1     Running   0          95s
ignition-server-proxy-54d4bb9b9b-6zkg7                1/1     Running   0          95s
ingress-operator-6548dc758b-f9gtg                     1/2     Running   0          94s
konnectivity-agent-7767cdc6f5-tw782                   1/1     Running   0          95s
kube-apiserver-7b5799b6c8-9f5bp                       4/4     Running   0          3m7s
kube-controller-manager-5465bc4dd6-zpdlk              1/1     Running   0          44s
kube-scheduler-5dd5f78b94-bbbck                       1/1     Running   0          2m36s
machine-approver-846c69f56-jxvfr                      1/1     Running   0          92s
oauth-openshift-79c7bf44bf-j975g                      2/2     Running   0          62s
olm-operator-767f9584c-4lcl2                          2/2     Running   0          93s
openshift-apiserver-5d469778c6-pl8tj                  3/3     Running   0          2m36s
openshift-controller-manager-6475fdff58-hl4f7         1/1     Running   0          95s
openshift-oauth-apiserver-dbbc5cc5f-98574             2/2     Running   0          95s
openshift-route-controller-manager-5f6997b48f-s9vdc   1/1     Running   0          95s
packageserver-67c87d4d4f-kl7qh                        2/2     Running   0          93s

  8. 查看托管集群的输出： 

    NAMESPACE   NAME         VERSION   KUBECONFIG                PROGRESS   AVAILABLE   PROGRESSING   MESSAGE
clusters    hosted-ipv6            hosted-admin-kubeconfig   Partial    True          False         The hosted control plane is available

接下来，创建 NodePool 对象。

1.7.12.6.9.2. 为托管集群创建 NodePool 对象

NodePool 是与托管集群关联的一组可扩展的 worker 节点。NodePool 机器架构在特定池中保持一致，独立于 control plane 的机器架构。

  1. 使用有关 NodePool 对象的以下信息创建 YAML 文件，根据需要替换值： 

    apiVersion: hypershift.openshift.io/v1beta1
kind: NodePool
metadata:
  creationTimestamp: null
  name: hosted-ipv6
  namespace: clusters
spec:
  arch: amd64
  clusterName: hosted-ipv6
  management:
    autoRepair: false 1
    upgradeType: InPlace 2
  nodeDrainTimeout: 0s
  platform:
    type: Agent
  release:
    image: registry.dns.base.domain.name:5000/openshift/release-images:4.x.y-x86_64 3
  replicas: 0
status:
  replicas: 0 4
    1
    autoRepair 字段被设置为 false，因为如果删除了该节点，则不会重新创建该节点。
    2
    upgradeType 设置为 InPlace，这表示升级过程中会重复使用相同的裸机节点。
    3
    此 NodePool 中包含的所有节点都基于以下 OpenShift Container Platform 版本： 4.x.y-x86_64。将 dns.base.domain.name 替换为 DNS 基础域名，将 4.x.y 替换为您要使用的 OpenShift Container Platform 版本。
    4
    replicas 值设为 0， 以便在需要时可以扩展它们。务必要将 NodePool 副本保持为 0，直到所有步骤都完成为止。

  2. 运行以下命令来创建 NodePool 对象： 

    oc apply -f 02-nodepool.yaml

  3. 查看输出： 

    NAMESPACE   NAME          CLUSTER   DESIRED NODES   CURRENT NODES   AUTOSCALING   AUTOREPAIR   VERSION                              UPDATINGVERSION   UPDATINGCONFIG   MESSAGE
clusters    hosted-ipv6   hosted    0                               False         False        4.x.y-x86_64

接下来，创建一个 InfraEnv 资源。

1.7.12.6.9.3. 为托管集群创建 InfraEnv 资源

InfraEnv 资源是一个 Assisted Service 对象，其中包含基本详情，如 pullSecretRef 和 sshAuthorizedKey。这些详情用于创建为托管集群自定义的 Red Hat Enterprise Linux CoreOS (RHCOS)引导镜像。

  1. 使用以下有关 InfraEnv 资源的信息创建 YAML 文件，根据需要替换值： 

    ---
apiVersion: agent-install.openshift.io/v1beta1
kind: InfraEnv
metadata:
  name: hosted-ipv6
  namespace: clusters-hosted-ipv6
spec:
  pullSecretRef: 1
    name: pull-secret
  sshAuthorizedKey: ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQDk7ICaUE+/k4zTpxLk4+xFdHi4ZuDi5qjeF52afsNkw0w/glILHhwpL5gnp5WkRuL8GwJuZ1VqLC9EKrdmegn4MrmUlq7WTsP0VFOZFBfq2XRUxo1wrRdor2z0Bbh93ytR+ZsDbbLlGngXaMa0Vbt+z74FqlcajbHTZ6zBmTpBVq5RHtDPgKITdpE1fongp7+ZXQNBlkaavaqv8bnyrP4BWahLP4iO9/xJF9lQYboYwEEDzmnKLMW1VtCE6nJzEgWCufACTbxpNS7GvKtoHT/OVzw8ArEXhZXQUS1UY8zKsX2iXwmyhw5Sj6YboA8WICs4z+TrFP89LmxXY0j6536TQFyRz1iB4WWvCbH5n6W+ABV2e8ssJB1AmEy8QYNwpJQJNpSxzoKBjI73XxvPYYC/IjPFMySwZqrSZCkJYqQ023ySkaQxWZT7in4KeMu7eS2tC+Kn4deJ7KwwUycx8n6RHMeD8Qg9flTHCv3gmab8JKZJqN3hW1D378JuvmIX4V0= 2
    1
    pullSecretRef 引用与 InfraEnv 相同的命名空间中的配置映射引用，其中使用 pull secret。
    2
    sshAuthorizedKey 代表放在引导镜像中的 SSH 公钥。SSH 密钥允许以 core 用户身份访问 worker 节点。

  2. 运行以下命令来创建 InfraEnv 资源： 

    oc apply -f 03-infraenv.yaml

  3. 请参见以下输出： 

    NAMESPACE              NAME     ISO CREATED AT
clusters-hosted-ipv6   hosted   2023-09-11T15:14:10Z

接下来，创建 worker 节点。

1.7.12.6.9.4. 为托管集群创建 worker 节点

如果您在裸机平台上工作，创建 worker 节点对于确保正确配置了 BareMetalHost 的详情至关重要。

如果使用虚拟机，您可以完成以下步骤来创建 Metal3 Operator 消耗的空 worker 节点。为此，您可以使用 kcli 工具。

  1. 如果这不是您首次尝试创建 worker 节点，您必须首先删除之前的设置。要做到这一点，请输入以下命令删除计划： 

    kcli delete plan hosted-ipv6
    1. 当系统提示您确认是否要删除计划时，键入 y。
    2. 确认您看到一条消息，表示计划已被删除。

  2. 输入以下命令来创建虚拟机： 

    kcli create vm -P start=False -P uefi_legacy=true -P plan=hosted-ipv6 -P memory=8192 -P numcpus=16 -P disks=[200,200] -P nets=["{\"name\": \"ipv6\", \"mac\": \"aa:aa:aa:aa:02:11\"}"] -P uuid=aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaa0211 -P name=hosted-ipv6-worker0
    kcli create vm -P start=False -P uefi_legacy=true -P plan=hosted-ipv6 -P memory=8192 -P numcpus=16 -P disks=[200,200] -P nets=["{\"name\": \"ipv6\", \"mac\": \"aa:aa:aa:aa:02:12\"}"] -P uuid=aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaa0212 -P name=hosted-ipv6-worker1
    kcli create vm -P start=False -P uefi_legacy=true -P plan=hosted-ipv6 -P memory=8192 -P numcpus=16 -P disks=[200,200] -P nets=["{\"name\": \"ipv6\", \"mac\": \"aa:aa:aa:aa:02:13\"}"] -P uuid=aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaa0213 -P name=hosted-ipv6-worker2
    systemctl restart ksushy

    其中：

    • start=False 表示虚拟机(VM)不会在创建时自动启动。
    • uefi_legacy=true 表示您将使用 UEFI 传统引导来确保与之前的 UEFI 实现兼容。
    • plan=hosted-dual 表示计划名称，将一组机器标识为集群。
    • memory=8192 和 numcpus=16 是指定虚拟机资源的参数，包括 RAM 和 CPU。
    • disks=[200,200] 表示您要在虚拟机中创建两个精简置备磁盘。
    • nets=[{"name": "dual", "mac": "aa:aa:aa:02:13"}] 是网络详情，包括要连接到的网络详情以及主接口的 MAC 地址。
    • 重启 ksushy 重启 ksushy 工具，以确保工具检测到您添加的虚拟机。

  3. 查看生成的输出： 

    +---------------------+--------+-------------------+----------------------------------------------------+-------------+---------+
|         Name        | Status |         Ip        |                       Source                       |     Plan    | Profile |
+---------------------+--------+-------------------+----------------------------------------------------+-------------+---------+
|    hosted-worker0   |  down  |                   |                                                    | hosted-ipv6 |  kvirt  |
|    hosted-worker1   |  down  |                   |                                                    | hosted-ipv6 |  kvirt  |
|    hosted-worker2   |  down  |                   |                                                    | hosted-ipv6 |  kvirt  |
+---------------------+--------+-------------------+----------------------------------------------------+-------------+---------+

接下来，为托管集群创建裸机主机。

1.7.12.6.9.5. 为托管集群创建裸机主机

裸机主机 是一个 openshift-machine-api 对象，其中包含物理和虚拟详情，以便可以通过 Metal3 Operator 识别它。这些详细信息与其他辅助服务对象关联，称为 代理。

重要： 在创建裸机主机和目标节点前，您必须创建虚拟机。

要创建裸机主机，请完成以下步骤：

  1. 使用以下信息创建 YAML 文件：

    注： 因为至少有一个 secret 包含裸机主机凭证，所以您需要为每个 worker 节点至少创建两个对象。 

    ---
apiVersion: v1
kind: Secret
metadata:
  name: hosted-ipv6-worker0-bmc-secret
  namespace: clusters-hosted-ipv6
data:
  password: YWRtaW4=
  username: YWRtaW4=
type: Opaque
---
apiVersion: metal3.io/v1alpha1
kind: BareMetalHost
metadata:
  name: hosted-ipv6-worker0
  namespace: clusters-hosted-ipv6
  labels:
    infraenvs.agent-install.openshift.io: hosted-ipv6 1
  annotations:
    inspect.metal3.io: disabled
    bmac.agent-install.openshift.io/hostname: hosted-ipv6-worker0 2
spec:
  automatedCleaningMode: disabled 3
  bmc:
    disableCertificateVerification: true 4
    address: redfish-virtualmedia://[192.168.125.1]:9000/redfish/v1/Systems/local/hosted-ipv6-worker0 5
    credentialsName: hosted-ipv6-worker0-bmc-secret 6
  bootMACAddress: aa:aa:aa:aa:03:11 7
  online: true 8
    1
    infraenvs.agent-install.openshift.io 作为 Assisted Installer 和 BareMetalHost 对象之间的链接。
    2
    bmac.agent-install.openshift.io/hostname 代表部署期间采用的节点名称。
    3
    automatedCleaningMode 可防止节点被 Metal3 Operator 擦除。
    4
    disableCertificateVerification 设置为 true，以从客户端绕过证书验证。
    5
    address 表示 worker 节点的基板管理控制器(BMC)地址。
    6
    credentialsName 指向存储了用户和密码凭证的 secret。
    7
    bootMACAddress 表示节点从其启动的接口 MAC 地址。
    8
    Online 定义 BareMetalHost 对象创建后节点的状态。

  2. 输入以下命令部署 BareMetalHost 对象： 

    oc apply -f 04-bmh.yaml

    在此过程中，您可以查看以下输出：

    • 这个输出表示进程正在尝试访问节点： 

      NAMESPACE         NAME             STATE         CONSUMER   ONLINE   ERROR   AGE
clusters-hosted   hosted-worker0   registering              true             2s
clusters-hosted   hosted-worker1   registering              true             2s
clusters-hosted   hosted-worker2   registering              true             2s

    • 此输出显示节点已启动： 

      NAMESPACE         NAME             STATE          CONSUMER   ONLINE   ERROR   AGE
clusters-hosted   hosted-worker0   provisioning              true             16s
clusters-hosted   hosted-worker1   provisioning              true             16s
clusters-hosted   hosted-worker2   provisioning              true             16s
    • 此输出显示节点成功启动： 
    NAMESPACE         NAME             STATE         CONSUMER   ONLINE   ERROR   AGE
clusters-hosted   hosted-worker0   provisioned              true             67s
clusters-hosted   hosted-worker1   provisioned              true             67s
clusters-hosted   hosted-worker2   provisioned              true             67s

  3. 节点启动后，请注意命名空间中的代理，如下例所示： 

    NAMESPACE         NAME                                   CLUSTER   APPROVED   ROLE          STAGE
clusters-hosted   aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaa0411             true       auto-assign
clusters-hosted   aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaa0412             true       auto-assign
clusters-hosted   aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaa0413             true       auto-assign

    代理代表可用于安装的节点。要将节点分配到托管集群，请扩展节点池。

1.7.12.6.9.6. 扩展节点池

创建裸机主机后，其状态将从 Registering 变为 Provisioning 。节点以代理的 LiveISO 开头，以及名为 agent 的默认 pod。该代理负责从 Assisted Service Operator 接收安装 OpenShift Container Platform 有效负载的说明。

  1. 要扩展节点池，请输入以下命令： 

    oc -n clusters scale nodepool hosted-ipv6 --replicas 3

  2. 扩展过程完成后，请注意代理被分配给一个托管的集群： 

    NAMESPACE         NAME                                   CLUSTER   APPROVED   ROLE          STAGE
clusters-hosted   aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaa0211   hosted    true       auto-assign
clusters-hosted   aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaa0212   hosted    true       auto-assign
clusters-hosted   aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaa0213   hosted    true       auto-assign

  3. 另请注意设置了节点池副本： 

    NAMESPACE   NAME     CLUSTER   DESIRED NODES   CURRENT NODES   AUTOSCALING   AUTOREPAIR   VERSION             UPDATINGVERSION   UPDATINGCONFIG   MESSAGE
clusters    hosted   hosted    3                               False         False        4.x.y-x86_64                                           Minimum availability requires 3 replicas, current 0 available
  4. 等待节点加入集群。在此过程中，代理在其阶段和状态上提供更新。

接下来，监控托管集群的部署。

1.7.12.6.10. 为 IPv6 网络完成托管集群部署

您可以从两个视角监控托管集群的部署：control plane 和 data plane。

1.7.12.6.10.1. 监控 control plane

在托管集群部署时，您可以输入以下命令来监控 control plane： 

export KUBECONFIG=/root/.kcli/clusters/hub-ipv4/auth/kubeconfig
watch "oc get pod -n hypershift;echo;echo;oc get pod -n clusters-hosted-ipv4;echo;echo;oc get bmh -A;echo;echo;oc get agent -A;echo;echo;oc get infraenv -A;echo;echo;oc get hostedcluster -A;echo;echo;oc get nodepool -A;echo;echo;"

这些命令提供有关以下工件的信息：

  • HyperShift Operator
  • HostedControlPlane pod
  • 裸机主机
  • 代理
  • InfraEnv 资源
  • HostedCluster 和 NodePool 资源
1.7.12.6.10.2. 监控数据平面

要监控 Operator 在部署过程中如何进行，请输入以下命令： 

oc get secret -n clusters-hosted-ipv4 admin-kubeconfig -o jsonpath='{.data.kubeconfig}' |base64 -d > /root/hc_admin_kubeconfig.yaml
export KUBECONFIG=/root/hc_admin_kubeconfig.yaml
watch "oc get clusterversion,nodes,co"

这些命令提供有关以下工件的信息：

  • 集群版本
  • 节点，特别是有关节点是否加入集群
  • 集群 Operator

1.7.12.7. 在双栈网络上配置托管的 control plane （技术预览）

在托管的 control plane 中，断开连接的环境是一个没有连接到互联网的 OpenShift Container Platform 集群，它使用托管的 control plane 作为基础。您可以在断开连接的环境中的双栈网络上配置托管的 control plane，因为远程 registry 无法使用 IPv6。

查看以下步骤在双栈网络中配置托管的 control plane：

  1. 为双栈网络配置 hypervisor
  2. 为双栈网络配置 DNS
  3. 为双栈网络部署 registry
  4. 为双栈网络设置管理集群
  5. 为双栈网络配置 Web 服务器
  6. 为双栈网络配置镜像镜像
  7. 为双栈网络部署多集群引擎 operator
  8. 为双栈网络配置 TLS 证书
  9. 为双栈网络部署托管集群
  10. 完成双栈网络的部署
1.7.12.7.1. 为双栈网络配置 hypervisor

以下信息仅适用于虚拟机环境。

1.7.12.7.1.1. 访问和部署虚拟 OpenShift Container Platform 集群的软件包

  1. 要部署虚拟 OpenShift Container Platform 管理集群，请输入以下命令来访问所需的软件包： 

    sudo dnf install dnsmasq radvd vim golang podman bind-utils net-tools httpd-tools tree htop strace tmux -y

  2. 输入以下命令启用并启动 Podman 服务： 

    systemctl enable --now podman

  3. 要使用 kcli 部署 OpenShift Container Platform 管理集群和其他虚拟组件，请输入以下命令安装和配置 hypervisor： 

    sudo yum -y install libvirt libvirt-daemon-driver-qemu qemu-kvm
    sudo usermod -aG qemu,libvirt $(id -un)
    sudo newgrp libvirt
    sudo systemctl enable --now libvirtd
    sudo dnf -y copr enable karmab/kcli
    sudo dnf -y install kcli
    sudo kcli create pool -p /var/lib/libvirt/images default
    kcli create host kvm -H 127.0.0.1 local
    sudo setfacl -m u:$(id -un):rwx /var/lib/libvirt/images
    kcli create network  -c 192.168.122.0/24 default
1.7.12.7.1.2. 启用网络管理器分配程序

  1. 启用网络管理器分配程序，以确保虚拟机可以解析所需的域、路由和 registry。要启用网络管理器分配程序，在 /etc/NetworkManager/dispatcher.d/ 目录中，创建一个名为 forcedns 的脚本，其中包含以下内容，根据需要替换与您的环境匹配的值： 

    #!/bin/bash

export IP="192.168.126.1" 1
export BASE_RESOLV_CONF="/run/NetworkManager/resolv.conf"

if ! [[ `grep -q "$IP" /etc/resolv.conf` ]]; then
export TMP_FILE=$(mktemp /etc/forcedns_resolv.conf.XXXXXX)
cp $BASE_RESOLV_CONF $TMP_FILE
chmod --reference=$BASE_RESOLV_CONF $TMP_FILE
sed -i -e "s/dns.base.domain.name//" -e "s/search /& dns.base.domain.name /" -e "0,/nameserver/s/nameserver/& $IP\n&/" $TMP_FILE 2
mv $TMP_FILE /etc/resolv.conf
fi
echo "ok"
    1
    修改 IP 变量，以指向托管 OpenShift Container Platform 管理集群的虚拟机监控程序接口的 IP 地址。
    2
    将 dns.base.domain.name 替换为 DNS 基域名称。

  2. 创建该文件后，输入以下命令添加权限： 

    chmod 755 /etc/NetworkManager/dispatcher.d/forcedns
  3. 运行脚本，并验证输出是否返回 ok。
1.7.12.7.1.3. 配置 BMC 访问

  1. 配置 ksushy 以模拟虚拟机的基板管理控制器(BMC)。输入以下命令： 

    sudo dnf install python3-pyOpenSSL.noarch python3-cherrypy -y
    kcli create sushy-service --ssl --ipv6 --port 9000
    sudo systemctl daemon-reload
    systemctl enable --now ksushy

  2. 输入以下命令测试该服务是否正常工作： 

    systemctl status ksushy
1.7.12.7.1.4. 配置 hypervisor 系统以允许连接

如果您在开发环境中工作，请将 hypervisor 系统配置为允许通过环境中不同虚拟网络进行各种连接。

注： 如果您在生产环境中工作，您必须为 firewalld 服务建立正确的规则，并配置 SELinux 策略以维护安全环境。

  • 对于 SELinux，输入以下命令： 

    sed -i s/^SELINUX=.*$/SELINUX=permissive/ /etc/selinux/config; setenforce 0

  • 对于 firewalld，输入以下命令： 

    systemctl disable --now firewalld

  • 对于 libvirtd，输入以下命令： 

    systemctl restart libvirtd
    systemctl enable --now libvirtd

接下来，为您的环境配置 DNS。

1.7.12.7.1.5. 其他资源
1.7.12.7.2. 为双栈网络配置 DNS

对于虚拟和裸机环境中的断开连接和连接的环境，配置 DNS 是强制的。虚拟和裸机环境之间的主要区别在于配置资源的位置。在非虚拟环境中，使用 Bind 等解决方案，而不是 dnsmasq 等轻量级解决方案。

接下来，部署 registry。

1.7.12.7.3. 为双栈网络部署 registry

对于开发环境，使用 Podman 容器部署小型自托管注册表。对于生产环境，部署企业级托管的 registry，如 Red Hat Quay、Nexus 或 Artifactory。

要使用 Podman 部署小 registry，请完成以下步骤：

  1. 以特权用户身份，访问 ${HOME} 目录并创建以下脚本： 

    #!/usr/bin/env bash

set -euo pipefail

PRIMARY_NIC=$(ls -1 /sys/class/net | grep -v podman | head -1)
export PATH=/root/bin:$PATH
export PULL_SECRET="/root/baremetal/hub/openshift_pull.json" 1

if [[ ! -f $PULL_SECRET ]];then
  echo "Pull Secret not found, exiting..."
  exit 1
fi

dnf -y install podman httpd httpd-tools jq skopeo libseccomp-devel
export IP=$(ip -o addr show $PRIMARY_NIC | head -1 | awk '{print $4}' | cut -d'/' -f1)
REGISTRY_NAME=registry.$(hostname --long)
REGISTRY_USER=dummy
REGISTRY_PASSWORD=dummy
KEY=$(echo -n $REGISTRY_USER:$REGISTRY_PASSWORD | base64)
echo "{\"auths\": {\"$REGISTRY_NAME:5000\": {\"auth\": \"$KEY\", \"email\": \"sample-email@domain.ltd\"}}}" > /root/disconnected_pull.json
mv ${PULL_SECRET} /root/openshift_pull.json.old
jq ".auths += {\"$REGISTRY_NAME:5000\": {\"auth\": \"$KEY\",\"email\": \"sample-email@domain.ltd\"}}" < /root/openshift_pull.json.old > $PULL_SECRET
mkdir -p /opt/registry/{auth,certs,data,conf}
cat <<EOF > /opt/registry/conf/config.yml
version: 0.1
log:
  fields:
    service: registry
storage:
  cache:
    blobdescriptor: inmemory
  filesystem:
    rootdirectory: /var/lib/registry
  delete:
    enabled: true
http:
  addr: :5000
  headers:
    X-Content-Type-Options: [nosniff]
health:
  storagedriver:
    enabled: true
    interval: 10s
    threshold: 3
compatibility:
  schema1:
    enabled: true
EOF
openssl req -newkey rsa:4096 -nodes -sha256 -keyout /opt/registry/certs/domain.key -x509 -days 3650 -out /opt/registry/certs/domain.crt -subj "/C=US/ST=Madrid/L=San Bernardo/O=Karmalabs/OU=Guitar/CN=$REGISTRY_NAME" -addext "subjectAltName=DNS:$REGISTRY_NAME"
cp /opt/registry/certs/domain.crt /etc/pki/ca-trust/source/anchors/
update-ca-trust extract
htpasswd -bBc /opt/registry/auth/htpasswd $REGISTRY_USER $REGISTRY_PASSWORD
podman create --name registry --net host --security-opt label=disable --replace -v /opt/registry/data:/var/lib/registry:z -v /opt/registry/auth:/auth:z -v /opt/registry/conf/config.yml:/etc/docker/registry/config.yml -e "REGISTRY_AUTH=htpasswd" -e "REGISTRY_AUTH_HTPASSWD_REALM=Registry" -e "REGISTRY_HTTP_SECRET=ALongRandomSecretForRegistry" -e REGISTRY_AUTH_HTPASSWD_PATH=/auth/htpasswd -v /opt/registry/certs:/certs:z -e REGISTRY_HTTP_TLS_CERTIFICATE=/certs/domain.crt -e REGISTRY_HTTP_TLS_KEY=/certs/domain.key docker.io/library/registry:latest
[ "$?" == "0" ] || !!
systemctl enable --now registry
    1
    将 PULL_SECRET 的位置替换为您的设置的适当位置。

  2. 命名脚本文件 registry.sh 并保存它。运行脚本时，它会拉取以下信息：

    • registry 名称，基于虚拟机监控程序主机名
    • 所需的凭证和用户访问详情

  3. 通过添加执行标记来调整权限，如下所示： 

    chmod u+x ${HOME}/registry.sh

  4. 要在没有任何参数的情况下运行脚本，请输入以下命令： 

    ${HOME}/registry.sh

    该脚本启动服务器。

  5. 该脚本使用 systemd 服务来管理目的。如果需要管理脚本，您可以使用以下命令： 

    systemctl status
    systemctl start
    systemctl stop

registry 的根文件夹位于 /opt/registry 目录中，包含以下子目录：

  • certs 包含 TLS 证书。
  • auth 包含凭据。
  • 数据 包含 registry 镜像。
  • conf 包含 registry 配置。
1.7.12.7.4. 为双栈网络设置管理集群

要设置 OpenShift Container Platform 管理集群，您可以使用 dev-scripts，或者基于虚拟机，您可以使用 kcli 工具。以下说明特定于 kcli 工具。

  1. 确保正确的网络已准备好在 hypervisor 中使用。网络将托管管理和托管集群。输入以下 kcli 命令： 

    kcli create network -c 192.168.126.0/24 -P dhcp=false -P dns=false -d 2620:52:0:1306::0/64 --domain dns.base.domain.name --nodhcp dual

    其中：

    • -c 指定网络的 CIDR。
    • -p dhcp=false 将网络配置为禁用 DHCP，该 DHCP 由您配置的 dnsmasq 处理。
    • -p dns=false 将网络配置为禁用 DNS，这也由您配置的 dnsmasq 处理。
    • --domain 设置要搜索的域。
    • dns.base.domain.name 是 DNS 基础域名。
    • dual 是您要创建的网络的名称。

  2. 创建网络后，查看以下输出： 

    [root@hypershiftbm ~]# kcli list network
Listing Networks...
+---------+--------+---------------------+-------+------------------+------+
| Network |  Type  |         Cidr        |  Dhcp |      Domain      | Mode |
+---------+--------+---------------------+-------+------------------+------+
| default | routed |   192.168.122.0/24  |  True |     default      | nat  |
| ipv4    | routed | 2620:52:0:1306::/64 | False | dns.base.domain.name | nat  |
| ipv4    | routed |   192.168.125.0/24  | False | dns.base.domain.name | nat  |
| ipv6    | routed | 2620:52:0:1305::/64 | False | dns.base.domain.name | nat  |
+---------+--------+---------------------+-------+------------------+------+
    [root@hypershiftbm ~]# kcli info network ipv6
Providing information about network ipv6...
cidr: 2620:52:0:1306::/64
dhcp: false
domain: dns.base.domain.name
mode: nat
plan: kvirt
type: routed

  3. 确保 pull secret 和 kcli 计划文件已就位，以便您可以部署 OpenShift Container Platform 管理集群：

    1. 确认 pull secret 与 kcli 计划位于同一个文件夹中，并且 pull secret 文件名为 openshift_pull.json。

    2. 在 mgmt-compact-hub-dual.yaml 文件中添加 kcli 计划，其中包含 OpenShift Container Platform 定义。确保更新文件内容以匹配您的环境： 

      plan: hub-dual
force: true
version: stable
tag: "4.x.y-x86_64" 1
cluster: "hub-dual"
dualstack: true
domain: dns.base.domain.name
api_ip: 192.168.126.10
ingress_ip: 192.168.126.11
service_networks:
- 172.30.0.0/16
- fd02::/112
cluster_networks:
- 10.132.0.0/14
- fd01::/48
disconnected_url: registry.dns.base.domain.name:5000
disconnected_update: true
disconnected_user: dummy
disconnected_password: dummy
disconnected_operators_version: v4.14
disconnected_operators:
- name: metallb-operator
- name: lvms-operator
  channels:
  - name: stable-4.13
disconnected_extra_images:
- quay.io/user-name/trbsht:latest
- quay.io/user-name/hypershift:BMSelfManage-v4.14-rc-v3
- registry.redhat.io/openshift4/ose-kube-rbac-proxy:v4.10
dualstack: true
disk_size: 200
extra_disks: [200]
memory: 48000
numcpus: 16
ctlplanes: 3
workers: 0
manifests: extra-manifests
metal3: true
network: dual
users_dev: developer
users_devpassword: developer
users_admin: admin
users_adminpassword: admin
metallb_pool: dual-virtual-network
metallb_ranges:
- 192.168.126.150-192.168.126.190
metallb_autoassign: true
apps:
- users
- lvms-operator
- metallb-operator
vmrules:
- hub-bootstrap:
    nets:
    - name: ipv6
      mac: aa:aa:aa:aa:10:07
- hub-ctlplane-0:
    nets:
    - name: ipv6
      mac: aa:aa:aa:aa:10:01
- hub-ctlplane-1:
    nets:
    - name: ipv6
      mac: aa:aa:aa:aa:10:02
- hub-ctlplane-2:
    nets:
    - name: ipv6
      mac: aa:aa:aa:aa:10:03
    1
    将 4.x.y 替换为您要使用的 OpenShift Container Platform 版本。

  4. 要置备管理集群，请输入以下命令： 

    kcli create cluster openshift --pf mgmt-compact-hub-dual.yaml

接下来，配置 Web 服务器。

1.7.12.7.4.1. 其他资源
1.7.12.7.5. 为双栈网络配置 Web 服务器

您需要配置一个额外的 Web 服务器来托管与您要部署为托管集群的 OpenShift Container Platform 发行版本关联的 Red Hat Enterprise Linux CoreOS (RHCOS)镜像。

要配置 web 服务器，请完成以下步骤：

  1. 输入以下命令从您要使用的 OpenShift Container Platform 发行版本中提取 openshift-install 二进制文件： 

    oc adm -a ${LOCAL_SECRET_JSON} release extract --command=openshift-install "${LOCAL_REGISTRY}/${LOCAL_REPOSITORY}:${OCP_RELEASE}-${ARCHITECTURE}"

  2. 运行以下脚本：该脚本在 /opt/srv 目录中创建文件夹。文件夹包含用于置备 worker 节点的 RHCOS 镜像。 

    #!/bin/bash

WEBSRV_FOLDER=/opt/srv
ROOTFS_IMG_URL="$(./openshift-install coreos print-stream-json | jq -r '.architectures.x86_64.artifacts.metal.formats.pxe.rootfs.location')" 1
LIVE_ISO_URL="$(./openshift-install coreos print-stream-json | jq -r '.architectures.x86_64.artifacts.metal.formats.iso.disk.location')" 2

mkdir -p ${WEBSRV_FOLDER}/images
curl -Lk ${ROOTFS_IMG_URL} -o ${WEBSRV_FOLDER}/images/${ROOTFS_IMG_URL##*/}
curl -Lk ${LIVE_ISO_URL} -o ${WEBSRV_FOLDER}/images/${LIVE_ISO_URL##*/}
chmod -R 755 ${WEBSRV_FOLDER}/*

## Run Webserver
podman ps --noheading | grep -q websrv-ai
if [[ $? == 0 ]];then
    echo "Launching Registry pod..."
    /usr/bin/podman run --name websrv-ai --net host -v /opt/srv:/usr/local/apache2/htdocs:z quay.io/alosadag/httpd:p8080
fi
    1
    您可以在 OpenShift CI Release 页面上找到 ROOTFS_IMG_URL 值。
    2
    您可以在 OpenShift CI Release 页面上找到 LIVE_ISO_URL 值。

下载完成后，容器将运行，以托管 Web 服务器上的镜像。容器使用官方 HTTPd 镜像的一种变体，这使得它能够使用 IPv6 网络。

1.7.12.7.6. 为双栈网络配置镜像镜像

镜像镜像是从外部 registry 获取镜像的过程，如 registry.redhat.com 或 quay.io，并将它们存储在私有 registry 中。

1.7.12.7.6.1. 完成镜像过程

注： 在 registry 服务器运行后启动镜像过程。

在以下步骤中，使用 oc-mirror 工具，它是一个使用 ImageSetConfiguration 对象的二进制文件。在文件中，您可以指定以下信息：

  • 要镜像的 OpenShift Container Platform 版本。版本位于 quay.io 中。
  • 要镜像的额外 Operator。单独选择软件包。
  • 要添加到存储库的额外镜像。

要配置镜像镜像，请完成以下步骤：

  1. 确保 ${HOME}/.docker/config.json 文件已更新为您要从中镜像 registry 以及您要将镜像推送到的私有 registry。

  2. 通过使用以下示例，创建一个 ImageSetConfiguration 对象以用于镜像。根据需要替换与您的环境匹配的值： 

    apiVersion: mirror.openshift.io/v1alpha2
kind: ImageSetConfiguration
storageConfig:
  registry:
    imageURL: registry.dns.base.domain.name:5000/openshift/release/metadata:latest
mirror:
  platform:
    channels:
    - name: candidate-4.14
      minVersion: 4.x.y-x86_64  1
      maxVersion: 4.x.y-x86_64
      type: ocp
    graph: true
  additionalImages:
  - name: quay.io/karmab/origin-keepalived-ipfailover:latest
  - name: quay.io/karmab/kubectl:latest
  - name: quay.io/karmab/haproxy:latest
  - name: quay.io/karmab/mdns-publisher:latest
  - name: quay.io/karmab/origin-coredns:latest
  - name: quay.io/karmab/curl:latest
  - name: quay.io/karmab/kcli:latest
  - name: quay.io/user-name/trbsht:latest
  - name: quay.io/user-name/hypershift:BMSelfManage-v4.14-rc-v3
  - name: registry.redhat.io/openshift4/ose-kube-rbac-proxy:v4.10
  operators:
  - catalog: registry.redhat.io/redhat/redhat-operator-index:v4.14
    packages:
    - name: lvms-operator
    - name: local-storage-operator
    - name: odf-csi-addons-operator
    - name: odf-operator
    - name: mcg-operator
    - name: ocs-operator
    - name: metallb-operator
    1
    将 4.x.y 替换为您要使用的 OpenShift Container Platform 版本。

  3. 输入以下命令启动镜像过程： 

    oc-mirror --source-skip-tls --config imagesetconfig.yaml docker://${REGISTRY}

    镜像过程完成后，您有一个名为 oc-mirror-workspace/results-XXXXXX/ 的新文件夹，其中包含 ICSP 和要应用到托管的集群的目录源。

  4. 使用 oc adm release mirror 命令镜像 OpenShift Container Platform 的 nightly 或 CI 版本。输入以下命令： 

    REGISTRY=registry.$(hostname --long):5000

oc adm release mirror \
  --from=registry.ci.openshift.org/ocp/release:4.x.y-x86_64 \
  --to=${REGISTRY}/openshift/release \
  --to-release-image=${REGISTRY}/openshift/release-images:registry.dns.base.domain.name:5000/openshift/release-images:4.x.y-x86_64

    将 4.x.y 替换为您要使用的 OpenShift Container Platform 版本。

  5. 按照在 断开连接的网络 上安装 中的步骤镜像最新的多集群引擎 operator 镜像。
1.7.12.7.6.2. 在管理集群中应用对象

镜像过程完成后，您需要在管理集群中应用两个对象：

  • 镜像内容源策略(ICSP)或镜像 Digest 镜像集(IDMS)
  • 目录源

当使用 oc-mirror 工具时，输出工件位于名为 oc-mirror-workspace/results-XXXXXX/ 的目录中。

ICSP 或 IDMS 会启动一个 MachineConfig 更改，它不会重启节点，而是在每个节点上重启 kubelet。节点标记为 READY 后，您需要应用新生成的目录源。

目录源在 openshift-marketplace Operator 中启动操作，如下载目录镜像并处理它来检索该镜像中包含的所有 PackageManifests。

  1. 要检查新源，请使用新的 CatalogSource 作为源运行以下命令： 

    oc get packagemanifest

  2. 要应用工件，请完成以下步骤：

    1. 输入以下命令来创建 ICSP 或 IDMS 工件： 

      oc apply -f oc-mirror-workspace/results-XXXXXX/imageContentSourcePolicy.yaml
    2. 等待节点就绪，然后输入以下命令： 
    oc apply -f catalogSource-XXXXXXXX-index.yaml

接下来，部署多集群引擎 operator。

1.7.12.7.6.3. 其他资源
1.7.12.7.7. 为双栈网络部署多集群引擎 operator

multicluster engine operator 在供应商间部署集群时扮演了关键角色。如果已安装 Red Hat Advanced Cluster Management，则不需要安装 multicluster engine operator，因为它会被自动安装。

如果您没有安装 multicluster engine operator，请参阅以下文档以了解安装它的先决条件和步骤：

1.7.12.7.7.1. 部署 AgentServiceConfig 资源

AgentServiceConfig 自定义资源是 Assisted Service add-on 的基本组件，它是 multicluster engine operator 的一部分。它负责裸机集群部署。启用附加组件后，您要部署 AgentServiceConfig 资源来配置附加组件。

除了配置 AgentServiceConfig 资源外，还需要包含额外的配置映射，以确保多集群引擎 Operator 在断开连接的环境中正常工作。

  1. 通过添加以下配置映射来配置自定义 registry，其中包含用于自定义部署的断开连接的详情： 

    ---
apiVersion: v1
kind: ConfigMap
metadata:
  name: custom-registries
  namespace: multicluster-engine
  labels:
    app: assisted-service
data:
  ca-bundle.crt: |
    -----BEGIN CERTIFICATE-----
    -----END CERTIFICATE-----
  registries.conf: |
    unqualified-search-registries = ["registry.access.redhat.com", "docker.io"]

    [[registry]]
    prefix = ""
    location = "registry.redhat.io/openshift4"
    mirror-by-digest-only = true

    [[registry.mirror]]
      location = "registry.dns.base.domain.name:5000/openshift4" 1

    [[registry]]
    prefix = ""
    location = "registry.redhat.io/rhacm2"
    mirror-by-digest-only = true
    ...
    ...
    1
    将 dns.base.domain.name 替换为 DNS 基域名称。

    对象包含两个字段：

    • 自定义 CA：此字段包含加载到部署各种进程的证书颁发机构(CA)。
    • Registry: Registries.conf 字段包含有关需要从镜像 registry 而不是原始源 registry 中消耗的镜像和命名空间的信息。

  2. 通过添加 AssistedServiceConfig 对象来配置 Assisted Service，如下例所示： 

    ---
apiVersion: agent-install.openshift.io/v1beta1
kind: AgentServiceConfig
metadata:
  annotations:
    unsupported.agent-install.openshift.io/assisted-service-configmap: assisted-service-config 1
  name: agent
  namespace: multicluster-engine
spec:
  mirrorRegistryRef:
    name: custom-registries 2
  databaseStorage:
    storageClassName: lvms-vg1
    accessModes:
    - ReadWriteOnce
    resources:
      requests:
        storage: 10Gi
  filesystemStorage:
    storageClassName: lvms-vg1
    accessModes:
    - ReadWriteOnce
    resources:
      requests:
        storage: 20Gi
  osImages: 3
  - cpuArchitecture: x86_64
    openshiftVersion: "4.14"
    rootFSUrl: http://registry.dns.base.domain.name:8080/images/rhcos-414.92.202308281054-0-live-rootfs.x86_64.img 4
    url: http://registry.dns.base.domain.name:8080/images/rhcos-414.92.202308281054-0-live.x86_64.iso
    version: 414.92.202308281054-0
    1
    metadata.annotations["unsupported.agent-install.openshift.io/assisted-service-configmap"] 注解引用 Operator 用来自定义行为的配置映射名称。
    2
    spec.mirrorRegistryRef.name 注解指向包含 Assisted Service Operator 使用断开连接的 registry 信息的配置映射。此配置映射在部署过程中添加这些资源。
    3
    spec.osImages 字段包含可供此 Operator 部署的不同版本。这个字段是必须的。本例假定您已下载了 RootFS 和 LiveISO 文件。
    4
    在 rootFSUrl 和 url 字段中，将 dns.base.domain.name 替换为 DNS 基域名称。

  3. 通过将所有对象串联到一个文件中，并将它们应用到管理集群，以此部署所有对象。要做到这一点，请输入以下命令： 

    oc apply -f agentServiceConfig.yaml

    该命令会触发两个 pod，如本示例输出所示： 

    assisted-image-service-0                               1/1     Running   2             11d 1
assisted-service-668b49548-9m7xw                       2/2     Running   5             11d 2
    1
    assisted-image-service pod 负责创建 Red Hat Enterprise Linux CoreOS (RHCOS)引导镜像模板，该模板针对您部署的每个集群自定义。
    2
    assisted-service 指的是 Operator。
1.7.12.7.8. 为双栈网络配置 TLS 证书

涉及几个 TLS 证书，以便在断开连接的环境中配置托管的 control plane。要将证书颁发机构(CA)添加到管理集群中，您需要修改 OpenShift Container Platform control plane 和 worker 节点上的以下文件的内容：

  • /etc/pki/ca-trust/extracted/pem/
  • /etc/pki/ca-trust/source/anchors
  • /etc/pki/tls/certs/

要在管理集群中添加 CA，请完成以下步骤：

  1. 完成官方 OpenShift Container Platform 文档中的 更新 CA 捆绑包 中的步骤。该方法涉及使用 image-registry-operator，它将 CA 部署到 OpenShift Container Platform 节点。

  2. 如果该方法不适用于您的情况，请检查管理集群中的 openshift-config 命名空间是否包含名为 user-ca-bundle 的配置映射。

    • 如果命名空间包含该配置映射，请输入以下命令： 

      ## REGISTRY_CERT_PATH=<PATH/TO/YOUR/CERTIFICATE/FILE>
export REGISTRY_CERT_PATH=/opt/registry/certs/domain.crt

oc create configmap user-ca-bundle -n openshift-config --from-file=ca-bundle.crt=${REGISTRY_CERT_PATH}

    • 如果命名空间不包含该配置映射，请输入以下命令： 

      ## REGISTRY_CERT_PATH=<PATH/TO/YOUR/CERTIFICATE/FILE>
export REGISTRY_CERT_PATH=/opt/registry/certs/domain.crt
export TMP_FILE=$(mktemp)

oc get cm -n openshift-config user-ca-bundle -ojsonpath='{.data.ca-bundle\.crt}' > ${TMP_FILE}
echo >> ${TMP_FILE}
echo \#registry.$(hostname --long) >> ${TMP_FILE}
cat ${REGISTRY_CERT_PATH} >> ${TMP_FILE}
oc create configmap user-ca-bundle -n openshift-config --from-file=ca-bundle.crt=${TMP_FILE} --dry-run=client -o yaml | kubectl apply -f -
1.7.12.7.9. 为双栈网络部署托管集群

托管的集群是一个 OpenShift Container Platform 集群，它带有托管在管理集群上的 control plane 和 API 端点。托管的集群包括控制平面和它的对应的数据平面。

虽然您可以使用 Red Hat Advanced Cluster Management 中的控制台创建托管集群，但以下步骤使用清单，这提供了修改相关工件的灵活性。

1.7.12.7.9.1. 部署托管集群对象

对于此过程，使用以下值：

  • HostedCluster 名称： hosted-dual
  • HostedCluster 命名空间： 集群
  • disconnected: true
  • 网络堆栈： Dual

通常，HyperShift Operator 会创建 HostedControlPlane 命名空间。但是，在这种情况下，您想要在 HyperShift Operator 开始协调 HostedCluster 对象前包含所有对象。然后，当 Operator 启动协调过程时，它可以找到所有对象。

  1. 使用有关命名空间的以下信息创建 YAML 文件： 

    ---
apiVersion: v1
kind: Namespace
metadata:
  creationTimestamp: null
  name: clusters-hosted-dual
spec: {}
status: {}
---
apiVersion: v1
kind: Namespace
metadata:
  creationTimestamp: null
  name: clusters
spec: {}
status: {}

  2. 创建一个 YAML 文件，其中包含有关配置映射和 secret 的信息，以便在 HostedCluster 部署中包括： 

    ---
apiVersion: v1
data:
  ca-bundle.crt: |
    -----BEGIN CERTIFICATE-----
    -----END CERTIFICATE-----
kind: ConfigMap
metadata:
  name: user-ca-bundle
  namespace: clusters
---
apiVersion: v1
data:
  .dockerconfigjson: xxxxxxxxx
kind: Secret
metadata:
  creationTimestamp: null
  name: hosted-dual-pull-secret
  namespace: clusters
---
apiVersion: v1
kind: Secret
metadata:
  name: sshkey-cluster-hosted-dual
  namespace: clusters
stringData:
  id_rsa.pub: ssh-rsa xxxxxxxxx
---
apiVersion: v1
data:
  key: nTPtVBEt03owkrKhIdmSW8jrWRxU57KO/fnZa8oaG0Y=
kind: Secret
metadata:
  creationTimestamp: null
  name: hosted-dual-etcd-encryption-key
  namespace: clusters
type: Opaque

  3. 创建一个包含 RBAC 角色的 YAML 文件，以便辅助服务代理可以与托管 control plane 位于同一个 HostedControlPlane 命名空间中，仍由集群 API 管理： 

    apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  creationTimestamp: null
  name: capi-provider-role
  namespace: clusters-hosted-dual
rules:
- apiGroups:
  - agent-install.openshift.io
  resources:
  - agents
  verbs:
  - '*'

  4. 使用 HostedCluster 对象的信息创建 YAML 文件，根据需要替换值： 

    apiVersion: hypershift.openshift.io/v1beta1
kind: HostedCluster
metadata:
  name: hosted-dual
  namespace: clusters
spec:
  additionalTrustBundle:
    name: "user-ca-bundle"
  olmCatalogPlacement: guest
  imageContentSources: 1
  - source: quay.io/openshift-release-dev/ocp-v4.0-art-dev
    mirrors:
    - registry.dns.base.domain.name:5000/openshift/release 2
  - source: quay.io/openshift-release-dev/ocp-release
    mirrors:
    - registry.dns.base.domain.name:5000/openshift/release-images
  - mirrors:
  ...
  ...
  autoscaling: {}
  controllerAvailabilityPolicy: SingleReplica
  dns:
    baseDomain: dns.base.domain.name
  etcd:
    managed:
      storage:
        persistentVolume:
          size: 8Gi
        restoreSnapshotURL: null
        type: PersistentVolume
    managementType: Managed
  fips: false
  networking:
    clusterNetwork:
    - cidr: 10.132.0.0/14
    - cidr: fd01::/48
    networkType: OVNKubernetes
    serviceNetwork:
    - cidr: 172.31.0.0/16
    - cidr: fd02::/112
  platform:
    agent:
      agentNamespace: clusters-hosted-dual
    type: Agent
  pullSecret:
    name: hosted-dual-pull-secret
  release:
    image: registry.dns.base.domain.name:5000/openshift/release-images:4.x.y-x86_64 3
  secretEncryption:
    aescbc:
      activeKey:
        name: hosted-dual-etcd-encryption-key
    type: aescbc
  services:
  - service: APIServer
    servicePublishingStrategy:
      nodePort:
        address: api.hosted-dual.dns.base.domain.name
      type: NodePort
  - service: OAuthServer
    servicePublishingStrategy:
      nodePort:
        address: api.hosted-dual.dns.base.domain.name
      type: NodePort
  - service: OIDC
    servicePublishingStrategy:
      nodePort:
        address: api.hosted-dual.dns.base.domain.name
      type: NodePort
  - service: Konnectivity
    servicePublishingStrategy:
      nodePort:
        address: api.hosted-dual.dns.base.domain.name
      type: NodePort
  - service: Ignition
    servicePublishingStrategy:
      nodePort:
        address: api.hosted-dual.dns.base.domain.name
      type: NodePort
  sshKey:
    name: sshkey-cluster-hosted-dual
status:
  controlPlaneEndpoint:
    host: ""
    port: 0
    1
    imageContentSources 部分包含托管集群中用户工作负载的镜像引用。
    2
    在 YAML 文件中，将 dns.base.domain.name 替换为 DNS 基域名称。
    3
    将 4.x.y 替换为您要使用的 OpenShift Container Platform 版本。

  5. 在 HostedCluster 对象中添加指向 OpenShift Container Platform 发行版本中 HyperShift Operator 发行版本的注解：

    1. 输入以下命令来获取镜像有效负载： 

      oc adm release info registry.dns.base.domain.name:5000/openshift-release-dev/ocp-release:4.x.y-x86_64 | grep hypershift

      其中 dns.base.domain.name 是 DNS 基础域名，而 4.x.y 是您要使用的 OpenShift Container Platform 版本。

    2. 请参见以下输出： 

      hypershift                                     sha256:31149e3e5f8c5e5b5b100ff2d89975cf5f7a73801b2c06c639bf6648766117f8

    3. 使用 OpenShift Container Platform Images 命名空间，输入以下命令检查摘要： 

      podman pull registry.dns.base.domain.name:5000/openshift-release-dev/ocp-v4.0-art-dev@sha256:31149e3e5f8c5e5b5b100ff2d89975cf5f7a73801b2c06c639bf6648766117f8

      其中 dns.base.domain.name 是 DNS 基础域名。

    4. 请参见以下输出： 

      podman pull registry.dns.base.domain.name:5000/openshift/release@sha256:31149e3e5f8c5e5b5b100ff2d89975cf5f7a73801b2c06c639bf6648766117f8
Trying to pull registry.dns.base.domain.name:5000/openshift/release@sha256:31149e3e5f8c5e5b5b100ff2d89975cf5f7a73801b2c06c639bf6648766117f8...
Getting image source signatures
Copying blob d8190195889e skipped: already exists
Copying blob c71d2589fba7 skipped: already exists
Copying blob d4dc6e74b6ce skipped: already exists
Copying blob 97da74cc6d8f skipped: already exists
Copying blob b70007a560c9 done
Copying config 3a62961e6e done
Writing manifest to image destination
Storing signatures
3a62961e6ed6edab46d5ec8429ff1f41d6bb68de51271f037c6cb8941a007fde

    注： HostedCluster 对象中设置的发行镜像必须使用摘要而不是标签；例如，quay.io/openshift-release-dev/ocp-release-dev/ocp-release@sha256:e3ba11bd1e5e8ea5a0b36a75791c90f29afb0fdbe4125be4e48f69c76a5c47a0。

  6. 通过将 YAML 文件中定义的所有对象串联成文件并根据管理集群应用，以创建您在 YAML 文件中定义的所有对象。要做到这一点，请输入以下命令： 

    oc apply -f 01-4.14-hosted_cluster-nodeport.yaml

  7. 查看托管 control plane 的输出： 

    NAME                                                  READY   STATUS    RESTARTS   AGE
capi-provider-5b57dbd6d5-pxlqc                        1/1     Running   0          3m57s
catalog-operator-9694884dd-m7zzv                      2/2     Running   0          93s
cluster-api-f98b9467c-9hfrq                           1/1     Running   0          3m57s
cluster-autoscaler-d7f95dd5-d8m5d                     1/1     Running   0          93s
cluster-image-registry-operator-5ff5944b4b-648ht      1/2     Running   0          93s
cluster-network-operator-77b896ddc-wpkq8              1/1     Running   0          94s
cluster-node-tuning-operator-84956cd484-4hfgf         1/1     Running   0          94s
cluster-policy-controller-5fd8595d97-rhbwf            1/1     Running   0          95s
cluster-storage-operator-54dcf584b5-xrnts             1/1     Running   0          93s
cluster-version-operator-9c554b999-l22s7              1/1     Running   0          95s
control-plane-operator-6fdc9c569-t7hr4                1/1     Running   0          3m57s
csi-snapshot-controller-785c6dc77c-8ljmr              1/1     Running   0          77s
csi-snapshot-controller-operator-7c6674bc5b-d9dtp     1/1     Running   0          93s
csi-snapshot-webhook-5b8584875f-2492j                 1/1     Running   0          77s
dns-operator-6874b577f-9tc6b                          1/1     Running   0          94s
etcd-0                                                3/3     Running   0          3m39s
hosted-cluster-config-operator-f5cf5c464-4nmbh        1/1     Running   0          93s
ignition-server-6b689748fc-zdqzk                      1/1     Running   0          95s
ignition-server-proxy-54d4bb9b9b-6zkg7                1/1     Running   0          95s
ingress-operator-6548dc758b-f9gtg                     1/2     Running   0          94s
konnectivity-agent-7767cdc6f5-tw782                   1/1     Running   0          95s
kube-apiserver-7b5799b6c8-9f5bp                       4/4     Running   0          3m7s
kube-controller-manager-5465bc4dd6-zpdlk              1/1     Running   0          44s
kube-scheduler-5dd5f78b94-bbbck                       1/1     Running   0          2m36s
machine-approver-846c69f56-jxvfr                      1/1     Running   0          92s
oauth-openshift-79c7bf44bf-j975g                      2/2     Running   0          62s
olm-operator-767f9584c-4lcl2                          2/2     Running   0          93s
openshift-apiserver-5d469778c6-pl8tj                  3/3     Running   0          2m36s
openshift-controller-manager-6475fdff58-hl4f7         1/1     Running   0          95s
openshift-oauth-apiserver-dbbc5cc5f-98574             2/2     Running   0          95s
openshift-route-controller-manager-5f6997b48f-s9vdc   1/1     Running   0          95s
packageserver-67c87d4d4f-kl7qh                        2/2     Running   0          93s

  8. 查看托管集群的输出： 

    NAMESPACE   NAME         VERSION   KUBECONFIG                PROGRESS   AVAILABLE   PROGRESSING   MESSAGE
clusters    hosted-dual            hosted-admin-kubeconfig   Partial    True          False         The hosted control plane is available

接下来，创建 NodePool 对象。

1.7.12.7.9.2. 为托管集群创建 NodePool 对象

NodePool 是与托管集群关联的一组可扩展的 worker 节点。NodePool 机器架构在特定池中保持一致，独立于 control plane 的机器架构。

  1. 使用有关 NodePool 对象的以下信息创建 YAML 文件，根据需要替换值： 

    apiVersion: hypershift.openshift.io/v1beta1
kind: NodePool
metadata:
  creationTimestamp: null
  name: hosted-dual
  namespace: clusters
spec:
  arch: amd64
  clusterName: hosted-dual
  management:
    autoRepair: false 1
    upgradeType: InPlace 2
  nodeDrainTimeout: 0s
  platform:
    type: Agent
  release:
    image: registry.dns.base.domain.name:5000/openshift/release-images:4.x.y-x86_64 3
  replicas: 0
status:
  replicas: 0 4
    1
    autoRepair 字段被设置为 false，因为如果删除了该节点，则不会重新创建该节点。
    2
    upgradeType 设置为 InPlace，这表示升级过程中会重复使用相同的裸机节点。
    3
    此 NodePool 中包含的所有节点都基于以下 OpenShift Container Platform 版本： 4.x.y-x86_64。将 dns.base.domain.name 值替换为您的 DNS 基域名，将 4.x.y 值替换为您要使用的 OpenShift Container Platform 版本。
    4
    replicas 值设为 0， 以便在需要时可以扩展它们。务必要将 NodePool 副本保持为 0，直到所有步骤都完成为止。

  2. 运行以下命令来创建 NodePool 对象： 

    oc apply -f 02-nodepool.yaml

  3. 查看输出： 

    NAMESPACE   NAME          CLUSTER   DESIRED NODES   CURRENT NODES   AUTOSCALING   AUTOREPAIR   VERSION                              UPDATINGVERSION   UPDATINGCONFIG   MESSAGE
clusters    hosted-dual   hosted    0                               False         False        4.x.y-x86_64

接下来，创建一个 InfraEnv 资源。

1.7.12.7.9.3. 为托管集群创建 InfraEnv 资源

InfraEnv 资源是一个 Assisted Service 对象，其中包含基本详情，如 pullSecretRef 和 sshAuthorizedKey。这些详情用于创建为托管集群自定义的 Red Hat Enterprise Linux CoreOS (RHCOS)引导镜像。

  1. 使用以下有关 InfraEnv 资源的信息创建 YAML 文件，根据需要替换值： 

    ---
apiVersion: agent-install.openshift.io/v1beta1
kind: InfraEnv
metadata:
  name: hosted-dual
  namespace: clusters-hosted-dual
spec:
  pullSecretRef: 1
    name: pull-secret
  sshAuthorizedKey: ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQDk7ICaUE+/k4zTpxLk4+xFdHi4ZuDi5qjeF52afsNkw0w/glILHhwpL5gnp5WkRuL8GwJuZ1VqLC9EKrdmegn4MrmUlq7WTsP0VFOZFBfq2XRUxo1wrRdor2z0Bbh93ytR+ZsDbbLlGngXaMa0Vbt+z74FqlcajbHTZ6zBmTpBVq5RHtDPgKITdpE1fongp7+ZXQNBlkaavaqv8bnyrP4BWahLP4iO9/xJF9lQYboYwEEDzmnKLMW1VtCE6nJzEgWCufACTbxpNS7GvKtoHT/OVzw8ArEXhZXQUS1UY8zKsX2iXwmyhw5Sj6YboA8WICs4z+TrFP89LmxXY0j6536TQFyRz1iB4WWvCbH5n6W+ABV2e8ssJB1AmEy8QYNwpJQJNpSxzoKBjI73XxvPYYC/IjPFMySwZqrSZCkJYqQ023ySkaQxWZT7in4KeMu7eS2tC+Kn4deJ7KwwUycx8n6RHMeD8Qg9flTHCv3gmab8JKZJqN3hW1D378JuvmIX4V0= 2
    1
    pullSecretRef 引用与 InfraEnv 相同的命名空间中的配置映射引用，其中使用 pull secret。
    2
    sshAuthorizedKey 代表放在引导镜像中的 SSH 公钥。SSH 密钥允许以 core 用户身份访问 worker 节点。

  2. 运行以下命令来创建 InfraEnv 资源： 

    oc apply -f 03-infraenv.yaml

  3. 请参见以下输出： 

    NAMESPACE              NAME     ISO CREATED AT
clusters-hosted-dual   hosted   2023-09-11T15:14:10Z

接下来，创建 worker 节点。

1.7.12.7.9.4. 为托管集群创建 worker 节点

如果您在裸机平台上工作，创建 worker 节点对于确保正确配置了 BareMetalHost 的详情至关重要。

如果使用虚拟机，您可以完成以下步骤来为 Metal3 Operator 创建空的 worker 节点。为此，您可以使用 kcli 工具。

  1. 如果这不是您首次尝试创建 worker 节点，您必须首先删除之前的设置。要做到这一点，请输入以下命令删除计划： 

    kcli delete plan hosted-dual
    1. 当系统提示您确认是否要删除计划时，键入 y。
    2. 确认您看到一条消息，表示计划已被删除。

  2. 输入以下命令来创建虚拟机： 

    kcli create vm -P start=False -P uefi_legacy=true -P plan=hosted-dual -P memory=8192 -P numcpus=16 -P disks=[200,200] -P nets=["{\"name\": \"dual\", \"mac\": \"aa:aa:aa:aa:11:01\"}"] -P uuid=aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaa1101 -P name=hosted-dual-worker0
    kcli create vm -P start=False -P uefi_legacy=true -P plan=hosted-dual -P memory=8192 -P numcpus=16 -P disks=[200,200] -P nets=["{\"name\": \"dual\", \"mac\": \"aa:aa:aa:aa:11:02\"}"] -P uuid=aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaa1102 -P name=hosted-dual-worker1
    kcli create vm -P start=False -P uefi_legacy=true -P plan=hosted-dual -P memory=8192 -P numcpus=16 -P disks=[200,200] -P nets=["{\"name\": \"dual\", \"mac\": \"aa:aa:aa:aa:11:03\"}"] -P uuid=aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaa1103 -P name=hosted-dual-worker2
    systemctl restart ksushy

    其中：

    • start=False 表示虚拟机(VM)不会在创建时自动启动。
    • uefi_legacy=true 表示您将使用 UEFI 传统引导来确保与之前的 UEFI 实现兼容。
    • plan=hosted-dual 表示计划名称，将一组机器标识为集群。
    • memory=8192 和 numcpus=16 是指定虚拟机资源的参数，包括 RAM 和 CPU。
    • disks=[200,200] 表示您要在虚拟机中创建两个精简置备磁盘。
    • nets=[{"name": "dual", "mac": "aa:aa:aa:02:13"}] 是网络详情，包括要连接到的网络详情以及主接口的 MAC 地址。
    • 重启 ksushy 重启 ksushy 工具，以确保工具检测到您添加的虚拟机。

  3. 查看生成的输出： 

    +---------------------+--------+-------------------+----------------------------------------------------+-------------+---------+
|         Name        | Status |         Ip        |                       Source                       |     Plan    | Profile |
+---------------------+--------+-------------------+----------------------------------------------------+-------------+---------+
|    hosted-worker0   |  down  |                   |                                                    | hosted-dual |  kvirt  |
|    hosted-worker1   |  down  |                   |                                                    | hosted-dual |  kvirt  |
|    hosted-worker2   |  down  |                   |                                                    | hosted-dual |  kvirt  |
+---------------------+--------+-------------------+----------------------------------------------------+-------------+---------+

接下来，为托管集群创建裸机主机。

1.7.12.7.9.5. 为托管集群创建裸机主机

裸机主机 是一个 openshift-machine-api 对象，其中包含物理和虚拟详情，以便可以通过 Metal3 Operator 识别它。这些详细信息与其他辅助服务对象关联，称为 代理。

重要： 在创建裸机主机和目标节点前，您必须创建虚拟机。

要创建裸机主机，请完成以下步骤：

  1. 使用以下信息创建 YAML 文件：

    注： 因为至少有一个 secret 包含裸机主机凭证，所以您需要为每个 worker 节点至少创建两个对象。 

    ---
apiVersion: v1
kind: Secret
metadata:
  name: hosted-dual-worker0-bmc-secret
  namespace: clusters-hosted-dual
data:
  password: YWRtaW4=
  username: YWRtaW4=
type: Opaque
---
apiVersion: metal3.io/v1alpha1
kind: BareMetalHost
metadata:
  name: hosted-dual-worker0
  namespace: clusters-hosted-dual
  labels:
    infraenvs.agent-install.openshift.io: hosted-dual 1
  annotations:
    inspect.metal3.io: disabled
    bmac.agent-install.openshift.io/hostname: hosted-dual-worker0 2
spec:
  automatedCleaningMode: disabled 3
  bmc:
    disableCertificateVerification: true 4
    address: redfish-virtualmedia://[192.168.126.1]:9000/redfish/v1/Systems/local/hosted-dual-worker0 5
    credentialsName: hosted-dual-worker0-bmc-secret 6
  bootMACAddress: aa:aa:aa:aa:02:11 7
  online: true 8
    1
    infraenvs.agent-install.openshift.io 作为 Assisted Installer 和 BareMetalHost 对象之间的链接。
    2
    bmac.agent-install.openshift.io/hostname 代表部署期间采用的节点名称。
    3
    automatedCleaningMode 可防止节点被 Metal3 Operator 擦除。
    4
    disableCertificateVerification 设置为 true，以从客户端绕过证书验证。
    5
    address 表示 worker 节点的基板管理控制器(BMC)地址。
    6
    credentialsName 指向存储了用户和密码凭证的 secret。
    7
    bootMACAddress 表示节点从其启动的接口 MAC 地址。
    8
    Online 定义 BareMetalHost 对象创建后节点的状态。

  2. 输入以下命令部署 BareMetalHost 对象： 

    oc apply -f 04-bmh.yaml

    在此过程中，您可以查看以下输出：

    • 这个输出表示进程正在尝试访问节点： 

      NAMESPACE         NAME             STATE         CONSUMER   ONLINE   ERROR   AGE
clusters-hosted   hosted-worker0   registering              true             2s
clusters-hosted   hosted-worker1   registering              true             2s
clusters-hosted   hosted-worker2   registering              true             2s

    • 此输出显示节点已启动： 

      NAMESPACE         NAME             STATE          CONSUMER   ONLINE   ERROR   AGE
clusters-hosted   hosted-worker0   provisioning              true             16s
clusters-hosted   hosted-worker1   provisioning              true             16s
clusters-hosted   hosted-worker2   provisioning              true             16s
    • 此输出显示节点成功启动： 
    NAMESPACE         NAME             STATE         CONSUMER   ONLINE   ERROR   AGE
clusters-hosted   hosted-worker0   provisioned              true             67s
clusters-hosted   hosted-worker1   provisioned              true             67s
clusters-hosted   hosted-worker2   provisioned              true             67s

  3. 节点启动后，请注意命名空间中的代理，如下例所示： 

    NAMESPACE         NAME                                   CLUSTER   APPROVED   ROLE          STAGE
clusters-hosted   aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaa0411             true       auto-assign
clusters-hosted   aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaa0412             true       auto-assign
clusters-hosted   aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaa0413             true       auto-assign

    代理代表可用于安装的节点。要将节点分配到托管集群，请扩展节点池。

1.7.12.7.9.6. 扩展节点池

创建裸机主机后，其状态将从 Registering 变为 Provisioning 。节点以代理的 LiveISO 开头，以及名为 agent 的默认 pod。该代理负责从 Assisted Service Operator 接收安装 OpenShift Container Platform 有效负载的说明。

  1. 要扩展节点池，请输入以下命令： 

    oc -n clusters scale nodepool hosted-dual --replicas 3

  2. 扩展过程完成后，请注意代理被分配给一个托管的集群： 

    NAMESPACE         NAME                                   CLUSTER   APPROVED   ROLE          STAGE
clusters-hosted   aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaa0411   hosted    true       auto-assign
clusters-hosted   aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaa0412   hosted    true       auto-assign
clusters-hosted   aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaa0413   hosted    true       auto-assign

  3. 另请注意设置了节点池副本： 

    NAMESPACE   NAME     CLUSTER   DESIRED NODES   CURRENT NODES   AUTOSCALING   AUTOREPAIR   VERSION                              UPDATINGVERSION   UPDATINGCONFIG   MESSAGE
clusters    hosted   hosted    3                               False         False        4.x.y-x86_64                                      Minimum availability requires 3 replicas, current 0 available

    将 4.x.y 替换为您要使用的 OpenShift Container Platform 版本。

  4. 等待节点加入集群。在此过程中，代理在其阶段和状态上提供更新。

接下来，监控托管集群的部署。

1.7.12.7.10. 为双栈网络完成托管集群部署

您可以从两个视角监控托管集群的部署：control plane 和 data plane。

1.7.12.7.10.1. 使用 control plane 监控托管集群部署

您可以使用 control plane 监控托管集群部署。

  1. 输入以下命令导出托管集群 kubeconfig 文件： 

    export KUBECONFIG=<path_to_hosted_cluster_kubeconfig>

  2. 输入以下命令观察托管集群部署进度： 

    watch "oc get pod -n hypershift;echo;echo;oc get pod -n <hosted_control_plane_namespace>;echo;echo;oc get bmh -A;echo;echo;oc get agent -A;echo;echo;oc get infraenv -A;echo;echo;oc get hostedcluster -A;echo;echo;oc get nodepool -A;echo;echo;"

此命令提供有关以下工件的信息：

  • HyperShift Operator
  • HostedControlPlane pod
  • 裸机主机
  • 代理
  • InfraEnv 资源
  • HostedCluster 和 NodePool 资源
1.7.12.7.10.2. 使用数据平面监控托管集群部署

您可以使用数据平面来监控 Operator 在托管集群部署期间如何进行。

  1. 输入以下命令为托管集群创建 kubeconfig 文件： 

    hcp create kubeconfig --name <hosted_cluster_name> --namespace <hosted_cluster_namespace>

  2. 输入以下命令导出托管集群 kubeconfig 文件： 

    export KUBECONFIG=<path_to_hosted_cluster_kubeconfig>

  3. 输入以下命令观察集群版本、节点和集群 Operator 的状态： 

    watch "oc get clusterversion,nodes,co"

1.7.13. 手动导入托管的 control plane 集群

托管的集群会在托管的 control plane 可用后自动导入到多集群引擎 Operator。如果要手动导入托管集群，请完成以下步骤：

  1. 在控制台中，点 Infrastructure > Clusters 并选择您要导入的托管集群。

  2. 点 Import hosted cluster。

    注： 对于 发现的 托管集群，您还可以从控制台导入，但集群必须处于可升级状态。如果托管集群没有处于可升级状态，则在集群中导入会被禁用，因为托管的 control plane 不可用。点 Import 开始进程。当集群接收更新时，状态为 Importing，然后变为 Ready。

1.7.13.1. 在 AWS 上手动导入托管的 control plane 集群

您还可以通过完成以下步骤，使用命令行界面在 AWS 上导入托管的 control plane 集群：

  1. 使用以下示例 YAML 文件创建 ManagedCluster 资源： 

    apiVersion: cluster.open-cluster-management.io/v1
kind: ManagedCluster
metadata:
  annotations:
    import.open-cluster-management.io/hosting-cluster-name: local-cluster
    import.open-cluster-management.io/klusterlet-deploy-mode: Hosted
    open-cluster-management/created-via: hypershift
  labels:
    cloud: auto-detect
    cluster.open-cluster-management.io/clusterset: default
    name: <cluster_name>
    vendor: OpenShift
  name: <cluster_name>
spec:
  hubAcceptsClient: true
  leaseDurationSeconds: 60

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

  2. 运行以下命令以应用资源： 

    oc apply -f <file_name>

    将 <file_name> 替换为您在上一步中创建的 YAML 文件名。

  3. 使用以下示例 YAML 文件创建 KlusterletAddonConfig 资源。这只适用于 Red Hat Advanced Cluster Management。如果您只安装了 multicluster engine operator，请跳过这一步： 

    apiVersion: agent.open-cluster-management.io/v1
kind: KlusterletAddonConfig
metadata:
  name: <cluster_name>
  namespace: <cluster_name>
spec:
  clusterName: <cluster_name>
  clusterNamespace: <cluster_name>
  clusterLabels:
    cloud: auto-detect
    vendor: auto-detect
  applicationManager:
    enabled: true
  certPolicyController:
    enabled: true
  iamPolicyController:
    enabled: true
  policyController:
    enabled: true
  searchCollector:
    enabled: false

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

  4. 运行以下命令以应用资源： 

    oc apply -f <file_name>

    将 <file_name> 替换为您在上一步中创建的 YAML 文件名。

  5. 导入过程完成后，您的托管集群会在控制台中可见。您还可以运行以下命令来检查托管集群的状态： 

    oc get managedcluster <cluster_name>

1.7.13.2. 其他资源

1.7.13.3. 禁用将托管集群自动导入到多集群引擎 operator

在 control plane 可用时，托管的集群会自动导入到 multicluster engine operator，您可以禁用自动导入托管集群。

任何之前导入的托管集群都不会受到影响，即使您禁用了自动导入。当您升级到 multicluster engine operator 2.5 并启用自动导入时，如果 control plane 可用，所有没有导入的托管集群都会被自动导入。

注： 如果安装了 Red Hat Advanced Cluster Management，也会启用所有 Red Hat Advanced Cluster Management 附加组件。

当禁用了自动导入时，只有新创建的托管集群才会自动导入。已导入的托管集群不会受到影响。您仍然可以使用控制台或创建 ManagedCluster 和 KlusterletAddonConfig 自定义资源来手动导入集群。

要禁用托管集群的自动导入，请完成以下步骤：

  1. 在 multicluster engine operator hub 集群中，打开 AddonDeploymentConfig 资源，以编辑 multicluster-engine 命名空间中的 hypershift-addon-deploy-config 规格。输入以下命令： 

    oc edit addondeploymentconfig hypershift-addon-deploy-config -n multicluster-engine

  2. 在 spec.customizedVariables 部分中，添加 autoImportDisabled 变量，值设为 "true"，如下例所示： 

    apiVersion: addon.open-cluster-management.io/v1alpha1
kind: AddOnDeploymentConfig
metadata:
  name: hypershift-addon-deploy-config
  namespace: multicluster-engine
spec:
  customizedVariables:
  - name: autoImportDisabled
    value: "true"
  3. 要重新启用自动导入，请将 autoImportDisabled 变量的值设置为 "false"，或者从 AddonDeploymentConfig 资源中删除变量。
1.7.13.3.1. 其他资源

有关手动导入托管集群的步骤，请参阅 手动导入托管的 control plane 集群。

1.7.14. 启用或禁用托管的 control plane 功能

托管的 control plane 功能以及 hypershift-addon 受管集群附加组件会被默认启用。如果要禁用这个功能，或者禁用它并希望手动启用它，请参阅以下步骤：

1.7.14.1. 手动启用托管的 control plane 功能

  1. 您可以运行以下命令来启用该功能： 

    oc patch mce multiclusterengine --type=merge -p '{"spec":{"overrides":{"components":[{"name":"hypershift","enabled": true}]}}}' 1
    1
    默认 MultiClusterEngine 资源实例名称为 multiclusterengine，但您可以通过运行以下命令来从集群中获取 MultiClusterEngine 名称 ：$ oc get mce。

  2. 运行以下命令，以验证 MultiClusterEngine 自定义资源中是否启用了 hypershift 和 hypershift-local-hosting 功能： 

    oc get mce multiclusterengine -o yaml 1
    1
    默认 MultiClusterEngine 资源实例名称为 multiclusterengine，但您可以通过运行以下命令来从集群中获取 MultiClusterEngine 名称 ：$ oc get mce。

    输出类似以下示例： 

    apiVersion: multicluster.openshift.io/v1
kind: MultiClusterEngine
metadata:
  name: multiclusterengine
spec:
  overrides:
    components:
    - name: hypershift
      enabled: true
    - name: hypershift-local-hosting
      enabled: true
1.7.14.1.1. 为 local-cluster 手动启用 hypershift-addon 受管集群附加组件

启用托管的 control plane 功能会自动启用 hypershift-addon 受管集群附加组件。如果您需要手动启用 hypershift-addon 受管集群附加组件，请完成以下步骤，使用 hypershift-addon 在 local-cluster 上安装 HyperShift Operator：

  1. 通过创建一个类似以下示例的文件来创建 ManagedClusterAddon HyperShift 附加组件： 

    apiVersion: addon.open-cluster-management.io/v1alpha1
kind: ManagedClusterAddOn
metadata:
  name: hypershift-addon
  namespace: local-cluster
spec:
  installNamespace: open-cluster-management-agent-addon

  2. 运行以下命令来应用该文件： 

    oc apply -f <filename>

    使用您创建的文件的名称替换 filename。

  3. 运行以下命令确认已安装 hypershift-addon: 

    oc get managedclusteraddons -n local-cluster hypershift-addon

    如果安装了附加组件，输出类似以下示例： 

    NAME               AVAILABLE   DEGRADED   PROGRESSING
hypershift-addon   True

您的 HyperShift 附加组件已安装，托管集群可用于创建和管理托管集群。

1.7.14.2. 禁用托管的 control plane 功能

您可以卸载 HyperShift Operator 并禁用托管的 control plane。当您禁用托管的 control plane 集群功能时，您必须销毁托管集群以及 multicluster engine operator 上的受管集群资源，如 管理托管的 control plane 集群 主题 中所述。

1.7.14.2.1. 卸载 HyperShift Operator

要卸载 HyperShift Operator 并从 local-cluster 禁用 hypershift-addon，请完成以下步骤：

  1. 运行以下命令，以确保没有托管集群正在运行： 

    oc get hostedcluster -A

    重要： 如果托管集群正在运行，则 HyperShift Operator 不会卸载，即使 hypershift-addon 被禁用。

  2. 运行以下命令来禁用 hypershift-addon ： 

    oc patch mce multiclusterengine --type=merge -p '{"spec":{"overrides":{"components":[{"name":"hypershift-local-hosting","enabled": false}]}}}' 1
    1
    默认 MultiClusterEngine 资源实例名称为 multiclusterengine，但您可以通过运行以下命令来从集群中获取 MultiClusterEngine 名称 ：$ oc get mce。

    注： 在禁用 hypershift-addon 后，您还可以从 multicluster engine operator 控制台为 local-cluster 禁用 hypershift-addon。

1.7.14.2.2. 禁用托管的 control plane 功能

在禁用托管的 control plane 功能前，您必须首先卸载 HyperShift Operator。运行以下命令来禁用托管的 control plane 功能： 

oc patch mce multiclusterengine --type=merge -p '{"spec":{"overrides":{"components":[{"name":"hypershift","enabled": false}]}}}' 1
1
默认 MultiClusterEngine 资源实例名称为 multiclusterengine，但您可以通过运行以下命令来从集群中获取 MultiClusterEngine 名称 ：$ oc get mce。

您可以运行以下命令来验证 MultiClusterEngine 自定义资源中禁用了 hypershift 和 hypershift-local-hosting 功能： 

oc get mce multiclusterengine -o yaml 1
1
默认 MultiClusterEngine 资源实例名称为 multiclusterengine，但您可以通过运行以下命令来从集群中获取 MultiClusterEngine 名称 ：$ oc get mce。

请参阅以下示例，其中 hypershift 和 hypershift-local-hosting 的 enabled: 标记设为 false ： 

apiVersion: multicluster.openshift.io/v1
kind: MultiClusterEngine
metadata:
  name: multiclusterengine
spec:
  overrides:
    components:
    - name: hypershift
      enabled: false
    - name: hypershift-local-hosting
      enabled: false

1.7.14.3. 其他资源

Red Hat logoGithubRedditYoutubeTwitter

学习

尝试、购买和销售

社区

关于红帽文档

通过我们的产品和服务，以及可以信赖的内容，帮助红帽用户创新并实现他们的目标。

让开源更具包容性

红帽致力于替换我们的代码、文档和 Web 属性中存在问题的语言。欲了解更多详情，请参阅红帽博客.

關於紅帽

我们提供强化的解决方案，使企业能够更轻松地跨平台和环境（从核心数据中心到网络边缘）工作。

© 2024 Red Hat, Inc.