使用 ARM 模板安装集群 - 在 Azure 上安装 | 安装 | OpenShift Container Platform 4.17

先决条件
OpenShift Container Platform 的互联网访问
配置您的 Azure 项目
- Azure 帐户限制
- 在 Azure 中配置公共 DNS 区域
- 提高 Azure 帐户限制
- 证书签名请求管理
- 记录订阅和租户 ID
- 支持访问 Azure 资源的身份
- 用户预配基础架构所需的 Azure 权限
- 使用 Azure 托管身份
- 创建服务主体
- 支持的 Azure 区域
使用用户预配基础架构的集群的要求
- 集群安装所需的机器
- 集群安装的最低资源要求
- Azure 的测试实例类型
- 64 位 ARM 基础架构上 Azure 的测试实例类型
使用 Azure 市场产品
获取安装程序
生成用于集群节点 SSH 访问的密钥对
创建 Azure 的安装文件
- 可选：创建单独的/var分区
- 创建安装配置文件
- 在安装过程中配置集群范围的代理
- 导出 ARM 模板的公共变量
- 创建 Kubernetes 清单和 Ignition 配置文件
创建 Azure 资源组
上传 RHCOS 集群镜像和引导 Ignition 配置文件
创建 DNS 区域的示例
在 Azure 中创建 VNet
- VNet 的 ARM 模板
为 Azure 基础架构部署 RHCOS 集群镜像
- 镜像存储的 ARM 模板
用户预配基础架构的网络要求
- 网络连接要求
在 Azure 中创建网络和负载均衡组件
- 网络和负载均衡器的 ARM 模板
在 Azure 中创建引导机器
- 引导机器的 ARM 模板
在 Azure 中创建控制平面机器
- 控制平面机器的 ARM 模板
等待引导完成并在 Azure 中删除引导资源
在 Azure 中创建额外的辅助机器
- 辅助机器的 ARM 模板
安装 OpenShift CLI
使用 CLI 登录到集群
批准机器的证书签名请求
添加 Ingress DNS 记录
完成用户预配基础架构上的 Azure 安装
OpenShift Container Platform 的遥测访问

在 OpenShift Container Platform 4.17 版本中，您可以使用您提供的基础架构在 Microsoft Azure 上安装集群。

提供了一些Azure 资源管理器 (ARM) 模板来帮助完成这些步骤或帮助您创建自己的模型。

执行用户预配基础架构安装的步骤仅作为示例提供。安装使用您提供的基础架构的集群需要了解云提供商和 OpenShift Container Platform 的安装过程。提供了一些 ARM 模板来帮助完成这些步骤或帮助您创建自己的模型。您也可以自由地通过其他方法创建所需的资源；这些模板只是一个示例。

先决条件

您已经查看了有关OpenShift Container Platform 安装和更新过程的详细信息。
您阅读了有关选择集群安装方法并为用户准备它的文档。
您已配置了一个 Azure 帐户来托管集群。
您已下载 Azure CLI 并将其安装在您的计算机上。请参阅 Azure 文档中的安装 Azure CLI。以下文档最后一次测试使用的是 Azure CLI 的 2.49.0 版本。Azure CLI 命令的执行结果可能会因您使用的版本而异。
如果您的环境中无法访问云身份和访问管理 (IAM) API，或者您不想在 kube-system 命名空间中存储管理员级凭据密钥，请参阅在 kube-system 项目中存储管理员级密钥的替代方法。
如果您使用防火墙并计划使用遥测服务，您已配置防火墙以允许您的集群需要访问的站点。

如果您正在配置代理，请务必也查看此站点列表。

OpenShift Container Platform 的互联网访问

在 OpenShift Container Platform 4.17 中，您需要访问互联网才能安装集群。

您必须具有互联网访问权限才能：

访问OpenShift 集群管理器以下载安装程序并执行订阅管理。如果集群具有互联网访问权限并且您未禁用遥测，则该服务会自动授权您的集群。
访问Quay.io以获取安装集群所需的软件包。
获取执行集群更新所需的软件包。

如果您的集群无法直接访问互联网，则可以在您配置的某些类型的基础架构上执行受限网络安装。在此过程中，您将下载所需的内容并使用它来填充包含安装包的镜像注册表。对于某些安装类型，您安装集群的环境将不需要互联网访问。在更新集群之前，请更新镜像注册表的内容。

配置您的 Azure 项目

在安装 OpenShift Container Platform 之前，您必须配置一个 Azure 项目来托管它。

通过公共端点可用的所有 Azure 资源都受资源名称限制，您不能创建使用某些术语的资源。有关 Azure 限制的术语列表，请参阅 Azure 文档中的解决保留的资源名称错误。

Azure 帐户限制

OpenShift Container Platform 集群使用许多 Microsoft Azure 组件，并且默认的Azure 订阅和服务限制、配额和约束会影响您安装 OpenShift Container Platform 集群的能力。

默认限制因产品类别类型（例如免费试用版和即用即付）和系列（例如 Dv2、F 和 G）而异。例如，企业协议订阅的默认值为 350 个内核。

在您在 Azure 上安装默认集群之前，请检查您的订阅类型的限制，如有必要，请增加帐户的配额限制。

下表总结了其限制可能会影响您安装和运行 OpenShift Container Platform 集群能力的 Azure 组件。

组件默认情况下所需的组件数量默认 Azure 限制描述

vCPU

每个区域 20 个

默认集群需要 40 个 vCPU，因此您必须增加帐户限制。

默认情况下，每个集群会创建以下实例：

一台引导机器，安装后将被移除
三台控制平面机器
三台计算机器

由于引导机器使用 Standard_D4s_v3 机器（使用 4 个 vCPU），控制平面机器使用 Standard_D8s_v3 虚拟机（使用 8 个 vCPU），而工作机器使用 Standard_D4s_v3 虚拟机（使用 4 个 vCPU），因此默认集群需要 40 个 vCPU。引导节点 VM（使用 4 个 vCPU）仅在安装期间使用。

要部署更多工作节点、启用自动缩放、部署大型工作负载或使用不同的实例类型，您必须进一步增加帐户的 vCPU 限制，以确保您的集群可以部署您所需的机器。

操作系统磁盘

每个集群机器必须至少具有 100 GB 的存储空间和 300 IOPS。虽然这些是最小支持值，但对于生产集群和具有密集型工作负载的集群，建议使用更快的存储。有关优化存储性能的更多信息，请参阅“可扩展性和性能”部分中标题为“优化存储”的页面。

虚拟网络 (VNet)

每个区域 1000 个

每个默认集群需要一个虚拟网络 (VNet)，其中包含两个子网。

网络接口

每个区域 65,536 个

每个默认集群需要七个网络接口。如果您创建更多机器或已部署的工作负载创建负载均衡器，则您的集群将使用更多网络接口。

网络安全组

5000

每个集群都会为 VNet 中的每个子网创建网络安全组。默认集群会为控制平面和计算节点子网创建网络安全组。

`控制平面`	允许从任何位置通过端口 6443 访问控制平面机器。
`节点`	允许通过端口 80 和 443 从互联网访问工作节点。

网络负载均衡器

每个区域 1000 个

每个集群都会创建以下负载均衡器：

`默认`	公共 IP 地址，用于在工作机器之间对端口 80 和 443 的请求进行负载均衡。
`内部`	专用 IP 地址，用于在控制平面机器之间对端口 6443 和 22623 的请求进行负载均衡。
`外部`	公共 IP 地址，用于在控制平面机器之间对端口 6443 的请求进行负载均衡。

如果您的应用程序创建更多 Kubernetes LoadBalancer 服务对象，则您的集群将使用更多负载均衡器。

公共 IP 地址

两个公共负载均衡器中的每一个都使用一个公共 IP 地址。引导机器还使用一个公共 IP 地址，以便您可以在安装过程中通过 SSH 登录到该机器以排除故障。引导节点的 IP 地址仅在安装期间使用。

专用 IP 地址

内部负载均衡器、三台控制平面机器中的每台以及三台工作机器中的每台都使用一个专用 IP 地址。

抢占式 VM vCPU（可选）

如果您配置了抢占式 VM，则您的集群必须为每个计算节点提供两个抢占式 VM vCPU。

每个区域 20 个

这是一个可选组件。要使用抢占式 VM，您必须将 Azure 默认限制增加到至少集群中计算节点数量的两倍。

不建议将抢占式 VM 用于控制平面节点。

其他资源

优化存储

在 Azure 中配置公共 DNS 区域

要安装 OpenShift Container Platform，您使用的 Microsoft Azure 帐户必须在您的帐户中具有专用的公共托管 DNS 区域。此区域必须是该域的权威机构。此服务为集群 DNS 解析和对集群的外部连接的名称查找提供支持。

步骤

确定您的域或子域和注册商。您可以转移现有域和注册商，或通过 Azure 或其他来源获取新的域和注册商。

有关通过 Azure 购买域的更多信息，请参阅 Azure 文档中的为 Azure 应用服务购买自定义域名。
如果您正在使用现有的域名和注册商，请将其 DNS 迁移到 Azure。请参阅 Azure 文档中的将活动 DNS 名称迁移到 Azure 应用服务。
配置您域名的 DNS。请按照 Azure 文档中的教程：在 Azure DNS 中托管您的域名中的步骤操作，为您的域名或子域名创建一个公共托管区域，提取新的权威名称服务器，并更新您的域名使用的名称服务器的注册商记录。

使用合适的根域名，例如openshiftcorp.com，或子域名，例如clusters.openshiftcorp.com。
如果您使用子域名，请按照公司规程将它的委派记录添加到父域名。

您可以访问此创建 DNS 区域的示例来查看 Azure 的 DNS 解决方案。

提高 Azure 帐户限制

要提高帐户限制，请在 Azure 门户上提交支持请求。

每个支持请求只能增加一种类型的配额。

步骤

在 Azure 门户中，单击左下角的**帮助 + 支持**。
单击**新建支持请求**，然后选择所需的值。
1. 从**问题类型**列表中，选择**服务和订阅限制（配额）**。
2. 从**订阅**列表中，选择要修改的订阅。
3. 从**配额类型**列表中，选择要提高的配额。例如，选择**计算-VM（核心-vCPU）订阅限制增加**以增加 vCPU 的数量，这是安装集群所需的。
4. 单击**下一步：解决方案**。
在**问题详细信息**页面上，提供配额增加所需的资讯。
1. 单击**提供详细信息**，并在**配额详细信息**窗口中提供所需的详细信息。
2. 在“支持方法”和“联系信息”部分，提供问题的严重程度和您的联系方式。
单击**下一步：审阅 + 创建**，然后单击**创建**。

证书签名请求管理

因为当您使用您自己配置的基础设施时，您的集群对自动机器管理的访问权限有限，所以您必须提供一种机制来批准集群证书签名请求 (CSR)（安装后）。kube-controller-manager 仅批准 kubelet 客户端 CSR。machine-approver无法保证使用 kubelet 凭据请求的服务证书的有效性，因为它无法确认正确的机器发出了请求。您必须确定并实施一种验证 kubelet 服务证书请求的有效性并批准它们的方法。

记录订阅和租户 ID

安装程序需要与您的 Azure 帐户关联的订阅和租户 ID。您可以使用 Azure CLI 收集此信息。

先决条件

您已安装或更新了Azure CLI。

步骤

运行以下命令登录到 Azure CLI：
```
$ az login
```

确保您使用的是正确的订阅。

运行以下命令查看可用订阅列表：

$ az account list --refresh

示例输出：

[
  {
    "cloudName": "AzureCloud",
    "id": "8xxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
    "isDefault": true,
    "name": "Subscription Name 1",
    "state": "Enabled",
    "tenantId": "6xxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
    "user": {
      "name": "[email protected]",
      "type": "user"
    }
  },
  {
    "cloudName": "AzureCloud",
    "id": "9xxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
    "isDefault": false,
    "name": "Subscription Name 2",
    "state": "Enabled",
    "tenantId": "7xxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
    "user": {
      "name": "[email protected]",
      "type": "user"
    }
  }
]

运行以下命令查看活动帐户的详细信息，并确认这是您要使用的订阅：

$ az account show

示例输出：

{
  "environmentName": "AzureCloud",
  "id": "8xxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
  "isDefault": true,
  "name": "Subscription Name 1",
  "state": "Enabled",
  "tenantId": "6xxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
  "user": {
    "name": "[email protected]",
    "type": "user"
  }
}

如果您没有使用正确的订阅：

运行以下命令更改活动订阅：
```
$ az account set -s <subscription_id>
```

运行以下命令验证您是否正在使用所需的订阅：

$ az account show

示例输出：

{
  "environmentName": "AzureCloud",
  "id": "9xxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
  "isDefault": true,
  "name": "Subscription Name 2",
  "state": "Enabled",
  "tenantId": "7xxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
  "user": {
    "name": "[email protected]",
    "type": "user"
  }
}

记录输出中的id和tenantId参数值。安装 OpenShift Container Platform 集群需要这些值。

支持用于访问 Azure 资源的身份

OpenShift Container Platform 集群需要一个 Azure 身份来创建和管理 Azure 资源。因此，您需要以下类型之一的身份才能完成安装。

服务主体
系统分配的托管身份
用户分配的托管身份

用户配置基础设施所需的 Azure 权限

安装程序需要访问具有必要权限的 Azure 服务主体或托管身份，以部署集群并维护其日常操作。必须将这些权限授予与该身份关联的 Azure 订阅。

您可以选择以下选项：

您可以为身份分配参与者和用户访问管理员角色。分配这些角色是授予所有必需权限的最快方法。

有关分配角色的更多信息，请参阅 Azure 文档中有关使用 Azure 门户管理对 Azure 资源的访问的内容。
如果贵公司的安全策略需要更严格的权限集，您可以创建具有必要权限的自定义角色。

在 Microsoft Azure 上创建 OpenShift Container Platform 集群需要以下权限。

创建授权资源所需的权限

Microsoft.Authorization/policies/audit/action
Microsoft.Authorization/policies/auditIfNotExists/action
Microsoft.Authorization/roleAssignments/read
Microsoft.Authorization/roleAssignments/write

创建计算资源所需的权限

Microsoft.Compute/images/read
Microsoft.Compute/images/write
Microsoft.Compute/images/delete
Microsoft.Compute/availabilitySets/read
Microsoft.Compute/disks/beginGetAccess/action
Microsoft.Compute/disks/delete
Microsoft.Compute/disks/read
Microsoft.Compute/disks/write
Microsoft.Compute/galleries/images/read
Microsoft.Compute/galleries/images/versions/read
Microsoft.Compute/galleries/images/versions/write
Microsoft.Compute/galleries/images/write
Microsoft.Compute/galleries/read
Microsoft.Compute/galleries/write
Microsoft.Compute/snapshots/read
Microsoft.Compute/snapshots/write
Microsoft.Compute/snapshots/delete
Microsoft.Compute/virtualMachines/delete
Microsoft.Compute/virtualMachines/powerOff/action
Microsoft.Compute/virtualMachines/read
Microsoft.Compute/virtualMachines/write
Microsoft.Compute/virtualMachines/deallocate/action

创建身份管理资源所需的权限

Microsoft.ManagedIdentity/userAssignedIdentities/assign/action
Microsoft.ManagedIdentity/userAssignedIdentities/read
Microsoft.ManagedIdentity/userAssignedIdentities/write

创建网络资源所需的权限

