使用部署管理器模板在 GCP 上安装集群 - 在 GCP 上安装 | 安装 | OpenShift Container Platform 4.17

先决条件
证书签名请求管理
OpenShift Container Platform的互联网访问
配置您的GCP项目
- 创建GCP项目
- 在GCP中启用API服务
- 为GCP配置DNS
- GCP帐户限制
- 在GCP中创建服务帐户
- 必需的GCP角色
- 用户提供的基础架构所需的GCP权限
- 支持的GCP区域
- 安装和配置GCP的CLI工具
使用用户提供的基础架构的集群的要求
- 集群安装所需的机器
- 集群安装的最低资源要求
- GCP的测试实例类型
- 64位ARM基础架构上GCP的测试实例类型
- 使用自定义机器类型
创建GCP的安装文件
- 可选：创建单独的/var分区
- 创建安装配置文件
- 启用Shielded VM
- 启用Confidential VM
- 在安装过程中配置集群范围的代理
- 创建Kubernetes清单和Ignition配置文件
导出公共变量
- 提取基础架构名称
- 为Deployment Manager模板导出公共变量
在GCP中创建VPC
- VPC的Deployment Manager模板
用户提供的基础架构的网络要求
- 通过DHCP设置集群节点主机名
- 网络连接要求
在GCP中创建负载均衡器
- 外部负载均衡器的Deployment Manager模板
- 内部负载均衡器的Deployment Manager模板
在GCP中创建私有DNS区域
- 私有DNS的Deployment Manager模板
在GCP中创建防火墙规则
- 防火墙规则的Deployment Manager模板
在GCP中创建IAM角色
- IAM角色的Deployment Manager模板
为GCP基础架构创建RHCOS集群镜像
在GCP中创建引导机器
- 引导机器的Deployment Manager模板
在GCP中创建控制平面机器
- 控制平面机器的Deployment Manager模板
等待引导完成并在GCP中删除引导资源
在GCP中创建其他工作节点
- 工作节点的Deployment Manager模板
安装OpenShift CLI
使用CLI登录集群
批准机器的证书签名请求
可选：添加入口DNS记录
完成用户提供的基础架构上的GCP安装
OpenShift Container Platform的遥测访问
后续步骤

在OpenShift Container Platform 4.17版本中，您可以安装一个使用您提供的基础架构的Google Cloud Platform (GCP)集群。

执行用户提供基础架构安装的步骤在此概述。提供了一些Deployment Manager模板来帮助完成这些步骤或帮助您创建自己的模板。您也可以自由地通过其他方法创建所需的资源。

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

先决条件

您已查看有关OpenShift Container Platform安装和更新流程的详细信息。
您已阅读有关选择集群安装方法并为用户准备集群的文档。
如果您使用防火墙并计划使用遥测服务，则您已配置防火墙以允许集群需要访问的站点。
如果您的环境中无法访问云身份和访问管理(IAM)API，或者您不想在kube-system命名空间中存储管理员级凭据密钥，您可以手动创建和维护长期凭据。

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

证书签名请求管理

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

OpenShift Container Platform的互联网访问

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

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

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

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

配置您的GCP项目

在您可以安装OpenShift Container Platform之前，您必须配置一个Google Cloud Platform (GCP)项目来托管它。

创建 GCP 项目

要安装 OpenShift Container Platform，您必须在 Google Cloud Platform (GCP) 帐户中创建一个项目来托管集群。

步骤

创建一个项目来托管您的 OpenShift Container Platform 集群。请参阅 GCP 文档中的创建和管理项目。

如果您使用安装程序预配的基础设施，则您的 GCP 项目必须使用高级网络服务层。对于使用安装程序安装的集群，不支持标准网络服务层。安装程序会为api-int.<cluster_name>.<base_domain> URL 配置内部负载平衡；内部负载平衡需要高级层。

在 GCP 中启用 API 服务

您的 Google Cloud Platform (GCP) 项目需要访问多个 API 服务才能完成 OpenShift Container Platform 的安装。

先决条件

您已创建了一个项目来托管您的集群。

步骤

在托管集群的项目中启用以下必需的 API 服务。您还可以启用安装不需要的可选 API 服务。请参阅 GCP 文档中的启用服务。

表 1. 必需的 API 服务
API 服务	控制台服务名称
Compute Engine API	`compute.googleapis.com`
Cloud 资源管理器 API	`cloudresourcemanager.googleapis.com`
Google DNS API	`dns.googleapis.com`
IAM 服务帐户凭据 API	`iamcredentials.googleapis.com`
身份和访问管理 (IAM) API	`iam.googleapis.com`
服务使用情况 API	`serviceusage.googleapis.com`

表 2. 可选的 API 服务
API 服务	控制台服务名称
Cloud Deployment Manager V2 API	`deploymentmanager.googleapis.com`
Google Cloud APIs	`cloudapis.googleapis.com`
服务管理 API	`servicemanagement.googleapis.com`
Google Cloud 存储 JSON API	`storage-api.googleapis.com`
Cloud 存储	`storage-component.googleapis.com`

配置 GCP 的 DNS

要安装 OpenShift Container Platform，您使用的 Google Cloud Platform (GCP) 帐户必须在您托管 OpenShift Container Platform 集群的同一项目中拥有一个专用的公共托管区域。此区域必须是域的权威区域。DNS 服务为集群 DNS 解析和对集群的外部连接的名称查找提供服务。

步骤

确定您的域名或子域名以及注册机构。您可以转移现有的域名和注册机构，也可以通过 GCP 或其他来源获得新的域名和注册机构。

如果您购买新域名，相关 DNS 更改的传播可能需要一些时间。有关通过 Google 购买域名的更多信息，请参阅Google Domains。
在您的 GCP 项目中为您的域名或子域名创建一个公共托管区域。请参阅 GCP 文档中的创建公共区域。

使用适当的根域名，例如openshiftcorp.com，或子域名，例如clusters.openshiftcorp.com。
从托管区域记录中提取新的权威名称服务器。请参阅 GCP 文档中的查找您的 Cloud DNS 域名服务器。

您通常有四个名称服务器。
更新您的域名使用的名称服务器的注册机构记录。例如，如果您在 Google Domains 注册了您的域名，请参阅 Google Domains 帮助中的以下主题：如何切换到自定义名称服务器。
如果您已将根域名迁移到 Google Cloud DNS，请迁移您的 DNS 记录。请参阅 GCP 文档中的迁移到 Cloud DNS。
如果您使用子域名，请按照您公司的流程将它的委派记录添加到父域名。此过程可能包括向您公司的 IT 部门或控制您公司根域名和 DNS 服务的部门提出请求。

GCP 帐户限制

OpenShift Container Platform 集群使用许多 Google Cloud Platform (GCP) 组件，但默认配额不会影响您安装默认 OpenShift Container Platform 集群的能力。

默认集群包含三台计算机器和三台控制平面机器，它使用以下资源。请注意，某些资源仅在引导过程中需要，并在集群部署后移除。

表 3. 默认集群中使用的 GCP 资源
服务	组件	位置	所需的总资源	引导后移除的资源
服务帐户	IAM	全局	6	1
防火墙规则	网络	全局	11	1
转发规则	计算	全局	2	0
运行状况检查	计算	全局	2	0
镜像	计算	全局	1	0
网络	网络	全局	1	0
路由器	网络	全局	1	0
路由	网络	全局	2	0
子网	计算	全局	2	0
目标池	网络	全局	2	0

如果在安装过程中任何配额不足，安装程序将显示一个错误，说明超过了哪个配额以及区域。

请务必考虑您的实际集群大小、计划的集群增长以及与您的帐户关联的其他集群的任何使用情况。CPU、静态 IP 地址和持久性磁盘 SSD（存储）配额最有可能不足。

如果您计划在以下任何区域部署集群，您将超过最大存储配额，并且很可能超过 CPU 配额限制

asia-east2
asia-northeast2
asia-south1
australia-southeast1
europe-north1
europe-west2
europe-west3
europe-west6
northamerica-northeast1
southamerica-east1
us-west2

您可以从GCP 控制台增加资源配额，但您可能需要提交支持工单。请务必尽早规划集群大小，以便您可以在安装 OpenShift Container Platform 集群之前留出时间来解决支持工单。

在 GCP 中创建服务帐户

OpenShift Container Platform 需要一个 Google Cloud Platform (GCP) 服务帐户，该帐户提供身份验证和授权以访问 Google API 中的数据。如果您没有现有包含项目中所需角色的 IAM 服务帐户，则必须创建一个。

先决条件

您已创建了一个项目来托管您的集群。

步骤

在您用来托管 OpenShift Container Platform 集群的项目中创建一个服务帐户。请参阅 GCP 文档中的创建服务帐户。

授予服务帐户相应的权限。您可以授予以下各个权限，也可以为其分配所有者角色。请参阅为特定资源授予服务帐户的角色。

虽然将服务帐户设为项目的拥有者是获得所需权限最简单的方法，但这意味着服务帐户对项目拥有完全控制权。您必须确定提供这种权限带来的风险是否可以接受。

您可以创建 JSON 格式的服务帐户密钥，或将服务帐户附加到 GCP 虚拟机。请参阅 GCP 文档中的创建服务帐户密钥和为实例创建和启用服务帐户。

如果您使用附加了服务帐户的虚拟机来创建集群，则必须在安装之前在install-config.yaml文件中设置credentialsMode: Manual。

所需 GCP 角色

当您将Owner角色附加到您创建的服务帐户时，您授予该服务帐户所有权限，包括安装 OpenShift Container Platform 所需的权限。如果贵组织的安全策略需要更严格的权限集，您可以创建一个具有以下权限的服务帐户。如果您将集群部署到现有的虚拟私有云 (VPC)，则服务帐户不需要某些网络权限，这些权限在以下列表中注明。

安装程序所需的角色

Compute Admin（计算管理员）
Role Administrator（角色管理员）
Security Admin（安全管理员）
Service Account Admin（服务帐户管理员）
Service Account Key Admin（服务帐户密钥管理员）
Service Account User（服务帐户用户）
Storage Admin（存储管理员）

安装期间创建网络资源所需的角色

DNS Administrator（DNS 管理员）

在直通模式下使用 Cloud Credential Operator 所需的角色

Compute Load Balancer Admin（计算负载均衡器管理员）
Tag User（标签用户）

用户预配的 GCP 基础架构所需的角色

Deployment Manager Editor（部署管理器编辑器）

以下角色应用于控制平面和计算机器使用的服务帐户

表 4. GCP 服务帐户角色
帐户	角色
控制平面	`roles/compute.instanceAdmin`
	`roles/compute.networkAdmin`
	`roles/compute.securityAdmin`
	`roles/storage.admin`
	`roles/iam.serviceAccountUser`
计算	`roles/compute.viewer`
	`roles/storage.admin`
	`roles/artifactregistry.reader`

用户预配的基础架构所需 GCP 权限

