OpenShift 文档正在迁移，很快将只在 docs.redhat.com（所有 Red Hat 产品文档的首页）提供。立即体验 新的文档体验。
  1. 文档
    2. history bug_report picture_as_pdf
×

使用 Deployment Manager 模板在 GCP 共享 VPC 上安装集群

在 OpenShift Container Platform 4.17 版本中，您可以将集群安装到 Google Cloud Platform (GCP) 上使用您提供的基础架构的共享虚拟私有云 (VPC) 中。在此上下文中，安装到共享 VPC 的集群是指配置为使用与部署集群的项目不同的项目的 VPC 的集群。

共享 VPC 使组织能够将来自多个项目的资源连接到一个公共 VPC 网络。您可以使用该网络中的内部 IP 安全高效地在组织内进行通信。有关共享 VPC 的更多信息，请参阅 GCP 文档中的共享 VPC 概述。

此处概述了将用户提供的基础架构安装到共享 VPC 中的步骤。提供了一些部署管理器模板来帮助完成这些步骤或帮助您构建自己的模板。您也可以自由地通过其他方法创建所需的资源。

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

先决条件

证书签名请求管理

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

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 服务 控制台服务名称

    Cloud Deployment Manager V2 API

    deploymentmanager.googleapis.com

    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 帐户限制

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 服务帐号，则必须创建一个。

先决条件

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

步骤

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

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

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

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

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

必需的 GCP 角色

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

安装程序所需的权限

  • Compute 管理员

  • 角色管理员

  • 安全管理员

  • 服务帐号管理员

  • 服务帐号密钥管理员

  • 服务帐号用户

  • 存储管理员

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

  • DNS 管理员

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

  • 计算负载平衡器管理员

  • 标签用户

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

  • Deployment Manager 编辑器

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

表 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 集群部署到以下 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 工具。

先决条件

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

  • 您已创建服务帐号并授予其必要的权限。

步骤

  1. 将以下二进制文件安装到 $PATH 中

    • gcloud

    • gsutil

    请参阅 GCP 文档中的 安装最新 Cloud SDK 版本。

  2. 使用已配置的服务帐号通过 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

  1. 当未启用同时多线程 (SMT) 或超线程时，一个 vCPU 等于一个物理核心。启用后，使用以下公式计算相应的比率：（每个核心的线程数 × 核心数）× 插槽数 = vCPU 数。

  2. OpenShift Container Platform 和 Kubernetes 对磁盘性能敏感，建议使用更快的存储，特别是对于控制平面节点上的 etcd，它需要 10 毫秒的 p99 fsync 持续时间。请注意，在许多云平台上，存储大小和 IOPS 是成比例的，因此您可能需要过度分配存储卷以获得足够的性能。

  3. 与所有用户预配的安装一样，如果您选择在集群中使用 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。

配置托管共享 VPC 网络的 GCP 项目

如果您使用共享虚拟专用云 (VPC) 来托管 Google Cloud Platform (GCP) 中的 OpenShift Container Platform 集群，则必须配置托管它的项目。

如果您已经拥有托管共享 VPC 网络的项目，请查看本节以确保该项目满足安装 OpenShift Container Platform 集群的所有要求。
步骤

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

  2. 在托管共享 VPC 的项目中创建一个服务帐号。请参阅 GCP 文档中的 创建服务帐号。

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

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

    托管共享 VPC 网络的项目的服务帐号需要以下角色：

    • 计算网络用户

    • 计算安全管理员

    • Deployment Manager 编辑器

    • DNS 管理员

    • 安全管理员

    • 网络管理管理员

配置 GCP 的 DNS

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

步骤

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

    如果您购买新域名，则相关 DNS 更改的传播可能需要一些时间。有关通过 Google 购买域名的更多信息，请参阅 Google Domains。

  2. 在您的 GCP 项目中为您的域名或子域名创建一个公共托管区域。请参阅 GCP 文档中的 创建公共区域。

    使用适当的根域名，例如 openshiftcorp.com，或子域名，例如 clusters.openshiftcorp.com。

  3. 从托管区域记录中提取新的权威名称服务器。请参阅 GCP 文档中的 查找您的 Cloud DNS 域名服务器。

    您通常有四个名称服务器。

  4. 更新您的域名使用的名称服务器的注册商记录。例如，如果您在 Google Domains 注册了您的域名，请参阅 Google Domains 帮助中的以下主题：如何切换到自定义名称服务器。

  5. 如果您已将根域迁移到 Google Cloud DNS，请迁移您的 DNS 记录。请参阅 GCP 文档中的迁移到 Cloud DNS。

  6. 如果您使用子域，请按照公司流程将它的委派记录添加到父域。此过程可能包括向公司 IT 部门或控制公司根域和 DNS 服务的部门提出请求。

