在受限网络中使用用户预配的基础架构在 GCP 上安装集群 - 在 GCP 上安装 | 安装 | OpenShift Container Platform 4.17

先决条件
关于在受限网络中的安装
- 其他限制
OpenShift Container Platform的互联网访问
配置您的GCP项目
- 创建GCP项目
- 在GCP中启用API服务
- 为GCP配置DNS
- GCP帐户限制
- 在GCP中创建服务帐户
- 所需的GCP角色
- 用户配置的基础设施所需的GCP权限
- 支持的GCP区域
- 安装和配置GCP的CLI工具
具有用户配置的基础设施的集群的要求
- 集群安装所需的机器
- 集群安装的最低资源要求
- 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中创建额外的worker机器
- worker机器的Deployment Manager模板
使用CLI登录集群
禁用默认的OperatorHub目录源
批准机器的证书签名请求
可选：添加入口DNS记录
完成用户配置的基础设施上的GCP安装
OpenShift Container Platform的遥测访问
后续步骤

在OpenShift Container Platform 4.17版本中，您可以在Google Cloud Platform (GCP)上安装一个集群，该集群使用您提供的基础设施和安装发行版内容的内部镜像。

虽然您可以使用镜像的安装发行版内容来安装OpenShift Container Platform集群，但您的集群仍然需要互联网访问才能使用GCP API。

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

以下步骤仅作为用户自备基础设施安装的示例。使用您提供的基础设施安装集群需要了解云提供商和 OpenShift Container Platform 的安装过程。我们提供了一些部署管理器模板来帮助您完成这些步骤或帮助您创建自己的模板。您也可以通过其他方法创建所需资源；这些模板只是一个示例。

前提条件

您已查看有关OpenShift Container Platform 安装和更新过程的详细信息。
您已阅读有关选择集群安装方法并为用户准备集群的文档。
您已在镜像主机上创建了一个注册表，并获得了 OpenShift Container Platform 版本的 imageContentSources 数据。

由于安装介质位于镜像主机上，您可以使用该计算机完成所有安装步骤。
如果您使用防火墙，您已将其配置为允许集群需要访问的站点。虽然您可能需要授予更多站点的访问权限，但必须授予 *.googleapis.com 和 accounts.google.com 的访问权限。
如果您的环境中无法访问云身份和访问管理 (IAM) API，或者您不想在 kube-system 命名空间中存储管理员级凭据密钥，您可以手动创建和维护长期凭据。

关于受限网络中的安装

在 OpenShift Container Platform 4.17 中，您可以执行无需主动连接到互联网即可获取软件组件的安装。受限网络安装可以使用安装程序配置的基础设施或用户自备的基础设施完成，具体取决于您要安装集群的云平台。

如果您选择在云平台上执行受限网络安装，您仍然需要访问其云 API。某些云功能（例如 Amazon Web Service 的 Route 53 DNS 和 IAM 服务）需要互联网访问。根据您的网络，在裸机硬件、Nutanix 或 VMware vSphere 上进行安装可能需要较少的互联网访问。

要完成受限网络安装，您必须创建一个注册表来镜像 OpenShift 镜像注册表的内容并包含安装介质。您可以在可以访问互联网和封闭网络的镜像主机上创建此注册表，或者使用满足您限制的其他方法。

由于用户自备安装的配置复杂，建议您先完成标准的用户自备基础设施安装，然后再尝试使用用户自备基础设施进行受限网络安装。完成此测试安装可以更容易地隔离和排除在受限网络中安装期间可能出现的任何问题。

其他限制

受限网络中的集群具有以下其他限制。

ClusterVersion 状态包含 无法检索可用更新 错误。
默认情况下，您无法使用开发者目录的内容，因为您无法访问所需的镜像流标签。

OpenShift Container Platform 的互联网访问

在 OpenShift Container Platform 4.17 中，您需要访问互联网才能获取安装集群所需的镜像。

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