当您将Owner角色附加到您创建的服务帐户时，您授予该服务帐户所有权限，包括安装 OpenShift Container Platform 所需的权限。

如果贵组织的安全策略需要更严格的权限集，您可以创建具有必要权限的自定义角色。以下权限是用户预配的基础架构创建和删除 OpenShift Container Platform 集群所需的权限。

创建网络资源所需的权限

compute.addresses.create
compute.addresses.createInternal
compute.addresses.delete
compute.addresses.get
compute.addresses.list
compute.addresses.use
compute.addresses.useInternal
compute.firewalls.create
compute.firewalls.delete
compute.firewalls.get
compute.firewalls.list
compute.forwardingRules.create
compute.forwardingRules.get
compute.forwardingRules.list
compute.forwardingRules.setLabels
compute.globalAddresses.create
compute.globalAddresses.get
compute.globalAddresses.use
compute.globalForwardingRules.create
compute.globalForwardingRules.get
compute.globalForwardingRules.setLabels
compute.networks.create
compute.networks.get
compute.networks.list
compute.networks.updatePolicy
compute.networks.use
compute.routers.create
compute.routers.get
compute.routers.list
compute.routers.update
compute.routes.list
compute.subnetworks.create
compute.subnetworks.get
compute.subnetworks.list
compute.subnetworks.use
compute.subnetworks.useExternalIp

创建负载均衡器资源所需的权限

compute.backendServices.create
compute.backendServices.get
compute.backendServices.list
compute.backendServices.update
compute.backendServices.use
compute.regionBackendServices.create
compute.regionBackendServices.get
compute.regionBackendServices.list
compute.regionBackendServices.update
compute.regionBackendServices.use
compute.targetPools.addInstance
compute.targetPools.create
compute.targetPools.get
compute.targetPools.list
compute.targetPools.removeInstance
compute.targetPools.use
compute.targetTcpProxies.create
compute.targetTcpProxies.get
compute.targetTcpProxies.use

创建 DNS 资源所需的权限

dns.changes.create
dns.changes.get
dns.managedZones.create
dns.managedZones.get
dns.managedZones.list
dns.networks.bindPrivateDNSZone
dns.resourceRecordSets.create
dns.resourceRecordSets.list
dns.resourceRecordSets.update

创建服务帐户资源所需的权限

iam.serviceAccountKeys.create
iam.serviceAccountKeys.delete
iam.serviceAccountKeys.get
iam.serviceAccountKeys.list
iam.serviceAccounts.actAs
iam.serviceAccounts.create
iam.serviceAccounts.delete
iam.serviceAccounts.get
iam.serviceAccounts.list
resourcemanager.projects.get
resourcemanager.projects.getIamPolicy
resourcemanager.projects.setIamPolicy

创建计算资源所需的权限

compute.disks.create
compute.disks.get
compute.disks.list
compute.instanceGroups.create
compute.instanceGroups.delete
compute.instanceGroups.get
compute.instanceGroups.list
compute.instanceGroups.update
compute.instanceGroups.use
compute.instances.create
compute.instances.delete
compute.instances.get
compute.instances.list
compute.instances.setLabels
compute.instances.setMetadata
compute.instances.setServiceAccount
compute.instances.setTags
compute.instances.use
compute.machineTypes.get
compute.machineTypes.list

创建存储资源所需权限

storage.buckets.create
storage.buckets.delete
storage.buckets.get
storage.buckets.list
storage.objects.create
storage.objects.delete
storage.objects.get
storage.objects.list

创建健康检查资源所需的权限

compute.healthChecks.create
compute.healthChecks.get
compute.healthChecks.list
compute.healthChecks.useReadOnly
compute.httpHealthChecks.create
compute.httpHealthChecks.get
compute.httpHealthChecks.list
compute.httpHealthChecks.useReadOnly
compute.regionHealthChecks.create
compute.regionHealthChecks.get
compute.regionHealthChecks.useReadOnly

获取 GCP 区域和地区相关信息所需的权限

compute.globalOperations.get
compute.regionOperations.get
compute.regions.get
compute.regions.list
compute.zoneOperations.get
compute.zones.get
compute.zones.list

检查服务和配额所需的权限

monitoring.timeSeries.list
serviceusage.quotas.get
serviceusage.services.list

安装所需的 IAM 权限

iam.roles.get

无需服务帐户密钥进行身份验证时的所需权限

iam.serviceAccounts.signBlob

安装所需的镜像权限

compute.images.create
compute.images.delete
compute.images.get
compute.images.list

运行收集引导程序的可选权限

compute.instances.getSerialPortOutput

删除网络资源所需的权限

compute.addresses.delete
compute.addresses.deleteInternal
compute.addresses.list
compute.addresses.setLabels
compute.firewalls.delete
compute.firewalls.list
compute.forwardingRules.delete
compute.forwardingRules.list
compute.globalAddresses.delete
compute.globalAddresses.list
compute.globalForwardingRules.delete
compute.globalForwardingRules.list
compute.networks.delete
compute.networks.list
compute.networks.updatePolicy
compute.routers.delete
compute.routers.list
compute.routes.list
compute.subnetworks.delete
compute.subnetworks.list

删除负载均衡器资源所需的权限

compute.backendServices.delete
compute.backendServices.list
compute.regionBackendServices.delete
compute.regionBackendServices.list
compute.targetPools.delete
compute.targetPools.list
compute.targetTcpProxies.delete
compute.targetTcpProxies.list

删除 DNS 资源所需的权限

dns.changes.create
dns.managedZones.delete
dns.managedZones.get
dns.managedZones.list
dns.resourceRecordSets.delete
dns.resourceRecordSets.list

删除服务帐户资源所需的权限

iam.serviceAccounts.delete
iam.serviceAccounts.get
iam.serviceAccounts.list
resourcemanager.projects.getIamPolicy
resourcemanager.projects.setIamPolicy

删除计算资源所需的权限

compute.disks.delete
compute.disks.list
compute.instanceGroups.delete
compute.instanceGroups.list
compute.instances.delete
compute.instances.list
compute.instances.stop
compute.machineTypes.list

删除存储资源所需权限

storage.buckets.delete
storage.buckets.getIamPolicy
storage.buckets.list
storage.objects.delete
storage.objects.list

删除健康检查资源所需的权限

compute.healthChecks.delete
compute.healthChecks.list
compute.httpHealthChecks.delete
compute.httpHealthChecks.list
compute.regionHealthChecks.delete
compute.regionHealthChecks.list

删除镜像所需的权限

compute.images.delete
compute.images.list

获取地区相关信息所需的权限

compute.regions.get

所需的部署管理器权限

deploymentmanager.deployments.create
deploymentmanager.deployments.delete
deploymentmanager.deployments.get
deploymentmanager.deployments.list
deploymentmanager.manifests.get
deploymentmanager.operations.get
deploymentmanager.resources.list

其他资源

优化存储

支持的 GCP 区域

您可以在以下 Google Cloud Platform (GCP) 区域部署 OpenShift Container Platform 集群

africa-south1（南非约翰内斯堡）
asia-east1（台湾彰化县）
asia-east2（香港）
asia-northeast1（日本东京）
asia-northeast2（日本大阪）
asia-northeast3（韩国首尔）
asia-south1（印度孟买）
asia-south2（印度德里）
asia-southeast1（新加坡裕廊西）
asia-southeast2（印度尼西亚雅加达）
australia-southeast1（澳大利亚悉尼）
australia-southeast2（澳大利亚墨尔本）
europe-central2（波兰华沙）
europe-north1（芬兰哈米纳）
europe-southwest1（西班牙马德里）
europe-west1（比利时圣吉斯兰）
europe-west2（英国伦敦）
europe-west3（德国法兰克福）
europe-west4（荷兰埃姆沙芬）
europe-west6（瑞士苏黎世）
europe-west8（意大利米兰）
europe-west9（法国巴黎）
europe-west12（意大利都灵）
me-central1（卡塔尔多哈，中东）
me-central2（沙特阿拉伯达曼，中东）
me-west1（以色列特拉维夫）
northamerica-northeast1（加拿大魁北克蒙特利尔）
northamerica-northeast2（加拿大安大略多伦多）
southamerica-east1（巴西圣保罗）
southamerica-west1（智利圣地亚哥）
us-central1（美国爱荷华州卡унсил布拉夫斯）
us-east1（美国南卡罗来纳州蒙克斯角）
us-east4（美国弗吉尼亚州北部阿什本）
us-east5（俄亥俄州哥伦布）
us-south1（美国德克萨斯州达拉斯）
us-west1（美国俄勒冈州达尔斯）
us-west2（美国加利福尼亚州洛杉矶）
us-west3（美国犹他州盐湖城）
us-west4（美国内华达州拉斯维加斯）

要确定按区域和区域划分的可用机器类型实例，请参阅 Google 文档。

安装和配置 GCP 的 CLI 工具

要使用用户预配的基础架构在 Google Cloud Platform (GCP) 上安装 OpenShift Container Platform，必须安装和配置 GCP 的 CLI 工具。

先决条件

您已创建了一个项目来托管您的集群。
您已创建服务帐户并授予其所需的权限。

步骤

在 $PATH 中安装以下二进制文件
- gcloud
- gsutil
请参阅 GCP 文档中的安装最新的 Cloud SDK 版本。
使用已配置的服务帐户通过 gcloud 工具进行身份验证。

请参阅 GCP 文档中的使用服务帐户进行授权。

使用用户预配的基础架构的集群要求

对于包含用户预配的基础架构的集群，必须部署所有必需的机器。

本节介绍在用户预配的基础架构上部署 OpenShift Container Platform 的要求。

集群安装所需的机器

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

表 5. 最低所需主机
主机	描述
一台临时引导机器	集群需要引导机器才能在三台控制平面机器上部署 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 技术能力和限制。

集群安装的最低资源要求

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

表 6. 最低资源要求
机器	操作系统	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 计算机器，则您将负责所有操作系统生命周期管理和维护，包括执行系统更新、应用补丁以及完成所有其他必需的任务。在 OpenShift Container Platform 4.10 及更高版本中，不再支持使用 RHEL 7 计算机器。

从 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 架构。

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

其他资源

优化存储

GCP 的测试实例类型

以下 Google Cloud Platform 实例类型已通过 OpenShift Container Platform 测试。

机器系列

A2
A3
C2
C2D
C3
C3D
E2
M1
N1
N2
N2D
N4
Tau T2D

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

以下 Google Cloud Platform (GCP) 64 位 ARM 实例类型已通过 OpenShift Container Platform 测试。

64 位 ARM 机器系列

Tau T2A

使用自定义机器类型

支持使用自定义机器类型安装 OpenShift Container Platform 集群。

使用自定义机器类型时，请考虑以下事项

与预定义实例类型类似，自定义机器类型必须满足控制平面和计算机的最低资源要求。更多信息，请参见“集群安装的最低资源要求”。
自定义机器类型的名称必须符合以下语法

custom-<number_of_cpus>-<amount_of_memory_in_mb>