在 GCP 中创建 VPC

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

如果您不使用提供的 Deployment Manager 模板来创建您的 GCP 基础架构，则必须查看提供的资料并手动创建基础架构。如果您的集群未正确初始化，您可能需要联系 Red Hat 支持并提供您的安装日志。
先决条件

  • 配置 GCP 帐户。

步骤

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

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

    1. 导出控制平面 CIDR

      $ export MASTER_SUBNET_CIDR='10.0.0.0/17'

    2. 导出计算 CIDR

      $ export WORKER_SUBNET_CIDR='10.0.128.0/17'

    3. 导出部署 VPC 网络和集群的区域

      $ export REGION='<region>'

  3. 导出托管共享 VPC 的项目的 ID 变量

    $ export HOST_PROJECT=<host_project>

  4. 导出属于主机项目的 Service Account 的电子邮件变量

    $ export HOST_PROJECT_ACCOUNT=<host_service_account_email>

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

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

resources:
- name: cluster-vpc
  type: 01_vpc.py
  properties:
    infra_id: '<prefix>' (1)
    region: '${REGION}' (2)
    master_subnet_cidr: '${MASTER_SUBNET_CIDR}' (3)
    worker_subnet_cidr: '${WORKER_SUBNET_CIDR}' (4)
EOF
    1 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。

  6. 使用gcloud CLI 创建部署

    $ gcloud deployment-manager deployments create <vpc_deployment_name> --config 01_vpc.yaml --project ${HOST_PROJECT} --account ${HOST_PROJECT_ACCOUNT} (1)
    1 对于<vpc_deployment_name>，指定要部署的 VPC 的名称。

  7. 导出其他组件所需的 VPC 变量

    1. 导出主机项目网络的名称

      $ export HOST_PROJECT_NETWORK=<vpc_network>

    2. 导出主机项目控制平面子网的名称

      $ export HOST_PROJECT_CONTROL_SUBNET=<control_plane_subnet>

    3. 导出主机项目计算子网的名称

      $ export HOST_PROJECT_COMPUTE_SUBNET=<compute_subnet>

  8. 设置共享 VPC。请参阅 GCP 文档中的设置共享 VPC。

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}

创建 GCP 的安装文件

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

手动创建安装配置文件

安装集群需要您手动创建安装配置文件。

先决条件

  • 您在本地机器上有一个 SSH 公钥，需要提供给安装程序。此密钥将用于 SSH 身份验证到您的集群节点，用于调试和灾难恢复。

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

步骤

  1. 创建一个安装目录来存储您所需的安装资源。

    $ mkdir <installation_directory>

    您必须创建一个目录。一些安装资源（如引导 X.509 证书）的有效期很短，因此您不能重复使用安装目录。如果您想重复使用来自另一个集群安装的单个文件，您可以将它们复制到您的目录中。但是，安装资源的文件名可能会在不同版本之间发生变化。从较早的 OpenShift Container Platform 版本复制安装文件时，请务必谨慎。

  2. 自定义提供的示例install-config.yaml文件模板，并将其保存在<installation_directory>中。

    您必须将此配置文件命名为install-config.yaml。

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

    install-config.yaml文件在安装过程的下一步中使用。您现在必须对其进行备份。
其他资源

启用 Shielded VM

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

目前，64 位 ARM 基础架构的集群不支持 Shielded VM。
先决条件

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

步骤

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

    1. 仅对控制平面机器使用 Shielded VM

      controlPlane:
  platform:
    gcp:
       secureBoot: Enabled

    2. 仅对计算机器使用 Shielded VM

      compute:
- platform:
    gcp:
       secureBoot: Enabled

    3. 对所有机器使用 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文件，并添加以下片段之一

    1. 仅对控制平面机器使用 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 指定 VM 在主机维护事件（例如硬件或软件更新）期间的行为。对于使用 Confidential VM 的机器，此值必须设置为Terminate，这将停止 VM。Confidential VM 不支持实时 VM 迁移。

    2. 仅对计算机器使用 Confidential VM

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

    3. 对所有机器使用 Confidential VM

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