Microsoft.Network/dnsZones/A/write
Microsoft.Network/dnsZones/CNAME/write
Microsoft.Network/dnszones/CNAME/read
Microsoft.Network/dnszones/read
Microsoft.Network/loadBalancers/backendAddressPools/join/action
Microsoft.Network/loadBalancers/backendAddressPools/read
Microsoft.Network/loadBalancers/backendAddressPools/write
Microsoft.Network/loadBalancers/read
Microsoft.Network/loadBalancers/write
Microsoft.Network/networkInterfaces/delete
Microsoft.Network/networkInterfaces/join/action
Microsoft.Network/networkInterfaces/read
Microsoft.Network/networkInterfaces/write
Microsoft.Network/networkSecurityGroups/join/action
Microsoft.Network/networkSecurityGroups/read
Microsoft.Network/networkSecurityGroups/securityRules/delete
Microsoft.Network/networkSecurityGroups/securityRules/read
Microsoft.Network/networkSecurityGroups/securityRules/write
Microsoft.Network/networkSecurityGroups/write
Microsoft.Network/privateDnsZones/A/read
Microsoft.Network/privateDnsZones/A/write
Microsoft.Network/privateDnsZones/A/delete
Microsoft.Network/privateDnsZones/SOA/read
Microsoft.Network/privateDnsZones/read
Microsoft.Network/privateDnsZones/virtualNetworkLinks/read
Microsoft.Network/privateDnsZones/virtualNetworkLinks/write
Microsoft.Network/privateDnsZones/write
Microsoft.Network/publicIPAddresses/delete
Microsoft.Network/publicIPAddresses/join/action
Microsoft.Network/publicIPAddresses/read
Microsoft.Network/publicIPAddresses/write
Microsoft.Network/virtualNetworks/join/action
Microsoft.Network/virtualNetworks/read
Microsoft.Network/virtualNetworks/subnets/join/action
Microsoft.Network/virtualNetworks/subnets/read
Microsoft.Network/virtualNetworks/subnets/write
Microsoft.Network/virtualNetworks/write

检查资源健康状况所需的权限

Microsoft.Resourcehealth/healthevent/Activated/action
Microsoft.Resourcehealth/healthevent/InProgress/action
Microsoft.Resourcehealth/healthevent/Pending/action
Microsoft.Resourcehealth/healthevent/Resolved/action
Microsoft.Resourcehealth/healthevent/Updated/action

创建资源组所需的权限

Microsoft.Resources/subscriptions/resourceGroups/read
Microsoft.Resources/subscriptions/resourcegroups/write

创建资源标签所需的权限

Microsoft.Resources/tags/write

创建存储资源所需的权限

Microsoft.Storage/storageAccounts/blobServices/read
Microsoft.Storage/storageAccounts/blobServices/containers/write
Microsoft.Storage/storageAccounts/fileServices/read
Microsoft.Storage/storageAccounts/fileServices/shares/read
Microsoft.Storage/storageAccounts/fileServices/shares/write
Microsoft.Storage/storageAccounts/fileServices/shares/delete
Microsoft.Storage/storageAccounts/listKeys/action
Microsoft.Storage/storageAccounts/read
Microsoft.Storage/storageAccounts/write

创建部署所需的权限

Microsoft.Resources/deployments/read
Microsoft.Resources/deployments/write
Microsoft.Resources/deployments/validate/action
Microsoft.Resources/deployments/operationstatuses/read

创建计算资源的可选权限

Microsoft.Compute/availabilitySets/delete
Microsoft.Compute/availabilitySets/write

创建市场虚拟机资源的可选权限

Microsoft.MarketplaceOrdering/offertypes/publishers/offers/plans/agreements/read
Microsoft.MarketplaceOrdering/offertypes/publishers/offers/plans/agreements/write

启用用户管理加密的可选权限

Microsoft.Compute/diskEncryptionSets/read
Microsoft.Compute/diskEncryptionSets/write
Microsoft.Compute/diskEncryptionSets/delete
Microsoft.KeyVault/vaults/read
Microsoft.KeyVault/vaults/write
Microsoft.KeyVault/vaults/delete
Microsoft.KeyVault/vaults/deploy/action
Microsoft.KeyVault/vaults/keys/read
Microsoft.KeyVault/vaults/keys/write
Microsoft.Features/providers/features/register/action

删除 Microsoft Azure 上的 OpenShift Container Platform 集群需要以下权限。

删除授权资源所需的权限

Microsoft.Authorization/roleAssignments/delete

删除计算资源所需的权限

Microsoft.Compute/disks/delete
Microsoft.Compute/galleries/delete
Microsoft.Compute/galleries/images/delete
Microsoft.Compute/galleries/images/versions/delete
Microsoft.Compute/virtualMachines/delete
Microsoft.Compute/images/delete

删除身份管理资源所需的权限

Microsoft.ManagedIdentity/userAssignedIdentities/delete

删除网络资源所需的权限

Microsoft.Network/dnszones/read
Microsoft.Network/dnsZones/A/read
Microsoft.Network/dnsZones/A/delete
Microsoft.Network/dnsZones/CNAME/read
Microsoft.Network/dnsZones/CNAME/delete
Microsoft.Network/loadBalancers/delete
Microsoft.Network/networkInterfaces/delete
Microsoft.Network/networkSecurityGroups/delete
Microsoft.Network/privateDnsZones/read
Microsoft.Network/privateDnsZones/A/read
Microsoft.Network/privateDnsZones/delete
Microsoft.Network/privateDnsZones/virtualNetworkLinks/delete
Microsoft.Network/publicIPAddresses/delete
Microsoft.Network/virtualNetworks/delete

检查资源健康状况所需的权限

Microsoft.Resourcehealth/healthevent/Activated/action
Microsoft.Resourcehealth/healthevent/Resolved/action
Microsoft.Resourcehealth/healthevent/Updated/action

删除资源组所需的权限

Microsoft.Resources/subscriptions/resourcegroups/delete

删除存储资源所需的权限

Microsoft.Storage/storageAccounts/delete
Microsoft.Storage/storageAccounts/listKeys/action

要在 Azure 上安装 OpenShift Container Platform，必须将与资源组创建相关的权限范围限定为您的订阅。创建资源组后，您可以将其余权限范围限定为已创建的资源组。如果公共 DNS 区域存在于不同的资源组中，则必须始终将与网络 DNS 区域相关的权限应用于您的订阅。

删除 OpenShift Container Platform 集群时，您可以将所有权限范围限定为您的订阅。

使用 Azure 托管身份

安装程序需要 Azure 身份才能完成安装。您可以使用系统分配的或用户分配的托管身份。

如果您无法使用托管身份，则可以使用服务主体。

步骤

如果您使用的是系统分配的托管身份，请在您将运行安装程序的虚拟机上启用它。
如果您使用的是用户分配的托管身份
1. 将其分配给您将运行安装程序的虚拟机。
2. 记录其客户端 ID。安装集群时需要此值。
  
  有关查看用户分配的托管身份详细信息的更多信息，请参阅 Microsoft Azure 文档，了解列出用户分配的托管身份。
验证托管身份是否已分配所需的权限。

创建服务主体

安装程序需要 Azure 身份才能完成安装。您可以使用服务主体。

如果您无法使用服务主体，则可以使用托管身份。

先决条件

您已安装或更新了Azure CLI。
您拥有 Azure 订阅 ID。
如果您不打算将 `Contributor` 和 `User Administrator Access` 角色分配给服务主体，则您已创建具有所需 Azure 权限的自定义角色。

步骤

通过运行以下命令为您的帐户创建服务主体

$ az ad sp create-for-rbac --role <role_name> \(1)
     --name <service_principal> \(2)
     --scopes /subscriptions/<subscription_id> (3)

1	定义角色名称。您可以使用 `Contributor` 角色，也可以指定包含必要权限的自定义角色。
2	定义服务主体名称。
3	指定订阅 ID。

示例输出：

Creating 'Contributor' role assignment under scope '/subscriptions/<subscription_id>'
The output includes credentials that you must protect. Be sure that you do not
include these credentials in your code or check the credentials into your source
control. For more information, see https://aka.ms/azadsp-cli
{
  "appId": "axxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
  "displayName": <service_principal>",
  "password": "00000000-0000-0000-0000-000000000000",
  "tenantId": "8xxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
}

记录输出中的 `appId` 和 `password` 参数的值。安装集群时需要这些值。

如果您将 `Contributor` 角色应用于您的服务主体，请通过运行以下命令分配 `User Administrator Access` 角色

$ az role assignment create --role "User Access Administrator" \
  --assignee-object-id $(az ad sp show --id <appId> --query id -o tsv) (1)
  --scope /subscriptions/<subscription_id> (2)

1	指定服务主体的 `appId` 参数值。
2	指定订阅 ID。

其他资源

有关 CCO 模式的更多信息，请参阅关于云凭据操作员。

支持的 Azure 区域

安装程序会根据您的订阅动态生成可用 Microsoft Azure 区域的列表。

支持的 Azure 公有区域

australiacentral（澳大利亚中部）
australiaeast（澳大利亚东部）
australiasoutheast（澳大利亚东南部）
brazilsouth（巴西南部）
canadacentral（加拿大中部）
canadaeast（加拿大东部）
centralindia（印度中部）
centralus（美国中部）
eastasia（东亚）
eastus（美国东部）
eastus2（美国东部 2）
francecentral（法国中部）
germanywestcentral（德国西部中部）
israelcentral（以色列中部）
italynorth（意大利北部）
japaneast（日本东部）
japanwest（日本西部）
koreacentral（韩国中部）
koreasouth（韩国南部）
mexicocentral（墨西哥中部）
northcentralus（美国北部中部）
northeurope（北欧）
norwayeast（挪威东部）
polandcentral（波兰中部）
qatarcentral（卡塔尔中部）
southafricanorth（南非北部）
southcentralus（美国南部中部）
southeastasia（东南亚）
southindia（印度南部）
spaincentral（西班牙中部）
swedencentral（瑞典中部）
switzerlandnorth（瑞士北部）
uaenorth（阿联酋北部）
uksouth（英国南部）
ukwest（英国西部）
westcentralus（美国西部中部）
westeurope（西欧）
westindia（印度西部）
westus（美国西部）
westus2（美国西部 2）
westus3（美国西部 3）

支持的 Azure 政府区域

在 OpenShift Container Platform 4.6 版本中添加了对以下 Microsoft Azure 政府 (MAG) 区域的支持

usgovtexas（美国政府德克萨斯州）
usgovvirginia（美国政府弗吉尼亚州）

您可以在Azure 文档中参考所有可用的 MAG 区域。其他提供的 MAG 区域预计可与 OpenShift Container Platform 配合使用，但尚未经过测试。

用户自备基础设施集群的要求

对于包含用户自备基础设施的集群，您必须部署所有必需的机器。

本节描述在用户自备基础设施上部署 OpenShift Container Platform 的要求。

集群安装所需的机器

最小的 OpenShift Container Platform 集群需要以下主机

表 1. 最低所需主机
主机	描述
一台临时引导机器	集群需要引导机器才能在三台控制平面机器上部署 OpenShift Container Platform 集群。安装集群后，您可以移除引导机器。
三台控制平面机器	控制平面机器运行构成控制平面的 Kubernetes 和 OpenShift Container Platform 服务。
至少两台计算机器，也称为工作机器。	OpenShift Container Platform 用户请求的工作负载在计算机器上运行。

为了保持集群的高可用性，请为这些集群机器使用独立的物理主机。

引导机器和控制平面机器必须使用 Red Hat Enterprise Linux CoreOS (RHCOS) 作为操作系统。但是，计算机器可以选择 Red Hat Enterprise Linux CoreOS (RHCOS)、Red Hat Enterprise Linux (RHEL) 8.6 及更高版本。

请注意，RHCOS 基于 Red Hat Enterprise Linux (RHEL) 9.2，并继承其所有硬件认证和要求。请参阅Red Hat Enterprise Linux 技术能力和限制。

集群安装的最低资源要求

每个集群机器必须满足以下最低要求

表 2. 最低资源要求
机器	操作系统	vCPU ^[1]	虚拟 RAM	存储	每秒输入/输出次数 (IOPS)^[2]
引导	RHCOS	4	16 GB	100 GB	300
控制平面	RHCOS	4	16 GB	100 GB	300
计算	RHCOS、RHEL 8.6 及更高版本 ^[3]	2	8 GB	100 GB	300

当未启用同时多线程 (SMT) 或超线程时，一个 vCPU 等于一个物理核心。启用时，请使用以下公式计算相应的比率：（每个核心的线程数 × 核心数）× 插槽数 = vCPU 数。
OpenShift Container Platform 和 Kubernetes 对磁盘性能敏感，建议使用更快的存储，特别是对于控制平面节点上的 etcd，它需要 10 毫秒 p99 fsync 时长。请注意，在许多云平台上，存储大小和 IOPS 是成比例缩放的，因此您可能需要过度分配存储卷才能获得足够的性能。
与所有用户自备安装一样，如果您选择在集群中使用 RHEL 计算机器，则您将负责所有操作系统生命周期管理和维护，包括执行系统更新、应用补丁以及完成所有其他所需的任务。RHEL 7 计算机器的使用已弃用，并在 OpenShift Container Platform 4.10 及更高版本中已被移除。

从 OpenShift Container Platform 4.13 版本开始，RHCOS 基于 RHEL 9.2 版本，更新了微架构要求。以下列表包含每个架构所需的最低指令集架构 (ISA)：

x86-64 架构需要 x86-64-v2 ISA
ARM64 架构需要 ARMv8.0-A ISA
IBM Power 架构需要 Power 9 ISA
s390x 架构需要 z14 ISA

更多信息，请参阅RHEL 架构。

您必须使用将premiumIO参数设置为true的 Azure 虚拟机。

如果您的平台的实例类型满足集群机器的最低要求，则支持在 OpenShift Container Platform 中使用它。

其他资源

优化存储

Azure 的测试实例类型

以下 Microsoft Azure 实例类型已通过 OpenShift Container Platform 测试。

基于 64 位 x86 架构的机器类型

standardBasv2Family
standardBSFamily
standardBsv2Family
standardDADSv5Family
standardDASv4Family
standardDASv5Family
standardDCACCV5Family
standardDCADCCV5Family
standardDCADSv5Family
standardDCASv5Family
standardDCSv3Family
standardDCSv2Family
standardDDCSv3Family
standardDDSv4Family
standardDDSv5Family
standardDLDSv5Family
standardDLSv5Family
standardDSFamily
standardDSv2Family
standardDSv2PromoFamily
standardDSv3Family
standardDSv4Family
standardDSv5Family
standardEADSv5Family
standardEASv4Family
standardEASv5Family
standardEBDSv5Family
standardEBSv5Family
standardECACCV5Family
standardECADCCV5Family
standardECADSv5Family
standardECASv5Family
standardEDSv4Family
standardEDSv5Family
standardEIADSv5Family
standardEIASv4Family
standardEIASv5Family
standardEIBDSv5Family
standardEIBSv5Family
standardEIDSv5Family
standardEISv3Family
standardEISv5Family
standardESv3Family
standardESv4Family
standardESv5Family
standardFXMDVSFamily
standardFSFamily
standardFSv2Family
standardGSFamily
standardHBrsv2Family
standardHBSFamily
standardHBv4Family
standardHCSFamily
standardHXFamily
standardLASv3Family
standardLSFamily
standardLSv2Family
standardLSv3Family
standardMDSHighMemoryv3Family
standardMDSMediumMemoryv2Family
standardMDSMediumMemoryv3Family
standardMIDSHighMemoryv3Family
standardMIDSMediumMemoryv2Family
standardMISHighMemoryv3Family
standardMISMediumMemoryv2Family
standardMSFamily
standardMSHighMemoryv3Family
standardMSMediumMemoryv2Family
standardMSMediumMemoryv3Family
StandardNCADSA100v4Family
Standard NCASv3_T4 Family
standardNCSv3Family
standardNDSv2Family
StandardNGADSV620v1Family
standardNPSFamily
StandardNVADSA10v5Family
standardNVSv3Family
standardXEISv4Family

64 位 ARM 架构 Azure 的测试实例类型

以下 Microsoft Azure ARM64 实例类型已通过 OpenShift Container Platform 测试。

基于 64 位 ARM 架构的机器类型

standardBpsv2Family
standardDPSv5Family
standardDPDSv5Family
standardDPLDSv5Family
standardDPLSv5Family
standardEPSv5Family
standardEPDSv5Family

使用 Azure 市场产品