访问OpenShift 集群管理器以下载安装程序并执行订阅管理。如果集群具有互联网访问权限并且您没有禁用遥测，则该服务会自动授权您的集群。
访问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 Resource Manager 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 服务	控制台服务名称
Google Cloud APIs	`cloudapis.googleapis.com`
服务管理 API	`servicemanagement.googleapis.com`
Google Cloud Storage JSON API	`storage-api.googleapis.com`
Cloud Storage	`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 角色

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

安装程序所需的权限

计算管理员
角色管理员
安全管理员
服务帐户管理员
服务帐户密钥管理员
服务帐户用户
存储管理员

安装过程中创建网络资源所需的权限

DNS 管理员

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

计算负载平衡器管理员
标签用户

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

部署管理器编辑器

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

表 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 权限

当您将所有者角色附加到您创建的服务帐户时，您会授予该服务帐户所有权限，包括安装 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
计算引擎后端服务更新
使用计算引擎后端服务
创建区域后端服务
获取区域后端服务
列出区域后端服务
更新区域后端服务
使用区域后端服务
向目标池添加实例
创建目标池
获取目标池
列出目标池
从目标池移除实例
使用目标池
创建目标TCP代理
获取目标TCP代理
使用目标TCP代理

创建DNS资源所需的权限

创建DNS变更
获取DNS变更
创建托管区域
获取托管区域
列出托管区域
将私有DNS区域绑定到网络
创建资源记录集
列出资源记录集
更新资源记录集

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

创建服务帐号密钥
删除服务帐号密钥
获取服务帐号密钥
列出服务帐号密钥
以服务帐号身份运行
创建服务帐号
删除服务帐号
获取服务帐号
列出服务帐号
获取项目
获取项目的IAM策略
设置项目的IAM策略

创建计算资源所需的权限

创建磁盘
获取磁盘
列出磁盘
创建实例组
删除实例组
获取实例组
列出实例组
更新实例组
使用实例组
创建实例
删除实例
获取实例
列出实例
设置实例标签
设置实例元数据
设置实例服务帐号
设置实例标签
使用实例
获取机器类型
列出机器类型

创建存储资源所需权限

创建存储桶
删除存储桶
获取存储桶
列出存储桶
创建对象
删除对象
获取对象
列出对象

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

创建健康检查
获取健康检查
列出健康检查
以只读模式使用健康检查
创建HTTP健康检查
获取HTTP健康检查
列出HTTP健康检查
以只读模式使用HTTP健康检查
创建区域健康检查
获取区域健康检查
以只读模式使用区域健康检查

获取GCP区域和可用区相关信息的权限

获取全局操作
获取区域操作
获取区域
列出区域
获取可用区操作
获取可用区
列出可用区

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

列出监控时间序列
获取配额
列出服务

安装所需的IAM权限

获取角色

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

签署Blob

安装所需的镜像权限

创建镜像
删除镜像
获取镜像
列出镜像

运行gather bootstrap的可选权限

获取串口输出

删除网络资源所需的权限

compute.addresses.delete
删除内部地址
compute.addresses.list
设置地址标签
compute.firewalls.delete
compute.firewalls.list
删除转发规则
compute.forwardingRules.list
删除全局地址
列出全局地址
删除全局转发规则
列出全局转发规则
删除网络
compute.networks.list
compute.networks.updatePolicy
删除路由器
compute.routers.list
compute.routes.list
删除子网
compute.subnetworks.list

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

删除后端服务
compute.backendServices.list
删除区域后端服务
列出区域后端服务
删除目标池
列出目标池
删除目标TCP代理
列出目标TCP代理

删除DNS资源所需的权限

创建DNS变更
删除托管区域
获取托管区域
列出托管区域
删除资源记录集
列出资源记录集

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

删除服务帐号
获取服务帐号
列出服务帐号
获取项目的IAM策略
设置项目的IAM策略

删除计算资源所需的权限

删除磁盘
列出磁盘
删除实例组
列出实例组
删除实例
列出实例
停止实例
列出机器类型

删除存储资源所需权限

删除存储桶
获取存储桶的IAM策略
列出存储桶
删除对象
列出对象

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

删除健康检查
列出健康检查
删除HTTP健康检查
列出HTTP健康检查
删除区域健康检查
列出区域健康检查

删除镜像所需的权限

删除镜像
列出镜像

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

获取区域

所需的Deployment Manager权限

创建部署
删除部署
获取部署
列出部署
获取清单
获取操作
列出资源

其他资源

优化存储

支持的GCP区域

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

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]	虚拟内存	存储	每秒输入/输出 (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 ms 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 架构。

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

GCP 已测试的实例类型

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

机器系列

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

使用自定义机器类型

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

使用自定义机器类型时，请考虑以下几点：

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

custom-<cpu数量>-<内存大小(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`，所以以下过程通过创建在 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（Mebibytes）。根文件系统会自动调整大小以填充所有可用空间，直到指定的偏移量。如果未指定值，或者指定的值小于建议的最小值，则生成的根文件系统将太小，并且将来重新安装 RHCOS 可能会覆盖数据分区的开头。
3	数据分区的大小（以 mebibytes 为单位）。
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 安装程序和集群的拉取密钥。对于受限网络安装，这些文件位于您的镜像主机上。
您拥有在镜像注册表创建期间生成的imageContentSources值。
您已获得镜像注册表的证书内容。