GCP 的示例自定义install-config.yaml文件

您可以自定义install-config.yaml文件，以指定有关OpenShift Container Platform集群平台的更多详细信息，或修改所需参数的值。

此示例YAML文件仅供参考。您必须使用安装程序获取您的install-config.yaml文件并对其进行修改。

 
apiVersion: v1
baseDomain: example.com (1)
controlPlane: (2)
  hyperthreading: Enabled  (3) (4)
  name: master
  platform:
    gcp:
      type: n2-standard-4
      zones:
      - us-central1-a
      - us-central1-c
      tags: (5)
      - control-plane-tag1
      - control-plane-tag2
  replicas: 3
compute: (2)
- hyperthreading: Enabled (3)
  name: worker
  platform:
    gcp:
      type: n2-standard-4
      zones:
      - us-central1-a
      - us-central1-c
      tags: (5)
      - compute-tag1
      - compute-tag2
  replicas: 0
metadata:
  name: test-cluster
networking:
  clusterNetwork:
  - cidr: 10.128.0.0/14
    hostPrefix: 23
  machineNetwork:
  - cidr: 10.0.0.0/16
  networkType: OVNKubernetes (6)
  serviceNetwork:
  - 172.30.0.0/16
platform:
  gcp:
    defaultMachinePlatform:
      tags: (5)
      - global-tag1
      - global-tag2
    projectID: openshift-production (7)
    region: us-central1 (8)
pullSecret: '{"auths": ...}'
fips: false (9)
sshKey: ssh-ed25519 AAAA... (10)
publish: Internal (11)
1 在主机项目上指定公共DNS。
2 如果您未提供这些参数和值，安装程序将提供默认值。
3 controlPlane部分是单个映射，但compute部分是映射序列。为了满足不同数据结构的要求，compute部分的第一行必须以连字符-开头，而controlPlane部分的第一行则不能。尽管这两个部分目前都定义了一个单一机器池，但OpenShift Container Platform的未来版本可能会支持在安装过程中定义多个计算池。仅使用一个控制平面池。
4 是否启用或禁用同时多线程处理，或超线程。默认情况下，启用同时多线程处理以提高机器内核的性能。您可以将其设置为Disabled来禁用它。如果您在某些集群机器中禁用了同时多线程处理，则必须在所有集群机器中禁用它。

如果您禁用同时多线程处理，请确保您的容量规划考虑了机器性能的大幅下降。如果您禁用同时多线程处理，请为您的机器使用更大的机器类型，例如n1-standard-8。
5 可选：一组要应用于控制平面或计算机器集的网络标签。platform.gcp.defaultMachinePlatform.tags参数同时应用于控制平面和计算机器。如果设置了compute.platform.gcp.tags或controlPlane.platform.gcp.tags参数，则它们将覆盖platform.gcp.defaultMachinePlatform.tags参数。
6 要安装的集群网络插件。默认值OVNKubernetes是唯一支持的值。
7 指定虚拟机实例所在的 utama 项目。
8 指定您的VPC网络所在的区域。
9 是否启用或禁用FIPS模式。默认情况下，未启用FIPS模式。如果启用了FIPS模式，则OpenShift Container Platform运行的Red Hat Enterprise Linux CoreOS (RHCOS)机器将绕过默认的Kubernetes加密套件，并改用RHCOS提供的加密模块。

要为您的集群启用FIPS模式，您必须从配置为在FIPS模式下运行的Red Hat Enterprise Linux (RHEL)计算机运行安装程序。有关在RHEL上配置FIPS模式的更多信息，请参见切换RHEL到FIPS模式。

在FIPS模式下启动Red Hat Enterprise Linux (RHEL)或Red Hat Enterprise Linux CoreOS (RHCOS)时，OpenShift Container Platform核心组件仅在x86_64、ppc64le和s390x架构上使用已提交给NIST进行FIPS 140-2/140-3验证的RHEL加密库。
10 您可以选择提供用于访问集群中机器的sshKey值。

对于要执行安装调试或灾难恢复的生产OpenShift Container Platform集群，请指定您的ssh-agent进程使用的SSH密钥。
11 如何发布集群的用户端点。将publish设置为Internal以部署私有集群，该集群无法从互联网访问。默认值为External。要在使用您配置的基础设施的集群中使用共享VPC，您必须将publish设置为Internal。安装程序将无法再访问主机项目中的公共DNS区域。

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