使用 Azure 市场产品，您可以部署 OpenShift Container Platform 集群，该集群通过 Azure 按使用付费（按小时、按核心）计费，同时仍直接由 Red Hat 支持。

要使用 Azure 市场产品部署 OpenShift Container Platform 集群，您必须首先获取 Azure 市场镜像。安装程序使用此镜像来部署工作节点或控制平面节点。获取镜像时，请考虑以下几点

虽然镜像相同，但 Azure 市场发布者因地区而异。如果您位于北美，请指定redhat作为发布者。如果您位于 EMEA 地区，请指定redhat-limited作为发布者。
此产品包含rh-ocp-worker SKU 和rh-ocp-worker-gen1 SKU。rh-ocp-worker SKU 代表 Hyper-V 2 代虚拟机镜像。OpenShift Container Platform 中使用的默认实例类型与 2 代兼容。如果您计划使用仅与 1 代兼容的实例类型，请使用与rh-ocp-worker-gen1 SKU 关联的镜像。rh-ocp-worker-gen1 SKU 代表 Hyper-V 1 代虚拟机镜像。

不支持在具有 64 位 ARM 实例的集群上使用 Azure 市场安装镜像。

先决条件

您已安装 Azure CLI 客户端(az)。
您的 Azure 帐户有权使用此产品，并且您已使用 Azure CLI 客户端登录到此帐户。

步骤

运行以下命令之一，显示所有可用的 OpenShift Container Platform 镜像

北美

$  az vm image list --all --offer rh-ocp-worker --publisher redhat -o table

示例输出：

Offer          Publisher       Sku                 Urn                                                             Version
-------------  --------------  ------------------  --------------------------------------------------------------  -----------------
rh-ocp-worker  RedHat          rh-ocp-worker       RedHat:rh-ocp-worker:rh-ocp-worker:4.15.2024072409              4.15.2024072409
rh-ocp-worker  RedHat          rh-ocp-worker-gen1  RedHat:rh-ocp-worker:rh-ocp-worker-gen1:4.15.2024072409         4.15.2024072409

EMEA

$  az vm image list --all --offer rh-ocp-worker --publisher redhat-limited -o table

示例输出：

Offer          Publisher       Sku                 Urn                                                                     Version
-------------  --------------  ------------------  --------------------------------------------------------------          -----------------
rh-ocp-worker  redhat-limited  rh-ocp-worker       redhat-limited:rh-ocp-worker:rh-ocp-worker:4.15.2024072409              4.15.2024072409
rh-ocp-worker  redhat-limited  rh-ocp-worker-gen1  redhat-limited:rh-ocp-worker:rh-ocp-worker-gen1:4.15.2024072409         4.15.2024072409

使用最新的可用于计算和控制平面节点的镜像。如有需要，您的虚拟机将在安装过程中自动升级。

运行以下命令之一，检查您的产品镜像

北美

$ az vm image show --urn redhat:rh-ocp-worker:rh-ocp-worker:<version>

EMEA

$ az vm image show --urn redhat-limited:rh-ocp-worker:rh-ocp-worker:<version>

运行以下命令之一，查看产品条款

北美

$ az vm image terms show --urn redhat:rh-ocp-worker:rh-ocp-worker:<version>

EMEA

$ az vm image terms show --urn redhat-limited:rh-ocp-worker:rh-ocp-worker:<version>

运行以下命令之一，接受产品条款

北美

$ az vm image terms accept --urn redhat:rh-ocp-worker:rh-ocp-worker:<version>

EMEA

$ az vm image terms accept --urn redhat-limited:rh-ocp-worker:rh-ocp-worker:<version>

记录您的产品镜像详细信息。如果您使用 Azure 资源管理器 (ARM) 模板部署计算节点

更新storageProfile.imageReference，方法是删除id参数，并使用产品中的值添加offer、publisher、sku和version参数。

为虚拟机 (VM) 指定一个plan。

已更新storageProfile.imageReference对象并指定plan的示例06_workers.json ARM 模板

...
  "plan" : {
    "name": "rh-ocp-worker",
    "product": "rh-ocp-worker",
    "publisher": "redhat"
  },
  "dependsOn" : [
    "[concat('Microsoft.Network/networkInterfaces/', concat(variables('vmNames')[copyIndex()], '-nic'))]"
  ],
  "properties" : {
...
  "storageProfile": {
    "imageReference": {
    "offer": "rh-ocp-worker",
    "publisher": "redhat",
    "sku": "rh-ocp-worker",
    "version": "413.92.2023101700"
    }
    ...
   }
...
  }

获取安装程序

在安装 OpenShift Container Platform 之前，请在您用于安装的主机上下载安装文件。

先决条件

您有一台运行 Linux 或 macOS 的计算机，具有 500 MB 的本地磁盘空间。

步骤

访问 Red Hat 混合云控制台上的集群类型页面。如果您有 Red Hat 帐户，请使用您的凭据登录。如果没有，请创建一个帐户。
从页面自行运行部分选择您的基础架构提供商。
从OpenShift 安装程序下的下拉菜单中选择您的主机操作系统和架构，然后单击下载安装程序。

将下载的文件放在您想要存储安装配置文件的目录中。

安装程序会在您用于安装集群的计算机上创建多个文件。安装集群完成后，您必须保留安装程序和安装程序创建的文件。这两个文件都是删除集群所必需的。
即使集群在安装过程中失败，删除安装程序创建的文件也不会删除您的集群。要删除集群，请完成针对您特定云提供商的 OpenShift Container Platform 卸载过程。

解压安装程序。例如，在使用 Linux 操作系统的计算机上，运行以下命令
```
$ tar -xvf openshift-install-linux.tar.gz
```
从 Red Hat OpenShift 集群管理器下载您的安装pull 密钥。此 pull 密钥允许您对包含的授权机构提供的服务进行身份验证，包括 Quay.io，它提供 OpenShift Container Platform 组件的容器镜像。

或者，您可以从Red Hat 客户门户检索安装程序，您可以在其中指定要下载的安装程序版本。但是，您必须拥有活动订阅才能访问此页面。

生成集群节点 SSH 访问的密钥对

在 OpenShift Container Platform 安装过程中，您可以向安装程序提供 SSH 公钥。该密钥通过 Ignition 配置文件传递给 Red Hat Enterprise Linux CoreOS (RHCOS) 节点，并用于对节点的 SSH 访问进行身份验证。该密钥将添加到每个节点上core用户的~/.ssh/authorized_keys列表中，从而启用无需密码的身份验证。

密钥传递到节点后，您可以使用密钥对以core用户身份通过 SSH 登录到 RHCOS 节点。要通过 SSH 访问节点，必须由 SSH 为您的本地用户管理私钥标识。

如果您要通过 SSH 登录到集群节点以执行安装调试或灾难恢复，则必须在安装过程中提供 SSH 公钥。./openshift-install gather命令也需要集群节点上已安装 SSH 公钥。

在需要灾难恢复和调试的生产环境中，请勿跳过此过程。

您必须使用本地密钥，而不是使用您使用特定于平台的方法（例如AWS 密钥对）配置的密钥。

步骤

如果您本地机器上没有现有的 SSH 密钥对可用于对集群节点进行身份验证，请创建一个。例如，在使用 Linux 操作系统的计算机上，运行以下命令

$ ssh-keygen -t ed25519 -N '' -f <path>/<file_name> (1)

1	指定新 SSH 密钥的路径和文件名，例如`~/.ssh/id_ed25519`。如果您有现有的密钥对，请确保您的公钥位于您的`~/.ssh`目录中。

如果您计划安装一个使用已提交给 NIST 以进行 FIPS 140-2/140-3 验证的 RHEL 加密库的 OpenShift Container Platform 集群（仅限于x86_64、ppc64le和s390x架构），请不要创建使用ed25519算法的密钥。而是创建使用rsa或ecdsa算法的密钥。

查看 SSH 公钥
```
$ cat <path>/<file_name>.pub
```
例如，运行以下命令以查看~/.ssh/id_ed25519.pub公钥
```
$ cat ~/.ssh/id_ed25519.pub
```
如果尚未添加，请将 SSH 私钥标识添加到本地用户的 SSH 代理。SSH 代理对密钥的管理对于无需密码的 SSH 身份验证到您的集群节点是必需的，或者如果您想使用./openshift-install gather命令。

在某些发行版中，默认的 SSH 私钥标识（例如~/.ssh/id_rsa和~/.ssh/id_dsa）会自动管理。
1. 如果本地用户的ssh-agent进程尚未运行，请将其作为后台任务启动
  $ eval "$(ssh-agent -s)"
  示例输出：
  Agent pid 31874
  如果您的集群处于 FIPS 模式，则只能使用符合 FIPS 的算法来生成 SSH 密钥。密钥必须是 RSA 或 ECDSA。
将您的 SSH 私钥添加到ssh-agent
```
$ ssh-add <path>/<file_name> (1)
```
1 指定您的 SSH 私钥的路径和文件名，例如 ~/.ssh/id_ed25519
示例输出：
```
Identity added: /home/<you>/<path>/<file_name> (<computer_name>)
```

后续步骤

安装 OpenShift Container Platform 时，请向安装程序提供 SSH 公钥。如果您在您自己配置的基础设施上安装集群，则必须向安装程序提供密钥。

为 Azure 创建安装文件

要在 Microsoft Azure 上使用用户预配的基础设施安装 OpenShift Container Platform，您必须生成安装程序部署集群所需的多个文件，并对其进行修改，以便集群仅创建其将使用的机器。您需要生成和自定义 install-config.yaml 文件、Kubernetes 清单文件和 Ignition 配置文件。您还可以选择在安装准备阶段先设置一个单独的 var 分区。

可选：创建单独的 `/var` 分区

建议将 OpenShift Container Platform 的磁盘分区留给安装程序处理。但是，在某些情况下，您可能希望在您预期会增长的文件系统的一部分中创建单独的分区。

OpenShift Container Platform 支持添加单个分区以将存储附加到 /var 分区或 /var 的子目录。例如：

/var/lib/containers：保存与容器相关的可能随着向系统添加更多镜像和容器而增长的内容。
/var/lib/etcd：保存您可能出于性能优化 etcd 存储等目的而希望单独保存的数据。
/var：保存您可能出于审计等目的而希望单独保存的数据。

将 /var 目录的内容单独存储，可以更轻松地在需要时为这些区域增加存储空间，并在以后重新安装 OpenShift Container Platform 时保持数据完整。使用此方法，您无需再次拉取所有容器，也不需要在更新系统时复制海量的日志文件。

因为在全新安装 Red Hat Enterprise Linux CoreOS (RHCOS) 之前必须存在 /var，所以以下过程通过在 OpenShift Container Platform 安装的 openshift-install 准备阶段插入机器配置清单来设置单独的 /var 分区。

如果您按照此过程中的步骤创建单独的 /var 分区，则无需如本节后面所述再次创建 Kubernetes 清单文件和 Ignition 配置文件。

步骤

创建一个目录来保存 OpenShift Container Platform 安装文件
```
$ mkdir $HOME/clusterconfig
```

运行 openshift-install 以在 manifest 和 openshift 子目录中创建一组文件。根据提示回答系统问题。

$ openshift-install create manifests --dir $HOME/clusterconfig

示例输出：

? SSH Public Key ...
INFO Credentials loaded from the "myprofile" profile in file "/home/myuser/.aws/credentials"
INFO Consuming Install Config from target directory
INFO Manifests created in: $HOME/clusterconfig/manifests and $HOME/clusterconfig/openshift

可选：确认安装程序在 clusterconfig/openshift 目录中创建了清单文件。

$ ls $HOME/clusterconfig/openshift/

示例输出：

99_kubeadmin-password-secret.yaml
99_openshift-cluster-api_master-machines-0.yaml
99_openshift-cluster-api_master-machines-1.yaml
99_openshift-cluster-api_master-machines-2.yaml
...

创建一个 Butane 配置文件来配置附加分区。例如，将文件名命名为 $HOME/clusterconfig/98-var-partition.bu，将磁盘设备名称更改为 worker 系统上存储设备的名称，并根据需要设置存储大小。此示例将 /var 目录放在单独的分区上。

variant: openshift
version: 4.17.0
metadata:
  labels:
    machineconfiguration.openshift.io/role: worker
  name: 98-var-partition
storage:
  disks:
  - device: /dev/disk/by-id/<device_name> (1)
    partitions:
    - label: var
      start_mib: <partition_start_offset> (2)
      size_mib: <partition_size> (3)
      number: 5
  filesystems:
    - device: /dev/disk/by-partlabel/var
      path: /var
      format: xfs
      mount_options: [defaults, prjquota] (4)
      with_mount_unit: true

1	您要分区的磁盘的存储设备名称。
2	向引导磁盘添加数据分区时，建议最小值为 25000 MiB（兆字节）。根文件系统将自动调整大小以填充所有可用空间，直至指定的偏移量。如果未指定值，或者指定的值小于建议的最小值，则生成的根文件系统将太小，并且以后重新安装 RHCOS 可能会覆盖数据分区的开头。
3	数据分区的大小（以兆字节为单位）。
4	必须为用于容器存储的文件系统启用 `prjquota` 挂载选项。

创建单独的 /var 分区时，如果不同的实例类型没有相同的设备名称，则不能为工作节点使用不同的实例类型。

从 Butane 配置文件创建一个清单文件，并将其保存到 clusterconfig/openshift 目录。例如，运行以下命令：
```
$ butane $HOME/clusterconfig/98-var-partition.bu -o $HOME/clusterconfig/openshift/98-var-partition.yaml
```

再次运行 openshift-install 以从 manifest 和 openshift 子目录中的一组文件创建 Ignition 配置文件。

$ openshift-install create ignition-configs --dir $HOME/clusterconfig
$ ls $HOME/clusterconfig/
auth  bootstrap.ign  master.ign  metadata.json  worker.ign

现在，您可以将 Ignition 配置文件作为输入提供给安装过程，以安装 Red Hat Enterprise Linux CoreOS (RHCOS) 系统。

创建安装配置文件

您可以自定义您在 Microsoft Azure 上安装的 OpenShift Container Platform 集群。

先决条件

您拥有 OpenShift Container Platform 安装程序和集群的拉取密钥。
您拥有 Azure 订阅 ID 和租户 ID。
如果您使用服务主体安装集群，则拥有其应用程序 ID 和密码。
如果您使用系统分配的托管标识安装集群，则已在您将运行安装程序的虚拟机上启用它。
如果您使用用户分配的托管标识安装集群，则已满足以下先决条件：
- 您拥有其客户端 ID。
- 您已将其分配给您将运行安装程序的虚拟机。

步骤

可选：如果您之前在此计算机上运行过安装程序，并且想要使用替代的服务主体或托管标识，请转到 ~/.azure/ 目录并删除 osServicePrincipal.json 配置文件。

删除此文件可防止安装程序自动重用先前安装中的订阅和身份验证值。

创建 install-config.yaml 文件。

更改到包含安装程序的目录，然后运行以下命令：
```
$ ./openshift-install create install-config --dir <installation_directory> (1)
```
1 对于 <installation_directory>，请指定用于存储安装程序创建文件的目录名称。

指定目录时：
- 验证该目录是否具有 execute 权限。此权限是运行安装目录下的 Terraform 二进制文件所必需的。
- 使用空目录。某些安装资源（例如引导 X.509 证书）的过期时间间隔很短，因此您必须不要重用安装目录。如果您想重用另一个集群安装中的单个文件，您可以将它们复制到您的目录中。但是，安装资源的文件名在不同版本之间可能会发生变化。从早期 OpenShift Container Platform 版本复制安装文件时，请谨慎操作。

在提示符下，提供云的配置详细信息。

可选：选择一个 SSH 密钥来访问您的集群机器。

对于要执行安装调试或灾难恢复的生产 OpenShift Container Platform 集群，请指定您的 ssh-agent 进程使用的 SSH 密钥。
选择 **azure** 作为目标平台。