例如，custom-6-20480。

创建 GCP 的安装文件

要使用用户预配的基础架构在 Google Cloud Platform (GCP) 上安装 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`，所以以下步骤通过创建一个机器配置清单来设置单独的 `/var` 分区，该清单在 OpenShift Container Platform 安装的 `openshift-install` 准备阶段插入。

如果您按照此过程中的步骤创建单独的 `/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) 系统。

创建安装配置文件

您可以自定义在 Google Cloud Platform (GCP) 上安装的 OpenShift Container Platform 集群。

先决条件

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

步骤

创建 `install-config.yaml` 文件。
1. 更改到包含安装程序的目录，然后运行以下命令
  $ ./openshift-install create install-config --dir <installation_directory> (1)
  1 对于 `<installation_directory>`，指定存储安装程序创建的文件的目录名称。
  
  指定目录时
  - 验证该目录是否具有 `execute` 权限。此权限是在安装目录下运行 Terraform 二进制文件所必需的。
  - 使用空目录。某些安装资源（例如引导 X.509 证书）的到期时间间隔很短，因此您不能重用安装目录。如果您想重用另一个集群安装中的单个文件，您可以将它们复制到您的目录中。但是，安装资源的文件名在不同版本之间可能会发生变化。从早期 OpenShift Container Platform 版本复制安装文件时，请务必小心。
2. 在提示符下，提供云的配置详细信息。
  1. 可选：选择一个 SSH 密钥来访问您的集群机器。
    
    对于要执行安装调试或灾难恢复的生产 OpenShift Container Platform 集群，请指定您的 `ssh-agent` 进程使用的 SSH 密钥。
  2. 选择 **gcp** 作为目标平台。
  3. 如果您尚未在您的计算机上为您的 GCP 帐户配置服务帐户密钥，则必须从 GCP 获取它并粘贴文件的内容或输入文件的绝对路径。
  4. 选择要在其中预配集群的项目 ID。默认值由您配置的服务帐户指定。
  5. 选择要将集群部署到的区域。
  6. 选择要将集群部署到的基础域。基础域对应于您为集群创建的公共 DNS 区域。
  7. 输入集群的描述性名称。

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

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

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

在安装过程中会使用 `install-config.yaml` 文件。如果您想重用该文件，则现在必须备份它。

其他资源

GCP 的安装配置参数

启用 Shielded VM

安装集群时可以使用 Shielded VM。Shielded VM 具有额外的安全功能，包括安全启动、固件和完整性监控以及 rootkit 检测。有关更多信息，请参阅 Google 关于Shielded VM的文档。

目前，64 位 ARM 架构的集群不支持 Shielded VM。

先决条件

您已创建 install-config.yaml 文件。

步骤

在部署集群之前，使用文本编辑器编辑 install-config.yaml 文件，并添加以下节之一：

仅为控制平面机器使用 Shielded VM

controlPlane:
  platform:
    gcp:
       secureBoot: Enabled

仅为计算机器使用 Shielded VM

compute:
- platform:
    gcp:
       secureBoot: Enabled

为所有机器使用 Shielded VM

platform:
  gcp:
    defaultMachinePlatform:
       secureBoot: Enabled

启用 Confidential VM

安装集群时可以使用 Confidential VM。Confidential VM 在数据处理过程中对其进行加密。有关更多信息，请参阅 Google 关于Confidential Computing的文档。您可以同时启用 Confidential VM 和 Shielded VM，尽管它们彼此之间并不依赖。

目前，64 位 ARM 架构不支持 Confidential VM。

先决条件

您已创建 install-config.yaml 文件。

步骤

在部署集群之前，使用文本编辑器编辑 install-config.yaml 文件，并添加以下节之一：

仅为控制平面机器使用 Confidential VM

controlPlane:
  platform:
    gcp:
       confidentialCompute: Enabled (1)
       type: n2d-standard-8 (2)
       onHostMaintenance: Terminate (3)

1	启用 Confidential VM。
2	指定支持 Confidential VM 的机器类型。Confidential VM 需要 N2D 或 C2D 系列机器类型。有关支持的机器类型的更多信息，请参阅支持的操作系统和机器类型。
3	指定虚拟机在主机维护事件（例如硬件或软件更新）期间的行为。对于使用 Confidential VM 的机器，此值必须设置为 `Terminate`，这将停止虚拟机。Confidential VM 不支持实时虚拟机迁移。

仅为计算机器使用 Confidential VM

compute:
- platform:
    gcp:
       confidentialCompute: Enabled
       type: n2d-standard-8
       onHostMaintenance: Terminate

为所有机器使用 Confidential VM

platform:
  gcp:
    defaultMachinePlatform:
       confidentialCompute: Enabled
       type: n2d-standard-8
       onHostMaintenance: Terminate

安装期间配置集群范围的代理

生产环境可能会拒绝直接访问互联网，而是提供 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 对象，并且无法创建其他代理。

创建 Kubernetes 清单和 Ignition 配置文件

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

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

OpenShift Container Platform 安装程序生成的 Ignition 配置文件包含在 24 小时后过期的证书，然后在此时续订。如果集群在续订证书之前关闭，并且集群在 24 小时后重新启动，则集群会自动恢复过期的证书。例外情况是，您必须手动批准挂起的 node-bootstrapper 证书签名请求 (CSR) 以恢复 kubelet 证书。有关更多信息，请参阅有关“从过期的控制平面证书中恢复”的文档。
建议您在生成 Ignition 配置文件后 12 小时内使用它们，因为集群安装后 16 到 22 小时，24 小时证书会轮换。在 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 清单文件。否则，您的集群将无法安装。

因为您自己创建和管理工作机器，所以不需要初始化这些机器。

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

当您将控制平面节点从默认的不可调度配置为可调度时，需要额外的订阅。这是因为控制平面节点随后会成为计算节点。
检查 <installation_directory>/manifests/cluster-scheduler-02-config.yml Kubernetes 清单文件中 mastersSchedulable 参数是否设置为 false。此设置可防止将 Pod 调度到控制平面机器上。
1. 打开 <installation_directory>/manifests/cluster-scheduler-02-config.yml 文件。
2. 找到 mastersSchedulable 参数并确保将其设置为 false。
3. 保存并退出文件。
可选：如果您不希望 Ingress Operator 代表您创建 DNS 记录，请从 <installation_directory>/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 完全删除此部分。

如果您这样做，则必须在后续步骤中手动添加入口 DNS 记录。
要创建 Ignition 配置文件，请从包含安装程序的目录运行以下命令：
```
$ ./openshift-install create ignition-configs --dir <installation_directory> (1)
```
1 对于 <installation_directory>，请指定相同的安装目录。

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

其他资源

可选：添加入口DNS记录

导出公共变量

提取基础设施名称

Ignition 配置文件包含一个唯一的集群标识符，您可以使用它来唯一标识您在 Google Cloud Platform (GCP) 中的集群。基础设施名称还用于在 OpenShift Container Platform 安装期间查找相应 GCP 资源。提供的 Deployment Manager 模板包含对此基础设施名称的引用，因此您必须提取它。

先决条件

您已获得 OpenShift Container Platform 安装程序和集群的拉取密钥。
您已为您的集群生成了 Ignition 配置文件。
您已安装 jq 包。

步骤

要从 Ignition 配置文件元数据中提取和查看基础设施名称，请运行以下命令：
```
$ jq -r .infraID <installation_directory>/metadata.json (1)
```
1 对于 <installation_directory>，请指定您存储安装文件的目录的路径。
示例输出
```
openshift-vw9j6 (1)
```
1 此命令的输出是您的集群名称和一个随机字符串。

为 Deployment Manager 模板导出公共变量

您必须导出与提供的 Deployment Manager 模板一起使用的公共变量集，这些模板用于帮助完成在 Google Cloud Platform (GCP) 上的用户提供的基础设施安装。

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

先决条件

获取 OpenShift Container Platform 安装程序和集群的拉取密钥。
为您的集群生成 Ignition 配置文件。
安装 jq 包。

步骤

导出以下公共变量，供提供的 Deployment Manager 模板使用。

$ export BASE_DOMAIN='<base_domain>'
$ export BASE_DOMAIN_ZONE_NAME='<base_domain_zone_name>'
$ export NETWORK_CIDR='10.0.0.0/16'
$ export MASTER_SUBNET_CIDR='10.0.0.0/17'
$ export WORKER_SUBNET_CIDR='10.0.128.0/17'

$ export KUBECONFIG=<installation_directory>/auth/kubeconfig (1)
$ export CLUSTER_NAME=`jq -r .clusterName <installation_directory>/metadata.json`
$ export INFRA_ID=`jq -r .infraID <installation_directory>/metadata.json`
$ export PROJECT_NAME=`jq -r .gcp.projectID <installation_directory>/metadata.json`
$ export REGION=`jq -r .gcp.region <installation_directory>/metadata.json`

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

在 GCP 中创建 VPC

您必须在 Google Cloud Platform (GCP) 中为您的 OpenShift Container Platform 集群创建一个 VPC。您可以自定义 VPC 以满足您的要求。创建 VPC 的一种方法是修改提供的 Deployment Manager 模板。

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

先决条件

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

步骤

从本主题的“VPC 的 Deployment Manager 模板”部分复制模板，并将其保存为计算机上的 01_vpc.py。此模板描述了集群所需的 VPC。

创建一个 01_vpc.yaml 资源定义文件。

$ cat <<EOF >01_vpc.yaml
imports:
- path: 01_vpc.py

resources:
- name: cluster-vpc
  type: 01_vpc.py
  properties:
    infra_id: '${INFRA_ID}' (1)
    region: '${REGION}' (2)
    master_subnet_cidr: '${MASTER_SUBNET_CIDR}' (3)
    worker_subnet_cidr: '${WORKER_SUBNET_CIDR}' (4)
EOF

1	`infra_id` 是提取步骤中的 `INFRA_ID` 基础设施名称。
2	`region` 是部署集群的区域，例如 `us-central1`。
3	`master_subnet_cidr` 是主子网的 CIDR，例如 `10.0.0.0/17`。
4	`worker_subnet_cidr` 是工作子网的 CIDR，例如 `10.0.128.0/17`。

使用 gcloud CLI 创建部署。

$ gcloud deployment-manager deployments create ${INFRA_ID}-vpc --config 01_vpc.yaml

VPC 的 Deployment Manager 模板

您可以使用以下 Deployment Manager 模板部署 OpenShift Container Platform 集群所需的 VPC。

01_vpc.py Deployment Manager 模板