生产环境可以拒绝直接访问互联网，而是提供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)。
步骤

  1. 编辑您的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

  2. 保存文件并在安装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 安装配置文件。

步骤

  1. 切换到包含 OpenShift Container Platform 安装程序的目录，并为集群生成 Kubernetes 清单。

    $ ./openshift-install create manifests --dir <installation_directory> (1)
    1 对于 <installation_directory>，请指定包含您创建的 install-config.yaml 文件的安装目录。

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

    $ rm -f <installation_directory>/openshift/99_openshift-cluster-api_master-machines-*.yaml

    通过删除这些文件，您可以防止集群自动生成控制平面机器。

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

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

  4. 删除定义工作机器的 Kubernetes 清单文件。

    $ rm -f <installation_directory>/openshift/99_openshift-cluster-api_worker-machineset-*.yaml

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

  5. 检查 <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. 保存并退出文件。

  6. 从 <installation_directory>/manifests/cluster-dns-02-config.yml DNS 配置文件中删除 privateZone 部分。

    apiVersion: config.openshift.io/v1
kind: DNS
metadata:
  creationTimestamp: null
  name: cluster
spec:
  baseDomain: example.openshift.com
  privateZone: (1)
    id: mycluster-100419-private-zone
status: {}
    1 完全删除此部分。

  7. 配置您 VPC 的云提供商。

    1. 打开 <installation_directory>/manifests/cloud-provider-config.yaml 文件。

    2. 添加 network-project-id 参数并将其值设置为托管共享 VPC 网络的项目的 ID。

    3. 添加 network-name 参数并将其值设置为托管 OpenShift Container Platform 集群的共享 VPC 网络的名称。

    4. 将 subnetwork-name 参数的值替换为托管您的计算机器的共享 VPC 子网的值。

    <installation_directory>/manifests/cloud-provider-config.yaml 的内容类似于以下示例

    config: |+
  [global]
  project-id      = example-project
  regional        = true
  multizone       = true
  node-tags       = opensh-ptzzx-master
  node-tags       = opensh-ptzzx-worker
  node-instance-prefix = opensh-ptzzx
  external-instance-groups-prefix = opensh-ptzzx
  network-project-id = example-shared-vpc
  network-name    = example-network
  subnetwork-name = example-worker-subnet

  8. 如果您部署的集群不在私有网络上，请打开 <installation_directory>/manifests/cluster-ingress-default-ingresscontroller.yaml 文件并将 scope 参数的值替换为 External。该文件的内容类似于以下示例

    apiVersion: operator.openshift.io/v1
kind: IngressController
metadata:
  creationTimestamp: null
  name: default
  namespace: openshift-ingress-operator
spec:
  endpointPublishingStrategy:
    loadBalancer:
      scope: External
    type: LoadBalancerService
status:
  availableReplicas: 0
  domain: ''
  selector: ''

  9. 要创建 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

导出常用变量

提取基础设施名称

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 包。

步骤

  1. 导出以下常用变量，供提供的 Deployment Manager 模板使用

$ export BASE_DOMAIN='<base_domain>' (1)
$ export BASE_DOMAIN_ZONE_NAME='<base_domain_zone_name>' (1)
$ export NETWORK_CIDR='10.0.0.0/16'

$ export KUBECONFIG=<installation_directory>/auth/kubeconfig (2)
$ 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`
1 提供主机项目的值。
2 对于 <installation_directory>，请指定您存储安装文件的目录的路径。

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

所有 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 模板。

如果您不使用提供的 Deployment Manager 模板来创建您的 GCP 基础架构，则必须查看提供的资料并手动创建基础架构。如果您的集群未正确初始化，您可能需要联系 Red Hat 支持并提供您的安装日志。
先决条件

  • 配置 GCP 帐户。

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

  • 在 GCP 中创建和配置 VPC 和关联的子网。

步骤

  1. 从本主题的“内部负载均衡器的 Deployment Manager 模板”部分复制模板，并将其保存到计算机上的 `02_lb_int.py` 文件中。此模板描述了集群所需的内部负载均衡对象。

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

  3. 导出部署模板使用的变量

    1. 导出集群网络位置

      $ export CLUSTER_NETWORK=(`gcloud compute networks describe ${HOST_PROJECT_NETWORK} --project ${HOST_PROJECT} --account ${HOST_PROJECT_ACCOUNT} --format json | jq -r .selfLink`)

    2. 导出控制平面子网位置

      $ export CONTROL_SUBNET=(`gcloud compute networks subnets describe ${HOST_PROJECT_CONTROL_SUBNET} --region=${REGION} --project ${HOST_PROJECT} --account ${HOST_PROJECT_ACCOUNT} --format json | jq -r .selfLink`)

    3. 导出集群使用的三个区域

      $ 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`)

  4. 创建一个 `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`。

  5. 使用gcloud CLI 创建部署

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

  6. 导出集群 IP 地址

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

  7. 对于外部集群，还要导出集群公共 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 模板。