如果安装程序无法找到先前安装中的 osServicePrincipal.json 配置文件，则会提示您输入 Azure 订阅和身份验证值。
输入订阅的以下 Azure 参数值：
- **azure subscription id**：输入要用于集群的订阅 ID。
- **azure tenant id**：输入租户 ID。
根据您用于部署集群的 Azure 身份，在系统提示您输入 **azure service principal client id** 时执行以下操作之一：
- 如果您使用的是服务主体，请输入其应用程序 ID。
- 如果您使用的是系统分配的托管标识，请将此值留空。
- 如果您使用的是用户分配的托管标识，请指定其客户端 ID。
根据您用于部署集群的 Azure 身份，在系统提示您输入 **azure service principal client secret** 时执行以下操作之一：
- 如果您使用的是服务主体，请输入其密码。
- 如果您使用的是系统分配的托管标识，请将此值留空。
- 如果您使用的是用户分配的托管标识，请将此值留空。
选择要将集群部署到的区域。
选择要将集群部署到的基础域。基础域对应于您为集群创建的 Azure DNS 区域。

输入集群的描述性名称。

修改install-config.yaml文件。您可以在“安装配置参数”部分找到有关可用参数的更多信息。

如果您正在安装三节点集群，请确保将compute.replicas参数设置为0。这确保了集群的控制平面是可调度的。有关更多信息，请参阅“在 Azure 上安装三节点集群”。

备份install-config.yaml文件，以便您可以使用它来安装多个集群。

install-config.yaml文件在安装过程中被使用。如果您想重用此文件，您现在必须对其进行备份。

如果之前未检测到，安装程序会创建一个osServicePrincipal.json配置文件并将此文件存储在您计算机上的~/.azure/目录中。这确保了安装程序在目标平台上创建 OpenShift Container Platform 集群时可以加载配置文件。

在安装过程中配置集群范围的代理

生产环境可能会拒绝直接访问互联网，而是提供 HTTP 或 HTTPS 代理。您可以通过在install-config.yaml文件中配置代理设置来配置新的 OpenShift Container Platform 集群以使用代理。

先决条件

您已拥有现有的install-config.yaml文件。

您已查看集群需要访问的站点，并确定其中任何站点是否需要绕过代理。默认情况下，所有集群出口流量都使用代理，包括对托管云提供商 API 的调用。如果需要，您可以将站点添加到Proxy对象的spec.noProxy字段以绕过代理。

Proxy对象的status.noProxy字段填充了安装配置中networking.machineNetwork[].cidr、networking.clusterNetwork[].cidr和networking.serviceNetwork[]字段的值。

对于在 Amazon Web Services (AWS)、Google Cloud Platform (GCP)、Microsoft Azure 和 Red Hat OpenStack Platform (RHOSP) 上的安装，Proxy对象的status.noProxy字段还会填充实例元数据端点 (169.254.169.254)。

步骤

编辑您的install-config.yaml文件并添加代理设置。例如

apiVersion: v1
baseDomain: my.domain.com
proxy:
  httpProxy: http://<username>:<pswd>@<ip>:<port> (1)
  httpsProxy: https://<username>:<pswd>@<ip>:<port> (2)
  noProxy: example.com (3)
additionalTrustBundle: | (4)
    -----BEGIN CERTIFICATE-----
    <MY_TRUSTED_CA_CERT>
    -----END CERTIFICATE-----
additionalTrustBundlePolicy: <policy_to_add_additionalTrustBundle> (5)

1	用于创建集群外部 HTTP 连接的代理 URL。URL 方案必须为`http`。
2	用于创建集群外部 HTTPS 连接的代理 URL。
3	要从代理中排除的目标域名、IP 地址或其他网络 CIDR 的逗号分隔列表。在域名前加上`.`以仅匹配子域。例如，`.y.com`匹配`x.y.com`，但不匹配`y.com`。使用`*`绕过所有目标的代理。
4	如果提供，安装程序将生成一个名为`user-ca-bundle`的 config map，它位于`openshift-config`命名空间中，其中包含一个或多个用于代理 HTTPS 连接所需的附加 CA 证书。然后，集群网络操作员创建一个`trusted-ca-bundle` config map，将这些内容与 Red Hat Enterprise Linux CoreOS (RHCOS) 信任捆绑包合并，并且此 config map 在`Proxy`对象的`trustedCA`字段中引用。除非代理的身份证书由 RHCOS 信任捆绑包中的机构签名，否则需要`additionalTrustBundle`字段。
5	可选：确定`Proxy`对象的配置以在`trustedCA`字段中引用`user-ca-bundle` config map 的策略。允许的值为`Proxyonly`和`Always`。使用`Proxyonly`仅在配置`http/https`代理时引用`user-ca-bundle` config map。使用`Always`始终引用`user-ca-bundle` config map。默认值为`Proxyonly`。

安装程序不支持代理readinessEndpoints字段。

如果安装程序超时，请重新启动，然后使用安装程序的wait-for命令完成部署。例如

$ ./openshift-install wait-for install-complete --log-level debug

保存文件并在安装 OpenShift Container Platform 时引用它。

安装程序创建一个名为cluster的集群范围代理，该代理使用install-config.yaml文件中提供的代理设置。如果没有提供代理设置，仍然会创建cluster Proxy对象，但它将具有 nil spec。

仅支持名为cluster的Proxy对象，并且不能创建其他代理。

导出 ARM 模板的公共变量

您必须导出与提供的 Azure 资源管理器 (ARM) 模板一起使用的公共变量集，这些模板用于帮助完成在 Microsoft Azure 上的用户提供的基础设施安装。

特定的 ARM 模板也可能需要额外的导出变量，这些变量在其相关的过程中有详细说明。

先决条件

获取 OpenShift Container Platform 安装程序和集群的拉取密钥。

步骤

导出install-config.yaml中找到的公共变量，以便由提供的 ARM 模板使用

$ export CLUSTER_NAME=<cluster_name>(1)
$ export AZURE_REGION=<azure_region>(2)
$ export SSH_KEY=<ssh_key>(3)
$ export BASE_DOMAIN=<base_domain>(4)
$ export BASE_DOMAIN_RESOURCE_GROUP=<base_domain_resource_group>(5)

1	`install-config.yaml`文件中`.metadata.name`属性的值。
2	将集群部署到的区域，例如`centralus`。这是`install-config.yaml`文件中`.platform.azure.region`属性的值。
3	作为字符串的 SSH RSA 公钥文件。您必须将 SSH 密钥放在引号中，因为它包含空格。这是`install-config.yaml`文件中`.sshKey`属性的值。
4	将集群部署到的基础域。基础域对应于您为集群创建的公共 DNS 区域。这是`install-config.yaml`文件中`.baseDomain`属性的值。
5	公共 DNS 区域所在的资源组。这是`install-config.yaml`文件中`.platform.azure.baseDomainResourceGroupName`属性的值。

例如

$ export CLUSTER_NAME=test-cluster
$ export AZURE_REGION=centralus
$ export SSH_KEY="ssh-rsa xxx/xxx/xxx= [email protected]"
$ export BASE_DOMAIN=example.com
$ export BASE_DOMAIN_RESOURCE_GROUP=ocp-cluster

导出 kubeadmin 凭据
```
$ export KUBECONFIG=<installation_directory>/auth/kubeconfig (1)
```
1 对于<installation_directory>，请指定您存储安装文件的目录的路径。

创建 Kubernetes 清单和 Ignition 配置文件

因为您必须修改一些集群定义文件并手动启动集群机器，所以您必须生成集群配置机器所需的 Kubernetes 清单和 Ignition 配置文件。

安装配置文件转换为 Kubernetes 清单。清单打包到 Ignition 配置文件中，这些文件稍后用于配置集群机器。

OpenShift Container Platform 安装程序生成的 Ignition 配置文件包含在 24 小时后过期的证书，然后在该时间更新。如果在更新证书之前关闭集群，并在 24 小时后重新启动集群，则集群会自动恢复过期的证书。例外情况是，您必须手动批准挂起的node-bootstrapper证书签名请求 (CSR) 以恢复 kubelet 证书。有关更多信息，请参阅有关“从过期的控制平面证书中恢复”的文档。
建议您在生成 Ignition 配置文件后 12 小时内使用它们，因为 24 小时证书会在集群安装后 16 到 22 小时之间轮换。通过在 12 小时内使用 Ignition 配置文件，如果证书更新在安装期间运行，您可以避免安装失败。

先决条件

您已获得 OpenShift Container Platform 安装程序。
您已创建install-config.yaml安装配置文件。

步骤

更改到包含 OpenShift Container Platform 安装程序的目录，并为集群生成 Kubernetes 清单
```
$ ./openshift-install create manifests --dir <installation_directory> (1)
```
1 对于<installation_directory>，请指定包含您创建的install-config.yaml文件的安装目录。
删除定义控制平面机器的 Kubernetes 清单文件。
```
$ rm -f <installation_directory>/openshift/99_openshift-cluster-api_master-machines-*.yaml
```
删除这些文件可以防止集群自动生成控制平面机器。

删除定义控制平面机器集的 Kubernetes 清单文件。

$ rm -f <installation_directory>/openshift/99_openshift-machine-api_master-control-plane-machine-set.yaml

删除定义工作机器的 Kubernetes 清单文件。
```
$ rm -f <installation_directory>/openshift/99_openshift-cluster-api_worker-machineset-*.yaml
```
如果您在用户自备基础设施上安装集群时禁用了MachineAPI功能，则必须删除定义工作机器的 Kubernetes 清单文件。否则，您的集群安装将失败。

由于您自己创建和管理工作机器，因此无需初始化这些机器。

如果您正在安装一个三节点集群，请跳过以下步骤以允许控制平面节点可调度。

将控制平面节点配置从默认的不可调度更改为可调度时，需要额外的订阅。这是因为控制平面节点随后将成为计算节点。
检查<安装目录>/manifests/cluster-scheduler-02-config.yml Kubernetes 清单文件中mastersSchedulable参数是否设置为false。此设置可防止将 Pod 调度到控制平面机器上。
1. 打开<安装目录>/manifests/cluster-scheduler-02-config.yml文件。
2. 找到mastersSchedulable参数并确保将其设置为false。
3. 保存并退出文件。
可选：如果您不希望Ingress 运算符代表您创建 DNS 记录，请从<安装目录>/manifests/cluster-dns-02-config.yml DNS 配置文件中删除privateZone和publicZone部分。
```
apiVersion: config.openshift.io/v1
kind: DNS
metadata:
  creationTimestamp: null
  name: cluster
spec:
  baseDomain: example.openshift.com
  privateZone: (1)
    id: mycluster-100419-private-zone
  publicZone: (1)
    id: example.openshift.com
status: {}
```
1 完全删除此部分。

如果您这样做，则必须在后面的步骤中手动添加 Ingress DNS 记录。

在用户自备基础设施上配置 Azure 时，必须导出清单文件中定义的一些常用变量，以便稍后在 Azure 资源管理器 (ARM) 模板中使用。

使用以下命令导出基础设施 ID：

$ export INFRA_ID=<infra_id> (1)

1	OpenShift Container Platform 集群已分配一个标识符 (`INFRA_ID`)，其格式为`<集群名称>-<随机字符串>`。这将用作使用提供的 ARM 模板创建的大多数资源的基本名称。这是`manifests/cluster-infrastructure-02-config.yml`文件中`.status.infrastructureName`属性的值。

使用以下命令导出资源组：

$ export RESOURCE_GROUP=<resource_group> (1)

1	此 Azure 部署中创建的所有资源都作为资源组的一部分存在。资源组名称也基于`INFRA_ID`，格式为`<集群名称>-<随机字符串>-rg`。这是`manifests/cluster-infrastructure-02-config.yml`文件中`.status.platformStatus.azure.resourceGroupName`属性的值。

要创建 Ignition 配置文件，请从包含安装程序的目录运行以下命令：
```
$ ./openshift-install create ignition-configs --dir <installation_directory> (1)
```
1 对于<安装目录>，请指定相同的安装目录。

Ignition 配置文件是为安装目录中的引导程序、控制平面和计算节点创建的。kubeadmin-password和kubeconfig文件创建在./<安装目录>/auth目录中。
```
.
├── auth
│   ├── kubeadmin-password
│   └── kubeconfig
├── bootstrap.ign
├── master.ign
├── metadata.json
└── worker.ign
```

创建 Azure 资源组

您必须为您的 OpenShift Container Platform 集群在 Azure 上的安装创建一个 Microsoft Azure 资源组和一个标识。这两者都在安装过程中使用。

步骤

在受支持的 Azure 区域创建资源组。

$ az group create --name ${RESOURCE_GROUP} --location ${AZURE_REGION}

为资源组创建一个 Azure 标识。
```
$ az identity create -g ${RESOURCE_GROUP} -n ${INFRA_ID}-identity
```
这用于向集群中的运算符授予所需的访问权限。例如，这允许 Ingress 运算符创建公有 IP 及其负载均衡器。您必须将 Azure 标识分配给一个角色。

将贡献者角色授予 Azure 标识。

导出 Azure 角色分配所需的以下变量：

$ export PRINCIPAL_ID=`az identity show -g ${RESOURCE_GROUP} -n ${INFRA_ID}-identity --query principalId --out tsv`

$ export RESOURCE_GROUP_ID=`az group show -g ${RESOURCE_GROUP} --query id --out tsv`

将贡献者角色分配给标识。

$ az role assignment create --assignee "${PRINCIPAL_ID}" --role 'Contributor' --scope "${RESOURCE_GROUP_ID}"

如果您想将具有所有所需权限的自定义角色分配给标识，请运行以下命令：

$ az role assignment create --assignee "${PRINCIPAL_ID}" --role <custom_role> \ (1)
--scope "${RESOURCE_GROUP_ID}"

1	指定自定义角色名称。

上传 RHCOS 集群映像和引导 Ignition 配置文件

Azure 客户端不支持基于本地现有文件的部署。您必须将 RHCOS 虚拟硬盘 (VHD) 集群映像和引导 Ignition 配置文件复制并存储在存储容器中，以便在部署期间可以访问它们。

先决条件

为您的集群生成 Ignition 配置文件。

步骤

创建一个 Azure 存储帐户来存储 VHD 集群映像。

$ az storage account create -g ${RESOURCE_GROUP} --location ${AZURE_REGION} --name ${CLUSTER_NAME}sa --kind Storage --sku Standard_LRS

Azure 存储帐户名称的长度必须在 3 到 24 个字符之间，并且只能使用数字和小写字母。如果您的CLUSTER_NAME变量不符合这些限制，则必须手动定义 Azure 存储帐户名称。有关 Azure 存储帐户名称限制的更多信息，请参阅 Azure 文档中的解决存储帐户名称错误。

将存储帐户密钥导出为环境变量。

$ export ACCOUNT_KEY=`az storage account keys list -g ${RESOURCE_GROUP} --account-name ${CLUSTER_NAME}sa --query "[0].value" -o tsv`

将 RHCOS VHD 的 URL 导出为环境变量。

$ export VHD_URL=`openshift-install coreos print-stream-json | jq -r '.architectures.<architecture>."rhel-coreos-extensions"."azure-disk".url'`

其中

<架构>

指定架构，有效值为x86_64或aarch64。

RHCOS 映像可能不会随着每次 OpenShift Container Platform 版本的发布而更改。您必须指定一个版本号小于或等于您安装的 OpenShift Container Platform 版本的映像。如果可用，请使用与您的 OpenShift Container Platform 版本匹配的映像版本。

为 VHD 创建存储容器。

$ az storage container create --name vhd --account-name ${CLUSTER_NAME}sa --account-key ${ACCOUNT_KEY}

将本地 VHD 复制到 Blob。

$ az storage blob copy start --account-name ${CLUSTER_NAME}sa --account-key ${ACCOUNT_KEY} --destination-blob "rhcos.vhd" --destination-container vhd --source-uri "${VHD_URL}"

创建一个 Blob 存储容器并上传生成的bootstrap.ign文件。