def GenerateConfig(context):

    resources = [{
        'name': context.properties['infra_id'] + '-network',
        'type': 'compute.v1.network',
        'properties': {
            'region': context.properties['region'],
            'autoCreateSubnetworks': False
        }
    }, {
        'name': context.properties['infra_id'] + '-master-subnet',
        'type': 'compute.v1.subnetwork',
        'properties': {
            'region': context.properties['region'],
            'network': '$(ref.' + context.properties['infra_id'] + '-network.selfLink)',
            'ipCidrRange': context.properties['master_subnet_cidr']
        }
    }, {
        'name': context.properties['infra_id'] + '-worker-subnet',
        'type': 'compute.v1.subnetwork',
        'properties': {
            'region': context.properties['region'],
            'network': '$(ref.' + context.properties['infra_id'] + '-network.selfLink)',
            'ipCidrRange': context.properties['worker_subnet_cidr']
        }
    }, {
        'name': context.properties['infra_id'] + '-router',
        'type': 'compute.v1.router',
        'properties': {
            'region': context.properties['region'],
            'network': '$(ref.' + context.properties['infra_id'] + '-network.selfLink)',
            'nats': [{
                'name': context.properties['infra_id'] + '-nat-master',
                'natIpAllocateOption': 'AUTO_ONLY',
                'minPortsPerVm': 7168,
                'sourceSubnetworkIpRangesToNat': 'LIST_OF_SUBNETWORKS',
                'subnetworks': [{
                    'name': '$(ref.' + context.properties['infra_id'] + '-master-subnet.selfLink)',
                    'sourceIpRangesToNat': ['ALL_IP_RANGES']
                }]
            }, {
                'name': context.properties['infra_id'] + '-nat-worker',
                'natIpAllocateOption': 'AUTO_ONLY',
                'minPortsPerVm': 512,
                'sourceSubnetworkIpRangesToNat': 'LIST_OF_SUBNETWORKS',
                'subnetworks': [{
                    'name': '$(ref.' + context.properties['infra_id'] + '-worker-subnet.selfLink)',
                    'sourceIpRangesToNat': ['ALL_IP_RANGES']
                }]
            }]
        }
    }]

    return {'resources': resources}

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

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

通过 DHCP 设置集群节点主机名

在 Red Hat Enterprise Linux CoreOS (RHCOS) 机器上，主机名由 NetworkManager 设置。默认情况下，机器通过 DHCP 获取主机名。如果 DHCP 未提供主机名，则通过内核参数或其他方法静态设置，否则通过反向 DNS 查询获取。反向 DNS 查询发生在节点网络初始化之后，解析可能需要一些时间。其他系统服务可能在此之前启动，并检测主机名为localhost或类似名称。您可以通过使用 DHCP 为每个集群节点提供主机名来避免这种情况。

此外，通过 DHCP 设置主机名可以绕过在具有 DNS 分裂视野实现的环境中任何手动 DNS 记录名称配置错误。

网络连接需求

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

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

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

表 7. 所有机器到所有机器通信使用的端口
协议	端口	描述
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)

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

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

在 GCP 中创建负载均衡器

您必须在 Google Cloud Platform (GCP) 中为您的 OpenShift Container Platform 集群配置负载均衡器。创建这些组件的一种方法是修改提供的 Deployment Manager 模板。

先决条件

配置 GCP 帐户。
为您的集群生成 Ignition 配置文件。
在 GCP 中创建和配置 VPC 和相关的子网。

步骤

复制本主题“内部负载均衡器的 Deployment Manager 模板”部分中的模板，并将其保存为计算机上的02_lb_int.py。此模板描述了集群所需的内部负载均衡对象。
对于外部集群，还要复制本主题“外部负载均衡器的 Deployment Manager 模板”部分中的模板，并将其保存为计算机上的02_lb_ext.py。此模板描述了集群所需的外部负载均衡对象。

导出部署模板使用的变量

导出集群网络位置

$ export CLUSTER_NETWORK=(`gcloud compute networks describe ${INFRA_ID}-network --format json | jq -r .selfLink`)

导出控制平面子网位置

$ export CONTROL_SUBNET=(`gcloud compute networks subnets describe ${INFRA_ID}-master-subnet --region=${REGION} --format json | jq -r .selfLink`)

导出集群使用的三个区域

$ export ZONE_0=(`gcloud compute regions describe ${REGION} --format=json | jq -r .zones[0] | cut -d "/" -f9`)

$ export ZONE_1=(`gcloud compute regions describe ${REGION} --format=json | jq -r .zones[1] | cut -d "/" -f9`)

$ export ZONE_2=(`gcloud compute regions describe ${REGION} --format=json | jq -r .zones[2] | cut -d "/" -f9`)

创建一个02_infra.yaml资源定义文件

$ cat <<EOF >02_infra.yaml
imports:
- path: 02_lb_ext.py
- path: 02_lb_int.py (1)
resources:
- name: cluster-lb-ext (1)
  type: 02_lb_ext.py
  properties:
    infra_id: '${INFRA_ID}' (2)
    region: '${REGION}' (3)
- name: cluster-lb-int
  type: 02_lb_int.py
  properties:
    cluster_network: '${CLUSTER_NETWORK}'
    control_subnet: '${CONTROL_SUBNET}' (4)
    infra_id: '${INFRA_ID}'
    region: '${REGION}'
    zones: (5)
    - '${ZONE_0}'
    - '${ZONE_1}'
    - '${ZONE_2}'
EOF

1	仅在部署外部集群时才需要。
2	`infra_id` 是提取步骤中的 `INFRA_ID` 基础设施名称。
3	`region` 是部署集群的区域，例如 `us-central1`。
4	`control_subnet` 是控制子网的 URI。
5	`zones` 是部署控制平面实例的区域，例如`us-east1-b`、`us-east1-c`和`us-east1-d`。

使用 gcloud CLI 创建部署。

$ gcloud deployment-manager deployments create ${INFRA_ID}-infra --config 02_infra.yaml

导出集群 IP 地址

$ export CLUSTER_IP=(`gcloud compute addresses describe ${INFRA_ID}-cluster-ip --region=${REGION} --format json | jq -r .address`)

对于外部集群，还要导出集群公网 IP 地址

$ export CLUSTER_PUBLIC_IP=(`gcloud compute addresses describe ${INFRA_ID}-cluster-public-ip --region=${REGION} --format json | jq -r .address`)

外部负载均衡器的 Deployment Manager 模板

您可以使用以下 Deployment Manager 模板部署 OpenShift Container Platform 集群所需的外部负载均衡器

02_lb_ext.py Deployment Manager 模板

def GenerateConfig(context):

    resources = [{
        'name': context.properties['infra_id'] + '-cluster-public-ip',
        'type': 'compute.v1.address',
        'properties': {
            'region': context.properties['region']
        }
    }, {
        # Refer to docs/dev/kube-apiserver-health-check.md on how to correctly setup health check probe for kube-apiserver
        'name': context.properties['infra_id'] + '-api-http-health-check',
        'type': 'compute.v1.httpHealthCheck',
        'properties': {
            'port': 6080,
            'requestPath': '/readyz'
        }
    }, {
        'name': context.properties['infra_id'] + '-api-target-pool',
        'type': 'compute.v1.targetPool',
        'properties': {
            'region': context.properties['region'],
            'healthChecks': ['$(ref.' + context.properties['infra_id'] + '-api-http-health-check.selfLink)'],
            'instances': []
        }
    }, {
        'name': context.properties['infra_id'] + '-api-forwarding-rule',
        'type': 'compute.v1.forwardingRule',
        'properties': {
            'region': context.properties['region'],
            'IPAddress': '$(ref.' + context.properties['infra_id'] + '-cluster-public-ip.selfLink)',
            'target': '$(ref.' + context.properties['infra_id'] + '-api-target-pool.selfLink)',
            'portRange': '6443'
        }
    }]

    return {'resources': resources}

内部负载均衡器的 Deployment Manager 模板

您可以使用以下 Deployment Manager 模板部署 OpenShift Container Platform 集群所需的内部负载均衡器

02_lb_int.py Deployment Manager 模板

def GenerateConfig(context):

    backends = []
    for zone in context.properties['zones']:
        backends.append({
            'group': '$(ref.' + context.properties['infra_id'] + '-master-' + zone + '-ig' + '.selfLink)'
        })

    resources = [{
        'name': context.properties['infra_id'] + '-cluster-ip',
        'type': 'compute.v1.address',
        'properties': {
            'addressType': 'INTERNAL',
            'region': context.properties['region'],
            'subnetwork': context.properties['control_subnet']
        }
    }, {
        # Refer to docs/dev/kube-apiserver-health-check.md on how to correctly setup health check probe for kube-apiserver
        'name': context.properties['infra_id'] + '-api-internal-health-check',
        'type': 'compute.v1.healthCheck',
        'properties': {
            'httpsHealthCheck': {
                'port': 6443,
                'requestPath': '/readyz'
            },
            'type': "HTTPS"
        }
    }, {
        'name': context.properties['infra_id'] + '-api-internal',
        'type': 'compute.v1.regionBackendService',
        'properties': {
            'backends': backends,
            'healthChecks': ['$(ref.' + context.properties['infra_id'] + '-api-internal-health-check.selfLink)'],
            'loadBalancingScheme': 'INTERNAL',
            'region': context.properties['region'],
            'protocol': 'TCP',
            'timeoutSec': 120
        }
    }, {
        'name': context.properties['infra_id'] + '-api-internal-forwarding-rule',
        'type': 'compute.v1.forwardingRule',
        'properties': {
            'backendService': '$(ref.' + context.properties['infra_id'] + '-api-internal.selfLink)',
            'IPAddress': '$(ref.' + context.properties['infra_id'] + '-cluster-ip.selfLink)',
            'loadBalancingScheme': 'INTERNAL',
            'ports': ['6443','22623'],
            'region': context.properties['region'],
            'subnetwork': context.properties['control_subnet']
        }
    }]

    for zone in context.properties['zones']:
        resources.append({
            'name': context.properties['infra_id'] + '-master-' + zone + '-ig',
            'type': 'compute.v1.instanceGroup',
            'properties': {
                'namedPorts': [
                    {
                        'name': 'ignition',
                        'port': 22623
                    }, {
                        'name': 'https',
                        'port': 6443
                    }
                ],
                'network': context.properties['cluster_network'],
                'zone': zone
            }
        })

    return {'resources': resources}

创建外部集群时，除了02_lb_ext.py模板之外，还需要此模板。

在 GCP 中创建私有 DNS 区域

您必须在 Google Cloud Platform (GCP) 中为您的 OpenShift Container Platform 集群配置私有 DNS 区域。创建此组件的一种方法是修改提供的 Deployment Manager 模板。

先决条件

配置 GCP 帐户。
为您的集群生成 Ignition 配置文件。
在 GCP 中创建和配置 VPC 和相关的子网。

步骤

复制本主题“私有 DNS 的 Deployment Manager 模板”部分中的模板，并将其保存为计算机上的02_dns.py。此模板描述了集群所需的私有 DNS 对象。

创建一个02_dns.yaml资源定义文件

$ cat <<EOF >02_dns.yaml
imports:
- path: 02_dns.py