如果您不使用提供的 Deployment Manager 模板来创建您的 GCP 基础架构，则必须查看提供的资料并手动创建基础架构。如果您的集群未正确初始化，您可能需要联系 Red Hat 支持并提供您的安装日志。
先决条件

  • 配置 GCP 帐户。

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

  • 在 GCP 中创建和配置 VPC 和关联的子网。

步骤

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

  2. 创建一个 `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。

  3. 使用gcloud CLI 创建部署

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

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

    1. 添加内部 DNS 条目

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

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

      $ if [ -f transaction.yaml ]; then rm transaction.yaml; fi
$ gcloud --account=${HOST_PROJECT_ACCOUNT} --project=${HOST_PROJECT} dns record-sets transaction start --zone ${BASE_DOMAIN_ZONE_NAME}
$ gcloud --account=${HOST_PROJECT_ACCOUNT} --project=${HOST_PROJECT} dns record-sets transaction add ${CLUSTER_PUBLIC_IP} --name api.${CLUSTER_NAME}.${BASE_DOMAIN}. --ttl 60 --type A --zone ${BASE_DOMAIN_ZONE_NAME}
$ gcloud --account=${HOST_PROJECT_ACCOUNT} --project=${HOST_PROJECT} 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 模板。

如果您不使用提供的 Deployment Manager 模板来创建您的 GCP 基础架构，则必须查看提供的资料并手动创建基础架构。如果您的集群未正确初始化，您可能需要联系 Red Hat 支持并提供您的安装日志。
先决条件

  • 配置 GCP 帐户。

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

  • 在 GCP 中创建和配置 VPC 和关联的子网。

步骤

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

  2. 创建一个 `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`。

  3. 使用gcloud CLI 创建部署

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

防火墙规则的 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 模板。

如果您不使用提供的 Deployment Manager 模板来创建您的 GCP 基础架构，则必须查看提供的资料并手动创建基础架构。如果您的集群未正确初始化，您可能需要联系 Red Hat 支持并提供您的安装日志。
先决条件

  • 配置 GCP 帐户。

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

  • 在 GCP 中创建和配置 VPC 和关联的子网。

步骤

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

  2. 创建一个 `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` 基础设施名称。

  3. 使用gcloud CLI 创建部署

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

  4. 导出主服务帐户的变量

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

  5. 导出工作程序服务帐户的变量

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

  6. 将安装程序所需的权限分配给托管控制平面和计算子网的子网的服务帐户

    1. 将托管共享 VPC 的项目的 `networkViewer` 角色授予主服务帐户

      $ gcloud --account=${HOST_PROJECT_ACCOUNT} --project=${HOST_PROJECT} projects add-iam-policy-binding ${HOST_PROJECT} --member "serviceAccount:${MASTER_SERVICE_ACCOUNT}" --role "roles/compute.networkViewer"

    2. 将 `networkUser` 角色授予控制平面子网的主服务帐户

      $ gcloud --account=${HOST_PROJECT_ACCOUNT} --project=${HOST_PROJECT} compute networks subnets add-iam-policy-binding "${HOST_PROJECT_CONTROL_SUBNET}" --member "serviceAccount:${MASTER_SERVICE_ACCOUNT}" --role "roles/compute.networkUser" --region ${REGION}

    3. 将 `networkUser` 角色授予控制平面子网的工作程序服务帐户

      $ gcloud --account=${HOST_PROJECT_ACCOUNT} --project=${HOST_PROJECT} compute networks subnets add-iam-policy-binding "${HOST_PROJECT_CONTROL_SUBNET}" --member "serviceAccount:${WORKER_SERVICE_ACCOUNT}" --role "roles/compute.networkUser" --region ${REGION}

    4. 将 `networkUser` 角色授予计算子网的主服务帐户

      $ gcloud --account=${HOST_PROJECT_ACCOUNT} --project=${HOST_PROJECT} compute networks subnets add-iam-policy-binding "${HOST_PROJECT_COMPUTE_SUBNET}" --member "serviceAccount:${MASTER_SERVICE_ACCOUNT}" --role "roles/compute.networkUser" --region ${REGION}

    5. 将 `networkUser` 角色授予计算子网的工作程序服务帐户

      $ gcloud --account=${HOST_PROJECT_ACCOUNT} --project=${HOST_PROJECT} compute networks subnets add-iam-policy-binding "${HOST_PROJECT_COMPUTE_SUBNET}" --member "serviceAccount:${WORKER_SERVICE_ACCOUNT}" --role "roles/compute.networkUser" --region ${REGION}

  7. 由于 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"

  8. 创建一个服务帐户密钥并将其存储在本地以供以后使用

    $ 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 节点使用有效的 Red Hat Enterprise Linux CoreOS (RHCOS) Google Cloud Platform (GCP) 镜像。

步骤

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

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

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

  2. 创建 Google 存储桶

    $ gsutil mb gs://<bucket_name>

  3. 将 RHCOS 镜像上传到 Google 存储桶

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

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

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

  5. 创建集群镜像

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

步骤

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

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

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

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

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

  4. 为引导实例创建签名的 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}'`

  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。

  6. 使用gcloud CLI 创建部署

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

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

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

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

    $ 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 中创建和配置网络和负载均衡器。

  • 创建控制平面和计算角色。

  • 创建引导机器。