$ az storage container create --name files --account-name ${CLUSTER_NAME}sa --account-key ${ACCOUNT_KEY}

$ az storage blob upload --account-name ${CLUSTER_NAME}sa --account-key ${ACCOUNT_KEY} -c "files" -f "<installation_directory>/bootstrap.ign" -n "bootstrap.ign"

创建 DNS 区域的示例

使用用户自备基础设施的集群需要 DNS 记录。您应该选择适合您场景的 DNS 策略。

在此示例中，使用了Azure 的 DNS 解决方案，因此您将为外部（互联网）可见性创建一个新的公共 DNS 区域，并为内部集群解析创建一个私有 DNS 区域。

公共 DNS 区域不需要与集群部署位于同一个资源组中，并且可能已存在于您组织中以用于所需的基域。如果是这种情况，您可以跳过创建公共 DNS 区域；请确保您之前生成的安装配置反映了这种情况。

步骤

在BASE_DOMAIN_RESOURCE_GROUP环境变量中导出的资源组中创建新的公共 DNS 区域。
```
$ az network dns zone create -g ${BASE_DOMAIN_RESOURCE_GROUP} -n ${CLUSTER_NAME}.${BASE_DOMAIN}
```
如果您使用的是已经存在的公共 DNS 区域，则可以跳过此步骤。

在与其余部署相同的资源组中创建私有 DNS 区域。

$ az network private-dns zone create -g ${RESOURCE_GROUP} -n ${CLUSTER_NAME}.${BASE_DOMAIN}

您可以通过访问该部分了解有关在 Azure 中配置公共 DNS 区域的更多信息。

在 Azure 中创建 VNet

您必须在 Microsoft Azure 中创建一个虚拟网络 (VNet)，供您的 OpenShift Container Platform 集群使用。您可以自定义 VNet 以满足您的需求。创建 VNet 的一种方法是修改提供的 Azure 资源管理器 (ARM) 模板。

如果您不使用提供的 ARM 模板创建 Azure 基础架构，则必须查看所提供的信息并手动创建基础架构。如果您的集群未正确初始化，您可能需要联系 Red Hat 支持并提供您的安装日志。

步骤

从本主题的**VNet 的 ARM 模板**部分复制模板，并将其保存为集群安装目录中的01_vnet.json。此模板描述了集群所需的 VNet。

使用az CLI 创建部署。

$ az deployment group create -g ${RESOURCE_GROUP} \
  --template-file "<installation_directory>/01_vnet.json" \
  --parameters baseName="${INFRA_ID}"(1)

1	要在资源名称中使用的基本名称；这通常是集群的基础架构 ID。

将 VNet 模板链接到私有 DNS 区域。

$ az network private-dns link vnet create -g ${RESOURCE_GROUP} -z ${CLUSTER_NAME}.${BASE_DOMAIN} -n ${INFRA_ID}-network-link -v "${INFRA_ID}-vnet" -e false

VNet 的 ARM 模板

您可以使用以下 Azure 资源管理器 (ARM) 模板部署 OpenShift Container Platform 集群所需的 VNet。

01_vnet.json ARM 模板

{
  "$schema" : "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
  "contentVersion" : "1.0.0.0",
  "parameters" : {
    "baseName" : {
      "type" : "string",
      "minLength" : 1,
      "metadata" : {
        "description" : "Base name to be used in resource names (usually the cluster's Infra ID)"
      }
    }
  },
  "variables" : {
    "location" : "[resourceGroup().location]",
    "virtualNetworkName" : "[concat(parameters('baseName'), '-vnet')]",
    "addressPrefix" : "10.0.0.0/16",
    "masterSubnetName" : "[concat(parameters('baseName'), '-master-subnet')]",
    "masterSubnetPrefix" : "10.0.0.0/24",
    "nodeSubnetName" : "[concat(parameters('baseName'), '-worker-subnet')]",
    "nodeSubnetPrefix" : "10.0.1.0/24",
    "clusterNsgName" : "[concat(parameters('baseName'), '-nsg')]"
  },
  "resources" : [
    {
      "apiVersion" : "2018-12-01",
      "type" : "Microsoft.Network/virtualNetworks",
      "name" : "[variables('virtualNetworkName')]",
      "location" : "[variables('location')]",
      "dependsOn" : [
        "[concat('Microsoft.Network/networkSecurityGroups/', variables('clusterNsgName'))]"
      ],
      "properties" : {
        "addressSpace" : {
          "addressPrefixes" : [
            "[variables('addressPrefix')]"
          ]
        },
        "subnets" : [
          {
            "name" : "[variables('masterSubnetName')]",
            "properties" : {
              "addressPrefix" : "[variables('masterSubnetPrefix')]",
              "serviceEndpoints": [],
              "networkSecurityGroup" : {
                "id" : "[resourceId('Microsoft.Network/networkSecurityGroups', variables('clusterNsgName'))]"
              }
            }
          },
          {
            "name" : "[variables('nodeSubnetName')]",
            "properties" : {
              "addressPrefix" : "[variables('nodeSubnetPrefix')]",
              "serviceEndpoints": [],
              "networkSecurityGroup" : {
                "id" : "[resourceId('Microsoft.Network/networkSecurityGroups', variables('clusterNsgName'))]"
              }
            }
          }
        ]
      }
    },
    {
      "type" : "Microsoft.Network/networkSecurityGroups",
      "name" : "[variables('clusterNsgName')]",
      "apiVersion" : "2018-10-01",
      "location" : "[variables('location')]",
      "properties" : {
        "securityRules" : [
          {
            "name" : "apiserver_in",
            "properties" : {
              "protocol" : "Tcp",
              "sourcePortRange" : "*",
              "destinationPortRange" : "6443",
              "sourceAddressPrefix" : "*",
              "destinationAddressPrefix" : "*",
              "access" : "Allow",
              "priority" : 101,
              "direction" : "Inbound"
            }
          }
        ]
      }
    }
  ]
}

部署 Azure 基础设施的 RHCOS 集群镜像

您必须为您的 OpenShift Container Platform 节点使用有效的 Red Hat Enterprise Linux CoreOS (RHCOS) Microsoft Azure 镜像。

先决条件

将 RHCOS 虚拟硬盘 (VHD) 集群镜像存储在 Azure 存储容器中。
将引导 Ignition 配置文件存储在 Azure 存储容器中。

步骤

从本主题的**镜像存储的 ARM 模板**部分复制模板，并将其保存为集群安装目录中的02_storage.json。此模板描述了集群所需的镜像存储。

将 RHCOS VHD Blob URL 导出为变量。

$ export VHD_BLOB_URL=`az storage blob url --account-name ${CLUSTER_NAME}sa --account-key ${ACCOUNT_KEY} -c vhd -n "rhcos.vhd" -o tsv`

部署集群镜像。

$ az deployment group create -g ${RESOURCE_GROUP} \
  --template-file "<installation_directory>/02_storage.json" \
  --parameters vhdBlobURL="${VHD_BLOB_URL}" \ (1)
  --parameters baseName="${INFRA_ID}" \ (2)
  --parameters storageAccount="${CLUSTER_NAME}sa" \ (3)
  --parameters architecture="<architecture>" (4)

1	用于创建主节点和工作节点的 RHCOS VHD 的 Blob URL。
2	要在资源名称中使用的基本名称；这通常是集群的基础架构 ID。
3	您的 Azure 存储帐户的名称。
4	指定系统架构。有效值为`x64`（默认值）或`Arm64`。

镜像存储的 ARM 模板

您可以使用以下 Azure 资源管理器 (ARM) 模板部署 OpenShift Container Platform 集群所需的 Red Hat Enterprise Linux CoreOS (RHCOS) 镜像。

02_storage.json ARM 模板

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "architecture": {
      "type": "string",
      "metadata": {
        "description": "The architecture of the Virtual Machines"
      },
      "defaultValue": "x64",
      "allowedValues": [
        "Arm64",
        "x64"
      ]
    },
    "baseName": {
      "type": "string",
      "minLength": 1,
      "metadata": {
        "description": "Base name to be used in resource names (usually the cluster's Infra ID)"
      }
    },
    "storageAccount": {
      "type": "string",
      "metadata": {
        "description": "The Storage Account name"
      }
    },
    "vhdBlobURL": {
      "type": "string",
      "metadata": {
        "description": "URL pointing to the blob where the VHD to be used to create master and worker machines is located"
      }
    }
  },
  "variables": {
    "location": "[resourceGroup().location]",
    "galleryName": "[concat('gallery_', replace(parameters('baseName'), '-', '_'))]",
    "imageName": "[parameters('baseName')]",
    "imageNameGen2": "[concat(parameters('baseName'), '-gen2')]",
    "imageRelease": "1.0.0"
  },
  "resources": [
    {
      "apiVersion": "2021-10-01",
      "type": "Microsoft.Compute/galleries",
      "name": "[variables('galleryName')]",
      "location": "[variables('location')]",
      "resources": [
        {
          "apiVersion": "2021-10-01",
          "type": "images",
          "name": "[variables('imageName')]",
          "location": "[variables('location')]",
          "dependsOn": [
            "[variables('galleryName')]"
          ],
          "properties": {
            "architecture": "[parameters('architecture')]",
            "hyperVGeneration": "V1",
            "identifier": {
              "offer": "rhcos",
              "publisher": "RedHat",
              "sku": "basic"
            },
            "osState": "Generalized",
            "osType": "Linux"
          },
          "resources": [
            {
              "apiVersion": "2021-10-01",
              "type": "versions",
              "name": "[variables('imageRelease')]",
              "location": "[variables('location')]",
              "dependsOn": [
                "[variables('imageName')]"
              ],
              "properties": {
                "publishingProfile": {
                  "storageAccountType": "Standard_LRS",
                  "targetRegions": [
                    {
                      "name": "[variables('location')]",
                      "regionalReplicaCount": "1"
                    }
                  ]
                },
                "storageProfile": {
                  "osDiskImage": {
                    "source": {
                      "id": "[resourceId('Microsoft.Storage/storageAccounts', parameters('storageAccount'))]",
                      "uri": "[parameters('vhdBlobURL')]"
                    }
                  }
                }
              }
            }
          ]
        },
        {
          "apiVersion": "2021-10-01",
          "type": "images",
          "name": "[variables('imageNameGen2')]",
          "location": "[variables('location')]",
          "dependsOn": [
            "[variables('galleryName')]"
          ],
          "properties": {
            "architecture": "[parameters('architecture')]",
            "hyperVGeneration": "V2",
            "identifier": {
              "offer": "rhcos-gen2",
              "publisher": "RedHat-gen2",
              "sku": "gen2"
            },
            "osState": "Generalized",
            "osType": "Linux"
          },
          "resources": [
            {
              "apiVersion": "2021-10-01",
              "type": "versions",
              "name": "[variables('imageRelease')]",
              "location": "[variables('location')]",
              "dependsOn": [
                "[variables('imageNameGen2')]"
              ],
              "properties": {
                "publishingProfile": {
                  "storageAccountType": "Standard_LRS",
                  "targetRegions": [
                    {
                      "name": "[variables('location')]",
                      "regionalReplicaCount": "1"
                    }
                  ]
                },
                "storageProfile": {
                  "osDiskImage": {
                    "source": {
                      "id": "[resourceId('Microsoft.Storage/storageAccounts', parameters('storageAccount'))]",
                      "uri": "[parameters('vhdBlobURL')]"
                    }
                  }
                }
              }
            }
          ]
        }
      ]
    }
  ]
}

用户预配基础设施的网络要求

所有 Red Hat Enterprise Linux CoreOS (RHCOS) 机器都需要在启动期间在initramfs中配置网络才能获取其 Ignition 配置文件。

网络连接要求

您必须配置机器之间的网络连接，以允许 OpenShift Container Platform 集群组件进行通信。每台机器必须能够解析集群中所有其他机器的主机名。

本节提供有关所需端口的详细信息。

在连接的 OpenShift Container Platform 环境中，所有节点都需要访问互联网才能提取平台容器的镜像并向 Red Hat 提供遥测数据。

表 3. 所有机器到所有机器通信使用的端口
协议	端口	描述
ICMP	N/A	网络可达性测试
TCP	`1936`	指标
	`9000`-`9999`	主机级服务，包括端口`9100`-`9101`上的节点导出器和端口`9099`上的集群版本运算符。
	`10250`-`10259`	Kubernetes 保留的默认端口
UDP	`4789`	VXLAN
	`6081`	Geneve
	`9000`-`9999`	主机级服务，包括端口`9100`-`9101`上的节点导出器。
	`500`	IPsec IKE 数据包
	`4500`	IPsec NAT-T 数据包
	`123`	UDP 端口`123`上的网络时间协议 (NTP) 如果配置了外部 NTP 时间服务器，则必须打开 UDP 端口`123`。
TCP/UDP	`30000`-`32767`	Kubernetes 节点端口
ESP	N/A	IPsec 封装安全负载 (ESP)

表 4. 所有机器到控制平面通信使用的端口
协议	端口	描述
TCP	`6443`	Kubernetes API

表 5. 控制平面机器到控制平面机器通信使用的端口
协议	端口	描述
TCP	`2379`-`2380`	etcd 服务器和对等端口

在 Azure 中创建网络和负载均衡组件

您必须在 Microsoft Azure 中配置网络和负载均衡，供您的 OpenShift Container Platform 集群使用。创建这些组件的一种方法是修改提供的 Azure 资源管理器 (ARM) 模板。

先决条件

在 Azure 中创建和配置 VNet 和关联的子网。

步骤

从本主题的**网络和负载均衡器的 ARM 模板**部分复制模板，并将其保存为集群安装目录中的03_infra.json。此模板描述了集群所需的网络和负载均衡对象。

使用az CLI 创建部署。

$ az deployment group create -g ${RESOURCE_GROUP} \
  --template-file "<installation_directory>/03_infra.json" \
  --parameters privateDNSZoneName="${CLUSTER_NAME}.${BASE_DOMAIN}" \ (1)
  --parameters baseName="${INFRA_ID}"(2)

1	私有 DNS 区域的名称。
2	要在资源名称中使用的基本名称；这通常是集群的基础架构 ID。

为 API 公共负载均衡器在公共区域中创建api DNS 记录。${BASE_DOMAIN_RESOURCE_GROUP}变量必须指向存在公共 DNS 区域的资源组。

导出以下变量。

$ export PUBLIC_IP=`az network public-ip list -g ${RESOURCE_GROUP} --query "[?name=='${INFRA_ID}-master-pip'] | [0].ipAddress" -o tsv`

在新公共区域中创建api DNS 记录。

$ az network dns record-set a add-record -g ${BASE_DOMAIN_RESOURCE_GROUP} -z ${CLUSTER_NAME}.${BASE_DOMAIN} -n api -a ${PUBLIC_IP} --ttl 60

如果您要将集群添加到现有公共区域，则可以改为在其上创建api DNS 记录。

$ az network dns record-set a add-record -g ${BASE_DOMAIN_RESOURCE_GROUP} -z ${BASE_DOMAIN} -n api.${CLUSTER_NAME} -a ${PUBLIC_IP} --ttl 60

网络和负载均衡器的 ARM 模板

您可以使用以下 Azure 资源管理器 (ARM) 模板部署 OpenShift Container Platform 集群所需的网络对象和负载均衡器。

03_infra.json ARM 模板