步骤

创建install-config.yaml文件。
1. 更改到包含安装程序的目录，并运行以下命令
  $ ./openshift-install create install-config --dir <installation_directory> (1)
  1 对于<installation_directory>，指定存储安装程序创建文件的目录名称。
  
  指定目录时
  - 验证目录是否具有执行权限。此权限是必需的，才能在安装目录下运行 Terraform 二进制文件。
  - 使用空目录。一些安装资源（例如 bootstrap 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文件以提供受限网络安装所需的附加信息。
1. 更新pullSecret值以包含注册表的身份验证信息
  pullSecret: '{"auths":{"<mirror_host_name>:5000": {"auth": "<credentials>","email": "[email protected]"}}}'
  对于<mirror_host_name>，指定您在镜像注册表的证书中指定的注册表域名，对于<credentials>，指定镜像注册表的 base64 编码用户名和密码。
2. 添加additionalTrustBundle参数和值。
  additionalTrustBundle: | -----BEGIN CERTIFICATE----- ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ -----END CERTIFICATE-----
  该值必须是您用于镜像注册表的证书文件的内容。证书文件可以是现有的受信任证书颁发机构，也可以是您为镜像注册表生成的自签名证书。
3. 在父platform.gcp字段下定义要安装集群的 VPC 的网络和子网
  network: <existing_vpc> controlPlaneSubnet: <control_plane_subnet> computeSubnet: <compute_subnet>
  对于platform.gcp.network，指定现有 Google VPC 的名称。对于platform.gcp.controlPlaneSubnet和platform.gcp.computeSubnet，分别指定要部署控制平面机器和计算机器的现有子网。
4. 添加镜像内容资源，类似于以下 YAML 片段
  imageContentSources: - mirrors: - <mirror_host_name>:5000/<repo_name>/release source: quay.io/openshift-release-dev/ocp-release - mirrors: - <mirror_host_name>:5000/<repo_name>/release source: registry.redhat.io/ocp/release
  对于这些值，使用您在镜像注册表创建期间记录的imageContentSources。
5. 可选：将发布策略设置为Internal
  publish: Internal
  通过设置此选项，您可以创建内部 Ingress 控制器和私有负载均衡器。
对install-config.yaml文件进行任何其他所需的修改。

有关参数的更多信息，请参阅“安装配置参数”。
备份install-config.yaml文件，以便您可以使用它来安装多个集群。

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

其他资源

GCP 的安装配置参数

启用 Shielded VM

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

目前，64 位 ARM 架构的集群不支持屏蔽虚拟机。

先决条件

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

步骤

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

仅对控制平面机器使用屏蔽虚拟机

controlPlane:
  platform:
    gcp:
       secureBoot: Enabled

仅对计算机器使用屏蔽虚拟机

compute:
- platform:
    gcp:
       secureBoot: Enabled

对所有机器使用屏蔽虚拟机

platform:
  gcp:
    defaultMachinePlatform:
       secureBoot: Enabled

启用机密虚拟机 (Confidential VMs)

安装集群时，您可以使用机密虚拟机。机密虚拟机会在数据处理过程中对其进行加密。更多信息，请参阅 Google 关于机密计算的文档。您可以同时启用机密虚拟机和屏蔽虚拟机，尽管它们之间并不依赖。

目前，64 位 ARM 架构不支持机密虚拟机。

先决条件

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

步骤

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

仅对控制平面机器使用机密虚拟机

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

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

仅对计算机器使用机密虚拟机

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