步骤

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

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

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

  3. 创建一个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文件的内容。

  4. 使用gcloud CLI 创建部署

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

  5. 由于 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 中创建和配置网络和负载均衡器。

  • 创建控制平面和计算角色。

  • 创建引导机器。

  • 创建控制平面机器。

步骤

  1. 切换到包含安装程序的目录并运行以下命令

    $ ./openshift-install wait-for bootstrap-complete --dir <installation_directory> \ (1)
    --log-level info (2)
    1 对于 <installation_directory>，请指定您存储安装文件的目录的路径。
    2 要查看不同的安装详细信息，请指定warn、debug或error代替info。

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

  2. 删除引导资源

    $ 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 中创建和配置网络和负载均衡器。

  • 创建控制平面和计算角色。

  • 创建引导机器。

  • 创建控制平面机器。

步骤

  1. 从本主题的“用于工作机器的 Deployment Manager 模板”部分复制模板，并将其保存到计算机上名为06_worker.py的文件中。此模板描述了集群所需的工作机器。

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

    1. 导出托管计算机器的子网。

      $ export COMPUTE_SUBNET=(`gcloud compute networks subnets describe ${HOST_PROJECT_COMPUTE_SUBNET} --region=${REGION} --project ${HOST_PROJECT} --account ${HOST_PROJECT_ACCOUNT} --format json | jq -r .selfLink`)

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

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

    3. 导出计算机器 Ignition 配置文件的路径。

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

  3. 创建一个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。1
    6 machine_type是实例的机器类型，例如n1-standard-4。
    7 service_account_email 是您创建的工作程序服务帐户的电子邮件地址。
    8 ignition 是worker.ign 文件的内容。

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

  5. 使用gcloud CLI 创建部署

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

  1. 要使用 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

用于工作机器的 Deployment Manager 模板

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

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}

安装 OpenShift CLI

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

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

在 Linux 上安装 OpenShift CLI

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

步骤

  1. 导航到 Red Hat 客户门户上的OpenShift Container Platform 下载页面。

  2. 从“产品变体”下拉列表中选择体系结构。

  3. 从“版本”下拉列表中选择相应的版本。

  4. 单击OpenShift v4.17 Linux 客户端条目旁边的立即下载，然后保存文件。

  5. 解压归档文件。

    $ tar xvf <file>

  6. 将oc二进制文件放置在PATH中的目录中。

    要检查您的PATH，请执行以下命令：

    $ echo $PATH
验证

  • 安装 OpenShift CLI 后，可以使用oc命令。

    $ oc <command>

在 Windows 上安装 OpenShift CLI

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

步骤

  1. 导航到 Red Hat 客户门户上的OpenShift Container Platform 下载页面。

  2. 从“版本”下拉列表中选择相应的版本。

  3. 单击OpenShift v4.17 Windows 客户端条目旁边的立即下载，然后保存文件。

  4. 使用 ZIP 程序解压缩归档文件。

  5. 将oc二进制文件移动到PATH中的目录。

    要检查您的PATH，请打开命令提示符并执行以下命令：

    C:\> path