{
  "$schema" : "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
  "contentVersion" : "1.0.0.0",
  "parameters" : {
    "baseName" : {
      "type" : "string",
      "minLength" : 1,
      "metadata" : {
        "description" : "Base name to be used in resource names (usually the cluster's Infra ID)"
      }
    },
    "vnetBaseName": {
      "type": "string",
      "defaultValue": "",
      "metadata" : {
        "description" : "The specific customer vnet's base name (optional)"
      }
    },
    "privateDNSZoneName" : {
      "type" : "string",
      "metadata" : {
        "description" : "Name of the private DNS zone"
      }
    }
  },
  "variables" : {
    "location" : "[resourceGroup().location]",
    "virtualNetworkName" : "[concat(if(not(empty(parameters('vnetBaseName'))), parameters('vnetBaseName'), parameters('baseName')), '-vnet')]",
    "virtualNetworkID" : "[resourceId('Microsoft.Network/virtualNetworks', variables('virtualNetworkName'))]",
    "masterSubnetName" : "[concat(if(not(empty(parameters('vnetBaseName'))), parameters('vnetBaseName'), parameters('baseName')), '-master-subnet')]",
    "masterSubnetRef" : "[concat(variables('virtualNetworkID'), '/subnets/', variables('masterSubnetName'))]",
    "masterPublicIpAddressName" : "[concat(parameters('baseName'), '-master-pip')]",
    "masterPublicIpAddressID" : "[resourceId('Microsoft.Network/publicIPAddresses', variables('masterPublicIpAddressName'))]",
    "masterLoadBalancerName" : "[parameters('baseName')]",
    "masterLoadBalancerID" : "[resourceId('Microsoft.Network/loadBalancers', variables('masterLoadBalancerName'))]",
    "internalLoadBalancerName" : "[concat(parameters('baseName'), '-internal-lb')]",
    "internalLoadBalancerID" : "[resourceId('Microsoft.Network/loadBalancers', variables('internalLoadBalancerName'))]",
    "skuName": "Standard"
  },
  "resources" : [
    {
      "apiVersion" : "2018-12-01",
      "type" : "Microsoft.Network/publicIPAddresses",
      "name" : "[variables('masterPublicIpAddressName')]",
      "location" : "[variables('location')]",
      "sku": {
        "name": "[variables('skuName')]"
      },
      "properties" : {
        "publicIPAllocationMethod" : "Static",
        "dnsSettings" : {
          "domainNameLabel" : "[variables('masterPublicIpAddressName')]"
        }
      }
    },
    {
      "apiVersion" : "2018-12-01",
      "type" : "Microsoft.Network/loadBalancers",
      "name" : "[variables('masterLoadBalancerName')]",
      "location" : "[variables('location')]",
      "sku": {
        "name": "[variables('skuName')]"
      },
      "dependsOn" : [
        "[concat('Microsoft.Network/publicIPAddresses/', variables('masterPublicIpAddressName'))]"
      ],
      "properties" : {
        "frontendIPConfigurations" : [
          {
            "name" : "public-lb-ip-v4",
            "properties" : {
              "publicIPAddress" : {
                "id" : "[variables('masterPublicIpAddressID')]"
              }
            }
          }
        ],
        "backendAddressPools" : [
          {
            "name" : "[variables('masterLoadBalancerName')]"
          }
        ],
        "loadBalancingRules" : [
          {
            "name" : "api-internal",
            "properties" : {
              "frontendIPConfiguration" : {
                "id" :"[concat(variables('masterLoadBalancerID'), '/frontendIPConfigurations/public-lb-ip-v4')]"
              },
              "backendAddressPool" : {
                "id" : "[concat(variables('masterLoadBalancerID'), '/backendAddressPools/', variables('masterLoadBalancerName'))]"
              },
              "protocol" : "Tcp",
              "loadDistribution" : "Default",
              "idleTimeoutInMinutes" : 30,
              "frontendPort" : 6443,
              "backendPort" : 6443,
              "probe" : {
                "id" : "[concat(variables('masterLoadBalancerID'), '/probes/api-internal-probe')]"
              }
            }
          }
        ],
        "probes" : [
          {
            "name" : "api-internal-probe",
            "properties" : {
              "protocol" : "Https",
              "port" : 6443,
              "requestPath": "/readyz",
              "intervalInSeconds" : 10,
              "numberOfProbes" : 3
            }
          }
        ]
      }
    },
    {
      "apiVersion" : "2018-12-01",
      "type" : "Microsoft.Network/loadBalancers",
      "name" : "[variables('internalLoadBalancerName')]",
      "location" : "[variables('location')]",
      "sku": {
        "name": "[variables('skuName')]"
      },
      "properties" : {
        "frontendIPConfigurations" : [
          {
            "name" : "internal-lb-ip",
            "properties" : {
              "privateIPAllocationMethod" : "Dynamic",
              "subnet" : {
                "id" : "[variables('masterSubnetRef')]"
              },
              "privateIPAddressVersion" : "IPv4"
            }
          }
        ],
        "backendAddressPools" : [
          {
            "name" : "internal-lb-backend"
          }
        ],
        "loadBalancingRules" : [
          {
            "name" : "api-internal",
            "properties" : {
              "frontendIPConfiguration" : {
                "id" : "[concat(variables('internalLoadBalancerID'), '/frontendIPConfigurations/internal-lb-ip')]"
              },
              "frontendPort" : 6443,
              "backendPort" : 6443,
              "enableFloatingIP" : false,
              "idleTimeoutInMinutes" : 30,
              "protocol" : "Tcp",
              "enableTcpReset" : false,
              "loadDistribution" : "Default",
              "backendAddressPool" : {
                "id" : "[concat(variables('internalLoadBalancerID'), '/backendAddressPools/internal-lb-backend')]"
              },
              "probe" : {
                "id" : "[concat(variables('internalLoadBalancerID'), '/probes/api-internal-probe')]"
              }
            }
          },
          {
            "name" : "sint",
            "properties" : {
              "frontendIPConfiguration" : {
                "id" : "[concat(variables('internalLoadBalancerID'), '/frontendIPConfigurations/internal-lb-ip')]"
              },
              "frontendPort" : 22623,
              "backendPort" : 22623,
              "enableFloatingIP" : false,
              "idleTimeoutInMinutes" : 30,
              "protocol" : "Tcp",
              "enableTcpReset" : false,
              "loadDistribution" : "Default",
              "backendAddressPool" : {
                "id" : "[concat(variables('internalLoadBalancerID'), '/backendAddressPools/internal-lb-backend')]"
              },
              "probe" : {
                "id" : "[concat(variables('internalLoadBalancerID'), '/probes/sint-probe')]"
              }
            }
          }
        ],
        "probes" : [
          {
            "name" : "api-internal-probe",
            "properties" : {
              "protocol" : "Https",
              "port" : 6443,
              "requestPath": "/readyz",
              "intervalInSeconds" : 10,
              "numberOfProbes" : 3
            }
          },
          {
            "name" : "sint-probe",
            "properties" : {
              "protocol" : "Https",
              "port" : 22623,
              "requestPath": "/healthz",
              "intervalInSeconds" : 10,
              "numberOfProbes" : 3
            }
          }
        ]
      }
    },
    {
      "apiVersion": "2018-09-01",
      "type": "Microsoft.Network/privateDnsZones/A",
      "name": "[concat(parameters('privateDNSZoneName'), '/api')]",
      "location" : "[variables('location')]",
      "dependsOn" : [
        "[concat('Microsoft.Network/loadBalancers/', variables('internalLoadBalancerName'))]"
      ],
      "properties": {
        "ttl": 60,
        "aRecords": [
          {
            "ipv4Address": "[reference(variables('internalLoadBalancerName')).frontendIPConfigurations[0].properties.privateIPAddress]"
          }
        ]
      }
    },
    {
      "apiVersion": "2018-09-01",
      "type": "Microsoft.Network/privateDnsZones/A",
      "name": "[concat(parameters('privateDNSZoneName'), '/api-int')]",
      "location" : "[variables('location')]",
      "dependsOn" : [
        "[concat('Microsoft.Network/loadBalancers/', variables('internalLoadBalancerName'))]"
      ],
      "properties": {
        "ttl": 60,
        "aRecords": [
          {
            "ipv4Address": "[reference(variables('internalLoadBalancerName')).frontendIPConfigurations[0].properties.privateIPAddress]"
          }
        ]
      }
    }
  ]
}

在 Azure 中创建引导机器

您必须在 Microsoft Azure 中创建引导机器，以便在 OpenShift Container Platform 集群初始化期间使用。创建此机器的一种方法是修改提供的 Azure 资源管理器 (ARM) 模板。

如果您不使用提供的 ARM 模板创建引导机器，则必须查看所提供的信息并手动创建基础架构。如果您的集群未正确初始化，您可能需要联系 Red Hat 支持并提供您的安装日志。

先决条件

在 Azure 中创建和配置网络和负载均衡器。
创建 Azure 标识并授予相应的角色。

步骤

从本主题的**引导机器的 ARM 模板**部分复制模板，并将其保存为集群安装目录中的04_bootstrap.json。此模板描述了集群所需的引导机器。

导出引导 URL 变量。

$ bootstrap_url_expiry=`date -u -d "10 hours" '+%Y-%m-%dT%H:%MZ'`

$ export BOOTSTRAP_URL=`az storage blob generate-sas -c 'files' -n 'bootstrap.ign' --https-only --full-uri --permissions r --expiry $bootstrap_url_expiry --account-name ${CLUSTER_NAME}sa --account-key ${ACCOUNT_KEY} -o tsv`

导出引导 Ignition 变量。

$ export BOOTSTRAP_IGNITION=`jq -rcnM --arg v "3.2.0" --arg url ${BOOTSTRAP_URL} '{ignition:{version:$v,config:{replace:{source:$url}}}}' | base64 | tr -d '\n'`

使用az CLI 创建部署。

$ az deployment group create -g ${RESOURCE_GROUP} \
  --template-file "<installation_directory>/04_bootstrap.json" \
  --parameters bootstrapIgnition="${BOOTSTRAP_IGNITION}" \ (1)
  --parameters baseName="${INFRA_ID}" \ (2)
  --parameter bootstrapVMSize="Standard_D4s_v3" (3)

1	引导集群的引导 Ignition 内容。
2	要在资源名称中使用的基本名称；这通常是集群的基础架构 ID。
3	可选：指定引导虚拟机的尺寸。使用与您指定的架构兼容的虚拟机尺寸。如果未定义此值，则设置模板中的默认值。

引导机器的 ARM 模板

您可以使用以下 Azure 资源管理器 (ARM) 模板部署 OpenShift Container Platform 集群所需的引导机器。

04_bootstrap.json ARM 模板

{
  "$schema" : "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
  "contentVersion" : "1.0.0.0",
  "parameters" : {
    "baseName" : {
      "type" : "string",
      "minLength" : 1,
      "metadata" : {
        "description" : "Base name to be used in resource names (usually the cluster's Infra ID)"
      }
    },
    "vnetBaseName": {
      "type": "string",
      "defaultValue": "",
      "metadata" : {
        "description" : "The specific customer vnet's base name (optional)"
      }
    },
    "bootstrapIgnition" : {
      "type" : "string",
      "minLength" : 1,
      "metadata" : {
        "description" : "Bootstrap ignition content for the bootstrap cluster"
      }
    },
    "sshKeyData" : {
      "type" : "securestring",
      "defaultValue" : "Unused",
      "metadata" : {
        "description" : "Unused"
      }
    },
    "bootstrapVMSize" : {
      "type" : "string",
      "defaultValue" : "Standard_D4s_v3",
      "metadata" : {
        "description" : "The size of the Bootstrap Virtual Machine"
      }
    },
    "hyperVGen": {
      "type": "string",
      "metadata": {
        "description": "VM generation image to use"
      },
      "defaultValue": "V2",
      "allowedValues": [
        "V1",
        "V2"
      ]
    }
  },
  "variables" : {
    "location" : "[resourceGroup().location]",
    "virtualNetworkName" : "[concat(if(not(empty(parameters('vnetBaseName'))), parameters('vnetBaseName'), parameters('baseName')), '-vnet')]",
    "virtualNetworkID" : "[resourceId('Microsoft.Network/virtualNetworks', variables('virtualNetworkName'))]",
    "masterSubnetName" : "[concat(if(not(empty(parameters('vnetBaseName'))), parameters('vnetBaseName'), parameters('baseName')), '-master-subnet')]",
    "masterSubnetRef" : "[concat(variables('virtualNetworkID'), '/subnets/', variables('masterSubnetName'))]",
    "masterLoadBalancerName" : "[parameters('baseName')]",
    "internalLoadBalancerName" : "[concat(parameters('baseName'), '-internal-lb')]",
    "sshKeyPath" : "/home/core/.ssh/authorized_keys",
    "identityName" : "[concat(parameters('baseName'), '-identity')]",
    "vmName" : "[concat(parameters('baseName'), '-bootstrap')]",
    "nicName" : "[concat(variables('vmName'), '-nic')]",
    "galleryName": "[concat('gallery_', replace(parameters('baseName'), '-', '_'))]",
    "imageName" : "[concat(parameters('baseName'), if(equals(parameters('hyperVGen'), 'V2'), '-gen2', ''))]",
    "clusterNsgName" : "[concat(if(not(empty(parameters('vnetBaseName'))), parameters('vnetBaseName'), parameters('baseName')), '-nsg')]",
    "sshPublicIpAddressName" : "[concat(variables('vmName'), '-ssh-pip')]"
  },
  "resources" : [
    {
      "apiVersion" : "2018-12-01",
      "type" : "Microsoft.Network/publicIPAddresses",
      "name" : "[variables('sshPublicIpAddressName')]",
      "location" : "[variables('location')]",
      "sku": {
        "name": "Standard"
      },
      "properties" : {
        "publicIPAllocationMethod" : "Static",
        "dnsSettings" : {
          "domainNameLabel" : "[variables('sshPublicIpAddressName')]"
        }
      }
    },
    {
      "apiVersion" : "2018-06-01",
      "type" : "Microsoft.Network/networkInterfaces",
      "name" : "[variables('nicName')]",
      "location" : "[variables('location')]",
      "dependsOn" : [
        "[resourceId('Microsoft.Network/publicIPAddresses', variables('sshPublicIpAddressName'))]"
      ],
      "properties" : {
        "ipConfigurations" : [
          {
            "name" : "pipConfig",
            "properties" : {
              "privateIPAllocationMethod" : "Dynamic",
              "publicIPAddress": {
                "id": "[resourceId('Microsoft.Network/publicIPAddresses', variables('sshPublicIpAddressName'))]"
              },
              "subnet" : {
                "id" : "[variables('masterSubnetRef')]"
              },
              "loadBalancerBackendAddressPools" : [
                {
                  "id" : "[concat('/subscriptions/', subscription().subscriptionId, '/resourceGroups/', resourceGroup().name, '/providers/Microsoft.Network/loadBalancers/', variables('masterLoadBalancerName'), '/backendAddressPools/', variables('masterLoadBalancerName'))]"
                },
                {
                  "id" : "[concat('/subscriptions/', subscription().subscriptionId, '/resourceGroups/', resourceGroup().name, '/providers/Microsoft.Network/loadBalancers/', variables('internalLoadBalancerName'), '/backendAddressPools/internal-lb-backend')]"
                }
              ]
            }
          }
        ]
      }
    },
    {
      "apiVersion" : "2018-06-01",
      "type" : "Microsoft.Compute/virtualMachines",
      "name" : "[variables('vmName')]",
      "location" : "[variables('location')]",
      "identity" : {
        "type" : "userAssigned",
        "userAssignedIdentities" : {
          "[resourceID('Microsoft.ManagedIdentity/userAssignedIdentities/', variables('identityName'))]" : {}
        }
      },
      "dependsOn" : [
        "[concat('Microsoft.Network/networkInterfaces/', variables('nicName'))]"
      ],
      "properties" : {
        "hardwareProfile" : {
          "vmSize" : "[parameters('bootstrapVMSize')]"
        },
        "osProfile" : {
          "computerName" : "[variables('vmName')]",
          "adminUsername" : "core",
          "adminPassword" : "NotActuallyApplied!",
          "customData" : "[parameters('bootstrapIgnition')]",
          "linuxConfiguration" : {
            "disablePasswordAuthentication" : false
          }
        },
        "storageProfile" : {
          "imageReference": {
            "id": "[resourceId('Microsoft.Compute/galleries/images', variables('galleryName'), variables('imageName'))]"
          },
          "osDisk" : {
            "name": "[concat(variables('vmName'),'_OSDisk')]",
            "osType" : "Linux",
            "createOption" : "FromImage",
            "managedDisk": {
              "storageAccountType": "Premium_LRS"
            },
            "diskSizeGB" : 100
          }
        },
        "networkProfile" : {
          "networkInterfaces" : [
            {
              "id" : "[resourceId('Microsoft.Network/networkInterfaces', variables('nicName'))]"
            }
          ]
        }
      }
    },
    {
      "apiVersion" : "2018-06-01",
      "type": "Microsoft.Network/networkSecurityGroups/securityRules",
      "name" : "[concat(variables('clusterNsgName'), '/bootstrap_ssh_in')]",
      "location" : "[variables('location')]",
      "dependsOn" : [
        "[resourceId('Microsoft.Compute/virtualMachines', variables('vmName'))]"
      ],
      "properties": {
        "protocol" : "Tcp",
        "sourcePortRange" : "*",
        "destinationPortRange" : "22",
        "sourceAddressPrefix" : "*",
        "destinationAddressPrefix" : "*",
        "access" : "Allow",
        "priority" : 100,
        "direction" : "Inbound"
      }
    }
  ]
}