对所有机器使用机密虚拟机

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	如果提供，安装程序将在 `openshift-config` 命名空间中生成一个名为 `user-ca-bundle` 的配置映射，其中包含代理 HTTPS 连接所需的额外 CA 证书。然后，集群网络操作员将创建 `trusted-ca-bundle` 配置映射，并将这些内容与 Red Hat Enterprise Linux CoreOS (RHCOS) 信任捆绑包合并，并在此 `Proxy` 对象的 `trustedCA` 字段中引用此配置映射。除非代理的身份证书是由 RHCOS 信任捆绑包中的机构签名的，否则需要 `additionalTrustBundle` 字段。
5	可选：确定 `Proxy` 对象的配置以在 `trustedCA` 字段中引用 `user-ca-bundle` 配置映射的策略。允许的值为 `Proxyonly` 和 `Always`。使用 `Proxyonly` 仅在配置了 `http/https` 代理时引用 `user-ca-bundle` 配置映射。使用 `Always` 始终引用 `user-ca-bundle` 配置映射。默认值为 `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 小时内使用它们，因为 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 记录。
要创建 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
```

其他资源

可选：添加入口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 对于<安装目录>，请指定您存储安装文件的目录的路径。
示例输出
```
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	对于`<安装目录>`，请指定您存储安装文件的目录的路径。

在 GCP 中创建 VPC

您必须在 Google Cloud Platform (GCP) 中创建一个 VPC 供您的 OpenShift Container Platform 集群使用。您可以自定义 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 集群组件进行通信。每台机器都必须能够解析集群中所有其他机器的主机名。

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

表 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) 中配置私有 DNS 区域，才能使用您的 OpenShift Container Platform 集群。创建此组件的一种方法是修改提供的 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 角色

您必须在 Google Cloud Platform (GCP) 中创建 IAM 角色，才能使用您的 OpenShift Container Platform 集群。创建这些组件的一种方法是修改提供的 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 集群镜像

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

步骤

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

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

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

创建 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 中创建引导机器

您必须在 Google Cloud Platform (GCP) 中创建引导机器，以便在 OpenShift Container Platform 集群初始化期间使用。创建此机器的一种方法是修改提供的 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 对于<安装目录>，请指定您存储安装文件的目录的路径。

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。

在此示例中，您使用 Deployment Manager 模板手动启动一个实例。可以通过在文件中包含其他类型为 `06_worker.py` 的资源来启动其他实例。

如果您不使用提供的 Deployment Manager 模板创建计算机器，则必须查看提供的资料并手动创建基础设施。如果您的集群无法正确初始化，您可能需要联系 Red Hat 支持，并提供您的安装日志。

先决条件

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

步骤

从本主题的“计算机器的 Deployment Manager 模板”部分复制模板，并将其保存为计算机上的 `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 引擎：https://www.googleapis.com/compute/v1/projects/redhat-marketplace-public/global/images/redhat-coreos-oke-413-x86-64-202305021736

工作机器的 Deployment Manager 模板

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

06_worker.py Deployment Manager 模板

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}

使用 CLI 登录集群

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

先决条件

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

步骤

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

禁用默认 OperatorHub 目录源

在 OpenShift Container Platform 安装期间，默认情况下会为 OperatorHub 配置从 Red Hat 和社区项目提供的內容获取来源的 Operator 目录。在受限网络环境中，您必须以集群管理员身份禁用默认目录。

步骤

通过将disableAllDefaultSources: true添加到OperatorHub对象来禁用默认目录的源。

$ oc patch OperatorHub cluster --type json \
    -p '[{"op": "add", "path": "/spec/disableAllDefaultSources", "value": true}]'

或者，您可以使用 Web 控制台管理目录源。在**管理** → **集群设置** → **配置** → **OperatorHub**页面中，单击**源**选项卡，您可以在此处创建、更新、删除、禁用和启用各个源。

批准机器的证书签名请求 (CSR)

将机器添加到集群时，会为每个添加的机器生成两个挂起的证书签名请求 (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

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

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

$ 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状态。

其他信息

证书签名请求

可选：添加 Ingress DNS 记录

如果您在创建 Kubernetes 清单和生成 Ignition 配置时删除了 DNS 区域配置，则必须手动创建指向 Ingress 负载均衡器的 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	对于`<安装目录>`，请指定您存储安装文件的目录的路径。

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

观察集群的运行状态。

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

$ oc get clusterversion

示例输出

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

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

$ 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 订阅。

其他资源

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

后续步骤

自定义您的集群.
为集群示例操作符和must-gather工具配置镜像流。
了解如何在断开连接的环境中使用操作符生命周期管理器。
如果您用于安装集群的镜像仓库具有受信任的 CA，请通过配置额外的信任存储将其添加到集群。
如有必要，您可以选择退出远程健康报告。
如有必要，请参阅注册您的断开连接的集群

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