验证

  • 安装 OpenShift CLI 后，可以使用oc命令。

    C:\> oc <command>

在 macOS 上安装 OpenShift CLI

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

步骤

  1. 导航到 Red Hat 客户门户上的OpenShift Container Platform 下载页面。

  2. 从“版本”下拉列表中选择相应的版本。

  3. 单击OpenShift v4.17 macOS 客户端条目旁边的立即下载，然后保存文件。

    对于 macOS arm64，请选择OpenShift v4.17 macOS arm64 客户端条目。

  4. 解压归档文件。

  5. 将oc二进制文件移动到PATH中的目录。

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

    $ echo $PATH
验证

  • 使用oc命令验证您的安装。

    $ oc <command>

使用 CLI 登录集群

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

先决条件

  • 您已部署了 OpenShift Container Platform 集群。

  • 您已安装oc CLI。

步骤

  1. 导出kubeadmin凭据。

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

  2. 验证您可以使用导出的配置成功运行oc命令。

    $ oc whoami
    示例输出
    system:admin

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

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

先决条件

  • 您已向集群添加了机器。

步骤

  1. 确认集群识别这些机器。

    $ 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 之前，上述输出可能不包含计算节点（也称为工作节点）。

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

    $ oc get csr
    示例输出
    NAME        AGE     REQUESTOR                                                                   CONDITION
csr-8b2br   15m     system:serviceaccount:openshift-machine-config-operator:node-bootstrapper   Pending
csr-8vnps   15m     system:serviceaccount:openshift-machine-config-operator:node-bootstrapper   Pending
...

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

  3. 如果未批准 CSR，则在您添加的所有机器的挂起 CSR 都处于“挂起”状态后，请批准集群机器的 CSR。

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

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

    • 要分别批准它们，请对每个有效的 CSR 运行以下命令：

      $ oc adm certificate approve <csr_name> (1)
      1 <csr_name> 是当前 CSR 列表中 CSR 的名称。

    • 要批准所有挂起的 CSR，请运行以下命令：

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

      在批准某些 CSR 之前，某些运算符可能不可用。

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

    $ 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
...

  5. 如果剩余的 CSR 未获批准且处于“挂起”状态，请批准集群机器的 CSR。

    • 要分别批准它们，请对每个有效的 CSR 运行以下命令：

      $ oc adm certificate approve <csr_name> (1)
      1 <csr_name> 是当前 CSR 列表中 CSR 的名称。

    • 要批准所有挂起的 CSR，请运行以下命令：

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

  6. 所有客户端和服务器CSR都批准后，机器状态将变为就绪。请运行以下命令进行验证：

    $ oc get nodes
    示例输出
    NAME      STATUS    ROLES   AGE  VERSION
master-0  Ready     master  73m  v1.30.3
master-1  Ready     master  73m  v1.30.3
master-2  Ready     master  74m  v1.30.3
worker-0  Ready     worker  11m  v1.30.3
worker-1  Ready     worker  11m  v1.30.3

    服务器CSR批准后，机器可能需要几分钟才能转变为就绪状态。
附加信息

添加入口DNS记录

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

先决条件

  • 配置 GCP 帐户。

  • 创建Kubernetes清单和生成Ignition配置文件时，移除DNS区域配置。

  • 在 GCP 中创建和配置 VPC 和关联的子网。

  • 在 GCP 中创建和配置网络和负载均衡器。

  • 创建控制平面和计算角色。

  • 创建引导机器。

  • 创建控制平面机器。

  • 创建工作机器。

步骤

  1. 等待入口路由器创建负载均衡器并填充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

  2. 将A记录添加到您的区域

    • 要使用A记录

      1. 导出路由器IP地址的变量

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

      2. 将A记录添加到私有区域

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

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

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

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

      $ 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

添加入口防火墙规则

集群需要多个防火墙规则。如果您不使用共享VPC，则这些规则由入口控制器通过GCP云提供商创建。当您使用共享VPC时，您可以现在为所有服务创建集群范围的防火墙规则，或者根据事件（当集群请求访问时）创建每个规则。通过在集群请求访问时创建每个规则，您可以准确知道需要哪些防火墙规则。通过创建集群范围的防火墙规则，您可以跨多个集群应用相同的规则集。

如果您选择根据事件创建每个规则，则必须在您配置集群之后以及集群生命周期中控制台通知您缺少规则时创建防火墙规则。将显示类似于以下事件的事件，您必须添加所需的防火墙规则