resources:
- name: cluster-dns
  type: 02_dns.py
  properties:
    infra_id: '${INFRA_ID}' (1)
    cluster_domain: '${CLUSTER_NAME}.${BASE_DOMAIN}' (2)
    cluster_network: '${CLUSTER_NETWORK}' (3)
EOF

1	`infra_id` 是提取步骤中的 `INFRA_ID` 基础设施名称。
2	`cluster_domain` 是集群的域名，例如`openshift.example.com`。
3	`cluster_network` 是集群网络的`selfLink` URL。

使用 gcloud CLI 创建部署。

$ gcloud deployment-manager deployments create ${INFRA_ID}-dns --config 02_dns.yaml

由于 Deployment Manager 的限制，模板不会创建 DNS 条目，因此您必须手动创建它们

添加内部 DNS 条目

$ if [ -f transaction.yaml ]; then rm transaction.yaml; fi
$ gcloud dns record-sets transaction start --zone ${INFRA_ID}-private-zone
$ gcloud dns record-sets transaction add ${CLUSTER_IP} --name api.${CLUSTER_NAME}.${BASE_DOMAIN}. --ttl 60 --type A --zone ${INFRA_ID}-private-zone
$ gcloud dns record-sets transaction add ${CLUSTER_IP} --name api-int.${CLUSTER_NAME}.${BASE_DOMAIN}. --ttl 60 --type A --zone ${INFRA_ID}-private-zone
$ gcloud dns record-sets transaction execute --zone ${INFRA_ID}-private-zone

对于外部集群，还要添加外部 DNS 条目

$ if [ -f transaction.yaml ]; then rm transaction.yaml; fi
$ gcloud dns record-sets transaction start --zone ${BASE_DOMAIN_ZONE_NAME}
$ gcloud dns record-sets transaction add ${CLUSTER_PUBLIC_IP} --name api.${CLUSTER_NAME}.${BASE_DOMAIN}. --ttl 60 --type A --zone ${BASE_DOMAIN_ZONE_NAME}
$ gcloud dns record-sets transaction execute --zone ${BASE_DOMAIN_ZONE_NAME}

私有 DNS 的 Deployment Manager 模板

您可以使用以下 Deployment Manager 模板部署 OpenShift Container Platform 集群所需的私有 DNS

02_dns.py Deployment Manager 模板

def GenerateConfig(context):

    resources = [{
        'name': context.properties['infra_id'] + '-private-zone',
        'type': 'dns.v1.managedZone',
        'properties': {
            'description': '',
            'dnsName': context.properties['cluster_domain'] + '.',
            'visibility': 'private',
            'privateVisibilityConfig': {
                'networks': [{
                    'networkUrl': context.properties['cluster_network']
                }]
            }
        }
    }]

    return {'resources': resources}

在 GCP 中创建防火墙规则

您必须在 Google Cloud Platform (GCP) 中为您的 OpenShift Container Platform 集群创建防火墙规则。创建这些组件的一种方法是修改提供的 Deployment Manager 模板。

先决条件

配置 GCP 帐户。
为您的集群生成 Ignition 配置文件。
在 GCP 中创建和配置 VPC 和相关的子网。

步骤

复制本主题“防火墙规则的 Deployment Manager 模板”部分中的模板，并将其保存为计算机上的03_firewall.py。此模板描述了集群所需的安全性组。

创建一个03_firewall.yaml资源定义文件

$ cat <<EOF >03_firewall.yaml
imports:
- path: 03_firewall.py

resources:
- name: cluster-firewall
  type: 03_firewall.py
  properties:
    allowed_external_cidr: '0.0.0.0/0' (1)
    infra_id: '${INFRA_ID}' (2)
    cluster_network: '${CLUSTER_NETWORK}' (3)
    network_cidr: '${NETWORK_CIDR}' (4)
EOF

1	`allowed_external_cidr` 是可以访问集群 API 并通过 SSH 连接到引导主机的 CIDR 范围。对于内部集群，将此值设置为`${NETWORK_CIDR}`。
2	`infra_id` 是提取步骤中的 `INFRA_ID` 基础设施名称。
3	`cluster_network` 是集群网络的`selfLink` URL。
4	`network_cidr` 是 VPC 网络的 CIDR，例如`10.0.0.0/16`。

使用 gcloud CLI 创建部署。

$ gcloud deployment-manager deployments create ${INFRA_ID}-firewall --config 03_firewall.yaml

防火墙规则的 Deployment Manager 模板

您可以使用以下 Deployment Manager 模板部署 OpenShift Container Platform 集群所需的防火墙规则。

03_firewall.py Deployment Manager 模板

def GenerateConfig(context):

    resources = [{
        'name': context.properties['infra_id'] + '-bootstrap-in-ssh',
        'type': 'compute.v1.firewall',
        'properties': {
            'network': context.properties['cluster_network'],
            'allowed': [{
                'IPProtocol': 'tcp',
                'ports': ['22']
            }],
            'sourceRanges': [context.properties['allowed_external_cidr']],
            'targetTags': [context.properties['infra_id'] + '-bootstrap']
        }
    }, {
        'name': context.properties['infra_id'] + '-api',
        'type': 'compute.v1.firewall',
        'properties': {
            'network': context.properties['cluster_network'],
            'allowed': [{
                'IPProtocol': 'tcp',
                'ports': ['6443']
            }],
            'sourceRanges': [context.properties['allowed_external_cidr']],
            'targetTags': [context.properties['infra_id'] + '-master']
        }
    }, {
        'name': context.properties['infra_id'] + '-health-checks',
        'type': 'compute.v1.firewall',
        'properties': {
            'network': context.properties['cluster_network'],
            'allowed': [{
                'IPProtocol': 'tcp',
                'ports': ['6080', '6443', '22624']
            }],
            'sourceRanges': ['35.191.0.0/16', '130.211.0.0/22', '209.85.152.0/22', '209.85.204.0/22'],
            'targetTags': [context.properties['infra_id'] + '-master']
        }
    }, {
        'name': context.properties['infra_id'] + '-etcd',
        'type': 'compute.v1.firewall',
        'properties': {
            'network': context.properties['cluster_network'],
            'allowed': [{
                'IPProtocol': 'tcp',
                'ports': ['2379-2380']
            }],
            'sourceTags': [context.properties['infra_id'] + '-master'],
            'targetTags': [context.properties['infra_id'] + '-master']
        }
    }, {
        'name': context.properties['infra_id'] + '-control-plane',
        'type': 'compute.v1.firewall',
        'properties': {
            'network': context.properties['cluster_network'],
            'allowed': [{
                'IPProtocol': 'tcp',
                'ports': ['10257']
            },{
                'IPProtocol': 'tcp',
                'ports': ['10259']
            },{
                'IPProtocol': 'tcp',
                'ports': ['22623']
            }],
            'sourceTags': [
                context.properties['infra_id'] + '-master',
                context.properties['infra_id'] + '-worker'
            ],
            'targetTags': [context.properties['infra_id'] + '-master']
        }
    }, {
        'name': context.properties['infra_id'] + '-internal-network',
        'type': 'compute.v1.firewall',
        'properties': {
            'network': context.properties['cluster_network'],
            'allowed': [{
                'IPProtocol': 'icmp'
            },{
                'IPProtocol': 'tcp',
                'ports': ['22']
            }],
            'sourceRanges': [context.properties['network_cidr']],
            'targetTags': [
                context.properties['infra_id'] + '-master',
                context.properties['infra_id'] + '-worker'
            ]
        }
    }, {
        'name': context.properties['infra_id'] + '-internal-cluster',
        'type': 'compute.v1.firewall',
        'properties': {
            'network': context.properties['cluster_network'],
            'allowed': [{
                'IPProtocol': 'udp',
                'ports': ['4789', '6081']
            },{
                'IPProtocol': 'udp',
                'ports': ['500', '4500']
            },{
                'IPProtocol': 'esp',
            },{
                'IPProtocol': 'tcp',
                'ports': ['9000-9999']
            },{
                'IPProtocol': 'udp',
                'ports': ['9000-9999']
            },{
                'IPProtocol': 'tcp',
                'ports': ['10250']
            },{
                'IPProtocol': 'tcp',
                'ports': ['30000-32767']
            },{
                'IPProtocol': 'udp',
                'ports': ['30000-32767']
            }],
            'sourceTags': [
                context.properties['infra_id'] + '-master',
                context.properties['infra_id'] + '-worker'
            ],
            'targetTags': [
                context.properties['infra_id'] + '-master',
                context.properties['infra_id'] + '-worker'
            ]
        }
    }]

    return {'resources': resources}

在 GCP 中创建 IAM 角色

您的 OpenShift Container Platform 集群必须在 Google Cloud Platform (GCP) 中创建 IAM 角色才能使用。创建这些组件的一种方法是修改提供的 Deployment Manager 模板。

先决条件

配置 GCP 帐户。
为您的集群生成 Ignition 配置文件。
在 GCP 中创建和配置 VPC 和相关的子网。

步骤

从本主题的“IAM 角色的 Deployment Manager 模板”部分复制模板，并将其另存为计算机上的03_iam.py。此模板描述了集群所需的 IAM 角色。

创建一个03_iam.yaml 资源定义文件。

$ cat <<EOF >03_iam.yaml
imports:
- path: 03_iam.py
resources:
- name: cluster-iam
  type: 03_iam.py
  properties:
    infra_id: '${INFRA_ID}' (1)
EOF

1	`infra_id` 是提取步骤中的 `INFRA_ID` 基础设施名称。

使用 gcloud CLI 创建部署。

$ gcloud deployment-manager deployments create ${INFRA_ID}-iam --config 03_iam.yaml

导出主服务帐户的变量。

$ export MASTER_SERVICE_ACCOUNT=(`gcloud iam service-accounts list --filter "email~^${INFRA_ID}-m@${PROJECT_NAME}." --format json | jq -r '.[0].email'`)

导出工作服务帐户的变量。

$ export WORKER_SERVICE_ACCOUNT=(`gcloud iam service-accounts list --filter "email~^${INFRA_ID}-w@${PROJECT_NAME}." --format json | jq -r '.[0].email'`)

导出托管计算机的子网的变量。

$ export COMPUTE_SUBNET=(`gcloud compute networks subnets describe ${INFRA_ID}-worker-subnet --region=${REGION} --format json | jq -r .selfLink`)

由于 Deployment Manager 的限制，模板不会创建策略绑定，因此您必须手动创建它们。

$ gcloud projects add-iam-policy-binding ${PROJECT_NAME} --member "serviceAccount:${MASTER_SERVICE_ACCOUNT}" --role "roles/compute.instanceAdmin"
$ gcloud projects add-iam-policy-binding ${PROJECT_NAME} --member "serviceAccount:${MASTER_SERVICE_ACCOUNT}" --role "roles/compute.networkAdmin"
$ gcloud projects add-iam-policy-binding ${PROJECT_NAME} --member "serviceAccount:${MASTER_SERVICE_ACCOUNT}" --role "roles/compute.securityAdmin"
$ gcloud projects add-iam-policy-binding ${PROJECT_NAME} --member "serviceAccount:${MASTER_SERVICE_ACCOUNT}" --role "roles/iam.serviceAccountUser"
$ gcloud projects add-iam-policy-binding ${PROJECT_NAME} --member "serviceAccount:${MASTER_SERVICE_ACCOUNT}" --role "roles/storage.admin"