在 Azure 中创建控制平面机器

您必须在 Microsoft Azure 中创建控制平面机器，供您的集群使用。创建这些机器的一种方法是修改提供的 Azure 资源管理器 (ARM) 模板。

默认情况下，Microsoft Azure 会将控制平面机器和计算机器放置在预设的可用区中。您可以手动为计算节点或控制平面节点设置可用区。为此，请修改供应商的 Azure 资源管理器 (ARM) 模板，在虚拟机资源的zones参数中指定每个可用区。

如果您不使用提供的 ARM 模板创建控制平面机器，则必须查看提供的资料并手动创建基础设施。如果您的集群未正确初始化，请考虑联系 Red Hat 支持并提供您的安装日志。

先决条件

创建引导机器。

步骤

从本主题的**控制平面机器的 ARM 模板**部分复制模板，并将其另存为集群安装目录中的05_masters.json。此模板描述了集群所需的控制平面机器。

导出控制平面机器部署所需的以下变量

$ export MASTER_IGNITION=`cat <installation_directory>/master.ign | base64 | tr -d '\n'`

使用az CLI 创建部署。

$ az deployment group create -g ${RESOURCE_GROUP} \
  --template-file "<installation_directory>/05_masters.json" \
  --parameters masterIgnition="${MASTER_IGNITION}" \ (1)
  --parameters baseName="${INFRA_ID}" \ (2)
  --parameters masterVMSize="Standard_D8s_v3" (3)

1	控制平面节点的 Ignition 内容。
2	要在资源名称中使用的基本名称；这通常是集群的基础架构 ID。
3	可选：指定控制平面虚拟机的尺寸。使用与您指定的架构兼容的虚拟机尺寸。如果未定义此值，则使用模板中的默认值。

控制平面机器的 ARM 模板

您可以使用以下 Azure 资源管理器 (ARM) 模板部署 OpenShift Container Platform 集群所需的控制平面机器

05_masters.json ARM 模板

{
  "$schema" : "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
  "contentVersion" : "1.0.0.0",
  "parameters" : {
    "baseName" : {
      "type" : "string",
      "minLength" : 1,
      "metadata" : {
        "description" : "Base name to be used in resource names (usually the cluster's Infra ID)"
      }
    },
    "vnetBaseName": {
      "type": "string",
      "defaultValue": "",
      "metadata" : {
        "description" : "The specific customer vnet's base name (optional)"
      }
    },
    "masterIgnition" : {
      "type" : "string",
      "metadata" : {
        "description" : "Ignition content for the master nodes"
      }
    },
    "numberOfMasters" : {
      "type" : "int",
      "defaultValue" : 3,
      "minValue" : 2,
      "maxValue" : 30,
      "metadata" : {
        "description" : "Number of OpenShift masters to deploy"
      }
    },
    "sshKeyData" : {
      "type" : "securestring",
      "defaultValue" : "Unused",
      "metadata" : {
        "description" : "Unused"
      }
    },
    "privateDNSZoneName" : {
      "type" : "string",
      "defaultValue" : "",
      "metadata" : {
        "description" : "unused"
      }
    },
    "masterVMSize" : {
      "type" : "string",
      "defaultValue" : "Standard_D8s_v3",
      "metadata" : {
        "description" : "The size of the Master Virtual Machines"
      }
    },
    "diskSizeGB" : {
      "type" : "int",
      "defaultValue" : 1024,
      "metadata" : {
        "description" : "Size of the Master VM OS disk, in GB"
      }
    },
    "hyperVGen": {
      "type": "string",
      "metadata": {
        "description": "VM generation image to use"
      },
      "defaultValue": "V2",
      "allowedValues": [
        "V1",
        "V2"
      ]
    }
  },
  "variables" : {
    "location" : "[resourceGroup().location]",
    "virtualNetworkName" : "[concat(if(not(empty(parameters('vnetBaseName'))), parameters('vnetBaseName'), parameters('baseName')), '-vnet')]",
    "virtualNetworkID" : "[resourceId('Microsoft.Network/virtualNetworks', variables('virtualNetworkName'))]",
    "masterSubnetName" : "[concat(if(not(empty(parameters('vnetBaseName'))), parameters('vnetBaseName'), parameters('baseName')), '-master-subnet')]",
    "masterSubnetRef" : "[concat(variables('virtualNetworkID'), '/subnets/', variables('masterSubnetName'))]",
    "masterLoadBalancerName" : "[parameters('baseName')]",
    "internalLoadBalancerName" : "[concat(parameters('baseName'), '-internal-lb')]",
    "sshKeyPath" : "/home/core/.ssh/authorized_keys",
    "identityName" : "[concat(parameters('baseName'), '-identity')]",
    "galleryName": "[concat('gallery_', replace(parameters('baseName'), '-', '_'))]",
    "imageName" : "[concat(parameters('baseName'), if(equals(parameters('hyperVGen'), 'V2'), '-gen2', ''))]",
    "copy" : [
      {
        "name" : "vmNames",
        "count" :  "[parameters('numberOfMasters')]",
        "input" : "[concat(parameters('baseName'), '-master-', copyIndex('vmNames'))]"
      }
    ]
  },
  "resources" : [
    {
      "apiVersion" : "2018-06-01",
      "type" : "Microsoft.Network/networkInterfaces",
      "copy" : {
        "name" : "nicCopy",
        "count" : "[length(variables('vmNames'))]"
      },
      "name" : "[concat(variables('vmNames')[copyIndex()], '-nic')]",
      "location" : "[variables('location')]",
      "properties" : {
        "ipConfigurations" : [
          {
            "name" : "pipConfig",
            "properties" : {
              "privateIPAllocationMethod" : "Dynamic",
              "subnet" : {
                "id" : "[variables('masterSubnetRef')]"
              },
              "loadBalancerBackendAddressPools" : [
                {
                  "id" : "[concat('/subscriptions/', subscription().subscriptionId, '/resourceGroups/', resourceGroup().name, '/providers/Microsoft.Network/loadBalancers/', variables('masterLoadBalancerName'), '/backendAddressPools/', variables('masterLoadBalancerName'))]"
                },
                {
                  "id" : "[concat('/subscriptions/', subscription().subscriptionId, '/resourceGroups/', resourceGroup().name, '/providers/Microsoft.Network/loadBalancers/', variables('internalLoadBalancerName'), '/backendAddressPools/internal-lb-backend')]"
                }
              ]
            }
          }
        ]
      }
    },
    {
      "apiVersion" : "2018-06-01",
      "type" : "Microsoft.Compute/virtualMachines",
      "copy" : {
        "name" : "vmCopy",
        "count" : "[length(variables('vmNames'))]"
      },
      "name" : "[variables('vmNames')[copyIndex()]]",
      "location" : "[variables('location')]",
      "identity" : {
        "type" : "userAssigned",
        "userAssignedIdentities" : {
          "[resourceID('Microsoft.ManagedIdentity/userAssignedIdentities/', variables('identityName'))]" : {}
        }
      },
      "dependsOn" : [
        "[concat('Microsoft.Network/networkInterfaces/', concat(variables('vmNames')[copyIndex()], '-nic'))]"
      ],
      "properties" : {
        "hardwareProfile" : {
          "vmSize" : "[parameters('masterVMSize')]"
        },
        "osProfile" : {
          "computerName" : "[variables('vmNames')[copyIndex()]]",
          "adminUsername" : "core",
          "adminPassword" : "NotActuallyApplied!",
          "customData" : "[parameters('masterIgnition')]",
          "linuxConfiguration" : {
            "disablePasswordAuthentication" : false
          }
        },
        "storageProfile" : {
          "imageReference": {
            "id": "[resourceId('Microsoft.Compute/galleries/images', variables('galleryName'), variables('imageName'))]"
          },
          "osDisk" : {
            "name": "[concat(variables('vmNames')[copyIndex()], '_OSDisk')]",
            "osType" : "Linux",
            "createOption" : "FromImage",
            "caching": "ReadOnly",
            "writeAcceleratorEnabled": false,
            "managedDisk": {
              "storageAccountType": "Premium_LRS"
            },
            "diskSizeGB" : "[parameters('diskSizeGB')]"
          }
        },
        "networkProfile" : {
          "networkInterfaces" : [
            {
              "id" : "[resourceId('Microsoft.Network/networkInterfaces', concat(variables('vmNames')[copyIndex()], '-nic'))]",
              "properties": {
                "primary": false
              }
            }
          ]
        }
      }
    }
  ]
}

等待引导完成并在 Azure 中删除引导资源

在 Microsoft Azure 中创建所有必需的基础设施后，请等待使用安装程序生成的 Ignition 配置文件预配的机器上的引导过程完成。

先决条件

创建控制平面机器。

步骤

更改到包含安装程序的目录，然后运行以下命令：
```
$ ./openshift-install wait-for bootstrap-complete --dir <installation_directory> \ (1)
    --log-level info (2)
```
1 对于<installation_directory>，请指定您存储安装文件的目录的路径。

2 要查看不同的安装详细信息，请指定warn、debug或error代替info。

如果命令退出时没有FATAL警告，则您的生产控制平面已初始化。

删除引导资源

$ az network nsg rule delete -g ${RESOURCE_GROUP} --nsg-name ${INFRA_ID}-nsg --name bootstrap_ssh_in
$ az vm stop -g ${RESOURCE_GROUP} --name ${INFRA_ID}-bootstrap
$ az vm deallocate -g ${RESOURCE_GROUP} --name ${INFRA_ID}-bootstrap
$ az vm delete -g ${RESOURCE_GROUP} --name ${INFRA_ID}-bootstrap --yes
$ az disk delete -g ${RESOURCE_GROUP} --name ${INFRA_ID}-bootstrap_OSDisk --no-wait --yes
$ az network nic delete -g ${RESOURCE_GROUP} --name ${INFRA_ID}-bootstrap-nic --no-wait
$ az storage blob delete --account-key ${ACCOUNT_KEY} --account-name ${CLUSTER_NAME}sa --container-name files --name bootstrap.ign
$ az network public-ip delete -g ${RESOURCE_GROUP} --name ${INFRA_ID}-bootstrap-ssh-pip

如果不删除引导服务器，则安装可能会失败，因为 API 流量会被路由到引导服务器。

在 Azure 中创建额外的计算节点机器

您可以通过单独启动实例或通过集群外部的自动化流程（例如自动缩放组）在 Microsoft Azure 中为集群创建计算节点机器。您还可以利用 OpenShift Container Platform 中内置的集群缩放机制和机器 API。

如果您正在安装三节点集群，请跳过此步骤。三节点集群由三个控制平面机器组成，它们也充当计算机器。

在此示例中，您使用 Azure 资源管理器 (ARM) 模板手动启动一个实例。可以通过在文件中包含更多类型为06_workers.json的资源来启动其他实例。

默认情况下，Microsoft Azure 会将控制平面机器和计算机器放置在预设的可用区中。您可以手动为计算节点或控制平面节点设置可用区。为此，请修改供应商的 ARM 模板，在虚拟机资源的zones参数中指定每个可用区。

步骤

从本主题的**计算节点机器的 ARM 模板**部分复制模板，并将其另存为集群安装目录中的06_workers.json。此模板描述了集群所需的计算节点机器。

导出计算节点机器部署所需的以下变量

$ export WORKER_IGNITION=`cat <installation_directory>/worker.ign | base64 | tr -d '\n'`

使用az CLI 创建部署。

$ az deployment group create -g ${RESOURCE_GROUP} \
  --template-file "<installation_directory>/06_workers.json" \
  --parameters workerIgnition="${WORKER_IGNITION}" \ (1)
  --parameters baseName="${INFRA_ID}" \ (2)
  --parameters nodeVMSize="Standard_D4s_v3" (3)

1	计算节点的 Ignition 内容。
2	要在资源名称中使用的基本名称；这通常是集群的基础架构 ID。
3	可选：指定计算节点虚拟机的尺寸。使用与您指定的架构兼容的虚拟机尺寸。如果未定义此值，则使用模板中的默认值。

计算节点机器的 ARM 模板

您可以使用以下 Azure 资源管理器 (ARM) 模板部署 OpenShift Container Platform 集群所需的计算节点机器

06_workers.json ARM 模板