$ oc get events -n openshift-ingress --field-selector="reason=LoadBalancerManualChange"
示例输出
Firewall change required by security admin: `gcloud compute firewall-rules create k8s-fw-a26e631036a3f46cba28f8df67266d55 --network example-network --description "{\"kubernetes.io/service-name\":\"openshift-ingress/router-default\", \"kubernetes.io/service-ip\":\"35.237.236.234\"}\" --allow tcp:443,tcp:80 --source-ranges 0.0.0.0/0 --target-tags exampl-fqzq7-master,exampl-fqzq7-worker --project example-project`

如果您在创建这些基于规则的事件时遇到问题，可以在集群运行时配置集群范围的防火墙规则。

为GCP中的共享VPC创建集群范围的防火墙规则

您可以创建集群范围的防火墙规则以允许OpenShift Container Platform集群所需的访问。

如果您不选择根据集群事件创建防火墙规则，则必须创建集群范围的防火墙规则。
先决条件

  • 您导出了部署管理器模板部署集群所需的变量。

  • 您创建了集群所需的GCP中的网络和负载均衡组件。

步骤

  1. 添加单个防火墙规则以允许Google Cloud Engine运行状况检查访问所有服务。此规则使入口负载均衡器能够确定其实例的运行状况。

    $ gcloud compute firewall-rules create --allow='tcp:30000-32767,udp:30000-32767' --network="${CLUSTER_NETWORK}" --source-ranges='130.211.0.0/22,35.191.0.0/16,209.85.152.0/22,209.85.204.0/22' --target-tags="${INFRA_ID}-master,${INFRA_ID}-worker" ${INFRA_ID}-ingress-hc --account=${HOST_PROJECT_ACCOUNT} --project=${HOST_PROJECT}

  2. 添加单个防火墙规则以允许访问所有集群服务

    • 对于外部集群

      $ gcloud compute firewall-rules create --allow='tcp:80,tcp:443' --network="${CLUSTER_NETWORK}" --source-ranges="0.0.0.0/0" --target-tags="${INFRA_ID}-master,${INFRA_ID}-worker" ${INFRA_ID}-ingress --account=${HOST_PROJECT_ACCOUNT} --project=${HOST_PROJECT}

    • 对于私有集群

      $ gcloud compute firewall-rules create --allow='tcp:80,tcp:443' --network="${CLUSTER_NETWORK}" --source-ranges=${NETWORK_CIDR} --target-tags="${INFRA_ID}-master,${INFRA_ID}-worker" ${INFRA_ID}-ingress --account=${HOST_PROJECT_ACCOUNT} --project=${HOST_PROJECT}

    因为此规则仅允许在TCP端口80和443上进行流量，请确保添加您的服务使用的所有端口。

完成用户预配基础架构上的GCP安装

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

先决条件

  • 为用户预配的GCP基础架构上的OpenShift Container Platform集群部署引导机器。

  • 安装oc CLI并登录。

步骤

  1. 完成集群安装

    $ ./openshift-install --dir <installation_directory> wait-for install-complete (1)
    示例输出
    INFO Waiting up to 30m0s for the cluster to initialize...
    1 对于 <installation_directory>，请指定您存储安装文件的目录的路径。

    • 安装程序生成的Ignition配置文件包含24小时后过期的证书，然后在该时间更新。如果在更新证书之前集群关闭，并且集群在24小时后重新启动，则集群会自动恢复过期的证书。例外情况是，您必须手动批准挂起的node-bootstrapper证书签名请求 (CSR) 以恢复kubelet证书。有关更多信息，请参阅有关“从过期的控制平面证书恢复”的文档。

    • 建议您在生成 Ignition 配置文件后 12 小时内使用它们，因为 24 小时证书会在集群安装后 16 到 22 小时之间轮换。通过在 12 小时内使用 Ignition 配置文件，如果证书更新在安装期间运行，您可以避免安装失败。

  2. 观察集群的运行状态。

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

      $ oc get clusterversion
      示例输出
      NAME      VERSION   AVAILABLE   PROGRESSING   SINCE   STATUS
version             False       True          24m     Working towards 4.5.4: 99% complete

    2. 运行以下命令以查看由集群版本运算符 (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

    3. 运行以下命令以查看您的集群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

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

OpenShift Container Platform的遥测访问

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

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

其他资源

后续步骤