$ gcloud projects add-iam-policy-binding ${PROJECT_NAME} --member "serviceAccount:${WORKER_SERVICE_ACCOUNT}" --role "roles/compute.viewer"
$ gcloud projects add-iam-policy-binding ${PROJECT_NAME} --member "serviceAccount:${WORKER_SERVICE_ACCOUNT}" --role "roles/storage.admin"

创建服务帐户密钥并将其存储在本地以备后用。

$ gcloud iam service-accounts keys create service-account-key.json --iam-account=${MASTER_SERVICE_ACCOUNT}

IAM 角色的 Deployment Manager 模板

您可以使用以下 Deployment Manager 模板部署 OpenShift Container Platform 集群所需的 IAM 角色。

03_iam.py Deployment Manager 模板

def GenerateConfig(context):

    resources = [{
        'name': context.properties['infra_id'] + '-master-node-sa',
        'type': 'iam.v1.serviceAccount',
        'properties': {
            'accountId': context.properties['infra_id'] + '-m',
            'displayName': context.properties['infra_id'] + '-master-node'
        }
    }, {
        'name': context.properties['infra_id'] + '-worker-node-sa',
        'type': 'iam.v1.serviceAccount',
        'properties': {
            'accountId': context.properties['infra_id'] + '-w',
            'displayName': context.properties['infra_id'] + '-worker-node'
        }
    }]

    return {'resources': resources}

为 GCP 基础架构创建 RHCOS 集群镜像

您的 OpenShift Container Platform 节点必须使用适用于 Google Cloud Platform (GCP) 的有效 Red Hat Enterprise Linux CoreOS (RHCOS) 镜像。

步骤

从RHCOS 镜像镜像页面获取 RHCOS 镜像。

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

文件名包含 OpenShift Container Platform 版本号，格式为rhcos-<version>-<arch>-gcp.<arch>.tar.gz。

创建 Google 存储桶。
```
$ gsutil mb gs://<bucket_name>
```

将 RHCOS 镜像上传到 Google 存储桶。

$ gsutil cp <downloaded_image_file_path>/rhcos-<version>-x86_64-gcp.x86_64.tar.gz  gs://<bucket_name>

将上传的 RHCOS 镜像位置导出为变量。

$ export IMAGE_SOURCE=gs://<bucket_name>/rhcos-<version>-x86_64-gcp.x86_64.tar.gz

创建集群镜像。

$ gcloud compute images create "${INFRA_ID}-rhcos-image" \
    --source-uri="${IMAGE_SOURCE}"

在 GCP 中创建引导机器

在 OpenShift Container Platform 集群初始化期间，您必须在 Google Cloud Platform (GCP) 中创建引导机器。创建此机器的一种方法是修改提供的 Deployment Manager 模板。

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

先决条件

配置 GCP 帐户。
为您的集群生成 Ignition 配置文件。
在 GCP 中创建和配置 VPC 和相关的子网。
在 GCP 中创建和配置网络和负载均衡器。
创建控制平面和计算角色。
确保已安装 pyOpenSSL。

步骤

从本主题的“引导机器的 Deployment Manager 模板”部分复制模板，并将其另存为计算机上的04_bootstrap.py。此模板描述了集群所需的引导机器。

导出安装程序所需的 Red Hat Enterprise Linux CoreOS (RHCOS) 镜像的位置。

$ export CLUSTER_IMAGE=(`gcloud compute images describe ${INFRA_ID}-rhcos-image --format json | jq -r .selfLink`)

创建一个存储桶并上传bootstrap.ign文件。

$ gsutil mb gs://${INFRA_ID}-bootstrap-ignition

$ gsutil cp <installation_directory>/bootstrap.ign gs://${INFRA_ID}-bootstrap-ignition/

为引导实例创建签名的 URL，以便访问 Ignition 配置。将输出中的 URL 导出为变量。

$ export BOOTSTRAP_IGN=`gsutil signurl -d 1h service-account-key.json gs://${INFRA_ID}-bootstrap-ignition/bootstrap.ign | grep "^gs:" | awk '{print $5}'`

创建一个04_bootstrap.yaml资源定义文件。

$ cat <<EOF >04_bootstrap.yaml
imports:
- path: 04_bootstrap.py

resources:
- name: cluster-bootstrap
  type: 04_bootstrap.py
  properties:
    infra_id: '${INFRA_ID}' (1)
    region: '${REGION}' (2)
    zone: '${ZONE_0}' (3)

    cluster_network: '${CLUSTER_NETWORK}' (4)
    control_subnet: '${CONTROL_SUBNET}' (5)
    image: '${CLUSTER_IMAGE}' (6)
    machine_type: 'n1-standard-4' (7)
    root_volume_size: '128' (8)

    bootstrap_ign: '${BOOTSTRAP_IGN}' (9)
EOF

1	`infra_id` 是提取步骤中的 `INFRA_ID` 基础设施名称。
2	`region` 是部署集群的区域，例如 `us-central1`。
3	`zone` 是部署引导实例的区域，例如`us-central1-b`。
4	`cluster_network` 是集群网络的`selfLink` URL。
5	`control_subnet` 是控制子网的`selfLink` URL。
6	`image` 是 RHCOS 镜像的`selfLink` URL。
7	`machine_type` 是实例的机器类型，例如`n1-standard-4`。
8	`root_volume_size` 是引导机器的引导磁盘大小。
9	`bootstrap_ign` 是创建签名的 URL 时输出的 URL。

使用 gcloud CLI 创建部署。

$ gcloud deployment-manager deployments create ${INFRA_ID}-bootstrap --config 04_bootstrap.yaml

由于 Deployment Manager 的限制，模板不管理负载均衡器成员资格，因此您必须手动添加引导机器。

将引导实例添加到内部负载均衡器实例组。

$ gcloud compute instance-groups unmanaged add-instances \
    ${INFRA_ID}-bootstrap-ig --zone=${ZONE_0} --instances=${INFRA_ID}-bootstrap

将引导实例组添加到内部负载均衡器后端服务。

$ gcloud compute backend-services add-backend \
    ${INFRA_ID}-api-internal --region=${REGION} --instance-group=${INFRA_ID}-bootstrap-ig --instance-group-zone=${ZONE_0}

引导机器的 Deployment Manager 模板

您可以使用以下 Deployment Manager 模板部署 OpenShift Container Platform 集群所需的引导机器。

04_bootstrap.py Deployment Manager 模板

def GenerateConfig(context):

    resources = [{
        'name': context.properties['infra_id'] + '-bootstrap-public-ip',
        'type': 'compute.v1.address',
        'properties': {
            'region': context.properties['region']
        }
    }, {
        'name': context.properties['infra_id'] + '-bootstrap',
        'type': 'compute.v1.instance',
        'properties': {
            'disks': [{
                'autoDelete': True,
                'boot': True,
                'initializeParams': {
                    'diskSizeGb': context.properties['root_volume_size'],
                    'sourceImage': context.properties['image']
                }
            }],
            'machineType': 'zones/' + context.properties['zone'] + '/machineTypes/' + context.properties['machine_type'],
            'metadata': {
                'items': [{
                    'key': 'user-data',
                    'value': '{"ignition":{"config":{"replace":{"source":"' + context.properties['bootstrap_ign'] + '"}},"version":"3.2.0"}}',
                }]
            },
            'networkInterfaces': [{
                'subnetwork': context.properties['control_subnet'],
                'accessConfigs': [{
                    'natIP': '$(ref.' + context.properties['infra_id'] + '-bootstrap-public-ip.address)'
                }]
            }],
            'tags': {
                'items': [
                    context.properties['infra_id'] + '-master',
                    context.properties['infra_id'] + '-bootstrap'
                ]
            },
            'zone': context.properties['zone']
        }
    }, {
        'name': context.properties['infra_id'] + '-bootstrap-ig',
        'type': 'compute.v1.instanceGroup',
        'properties': {
            'namedPorts': [
                {
                    'name': 'ignition',
                    'port': 22623
                }, {
                    'name': 'https',
                    'port': 6443
                }
            ],
            'network': context.properties['cluster_network'],
            'zone': context.properties['zone']
        }
    }]

    return {'resources': resources}

在 GCP 中创建控制平面机器

您的集群必须在 Google Cloud Platform (GCP) 中创建控制平面机器才能使用。创建这些机器的一种方法是修改提供的 Deployment Manager 模板。

如果您不使用提供的 Deployment Manager 模板创建控制平面机器，则必须查看提供的信息并手动创建基础架构。如果您的集群无法正确初始化，您可能需要联系 Red Hat 支持人员并提供您的安装日志。

先决条件

配置 GCP 帐户。
为您的集群生成 Ignition 配置文件。
在 GCP 中创建和配置 VPC 和相关的子网。
在 GCP 中创建和配置网络和负载均衡器。
创建控制平面和计算角色。
创建引导机器。

步骤

从本主题的“控制平面机器的 Deployment Manager 模板”部分复制模板，并将其另存为计算机上的05_control_plane.py。此模板描述了集群所需的控制平面机器。

导出资源定义所需的以下变量。

$ export MASTER_IGNITION=`cat <installation_directory>/master.ign`

创建一个05_control_plane.yaml资源定义文件。

$ cat <<EOF >05_control_plane.yaml
imports:
- path: 05_control_plane.py

resources:
- name: cluster-control-plane
  type: 05_control_plane.py
  properties:
    infra_id: '${INFRA_ID}' (1)
    zones: (2)
    - '${ZONE_0}'
    - '${ZONE_1}'
    - '${ZONE_2}'

    control_subnet: '${CONTROL_SUBNET}' (3)
    image: '${CLUSTER_IMAGE}' (4)
    machine_type: 'n1-standard-4' (5)
    root_volume_size: '128'
    service_account_email: '${MASTER_SERVICE_ACCOUNT}' (6)

    ignition: '${MASTER_IGNITION}' (7)
EOF

1	`infra_id` 是提取步骤中的 `INFRA_ID` 基础设施名称。
2	`zones` 是部署控制平面实例的区域，例如`us-central1-a`、`us-central1-b`和`us-central1-c`。
3	`control_subnet` 是控制子网的`selfLink` URL。
4	`image` 是 RHCOS 镜像的`selfLink` URL。
5	`machine_type` 是实例的机器类型，例如`n1-standard-4`。
6	`service_account_email` 是您创建的主服务帐户的电子邮件地址。
7	`ignition` 是`master.ign`文件的内容。

使用 gcloud CLI 创建部署。

$ gcloud deployment-manager deployments create ${INFRA_ID}-control-plane --config 05_control_plane.yaml