{
  "$schema" : "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
  "contentVersion" : "1.0.0.0",
  "parameters" : {
    "baseName" : {
      "type" : "string",
      "minLength" : 1,
      "metadata" : {
        "description" : "Base name to be used in resource names (usually the cluster's Infra ID)"
      }
    },
    "vnetBaseName": {
      "type": "string",
      "defaultValue": "",
      "metadata" : {
        "description" : "The specific customer vnet's base name (optional)"
      }
    },
    "workerIgnition" : {
      "type" : "string",
      "metadata" : {
        "description" : "Ignition content for the worker nodes"
      }
    },
    "numberOfNodes" : {
      "type" : "int",
      "defaultValue" : 3,
      "minValue" : 2,
      "maxValue" : 30,
      "metadata" : {
        "description" : "Number of OpenShift compute nodes to deploy"
      }
    },
    "sshKeyData" : {
      "type" : "securestring",
      "defaultValue" : "Unused",
      "metadata" : {
        "description" : "Unused"
      }
    },
    "nodeVMSize" : {
      "type" : "string",
      "defaultValue" : "Standard_D4s_v3",
      "metadata" : {
        "description" : "The size of the each Node Virtual Machine"
      }
    },
    "hyperVGen": {
      "type": "string",
      "metadata": {
        "description": "VM generation image to use"
      },
      "defaultValue": "V2",
      "allowedValues": [
        "V1",
        "V2"
      ]
    }
  },
  "variables" : {
    "location" : "[resourceGroup().location]",
    "virtualNetworkName" : "[concat(if(not(empty(parameters('vnetBaseName'))), parameters('vnetBaseName'), parameters('baseName')), '-vnet')]",
    "virtualNetworkID" : "[resourceId('Microsoft.Network/virtualNetworks', variables('virtualNetworkName'))]",
    "nodeSubnetName" : "[concat(if(not(empty(parameters('vnetBaseName'))), parameters('vnetBaseName'), parameters('baseName')), '-worker-subnet')]",
    "nodeSubnetRef" : "[concat(variables('virtualNetworkID'), '/subnets/', variables('nodeSubnetName'))]",
    "infraLoadBalancerName" : "[parameters('baseName')]",
    "sshKeyPath" : "/home/capi/.ssh/authorized_keys",
    "identityName" : "[concat(parameters('baseName'), '-identity')]",
    "galleryName": "[concat('gallery_', replace(parameters('baseName'), '-', '_'))]",
    "imageName" : "[concat(parameters('baseName'), if(equals(parameters('hyperVGen'), 'V2'), '-gen2', ''))]",
    "copy" : [
      {
        "name" : "vmNames",
        "count" :  "[parameters('numberOfNodes')]",
        "input" : "[concat(parameters('baseName'), '-worker-', variables('location'), '-', copyIndex('vmNames', 1))]"
      }
    ]
  },
  "resources" : [
    {
      "apiVersion" : "2019-05-01",
      "name" : "[concat('node', copyIndex())]",
      "type" : "Microsoft.Resources/deployments",
      "copy" : {
        "name" : "nodeCopy",
        "count" : "[length(variables('vmNames'))]"
      },
      "properties" : {
        "mode" : "Incremental",
        "template" : {
          "$schema" : "http://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
          "contentVersion" : "1.0.0.0",
          "resources" : [
            {
              "apiVersion" : "2018-06-01",
              "type" : "Microsoft.Network/networkInterfaces",
              "name" : "[concat(variables('vmNames')[copyIndex()], '-nic')]",
              "location" : "[variables('location')]",
              "properties" : {
                "ipConfigurations" : [
                  {
                    "name" : "pipConfig",
                    "properties" : {
                      "privateIPAllocationMethod" : "Dynamic",
                      "subnet" : {
                        "id" : "[variables('nodeSubnetRef')]"
                      }
                    }
                  }
                ]
              }
            },
            {
              "apiVersion" : "2018-06-01",
              "type" : "Microsoft.Compute/virtualMachines",
              "name" : "[variables('vmNames')[copyIndex()]]",
              "location" : "[variables('location')]",
              "tags" : {
                "kubernetes.io-cluster-ffranzupi": "owned"
              },
              "identity" : {
                "type" : "userAssigned",
                "userAssignedIdentities" : {
                  "[resourceID('Microsoft.ManagedIdentity/userAssignedIdentities/', variables('identityName'))]" : {}
                }
              },
              "dependsOn" : [
                "[concat('Microsoft.Network/networkInterfaces/', concat(variables('vmNames')[copyIndex()], '-nic'))]"
              ],
              "properties" : {
                "hardwareProfile" : {
                  "vmSize" : "[parameters('nodeVMSize')]"
                },
                "osProfile" : {
                  "computerName" : "[variables('vmNames')[copyIndex()]]",
                  "adminUsername" : "capi",
                  "adminPassword" : "NotActuallyApplied!",
                  "customData" : "[parameters('workerIgnition')]",
                  "linuxConfiguration" : {
                    "disablePasswordAuthentication" : false
                  }
                },
                "storageProfile" : {
                  "imageReference": {
                    "id": "[resourceId('Microsoft.Compute/galleries/images', variables('galleryName'), variables('imageName'))]"
                  },
                  "osDisk" : {
                    "name": "[concat(variables('vmNames')[copyIndex()],'_OSDisk')]",
                    "osType" : "Linux",
                    "createOption" : "FromImage",
                    "managedDisk": {
                      "storageAccountType": "Premium_LRS"
                    },
                    "diskSizeGB": 128
                  }
                },
                "networkProfile" : {
                  "networkInterfaces" : [
                    {
                      "id" : "[resourceId('Microsoft.Network/networkInterfaces', concat(variables('vmNames')[copyIndex()], '-nic'))]",
                      "properties": {
                        "primary": true
                      }
                    }
                  ]
                }
              }
            }
          ]
        }
      }
    }
  ]
}

安装 OpenShift CLI

您可以安装 OpenShift CLI (oc) 以通过命令行界面与 OpenShift Container Platform 交互。您可以在 Linux、Windows 或 macOS 上安装oc。

如果您安装了早期版本的oc，则无法使用它来完成 OpenShift Container Platform 4.17 中的所有命令。下载并安装新版本的oc。

在 Linux 上安装 OpenShift CLI

您可以使用以下步骤在 Linux 上安装 OpenShift CLI (oc) 二进制文件。

步骤

导航到 Red Hat 客户门户上的OpenShift Container Platform 下载页面。
从**产品变体**下拉列表中选择架构。
从**版本**下拉列表中选择相应的版本。
点击**OpenShift v4.17 Linux 客户端**条目的旁边的**立即下载**并保存文件。
解压归档文件
```
$ tar xvf <file>
```
将oc二进制文件放置在PATH中的目录中。

要检查您的PATH，请执行以下命令
```
$ echo $PATH
```

验证

安装 OpenShift CLI 后，可以使用oc命令。
```
$ oc <command>
```

在 Windows 上安装 OpenShift CLI

您可以使用以下步骤在 Windows 上安装 OpenShift CLI (oc) 二进制文件。

步骤

导航到 Red Hat 客户门户上的OpenShift Container Platform 下载页面。
从**版本**下拉列表中选择相应的版本。
点击**OpenShift v4.17 Windows 客户端**条目的旁边的**立即下载**并保存文件。
使用 ZIP 程序解压缩归档文件。
将oc二进制文件移动到PATH中的目录。

要检查您的PATH，请打开命令提示符并执行以下命令
```
C:\> path
```

验证

安装 OpenShift CLI 后，可以使用oc命令。
```
C:\> oc <command>
```

在 macOS 上安装 OpenShift CLI

您可以使用以下步骤在 macOS 上安装 OpenShift CLI (oc) 二进制文件。

步骤

导航到 Red Hat 客户门户上的OpenShift Container Platform 下载页面。
从**版本**下拉列表中选择相应的版本。
点击**OpenShift v4.17 macOS 客户端**条目的旁边的**立即下载**并保存文件。

对于 macOS arm64，请选择**OpenShift v4.17 macOS arm64 客户端**条目。
解压归档文件。
将oc二进制文件移动到PATH中的目录。

要检查您的PATH，请打开终端并执行以下命令
```
$ echo $PATH
```

验证

使用oc命令验证您的安装
```
$ oc <command>
```

使用 CLI 登录集群

您可以通过导出集群kubeconfig文件以默认系统用户身份登录到您的集群。kubeconfig文件包含集群信息，CLI 使用这些信息将客户端连接到正确的集群和API服务器。该文件特定于某个集群，并在OpenShift Container Platform安装期间创建。

先决条件

您已部署了一个OpenShift Container Platform集群。
您已安装oc CLI。

步骤

导出kubeadmin凭据
```
$ export KUBECONFIG=<installation_directory>/auth/kubeconfig (1)
```
1 对于<installation_directory>，请指定您存储安装文件的目录的路径。
验证您可以使用导出的配置成功运行oc命令
```
$ oc whoami
```
示例输出：
```
system:admin
```

批准您的机器的证书签名请求

当您向集群添加机器时，会为每台添加的机器生成两个待处理的证书签名请求 (CSR)。您必须确认这些CSR已获批准，或者如有必要，自行批准它们。必须先批准客户端请求，然后再批准服务器请求。

先决条件

您已向集群添加了机器。

步骤

确认集群识别这些机器
```
$ oc get nodes
```
示例输出：
```
NAME      STATUS    ROLES   AGE  VERSION
master-0  Ready     master  63m  v1.30.3
master-1  Ready     master  63m  v1.30.3
master-2  Ready     master  64m  v1.30.3
```
输出列出了您创建的所有机器。

在批准一些CSR之前，上述输出可能不包含计算节点（也称为工作节点）。

查看待处理的CSR，并确保您看到为添加到集群的每台机器的客户端请求显示“待处理”或“已批准”状态。

$ oc get csr

示例输出：

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

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

如果CSR未获批准，在您添加的所有机器的待处理CSR均处于“待处理”状态后，请批准集群机器的CSR。

由于CSR会自动轮换，请在将机器添加到集群后一小时内批准您的CSR。如果您在一小时内未批准它们，证书将轮换，每个节点将出现两个以上的证书。您必须批准所有这些证书。批准客户端CSR后，Kubelet会为服务证书创建一个辅助CSR，这需要手动批准。然后，如果Kubelet请求具有相同参数的新证书，则machine-approver会自动批准后续的服务证书续订请求。

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

要单独批准它们，请对每个有效的CSR运行以下命令
```
$ oc adm certificate approve <csr_name> (1)
```
1 <csr_name>是当前CSR列表中CSR的名称。

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

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

在批准一些CSR之前，某些操作符可能不可用。

现在您的客户端请求已获批准，您必须查看为添加到集群的每台机器的服务器请求。

$ oc get csr

示例输出：

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

如果剩余的CSR未获批准且处于“待处理”状态，请批准集群机器的CSR。
- 要单独批准它们，请对每个有效的CSR运行以下命令
  $ oc adm certificate approve <csr_name> (1)
  1 <csr_name>是当前CSR列表中CSR的名称。
- 要批准所有待处理的CSR，请运行以下命令
  $ oc get csr -o go-template='{{range .items}}{{if not .status}}{{.metadata.name}}{{"\n"}}{{end}}{{end}}' | xargs oc adm certificate approve

批准所有客户端和服务器CSR后，机器将具有“就绪”状态。通过运行以下命令进行验证

$ oc get nodes

示例输出：

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

批准服务器CSR后，机器可能需要几分钟才能过渡到“就绪”状态。

附加信息

证书签名请求

添加 Ingress DNS 记录

如果您在创建 Kubernetes 清单和生成 Ignition 配置时删除了 DNS 区域配置，则必须手动创建指向 Ingress 负载均衡器的 DNS 记录。您可以创建通配符*.apps.{baseDomain}.或特定记录。您可以根据您的要求使用 A、CNAME 和其他记录。

先决条件

您已使用您配置的基础设施在 Microsoft Azure 上部署了 OpenShift Container Platform 集群。
安装 OpenShift CLI (oc)。
安装或更新Azure CLI。

步骤

确认 Ingress 路由器已创建负载均衡器并填充了EXTERNAL-IP字段

$ oc -n openshift-ingress get service router-default

示例输出：

NAME             TYPE           CLUSTER-IP      EXTERNAL-IP     PORT(S)                      AGE
router-default   LoadBalancer   172.30.20.10   35.130.120.110   80:32288/TCP,443:31215/TCP   20

将 Ingress 路由器的 IP 导出为变量

$ export PUBLIC_IP_ROUTER=`oc -n openshift-ingress get service router-default --no-headers | awk '{print $4}'`

向公共 DNS 区域添加*.apps记录。

如果您要将此集群添加到新的公共区域，请运行

$ az network dns record-set a add-record -g ${BASE_DOMAIN_RESOURCE_GROUP} -z ${CLUSTER_NAME}.${BASE_DOMAIN} -n *.apps -a ${PUBLIC_IP_ROUTER} --ttl 300

如果您要将此集群添加到已存在的公共区域，请运行

$ az network dns record-set a add-record -g ${BASE_DOMAIN_RESOURCE_GROUP} -z ${BASE_DOMAIN} -n *.apps.${CLUSTER_NAME} -a ${PUBLIC_IP_ROUTER} --ttl 300

向私有 DNS 区域添加*.apps记录

使用以下命令创建*.apps记录

$ az network private-dns record-set a create -g ${RESOURCE_GROUP} -z ${CLUSTER_NAME}.${BASE_DOMAIN} -n *.apps --ttl 300

使用以下命令将*.apps记录添加到私有 DNS 区域

$ az network private-dns record-set a add-record -g ${RESOURCE_GROUP} -z ${CLUSTER_NAME}.${BASE_DOMAIN} -n *.apps -a ${PUBLIC_IP_ROUTER}

如果您更愿意添加显式域名而不是使用通配符，您可以为集群的每个当前路由创建条目

$ oc get --all-namespaces -o jsonpath='{range .items[*]}{range .status.ingress[*]}{.host}{"\n"}{end}{end}' routes

示例输出：

oauth-openshift.apps.cluster.basedomain.com
console-openshift-console.apps.cluster.basedomain.com
downloads-openshift-console.apps.cluster.basedomain.com
alertmanager-main-openshift-monitoring.apps.cluster.basedomain.com
prometheus-k8s-openshift-monitoring.apps.cluster.basedomain.com

完成用户配置基础设施上的 Azure 安装

在 Microsoft Azure 用户配置的基础设施上启动 OpenShift Container Platform 安装后，您可以监视集群事件，直到集群准备就绪。

先决条件

为用户配置的 Azure 基础设施上的 OpenShift Container Platform 集群部署引导机器。
安装oc CLI 并登录。

步骤

完成集群安装

$ ./openshift-install --dir <installation_directory> wait-for install-complete (1)

示例输出：

INFO Waiting up to 30m0s for the cluster to initialize...

1	对于`<installation_directory>`，请指定您存储安装文件的目录的路径。

安装程序生成的 Ignition 配置文件包含在 24 小时后过期的证书，然后在该时间点续订。如果集群在续订证书之前关闭，并且在 24 小时后重新启动集群，则集群会自动恢复过期的证书。例外情况是，您必须手动批准待处理的node-bootstrapper证书签名请求 (CSR) 以恢复 kubelet 证书。有关更多信息，请参阅有关“从过期的控制平面证书中恢复”的文档。
建议您在生成 Ignition 配置文件后 12 小时内使用它们，因为 24 小时证书会在集群安装后 16 到 22 小时之间轮换。通过在 12 小时内使用 Ignition 配置文件，如果证书更新在安装期间运行，您可以避免安装失败。

OpenShift Container Platform 的遥测访问

在 OpenShift Container Platform 4.17 中，默认情况下运行的遥测服务（用于提供有关集群运行状况和更新成功的指标）需要互联网访问。如果您的集群连接到互联网，则遥测会自动运行，并且您的集群会注册到OpenShift Cluster Manager。

确认您的OpenShift Cluster Manager清单正确后（由遥测自动维护或使用 OpenShift Cluster Manager 手动维护），使用订阅监视在帐户或多集群级别跟踪您的 OpenShift Container Platform 订阅。

其他资源

有关遥测服务的更多信息，请参阅关于远程运行状况监控

1	对于`<installation_directory>`，请指定您存储安装文件的目录的路径。
2	要查看不同的安装详细信息，请指定`warn`、`debug`或`error`代替`info`。

使用 ARM 模板在 Azure 上安装集群

先决条件

OpenShift Container Platform 的互联网访问

配置您的 Azure 项目

Azure 帐户限制

在 Azure 中配置公共 DNS 区域

提高 Azure 帐户限制

证书签名请求管理

记录订阅和租户 ID

支持用于访问 Azure 资源的身份

用户配置基础设施所需的 Azure 权限

使用 Azure 托管身份

创建服务主体

支持的 Azure 区域

支持的 Azure 公有区域

支持的 Azure 政府区域

用户自备基础设施集群的要求

集群安装所需的机器

集群安装的最低资源要求

Azure 的测试实例类型

64 位 ARM 架构 Azure 的测试实例类型

使用 Azure 市场产品

获取安装程序

生成集群节点 SSH 访问的密钥对

为 Azure 创建安装文件

可选：创建单独的 /var 分区

创建安装配置文件

在安装过程中配置集群范围的代理

导出 ARM 模板的公共变量

创建 Kubernetes 清单和 Ignition 配置文件

创建 Azure 资源组

上传 RHCOS 集群映像和引导 Ignition 配置文件

创建 DNS 区域的示例

在 Azure 中创建 VNet

VNet 的 ARM 模板

部署 Azure 基础设施的 RHCOS 集群镜像

镜像存储的 ARM 模板

用户预配基础设施的网络要求

网络连接要求

在 Azure 中创建网络和负载均衡组件

网络和负载均衡器的 ARM 模板

在 Azure 中创建引导机器

引导机器的 ARM 模板

在 Azure 中创建控制平面机器

控制平面机器的 ARM 模板

等待引导完成并在 Azure 中删除引导资源

在 Azure 中创建额外的计算节点机器

计算节点机器的 ARM 模板

安装 OpenShift CLI

在 Linux 上安装 OpenShift CLI

在 Windows 上安装 OpenShift CLI

在 macOS 上安装 OpenShift CLI

使用 CLI 登录集群

批准您的机器的证书签名请求

添加 Ingress DNS 记录

完成用户配置基础设施上的 Azure 安装

OpenShift Container Platform 的遥测访问

可选：创建单独的 `/var` 分区