由于 Deployment Manager 的限制，模板不管理负载均衡器成员资格，因此您必须手动添加控制平面机器。

运行以下命令将控制平面机器添加到相应的实例组。

$ gcloud compute instance-groups unmanaged add-instances ${INFRA_ID}-master-${ZONE_0}-ig --zone=${ZONE_0} --instances=${INFRA_ID}-master-0

$ gcloud compute instance-groups unmanaged add-instances ${INFRA_ID}-master-${ZONE_1}-ig --zone=${ZONE_1} --instances=${INFRA_ID}-master-1

$ gcloud compute instance-groups unmanaged add-instances ${INFRA_ID}-master-${ZONE_2}-ig --zone=${ZONE_2} --instances=${INFRA_ID}-master-2

对于外部集群，您还必须运行以下命令才能将控制平面机器添加到目标池。

$ gcloud compute target-pools add-instances ${INFRA_ID}-api-target-pool --instances-zone="${ZONE_0}" --instances=${INFRA_ID}-master-0

$ gcloud compute target-pools add-instances ${INFRA_ID}-api-target-pool --instances-zone="${ZONE_1}" --instances=${INFRA_ID}-master-1

$ gcloud compute target-pools add-instances ${INFRA_ID}-api-target-pool --instances-zone="${ZONE_2}" --instances=${INFRA_ID}-master-2

控制平面机器的 Deployment Manager 模板

您可以使用以下 Deployment Manager 模板部署 OpenShift Container Platform 集群所需的控制平面机器。

05_control_plane.py Deployment Manager 模板

def GenerateConfig(context):

    resources = [{
        'name': context.properties['infra_id'] + '-master-0',
        'type': 'compute.v1.instance',
        'properties': {
            'disks': [{
                'autoDelete': True,
                'boot': True,
                'initializeParams': {
                    'diskSizeGb': context.properties['root_volume_size'],
                    'diskType': 'zones/' + context.properties['zones'][0] + '/diskTypes/pd-ssd',
                    'sourceImage': context.properties['image']
                }
            }],
            'machineType': 'zones/' + context.properties['zones'][0] + '/machineTypes/' + context.properties['machine_type'],
            'metadata': {
                'items': [{
                    'key': 'user-data',
                    'value': context.properties['ignition']
                }]
            },
            'networkInterfaces': [{
                'subnetwork': context.properties['control_subnet']
            }],
            'serviceAccounts': [{
                'email': context.properties['service_account_email'],
                'scopes': ['https://www.googleapis.com/auth/cloud-platform']
            }],
            'tags': {
                'items': [
                    context.properties['infra_id'] + '-master',
                ]
            },
            'zone': context.properties['zones'][0]
        }
    }, {
        'name': context.properties['infra_id'] + '-master-1',
        'type': 'compute.v1.instance',
        'properties': {
            'disks': [{
                'autoDelete': True,
                'boot': True,
                'initializeParams': {
                    'diskSizeGb': context.properties['root_volume_size'],
                    'diskType': 'zones/' + context.properties['zones'][1] + '/diskTypes/pd-ssd',
                    'sourceImage': context.properties['image']
                }
            }],
            'machineType': 'zones/' + context.properties['zones'][1] + '/machineTypes/' + context.properties['machine_type'],
            'metadata': {
                'items': [{
                    'key': 'user-data',
                    'value': context.properties['ignition']
                }]
            },
            'networkInterfaces': [{
                'subnetwork': context.properties['control_subnet']
            }],
            'serviceAccounts': [{
                'email': context.properties['service_account_email'],
                'scopes': ['https://www.googleapis.com/auth/cloud-platform']
            }],
            'tags': {
                'items': [
                    context.properties['infra_id'] + '-master',
                ]
            },
            'zone': context.properties['zones'][1]
        }
    }, {
        'name': context.properties['infra_id'] + '-master-2',
        'type': 'compute.v1.instance',
        'properties': {
            'disks': [{
                'autoDelete': True,
                'boot': True,
                'initializeParams': {
                    'diskSizeGb': context.properties['root_volume_size'],
                    'diskType': 'zones/' + context.properties['zones'][2] + '/diskTypes/pd-ssd',
                    'sourceImage': context.properties['image']
                }
            }],
            'machineType': 'zones/' + context.properties['zones'][2] + '/machineTypes/' + context.properties['machine_type'],
            'metadata': {
                'items': [{
                    'key': 'user-data',
                    'value': context.properties['ignition']
                }]
            },
            'networkInterfaces': [{
                'subnetwork': context.properties['control_subnet']
            }],
            'serviceAccounts': [{
                'email': context.properties['service_account_email'],
                'scopes': ['https://www.googleapis.com/auth/cloud-platform']
            }],
            'tags': {
                'items': [
                    context.properties['infra_id'] + '-master',
                ]
            },
            'zone': context.properties['zones'][2]
        }
    }]

    return {'resources': resources}

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

在 Google Cloud Platform (GCP) 中创建所有必需的基础架构后，请等待引导过程在您使用安装程序生成的 Ignition 配置文件配置的机器上完成。

先决条件

配置 GCP 帐户。
为您的集群生成 Ignition 配置文件。
在 GCP 中创建和配置 VPC 和相关的子网。
在 GCP 中创建和配置网络和负载均衡器。
创建控制平面和计算角色。
创建引导机器。
创建控制平面机器。

步骤

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

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

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

删除引导资源。

$ gcloud compute backend-services remove-backend ${INFRA_ID}-api-internal --region=${REGION} --instance-group=${INFRA_ID}-bootstrap-ig --instance-group-zone=${ZONE_0}

$ gsutil rm gs://${INFRA_ID}-bootstrap-ignition/bootstrap.ign

$ gsutil rb gs://${INFRA_ID}-bootstrap-ignition

$ gcloud deployment-manager deployments delete ${INFRA_ID}-bootstrap

在 GCP 中创建其他工作机器

您可以通过单独启动实例或通过集群外的自动化流程（例如自动扩展组）在 Google Cloud Platform (GCP) 中创建集群可以使用的工作机器。您还可以利用 OpenShift Container Platform 中内置的集群扩展机制和机器 API。

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

在本例中，您将使用部署管理器模板手动启动一个实例。可以通过在文件中包含更多类型为06_worker.py的资源来启动更多实例。

如果您不使用提供的部署管理器模板来创建您的工作机器，则必须查看提供的资料并手动创建基础设施。如果您的集群未正确初始化，您可能需要联系 Red Hat 支持并提供您的安装日志。

先决条件

配置 GCP 帐户。
为您的集群生成 Ignition 配置文件。
在 GCP 中创建和配置 VPC 和相关的子网。
在 GCP 中创建和配置网络和负载均衡器。
创建控制平面和计算角色。
创建引导机器。
创建控制平面机器。

步骤

从本主题的**工作机器部署管理器模板**部分复制模板，并将其保存为计算机上的06_worker.py文件。此模板描述了集群所需的工作机器。

导出资源定义使用的变量。

导出承载计算机的子网

$ export COMPUTE_SUBNET=(`gcloud compute networks subnets describe ${INFRA_ID}-worker-subnet --region=${REGION} --format json | jq -r .selfLink`)

导出您的服务帐户的电子邮件地址

$ export WORKER_SERVICE_ACCOUNT=(`gcloud iam service-accounts list --filter "email~^${INFRA_ID}-w@${PROJECT_NAME}." --format json | jq -r '.[0].email'`)

导出计算机器 Ignition 配置文件的位置

$ export WORKER_IGNITION=`cat <installation_directory>/worker.ign`

创建一个06_worker.yaml资源定义文件

$ cat <<EOF >06_worker.yaml
imports:
- path: 06_worker.py

resources:
- name: 'worker-0' (1)
  type: 06_worker.py
  properties:
    infra_id: '${INFRA_ID}' (2)
    zone: '${ZONE_0}' (3)
    compute_subnet: '${COMPUTE_SUBNET}' (4)
    image: '${CLUSTER_IMAGE}' (5)
    machine_type: 'n1-standard-4' (6)
    root_volume_size: '128'
    service_account_email: '${WORKER_SERVICE_ACCOUNT}' (7)
    ignition: '${WORKER_IGNITION}' (8)
- name: 'worker-1'
  type: 06_worker.py
  properties:
    infra_id: '${INFRA_ID}' (2)
    zone: '${ZONE_1}' (3)
    compute_subnet: '${COMPUTE_SUBNET}' (4)
    image: '${CLUSTER_IMAGE}' (5)
    machine_type: 'n1-standard-4' (6)
    root_volume_size: '128'
    service_account_email: '${WORKER_SERVICE_ACCOUNT}' (7)
    ignition: '${WORKER_IGNITION}' (8)
EOF

1	`name` 是工作机器的名称，例如`worker-0`。
2	`infra_id` 是提取步骤中的 `INFRA_ID` 基础设施名称。
3	`zone` 是部署工作机器的区域，例如`us-central1-a`。
4	`compute_subnet` 是计算子网的`selfLink` URL。
5	`image` 是 RHCOS 镜像的`selfLink` URL。¹
6	`machine_type` 是实例的机器类型，例如`n1-standard-4`。
7	`service_account_email` 是您创建的工作人员服务帐户的电子邮件地址。
8	`ignition` 是`worker.ign`文件的内容。

可选：如果您想启动更多实例，请在您的06_worker.yaml资源定义文件中包含更多类型为06_worker.py的资源。

使用 gcloud CLI 创建部署。

$ gcloud deployment-manager deployments create ${INFRA_ID}-worker --config 06_worker.yaml

要使用 GCP Marketplace 镜像，请指定要使用的产品。
- OpenShift Container Platform：https://www.googleapis.com/compute/v1/projects/redhat-marketplace-public/global/images/redhat-coreos-ocp-413-x86-64-202305021736
- OpenShift Platform Plus：https://www.googleapis.com/compute/v1/projects/redhat-marketplace-public/global/images/redhat-coreos-opp-413-x86-64-202305021736
- OpenShift Kubernetes Engine：https://www.googleapis.com/compute/v1/projects/redhat-marketplace-public/global/images/redhat-coreos-oke-413-x86-64-202305021736

工作机器部署管理器模板

您可以使用以下部署管理器模板部署 OpenShift Container Platform 集群所需的工作机器。

06_worker.py 部署管理器模板

def GenerateConfig(context):

    resources = [{
        'name': context.properties['infra_id'] + '-' + context.env['name'],
        'type': 'compute.v1.instance',
        'properties': {
            'disks': [{
                'autoDelete': True,
                'boot': True,
                'initializeParams': {
                    'diskSizeGb': context.properties['root_volume_size'],
                    'sourceImage': context.properties['image']
                }
            }],
            'machineType': 'zones/' + context.properties['zone'] + '/machineTypes/' + context.properties['machine_type'],
            'metadata': {
                'items': [{
                    'key': 'user-data',
                    'value': context.properties['ignition']
                }]
            },
            'networkInterfaces': [{
                'subnetwork': context.properties['compute_subnet']
            }],
            'serviceAccounts': [{
                'email': context.properties['service_account_email'],
                'scopes': ['https://www.googleapis.com/auth/cloud-platform']
            }],
            'tags': {
                'items': [
                    context.properties['infra_id'] + '-worker',
                ]
            },
            'zone': context.properties['zone']
        }
    }]

    return {'resources': resources}

安装 OpenShift 命令行工具

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

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

在 Linux 上安装 OpenShift 命令行工具

您可以使用以下步骤在 Linux 上安装 OpenShift 命令行工具 (oc) 二进制文件。

步骤

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

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

验证

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

在 Windows 上安装 OpenShift 命令行工具

您可以使用以下步骤在 Windows 上安装 OpenShift 命令行工具 (oc) 二进制文件。

步骤

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

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

验证

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

在 macOS 上安装 OpenShift 命令行工具

您可以使用以下步骤在 macOS 上安装 OpenShift 命令行工具 (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，并确保您看到每个添加到集群的机器的客户端请求的状态为Pending或Approved。

$ oc get csr

示例输出

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

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

如果 CSR 未获批准，在您添加的所有机器的挂起 CSR 状态均为Pending后，请批准集群机器的 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

某些 Operators 可能会在批准某些 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 未获批准且状态为Pending，请批准集群机器的 CSR。
- 要单独批准它们，请对每个有效的 CSR 运行以下命令：
  $ oc adm certificate approve <csr_name> (1)
  1 <csr_name> 是当前 CSR 列表中 CSR 的名称。
- 要批准所有挂起的 CSR，请运行以下命令：
  $ oc get csr -o go-template='{{range .items}}{{if not .status}}{{.metadata.name}}{{"\n"}}{{end}}{{end}}' | xargs oc adm certificate approve

批准所有客户端和服务器 CSR 后，机器将具有Ready 状态。通过运行以下命令验证这一点：

$ 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 后，机器可能需要几分钟才能转换为Ready 状态。

附加信息

证书签名请求

可选：添加入口 DNS 记录

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

先决条件

配置 GCP 帐户。
创建 Kubernetes 清单和生成 Ignition 配置时，删除 DNS 区域配置。
在 GCP 中创建和配置 VPC 和相关的子网。
在 GCP 中创建和配置网络和负载均衡器。
创建控制平面和计算角色。
创建引导机器。
创建控制平面机器。
创建工作机器。

步骤

等待 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.18.154   35.233.157.184   80:32288/TCP,443:31215/TCP   98

将 A 记录添加到您的区域。

要使用 A 记录：

导出路由器 IP 地址的变量。

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

将 A 记录添加到私有区域。

$ if [ -f transaction.yaml ]; then rm transaction.yaml; fi
$ gcloud dns record-sets transaction start --zone ${INFRA_ID}-private-zone
$ gcloud dns record-sets transaction add ${ROUTER_IP} --name \*.apps.${CLUSTER_NAME}.${BASE_DOMAIN}. --ttl 300 --type A --zone ${INFRA_ID}-private-zone
$ gcloud dns record-sets transaction execute --zone ${INFRA_ID}-private-zone

对于外部集群，还要将 A 记录添加到公共区域。

$ if [ -f transaction.yaml ]; then rm transaction.yaml; fi
$ gcloud dns record-sets transaction start --zone ${BASE_DOMAIN_ZONE_NAME}
$ gcloud dns record-sets transaction add ${ROUTER_IP} --name \*.apps.${CLUSTER_NAME}.${BASE_DOMAIN}. --ttl 300 --type A --zone ${BASE_DOMAIN_ZONE_NAME}
$ gcloud dns record-sets transaction execute --zone ${BASE_DOMAIN_ZONE_NAME}

要添加显式域名而不是使用通配符，请为集群的每个当前路由创建条目。

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

示例输出

oauth-openshift.apps.your.cluster.domain.example.com
console-openshift-console.apps.your.cluster.domain.example.com
downloads-openshift-console.apps.your.cluster.domain.example.com
alertmanager-main-openshift-monitoring.apps.your.cluster.domain.example.com
prometheus-k8s-openshift-monitoring.apps.your.cluster.domain.example.com

完成用户预配基础设施上的 GCP 安装

在 Google Cloud Platform (GCP) 用户预配的基础设施上启动 OpenShift Container Platform 安装后，您可以监视集群事件，直到集群准备就绪。

先决条件

为用户预配的 GCP 基础设施上的 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 小时内使用它们，因为集群安装后 16 到 22 小时，24 小时证书会轮换。在 12 小时内使用 Ignition 配置文件，可以避免在安装过程中证书更新导致安装失败。

观察集群的运行状态。

运行以下命令以查看当前集群版本和状态：

$ oc get clusterversion

示例输出

NAME      VERSION   AVAILABLE   PROGRESSING   SINCE   STATUS
version             False       True          24m     Working towards 4.5.4: 99% complete

运行以下命令以查看由集群版本运算符 (CVO) 在控制平面管理的 Operators：

$ oc get clusteroperators

示例输出

NAME                                       VERSION   AVAILABLE   PROGRESSING   DEGRADED   SINCE
authentication                             4.5.4     True        False         False      7m56s
cloud-credential                           4.5.4     True        False         False      31m
cluster-autoscaler                         4.5.4     True        False         False      16m
console                                    4.5.4     True        False         False      10m
csi-snapshot-controller                    4.5.4     True        False         False      16m
dns                                        4.5.4     True        False         False      22m
etcd                                       4.5.4     False       False         False      25s
image-registry                             4.5.4     True        False         False      16m
ingress                                    4.5.4     True        False         False      16m
insights                                   4.5.4     True        False         False      17m
kube-apiserver                             4.5.4     True        False         False      19m
kube-controller-manager                    4.5.4     True        False         False      20m
kube-scheduler                             4.5.4     True        False         False      20m
kube-storage-version-migrator              4.5.4     True        False         False      16m
machine-api                                4.5.4     True        False         False      22m
machine-config                             4.5.4     True        False         False      22m
marketplace                                4.5.4     True        False         False      16m
monitoring                                 4.5.4     True        False         False      10m
network                                    4.5.4     True        False         False      23m
node-tuning                                4.5.4     True        False         False      23m
openshift-apiserver                        4.5.4     True        False         False      17m
openshift-controller-manager               4.5.4     True        False         False      15m
openshift-samples                          4.5.4     True        False         False      16m
operator-lifecycle-manager                 4.5.4     True        False         False      22m
operator-lifecycle-manager-catalog         4.5.4     True        False         False      22m
operator-lifecycle-manager-packageserver   4.5.4     True        False         False      18m
service-ca                                 4.5.4     True        False         False      23m
service-catalog-apiserver                  4.5.4     True        False         False      23m
service-catalog-controller-manager         4.5.4     True        False         False      23m
storage                                    4.5.4     True        False         False      17m

运行以下命令以查看您的集群 Pod：

$ oc get pods --all-namespaces

示例输出

NAMESPACE                                               NAME                                                                READY     STATUS      RESTARTS   AGE
kube-system                                             etcd-member-ip-10-0-3-111.us-east-2.compute.internal                1/1       Running     0          35m
kube-system                                             etcd-member-ip-10-0-3-239.us-east-2.compute.internal                1/1       Running     0          37m
kube-system                                             etcd-member-ip-10-0-3-24.us-east-2.compute.internal                 1/1       Running     0          35m
openshift-apiserver-operator                            openshift-apiserver-operator-6d6674f4f4-h7t2t                       1/1       Running     1          37m
openshift-apiserver                                     apiserver-fm48r                                                     1/1       Running     0          30m
openshift-apiserver                                     apiserver-fxkvv                                                     1/1       Running     0          29m
openshift-apiserver                                     apiserver-q85nm                                                     1/1       Running     0          29m
...
openshift-service-ca-operator                           openshift-service-ca-operator-66ff6dc6cd-9r257                      1/1       Running     0          37m
openshift-service-ca                                    apiservice-cabundle-injector-695b6bcbc-cl5hm                        1/1       Running     0          35m
openshift-service-ca                                    configmap-cabundle-injector-8498544d7-25qn6                         1/1       Running     0          35m
openshift-service-ca                                    service-serving-cert-signer-6445fc9c6-wqdqn                         1/1       Running     0          35m
openshift-service-catalog-apiserver-operator            openshift-service-catalog-apiserver-operator-549f44668b-b5q2w       1/1       Running     0          32m
openshift-service-catalog-controller-manager-operator   openshift-service-catalog-controller-manager-operator-b78cr2lnm     1/1       Running     0          31m

当前集群版本为AVAILABLE时，安装完成。

OpenShift Container Platform 的遥测访问

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

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

其他资源

有关遥测服务的更多信息，请参阅关于远程健康监控

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

使用Deployment Manager模板在GCP上用户提供的基础架构上安装集群

先决条件

证书签名请求管理

OpenShift Container Platform的互联网访问

配置您的GCP项目

创建 GCP 项目

在 GCP 中启用 API 服务

配置 GCP 的 DNS

GCP 帐户限制

在 GCP 中创建服务帐户

所需 GCP 角色

用户预配的基础架构所需 GCP 权限

支持的 GCP 区域

安装和配置 GCP 的 CLI 工具

使用用户预配的基础架构的集群要求

集群安装所需的机器

集群安装的最低资源要求

GCP 的测试实例类型

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

使用自定义机器类型

创建 GCP 的安装文件

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

创建安装配置文件

启用 Shielded VM

启用 Confidential VM

安装期间配置集群范围的代理

创建 Kubernetes 清单和 Ignition 配置文件

导出公共变量

提取基础设施名称

为 Deployment Manager 模板导出公共变量

在 GCP 中创建 VPC

VPC 的 Deployment Manager 模板

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

通过 DHCP 设置集群节点主机名

网络连接需求

在 GCP 中创建负载均衡器

外部负载均衡器的 Deployment Manager 模板

内部负载均衡器的 Deployment Manager 模板

在 GCP 中创建私有 DNS 区域

私有 DNS 的 Deployment Manager 模板

在 GCP 中创建防火墙规则

防火墙规则的 Deployment Manager 模板

在 GCP 中创建 IAM 角色

IAM 角色的 Deployment Manager 模板

为 GCP 基础架构创建 RHCOS 集群镜像

在 GCP 中创建引导机器

引导机器的 Deployment Manager 模板

在 GCP 中创建控制平面机器

控制平面机器的 Deployment Manager 模板

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

在 GCP 中创建其他工作机器

工作机器部署管理器模板

安装 OpenShift 命令行工具

在 Linux 上安装 OpenShift 命令行工具

在 Windows 上安装 OpenShift 命令行工具

在 macOS 上安装 OpenShift 命令行工具

使用 CLI 登录集群

批准机器的证书签名请求

可选：添加入口 DNS 记录

完成用户预配基础设施上的 GCP 安装

OpenShift Container Platform 的遥测访问

后续步骤