教程

1. 点 Get started 按钮在 AWS 控制台页面中激活 带有 HCP 产品的 ROSA：

   图 2.1. 开始使用

   

   如果您在完成此过程前已激活了 ROSA，您可以点该按钮并完成帐户链接，如以下步骤所述。

2. 确认您希望与红帽共享联系信息并启用该服务：

   图 2.2. 启用 ROSA

   
   • 在此步骤中启用该服务不会收取。该连接是为在部署第一个集群后发生的计费和计量。这可能需要几分钟时间。

3. 过程完成后，您将看到确认：

   图 2.3. ROSA 启用确认

   

4. 此验证页面中的其他部分显示额外先决条件的状态。如果没有满足任何这些先决条件，则会显示对应的消息。以下是所选区域中配额不足的示例：

   图 2.4. 服务配额

   
   1. 单击 增加服务配额 按钮，或使用 了解更多 链接来获取有关如何管理服务配额的更多信息。如果配额不足，请注意配额是特定于区域的。您可以使用 web 控制台右上角的 region switcher 来重新运行您感兴趣的任何区域的配额检查，然后根据需要提交服务配额增加请求。

5. 如果满足所有先决条件，页面将类似如下：

   图 2.5. 验证 ROSA 的先决条件

   

   自动为您创建 ELB 服务链接的角色。您可以单击任何小的 Info blue 链接来获取上下文帮助和资源。

1. 点 orange Continue to Red Hat 按钮继续帐户链接：

   图 2.6. 继续红帽

   

2. 如果您还没有在当前浏览器的会话中登录到您的红帽帐户，则会要求您登录到您的帐户：

   注意

   您的 AWS 帐户必须链接到单个红帽机构。

   图 2.7. 登录到您的红帽帐户

   
   • 您还可以注册新的红帽帐户或在此页面中重置密码。
   • 确保登录到您计划与在前面的步骤中激活 ROSA 和 HCP 的 AWS 帐户关联的红帽帐户。
   • 用于服务账单的 AWS 帐户只能与单个红帽帐户关联。通常，AWS 付费帐户是用于订阅 ROSA 并用于帐户链接和计费的帐户。
   • 所有属于同一红帽机构的团队成员可在创建使用 HCP 集群的 ROSA 时，将链接的 AWS 帐户用于服务账单。

3. 查看条款和条件后完成红帽帐户链接：

   注意

   只有在 AWS 帐户之前没有链接到任何红帽帐户时，才提供此步骤。

   如果 AWS 帐户已链接到用户的登录红帽帐户，则会跳过这一步。

   如果 AWS 帐户链接到其他红帽帐户，则会显示错误。请参阅 Correcting Billing Account Information for HCP 集群 以进行故障排除。

   图 2.8. 完成您的帐户连接

   

   此屏幕中会显示 Red Hat 和 AWS 账户号。

4. 如果您同意了服务条款，请单击" 连接帐户 "按钮。

   如果您是第一次使用 Red Hat Hybrid Cloud 控制台，在创建第一个 ROSA 集群前，您需要同意常规受管服务条款和条件：

   图 2.9. 条款和条件

   

   点 View Conditions and Conditions 按钮后会显示需要审核和接受的其他条款 ：

   图 2.10. 红帽条款和条件

   

   在此时，您审核的任何其他条款后，提交您的协议。

5. Hybrid Cloud Console 提供了确认 AWS 帐户设置已完成，并列出集群部署的先决条件：

   图 2.11. 完成 ROSA 先决条件

   

   本页的最后一部分显示集群部署选项，可以使用 rosa CLI 或 Web 控制台：

   图 2.12. 部署集群并设置访问权限

   

1. 使用 rosa create cluster 命令启动集群部署。您可以点 Set up Red Hat OpenShift Service on AWS (ROSA)控制台页面中的副本 按钮，并在终端中粘贴命令。这会以互动模式启动集群创建过程：

   图 2.13. 部署集群并设置访问权限

   
2. 要使用自定义 AWS 配置集，在 ~/.aws/credentials 中指定的非默认配置集之一，您可以将 -profile <profile_name> 选择器添加到 rosa create cluster 命令中，以便命令类似 rosa create cluster -profile stage。如果没有使用这个选项指定 AWS CLI 配置集，则默认 AWS CLI 配置集将决定集群部署到的 AWS 基础架构配置集。账单 AWS 配置集在以下步骤之一中选择。

3. 当使用 HCP 集群部署 ROSA 时，需要指定计费 AWS 帐户：

   图 2.14. 指定 Billing 帐户

   
   • 只有链接到用户登录的红帽帐户的 AWS 帐户才会显示。
   • 指定的 AWS 帐户负责使用 ROSA 服务。

   • 指示器显示了是否为给定 AWS 账单帐户启用 ROSA 合同还是未启用。

     • 如果您选择了显示 Contract enabled 标签的 AWS 账单帐户，只有在消耗了预付费合同的容量后，才会收取按需消耗率。
     • 没有启用合同 标签的 AWS 帐户会收取适用的按需消耗率。

1. 通过选择简介 设置 ROSA 页面底部部分中的第二个选项，可以使用 Web 控制台创建集群：

   图 2.15. 使用 Web 界面部署

   
   注意

   在开始 Web 控制台部署过程前，请完成先决条件。

   某些任务（如创建帐户角色）需要 rosa CLI。如果您要首次部署 ROSA，请在启动 web 控制台部署步骤前，按照此 CLI 步骤操作，直到运行 rosa whoami 命令为止。

2. 使用 Web 控制台创建 ROSA 集群时的第一步是选择 control plane。在点 Next 按钮前，请确定选择了 Hosted 选项：

   图 2.16. 选择托管选项

   

3. 下一步 Accounts 和 roles 允许您指定基础架构 AWS 帐户、部署 ROSA 集群以及消耗和管理资源的位置：

   图 2.17. AWS 基础架构帐户

   
   • 如果没有看到您要部署 ROSA 集群的帐户，点 How to associate a new AWS account，以了解有关如何为此关联创建或链接帐户角色的详细信息。
   • rosa CLI 用于此目的。
   • 如果您使用多个 AWS 帐户，并为 AWS CLI 配置其配置集，您可以在使用 rosa CLI 命令时使用 --profile 选择器来指定 AWS 配置集。

4. 账单 AWS 帐户在以下部分中选择：

   图 2.18. AWS 账单帐户

   
   • 只有链接到用户登录的红帽帐户的 AWS 帐户才会显示。
   • 指定的 AWS 帐户负责使用 ROSA 服务。

   • 指示器显示了是否为给定 AWS 账单帐户启用 ROSA 合同还是未启用。

     • 如果您选择了显示 Contract enabled 标签的 AWS 账单帐户，只有在消耗了预付费合同的容量后，才会收取按需消耗率。
     • 没有启用合同 标签的 AWS 帐户会收取适用的按需消耗率。

1. 当您获得带有 HCP 的 ROSA 的私有产品时，会为您提供一个唯一的 URL，该 URL 只能通过销售者指定的特定 AWS 帐户 ID 访问。

   注意

   验证您是否使用指定为 buyer 的 AWS 帐户登录。尝试使用另一个 AWS 帐户访问所提供的信息会生成 "page not found" 错误消息，如下面的故障排除部分图 11 所示。

   1. 您可以在图 1 中看到带有常规私有提供的所提供的选择下拉菜单。只有在使用公共提供或其他私有产品前未激活带有 HCP 的 ROSA 时，才能接受此类优惠。

      图 3.1. 常规私有提供

      

   2. 您可以看到，为之前使用公共提供的 HCP 激活的 AWS 帐户创建的私有提供，显示产品名称和所选私有提供标记为"Upgrade"，它将当前运行 ROSA 的合同替换为 HCP。

      图 3.2. 私有提供选择屏幕

      

   3. 下拉菜单允许选择多个服务（如果可用）。之前激活的公共优惠与新提供的协议提供一起显示，在图 3 中被标记为"Upgrade"。

      图 3.3. 私有提供选择下拉菜单

      

2. 验证您的所提供的配置是否已选中。图 4 显示优惠页面底部部分，并提供详细信息。

   注意

   合同结束日期、所提供的单位数以及付款计划。在本例中，包括 1 个集群，最多使用 4 个 vCPU 的节点。

   图 3.4. 私有提供详情

   

3. 可选：您可以在购买的订阅 中添加您自己的购买订单(PO)号，以便其包含在后续 AWS 发票中。另外，请检查"新提供配置详情"范围以上任何使用量的"附加使用费用"。

   注意

   私有提供几个可用的配置。

   • 您接受的私有服务可能是您使用固定的未来开始日期设置的。
   • 如果您在接受私有产品时没有另一个活跃的带有 HCP 订阅的 ROSA，则提供公共或旧的私有提供权利，请接受私有提供自己，并在指定服务开始日期后继续帐户链接和集群部署步骤。

   您必须有一个活跃的带有 HCP 权利的 ROSA 才能完成这些步骤。服务开始日期总是在 UTC 时区中报告

4. 创建或升级您的合同。

   1. 对于私有提供的 AWS 帐户尚未激活 HCP，且正在为此服务创建第一个合同，请点击 Create contract 按钮。

      图 3.5. 创建合同按钮

      

   2. 对于基于协议的提供，请单击图 4 和 6 所示 的升级当前合同 按钮。

      图 3.6. 升级合同按钮

      

5. 单击 Confirm。

   图 3.7. 私有提供接受确认窗口

   

6. 如果接受的私人提供服务日期被设置为紧跟在所提供的接受后，点确认模态窗口中的 Set up your account 按钮。

   图 3.8. 订阅确认

   

7. 如果接受的私有服务在以后指定了开始日期，请在服务开始日期后返回到私有优惠页，然后点击 Setup your account 按钮继续 Red Hat 和 AWS 帐户链接。

   注意

   如果没有激活协议，则不会触发下面描述的帐户链接，"帐户设置"进程只能在"服务启动日期"后执行。

   它们始终在 UTC 时区。

1. 点击上一步中的 Set up your account 按钮可进入 AWS 和红帽帐户链接步骤。目前，您已使用接受提供的 AWS 帐户登录。如果您没有使用 Red Hat 帐户登录，系统会提示您这样做。

   带有 HCP 权利的 ROSA 通过您的红帽帐户与其他团队成员共享。同一红帽机构中的所有现有用户都可以按照上述步骤选择接受私有提供的账单 AWS 帐户。当您以 红帽机构管理员身份登录时，您可以管理 红帽机构中的用户，并邀请或创建新用户。

   注意

   使用 HCP 私有提供的 ROSA 无法通过 AWS 许可证管理器与 AWS 链接帐户共享。

2. 添加您要部署 ROSA 集群的任何用户。有关红帽帐户 用户管理任务的更多详细信息，请查看此用户管理常见问题解答。
3. 验证已登录的红帽帐户是否包含所有希望作为从接受的私有提供的优势的 ROSA 集群部署者的用户。

4. 验证红帽帐户号和 AWS 帐户 ID 是要链接的所需帐户。这个链接是唯一的，红帽帐户只能与一个 AWS （计费）帐户连接。

   图 3.9. AWS 和红帽帐户连接

   

5. 如果您要将 AWS 帐户与比图 9 显示的另一个红帽帐户链接，请在连接帐户前从 Red Hat Hybrid Cloud Console 注销，并通过返回到已接受的私有提供 URL 来重复设置帐户的步骤。

   AWS 帐户只能与单个红帽帐户连接。连接红帽和 AWS 帐户后，用户无法更改此帐户。如果需要更改，用户必须创建一个支持问题单。

6. 同意条款和条件，然后单击 连接帐户。

1. 要使用该脚本，请在 bash 终端中运行以下命令( -p 选项定义角色的前缀)：

   $ mkdir scratch
   $ cd scratch
   $ cat << 'EOF' > verify-permissions.sh
   #!/bin/bash
   while getopts 'p:' OPTION; do
     case "$OPTION" in
       p)
         PREFIX="$OPTARG"
         ;;
       ?)
         echo "script usage: $(basename \$0) [-p PREFIX]" >&2
         exit 1
         ;;
     esac
   done
   shift "$(($OPTIND -1))"
   rosa create account-roles --mode manual --prefix $PREFIX
   INSTALLER_POLICY=$(cat sts_installer_permission_policy.json | jq )
   CONTROL_PLANE_POLICY=$(cat sts_instance_controlplane_permission_policy.json | jq)
   WORKER_POLICY=$(cat sts_instance_worker_permission_policy.json | jq)
   SUPPORT_POLICY=$(cat sts_support_permission_policy.json | jq)
   simulatePolicy () {
       outputFile="${2}.results"
       echo $2
       aws iam simulate-custom-policy --policy-input-list "$1" --action-names $(jq '.Statement | map(select(.Effect == "Allow"))[].Action | if type == "string" then . else .[] end' "$2" -r) --output text > $outputFile
   }
   simulatePolicy "$INSTALLER_POLICY" "sts_installer_permission_policy.json"
   simulatePolicy "$CONTROL_PLANE_POLICY" "sts_instance_controlplane_permission_policy.json"
   simulatePolicy "$WORKER_POLICY" "sts_instance_worker_permission_policy.json"
   simulatePolicy "$SUPPORT_POLICY" "sts_support_permission_policy.json"
   EOF
   $ chmod +x verify-permissions.sh
   $ ./verify-permissions.sh -p SimPolTest

2. 脚本完成后，查看每个结果文件以确保没有所需的 API 调用被阻止：

   $ for file in $(ls *.results); do echo $file; cat $file; done

   输出结果类似如下：

   sts_installer_permission_policy.json.results
   EVALUATIONRESULTS       autoscaling:DescribeAutoScalingGroups   allowed *
   MATCHEDSTATEMENTS       PolicyInputList.1       IAM Policy
   ENDPOSITION     6       195
   STARTPOSITION   17      3
   EVALUATIONRESULTS       ec2:AllocateAddress     allowed *
   MATCHEDSTATEMENTS       PolicyInputList.1       IAM Policy
   ENDPOSITION     6       195
   STARTPOSITION   17      3
   EVALUATIONRESULTS       ec2:AssociateAddress    allowed *
   MATCHEDSTATEMENTS       PolicyInputList.1       IAM Policy
   ...

   注意

   如果阻止了任何操作，请查看 AWS 提供的错误，并咨询您的管理员来确定 SCP 是否阻断所需的 API 调用。

1. 配置以下环境变量：

   $ export VPC_ID=<vpc_ID> 1
   $ export REGION=<region> 2
   $ export VPC_CIDR=<vpc_CIDR> 3

   1

   将 <vpc_ID > 替换为您要将集群安装到的 VPC 的 ID。

   2

   将 &lt;region> 替换为您要将集群安装到的 AWS 区域。

   3

   将 <vpc_CIDR > 替换为 VPC 的 CIDR 范围。

2. 在移动到下一部分前，请确定所有字段都正确输出：

   $ echo "VPC ID: ${VPC_ID}, VPC CIDR Range: ${VPC_CIDR}, Region: ${REGION}"

1. 创建一个安全组，并允许从 VPC 访问端口 53/tcp 和 53/udp ：

   $ SG_ID=$(aws ec2 create-security-group --group-name rosa-inbound-resolver --description "Security group for ROSA inbound resolver" --vpc-id ${VPC_ID} --region ${REGION} --output text)
   $ aws ec2 authorize-security-group-ingress --group-id ${SG_ID} --protocol tcp --port 53 --cidr ${VPC_CIDR} --region ${REGION}
   $ aws ec2 authorize-security-group-ingress --group-id ${SG_ID} --protocol udp --port 53 --cidr ${VPC_CIDR} --region ${REGION}

2. 在 VPC 中创建 Amazon Route 53 Inbound Resolver：

   $ RESOLVER_ID=$(aws route53resolver create-resolver-endpoint \
     --name rosa-inbound-resolver \
     --creator-request-id rosa-$(date '+%Y-%m-%d') \
     --security-group-ids ${SG_ID} \
     --direction INBOUND \
     --ip-addresses $(aws ec2 describe-subnets --filter Name=vpc-id,Values=${VPC_ID} --region ${REGION} | jq -jr '.Subnets | map("SubnetId=\(.SubnetId) ") | .[]') \
     --region ${REGION} \
     --output text \
     --query 'ResolverEndpoint.Id')

   注意

   以上命令使用动态分配的 IP 地址将 Amazon Route 53 Inbound Resolver 端点附加到提供的 VPC 中的所有子网。如果要手动指定子网和/或 IP 地址，请运行以下命令：

   $ RESOLVER_ID=$(aws route53resolver create-resolver-endpoint \
     --name rosa-inbound-resolver \
     --creator-request-id rosa-$(date '+%Y-%m-%d') \
     --security-group-ids ${SG_ID} \
     --direction INBOUND \
     --ip-addresses SubnetId=<subnet_ID>,Ip=<endpoint_IP> SubnetId=<subnet_ID>,Ip=<endpoint_IP> \1
     --region ${REGION} \
     --output text \
     --query 'ResolverEndpoint.Id')

   1

   将 <subnet_ID > 替换为子网 ID，将 &lt ;endpoint_IP > 替换为您要入站解析器端点的静态 IP 地址。

3. 获取入站解析器端点的 IP 地址，以便在 DNS 服务器配置中配置：

   $ aws route53resolver list-resolver-endpoint-ip-addresses \
     --resolver-endpoint-id ${RESOLVER_ID} \
     --region=${REGION} \
     --query 'IpAddresses[*].Ip'

   输出示例

   [
       "10.0.45.253",
       "10.0.23.131",
       "10.0.148.159"
   ]

流程

1. 从私钥和公共证书创建一个新的 TLS secret，其中 fullchain.pem 是您的完整的通配符证书链（包括任何中间人），privkey.pem 是您的通配符证书的私钥。

   示例

   $ oc -n openshift-ingress create secret tls waf-tls --cert=fullchain.pem --key=privkey.pem

2. 创建新的 IngressController 资源：

   waf-ingress-controller.yaml示例

   apiVersion: operator.openshift.io/v1
   kind: IngressController
   metadata:
     name: cloudfront-waf
     namespace: openshift-ingress-operator
   spec:
     domain: apps.example.com 1
     defaultCertificate:
       name: waf-tls
     endpointPublishingStrategy:
       loadBalancer:
         dnsManagementPolicy: Unmanaged
         providerParameters:
           aws:
             type: NLB
           type: AWS
         scope: External
       type: LoadBalancerService
     routeSelector: 2
       matchLabels:
        route: waf

   1

   使用您要用于 IngressController 的自定义域替换。

   2

   过滤 Ingress Controller 服务的一组路由。在本教程中，我们将使用 waf 路由选择器，但如果不提供任何值，则不会发生过滤。

3. 应用 IngressController ：

   示例

   $ oc apply -f waf-ingress-controller.yaml

4. 验证 IngressController 是否已成功创建外部负载均衡器：

   $ oc -n openshift-ingress get service/router-cloudfront-waf

   输出示例

   NAME                    TYPE           CLUSTER-IP      EXTERNAL-IP                                                                     PORT(S)                      AGE
   router-cloudfront-waf   LoadBalancer   172.30.16.141   a68a838a7f26440bf8647809b61c4bc8-4225395f488830bd.elb.us-east-1.amazonaws.com   80:30606/TCP,443:31065/TCP   2m19s

1. 检索新创建的自定义 ingress 控制器的 NLB 主机名：

   $ NLB=$(oc -n openshift-ingress get service router-cloudfront-waf \
     -o jsonpath='{.status.loadBalancer.ingress[0].hostname}')

2. 将您的证书导入到 Amazon 证书管理器中，其中 cert.pem 是您的通配符证书，fullchain.pem 是您的通配符证书的链，privkey.pem 是您的通配符证书的私钥。

   注意

   无论您部署了集群是什么，都必须将此证书导入到 us-east-1 中，因为 Amazon CloudFront 都是全局 AWS 服务。

   示例

   $ aws acm import-certificate --certificate file://cert.pem \
     --certificate-chain file://fullchain.pem \
     --private-key file://privkey.pem \
     --region us-east-1

3. 登录到 AWS 控制台 以创建 CloudFront 发行版。

4. 使用以下信息配置 CloudFront 发行版：

   注意

   如果没有在下表中指定选项，请保留默认值（可能为空）。

   选项	值
   原始域	上一命令的输出 [1]
   Name	rosa-waf-ingress [2]
   查看器协议策略	将 HTTP 重定向到 HTTPS
   允许的 HTTP 方法	GET, HEAD, OPTIONS, PUT, POST, PATCH, DELETE
   缓存策略	CachingDisabled
   原始请求策略	AllViewer
   Web 应用程序防火墙(WAF)	启用安全保护
   使用现有的 WAF 配置	true
   选择 Web ACL	cloudfront-waf
   备用域名(CNAME)	*.apps.example.com [3]
   自定义 SSL 证书	从上面的步骤中选择您导入的证书 [4]

   1. 运行 echo ${NLB} 以获取原始域。
   2. 如果您有多个集群，请确保原始名称是唯一的。
   3. 这应该与您用来创建自定义入口控制器的通配符域匹配。
   4. 这应该与上面输入的替代域名匹配。

5. 检索 Amazon CloudFront Distribution 端点：

   $ aws cloudfront list-distributions --query "DistributionList.Items[?Origins.Items[?DomainName=='${NLB}']].DomainName" --output text

6. 使用 CNAME 将自定义通配符域的 DNS 更新到上面步骤中的 Amazon CloudFront 分发端点。

   示例

   *.apps.example.com CNAME d1b2c3d4e5f6g7.cloudfront.net

1. 运行以下命令，为示例应用程序创建一个新项目：

   $ oc new-project hello-world

2. 部署 hello world 应用：

   $ oc -n hello-world new-app --image=docker.io/openshift/hello-openshift

3. 为应用程序创建指定自定义域名的路由：

   示例

   $ oc -n hello-world create route edge --service=hello-openshift hello-openshift-tls \
   --hostname hello-openshift.${DOMAIN}

4. 标记路由，使其接受到自定义入口控制器：

   $ oc -n hello-world label route.route.openshift.io/hello-openshift-tls route=waf

1. 测试应用程序是否可以在 Amazon CloudFront 后面访问：

   示例

   $ curl "https://hello-openshift.${DOMAIN}"

   输出示例

   Hello OpenShift!

2. 测试 WAF 是否拒绝错误请求：

   示例

   $ curl -X POST "https://hello-openshift.${DOMAIN}" \
     -F "user='<script><alert>Hello></alert></script>'"

   输出示例

   <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
   <HTML><HEAD><META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=iso-8859-1">
   <TITLE>ERROR: The request could not be satisfied</TITLE>
   </HEAD><BODY>
   <H1>403 ERROR</H1>
   <H2>The request could not be satisfied.</H2>
   <HR noshade size="1px">
   Request blocked.
   We can't connect to the server for this app or website at this time. There might be too much traffic or a configuration error. Try again later, or contact the app or website owner.
   <BR clear="all">
   If you provide content to customers through CloudFront, you can find steps to troubleshoot and help prevent this error by reviewing the CloudFront documentation.
   <BR clear="all">
   <HR noshade size="1px">
   <PRE>
   Generated by cloudfront (CloudFront)
   Request ID: nFk9q2yB8jddI6FZOTjdliexzx-FwZtr8xUQUNT75HThPlrALDxbag==
   </PRE>
   <ADDRESS>
   </ADDRESS>
   </BODY></HTML>

   预期的结果是一个 403 ERROR，这意味着 AWS WAF 正在保护您的应用程序。

1. 运行以下命令，创建一个新项目来部署 AWS Load Balancer Operator：

   $ oc new-project aws-load-balancer-operator

2. 运行以下命令，为 AWS Load Balancer Controller 创建 AWS IAM 策略（如果不存在）：

   注意

   该策略 来自上游 AWS Load Balancer Controller 策略。Operator 需要它才能正常工作。

   $ POLICY_ARN=$(aws iam list-policies --query \
        "Policies[?PolicyName=='aws-load-balancer-operator-policy'].{ARN:Arn}" \
        --output text)

   $ if [[ -z "${POLICY_ARN}" ]]; then
       wget -O "${SCRATCH}/load-balancer-operator-policy.json" \
          https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/main/docs/install/iam_policy.json
        POLICY_ARN=$(aws --region "$REGION" --query Policy.Arn \
        --output text iam create-policy \
        --policy-name aws-load-balancer-operator-policy \
        --policy-document "file://${SCRATCH}/load-balancer-operator-policy.json")
   fi

3. 为 AWS Load Balancer Operator 创建 AWS IAM 信任策略：

   $ cat <<EOF > "${SCRATCH}/trust-policy.json"
   {
    "Version": "2012-10-17",
    "Statement": [
    {
    "Effect": "Allow",
    "Condition": {
      "StringEquals" : {
        "${OIDC_ENDPOINT}:sub": ["system:serviceaccount:aws-load-balancer-operator:aws-load-balancer-operator-controller-manager", "system:serviceaccount:aws-load-balancer-operator:aws-load-balancer-controller-cluster"]
      }
    },
    "Principal": {
      "Federated": "arn:aws:iam::$AWS_ACCOUNT_ID:oidc-provider/${OIDC_ENDPOINT}"
    },
    "Action": "sts:AssumeRoleWithWebIdentity"
    }
    ]
   }
   EOF

4. 为 AWS Load Balancer Operator 创建 AWS IAM 角色：

   $ ROLE_ARN=$(aws iam create-role --role-name "${CLUSTER}-alb-operator" \
      --assume-role-policy-document "file://${SCRATCH}/trust-policy.json" \
      --query Role.Arn --output text)

5. 运行以下命令，将 AWS Load Balancer Operator 策略附加到之前创建的 IAM 角色中：

   $ aws iam attach-role-policy --role-name "${CLUSTER}-alb-operator" \
        --policy-arn ${POLICY_ARN}

6. 为 AWS Load Balancer Operator 创建 secret，以假定我们新创建的 AWS IAM 角色：

   $ cat << EOF | oc apply -f -
   apiVersion: v1
   kind: Secret
   metadata:
     name: aws-load-balancer-operator
     namespace: aws-load-balancer-operator
   stringData:
     credentials: |
       [default]
       role_arn = ${ROLE_ARN}
       web_identity_token_file = /var/run/secrets/openshift/serviceaccount/token
   EOF

7. 安装 AWS Load Balancer Operator：

   $ cat << EOF | oc apply -f -
   apiVersion: operators.coreos.com/v1
   kind: OperatorGroup
   metadata:
     name: aws-load-balancer-operator
     namespace: aws-load-balancer-operator
   spec:
     upgradeStrategy: Default
   ---
   apiVersion: operators.coreos.com/v1alpha1
   kind: Subscription
   metadata:
     name: aws-load-balancer-operator
     namespace: aws-load-balancer-operator
   spec:
     channel: stable-v1.0
     installPlanApproval: Automatic
     name: aws-load-balancer-operator
     source: redhat-operators
     sourceNamespace: openshift-marketplace
     startingCSV: aws-load-balancer-operator.v1.0.0
   EOF

8. 使用 Operator 部署 AWS Load Balancer Controller 实例：

   注意

   如果您在此处收到错误并尝试重试，这意味着 Operator 还没有完成安装。

   $ cat << EOF | oc apply -f -
   apiVersion: networking.olm.openshift.io/v1
   kind: AWSLoadBalancerController
   metadata:
     name: cluster
   spec:
     credentials:
       name: aws-load-balancer-operator
     enabledAddons:
       - AWSWAFv2
   EOF

9. 检查 Operator 和控制器 pod 是否都在运行：

   $ oc -n aws-load-balancer-operator get pods

   如果没有等待片刻并重试，您应该看到以下内容：

   NAME                                                             READY   STATUS    RESTARTS   AGE
   aws-load-balancer-controller-cluster-6ddf658785-pdp5d            1/1     Running   0          99s
   aws-load-balancer-operator-controller-manager-577d9ffcb9-w6zqn   2/2     Running   0          2m4s

1. 为示例应用程序创建一个新项目：

   $ oc new-project hello-world

2. 部署 hello world 应用：

   $ oc new-app -n hello-world --image=docker.io/openshift/hello-openshift

3. 将预先创建的服务资源转换为 NodePort 服务类型：

   $ oc -n hello-world patch service hello-openshift -p '{"spec":{"type":"NodePort"}}'

4. 使用 AWS Load Balancer Operator 部署 AWS ALB：

   $ cat << EOF | oc apply -f -
   apiVersion: networking.k8s.io/v1
   kind: Ingress
   metadata:
     name: hello-openshift-alb
     namespace: hello-world
     annotations:
       alb.ingress.kubernetes.io/scheme: internet-facing
   spec:
     ingressClassName: alb
     rules:
       - http:
           paths:
             - path: /
               pathType: Exact
               backend:
                 service:
                   name: hello-openshift
                   port:
                     number: 8080
   EOF

5. curl AWS ALB Ingress 端点，以验证 hello world 应用程序是否可访问：

   注意

   AWS ALB 置备需要几分钟。如果您收到显示 curl: (6) Could not resolve host 的错误，请等待再试一次。

   $ INGRESS=$(oc -n hello-world get ingress hello-openshift-alb -o jsonpath='{.status.loadBalancer.ingress[0].hostname}')
   $ curl "http://${INGRESS}"

   输出示例

   Hello OpenShift!

1. 创建一个 IAM 策略来允许 S3 访问：

   $ POLICY_ARN=$(aws iam list-policies --query "Policies[?PolicyName=='RosaOadpVer1'].{ARN:Arn}" --output text)
   if [[ -z "${POLICY_ARN}" ]]; then
   $ cat << EOF > ${SCRATCH}/policy.json
   {
   "Version": "2012-10-17",
   "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "s3:CreateBucket",
        "s3:DeleteBucket",
        "s3:PutBucketTagging",
        "s3:GetBucketTagging",
        "s3:PutEncryptionConfiguration",
        "s3:GetEncryptionConfiguration",
        "s3:PutLifecycleConfiguration",
        "s3:GetLifecycleConfiguration",
        "s3:GetBucketLocation",
        "s3:ListBucket",
        "s3:GetObject",
        "s3:PutObject",
        "s3:DeleteObject",
        "s3:ListBucketMultipartUploads",
        "s3:AbortMultipartUpload",
        "s3:ListMultipartUploadParts",
        "ec2:DescribeSnapshots",
        "ec2:DescribeVolumes",
        "ec2:DescribeVolumeAttribute",
        "ec2:DescribeVolumesModifications",
        "ec2:DescribeVolumeStatus",
        "ec2:CreateTags",
        "ec2:CreateVolume",
        "ec2:CreateSnapshot",
        "ec2:DeleteSnapshot"
      ],
      "Resource": "*"
    }
   ]}
   EOF
   $ POLICY_ARN=$(aws iam create-policy --policy-name "RosaOadpVer1" \
   --policy-document file:///${SCRATCH}/policy.json --query Policy.Arn \
   --tags Key=rosa_openshift_version,Value=${CLUSTER_VERSION} Key=rosa_role_prefix,Value=ManagedOpenShift Key=operator_namespace,Value=openshift-oadp Key=operator_name,Value=openshift-oadp \
   --output text)
   fi
   $ echo ${POLICY_ARN}

2. 为集群创建 IAM 角色信任策略：

   $ cat <<EOF > ${SCRATCH}/trust-policy.json
   {
     "Version": "2012-10-17",
     "Statement": [{
       "Effect": "Allow",
       "Principal": {
         "Federated": "arn:aws:iam::${AWS_ACCOUNT_ID}:oidc-provider/${OIDC_ENDPOINT}"
       },
       "Action": "sts:AssumeRoleWithWebIdentity",
       "Condition": {
         "StringEquals": {
            "${OIDC_ENDPOINT}:sub": [
              "system:serviceaccount:openshift-adp:openshift-adp-controller-manager",
              "system:serviceaccount:openshift-adp:velero"]
         }
       }
     }]
   }
   EOF
   $ ROLE_ARN=$(aws iam create-role --role-name \
    "${ROLE_NAME}" \
     --assume-role-policy-document file://${SCRATCH}/trust-policy.json \
     --tags Key=rosa_cluster_id,Value=${ROSA_CLUSTER_ID} Key=rosa_openshift_version,Value=${CLUSTER_VERSION} Key=rosa_role_prefix,Value=ManagedOpenShift Key=operator_namespace,Value=openshift-adp Key=operator_name,Value=openshift-oadp \
     --query Role.Arn --output text)
   
   $ echo ${ROLE_ARN}

3. 将 IAM 策略附加到 IAM 角色：

   $ aws iam attach-role-policy --role-name "${ROLE_NAME}" \
    --policy-arn ${POLICY_ARN}

1. 为 OADP 创建命名空间：

   $ oc create namespace openshift-adp

2. 创建凭证 secret：

   $ cat <<EOF > ${SCRATCH}/credentials
   [default]
   role_arn = ${ROLE_ARN}
   web_identity_token_file = /var/run/secrets/openshift/serviceaccount/token
   region=<aws_region> 1
   EOF
   $ oc -n openshift-adp create secret generic cloud-credentials \
    --from-file=${SCRATCH}/credentials

   1

   将 <aws_region > 替换为用于安全令牌服务(STS)端点的 AWS 区域。

3. 部署 OADP Operator：

   注意

   目前，Operator 版本 1.1 存在一个带有 PartiallyFailed 状态的备份版本 1.1 的问题。这不会影响备份和恢复过程，但应注意，因为它存在问题。

   $ cat << EOF | oc create -f -
   apiVersion: operators.coreos.com/v1
   kind: OperatorGroup
   metadata:
    generateName: openshift-adp-
    namespace: openshift-adp
    name: oadp
   spec:
    targetNamespaces:
    - openshift-adp
   ---
   apiVersion: operators.coreos.com/v1alpha1
   kind: Subscription
   metadata:
    name: redhat-oadp-operator
    namespace: openshift-adp
   spec:
    channel: stable-1.2
    installPlanApproval: Automatic
    name: redhat-oadp-operator
    source: redhat-operators
    sourceNamespace: openshift-marketplace
   EOF

4. 等待 Operator 就绪：

   $ watch oc -n openshift-adp get pods

   输出示例

   NAME                                                READY   STATUS    RESTARTS   AGE
   openshift-adp-controller-manager-546684844f-qqjhn   1/1     Running   0          22s

5. 创建云存储：

   $ cat << EOF | oc create -f -
   apiVersion: oadp.openshift.io/v1alpha1
   kind: CloudStorage
   metadata:
    name: ${CLUSTER_NAME}-oadp
    namespace: openshift-adp
   spec:
    creationSecret:
      key: credentials
      name: cloud-credentials
    enableSharedConfig: true
    name: ${CLUSTER_NAME}-oadp
    provider: aws
    region: $REGION
   EOF

6. 检查应用程序的存储默认存储类：

   $ oc get pvc -n <namespace> 1

   1

   输入应用程序的命名空间。

   输出示例

   NAME     STATUS   VOLUME                                     CAPACITY   ACCESS MODES   STORAGECLASS   AGE
   applog   Bound    pvc-351791ae-b6ab-4e8b-88a4-30f73caf5ef8   1Gi        RWO            gp3-csi        4d19h
   mysql    Bound    pvc-16b8e009-a20a-4379-accc-bc81fedd0621   1Gi        RWO            gp3-csi        4d19h

   $ oc get storageclass

   输出示例

   NAME                PROVISIONER             RECLAIMPOLICY   VOLUMEBINDINGMODE      ALLOWVOLUMEEXPANSION   AGE
   gp2                 kubernetes.io/aws-ebs   Delete          WaitForFirstConsumer   true                   4d21h
   gp2-csi             ebs.csi.aws.com         Delete          WaitForFirstConsumer   true                   4d21h
   gp3                 ebs.csi.aws.com         Delete          WaitForFirstConsumer   true                   4d21h
   gp3-csi (default)   ebs.csi.aws.com         Delete          WaitForFirstConsumer   true                   4d21h

   使用 gp3-csi, gp2-csi, gp3 或 gp2 将可以正常工作。如果要备份的应用程序都使用带有 CSI 的 PV，请在 OADP DPA 配置中包含 CSI 插件。

7. 仅限 CSI：部署数据保护应用程序：

   $ cat << EOF | oc create -f -
   apiVersion: oadp.openshift.io/v1alpha1
   kind: DataProtectionApplication
   metadata:
    name: ${CLUSTER_NAME}-dpa
    namespace: openshift-adp
   spec:
    backupImages: true
    features:
      dataMover:
        enable: false
    backupLocations:
    - bucket:
        cloudStorageRef:
          name: ${CLUSTER_NAME}-oadp
        credential:
          key: credentials
          name: cloud-credentials
        prefix: velero
        default: true
        config:
          region: ${REGION}
    configuration:
      velero:
        defaultPlugins:
        - openshift
        - aws
        - csi
      restic:
        enable: false
   EOF

   注意

   如果为 CSI 卷运行这个命令，您可以跳过下一步。

8. 非 CSI 卷：部署数据保护应用程序：

   $ cat << EOF | oc create -f -
   apiVersion: oadp.openshift.io/v1alpha1
   kind: DataProtectionApplication
   metadata:
    name: ${CLUSTER_NAME}-dpa
    namespace: openshift-adp
   spec:
    backupImages: true
    features:
      dataMover:
        enable: false
    backupLocations:
    - bucket:
        cloudStorageRef:
          name: ${CLUSTER_NAME}-oadp
        credential:
          key: credentials
          name: cloud-credentials
        prefix: velero
        default: true
        config:
          region: ${REGION}
    configuration:
      velero:
        defaultPlugins:
        - openshift
        - aws
      restic:
        enable: false
    snapshotLocations:
      - velero:
          config:
            credentialsFile: /tmp/credentials/openshift-adp/cloud-credentials-credentials
            enableSharedConfig: 'true'
            profile: default
            region: ${REGION}
          provider: aws
   EOF

1. 创建要备份的工作负载：

   $ oc create namespace hello-world
   $ oc new-app -n hello-world --image=docker.io/openshift/hello-openshift

2. 公开路由：

   $ oc expose service/hello-openshift -n hello-world

3. 检查应用程序是否正常工作：

   $ curl `oc get route/hello-openshift -n hello-world -o jsonpath='{.spec.host}'`

   输出示例

   Hello OpenShift!

4. 备份工作负载：

   $ cat << EOF | oc create -f -
   apiVersion: velero.io/v1
   kind: Backup
   metadata:
    name: hello-world
    namespace: openshift-adp
   spec:
    includedNamespaces:
    - hello-world
    storageLocation: ${CLUSTER_NAME}-dpa-1
    ttl: 720h0m0s
   EOF

5. 等待备份完成：

   $ watch "oc -n openshift-adp get backup hello-world -o json | jq .status"

   输出示例

   {
    "completionTimestamp": "2022-09-07T22:20:44Z",
    "expiration": "2022-10-07T22:20:22Z",
    "formatVersion": "1.1.0",
    "phase": "Completed",
    "progress": {
      "itemsBackedUp": 58,
      "totalItems": 58
    },
    "startTimestamp": "2022-09-07T22:20:22Z",
    "version": 1
   }

6. 删除 demo 工作负载：

   $ oc delete ns hello-world

7. 从备份中恢复：

   $ cat << EOF | oc create -f -
   apiVersion: velero.io/v1
   kind: Restore
   metadata:
    name: hello-world
    namespace: openshift-adp
   spec:
    backupName: hello-world
   EOF

8. 等待 Restore 完成：

   $ watch "oc -n openshift-adp get restore hello-world -o json | jq .status"

   输出示例

   {
    "completionTimestamp": "2022-09-07T22:25:47Z",
    "phase": "Completed",
    "progress": {
      "itemsRestored": 38,
      "totalItems": 38
    },
    "startTimestamp": "2022-09-07T22:25:28Z",
    "warnings": 9
   }

9. 检查工作负载是否已恢复：

   $ oc -n hello-world get pods

   输出示例

   NAME                              READY   STATUS    RESTARTS   AGE
   hello-openshift-9f885f7c6-kdjpj   1/1     Running   0          90s

   $ curl `oc get route/hello-openshift -n hello-world -o jsonpath='{.spec.host}'`

   输出示例

   Hello OpenShift!

10. 有关故障排除提示的信息，请参阅 OADP 团队的 故障排除文档
11. 其他示例应用程序可以在 OADP 团队 的示例应用程序目录中找到

1. 删除工作负载：

   $ oc delete ns hello-world

2. 如果不再需要，从集群中删除备份和恢复资源：

   $ oc delete backups.velero.io hello-world
   $ oc delete restores.velero.io hello-world

3. 删除 s3 中的备份/恢复和远程对象：

   $ velero backup delete hello-world
   $ velero restore delete hello-world

4. 删除数据保护应用程序：

   $ oc -n openshift-adp delete dpa ${CLUSTER_NAME}-dpa

5. 删除云存储：

   $ oc -n openshift-adp delete cloudstorage ${CLUSTER_NAME}-oadp

   警告

   如果这个命令挂起，您可能需要删除终结器：

   $ oc -n openshift-adp patch cloudstorage ${CLUSTER_NAME}-oadp -p '{"metadata":{"finalizers":null}}' --type=merge

6. 如果不再需要，删除 Operator：

   $ oc -n openshift-adp delete subscription oadp-operator

7. 删除 Operator 的命名空间：

   $ oc delete ns redhat-openshift-adp

8. 如果不再有它们，请从集群中删除自定义资源定义：

   $ for CRD in `oc get crds | grep velero | awk '{print $1}'`; do oc delete crd $CRD; done
   $ for CRD in `oc get crds | grep -i oadp | awk '{print $1}'`; do oc delete crd $CRD; done

9. 删除 AWS S3 Bucket：

   $ aws s3 rm s3://${CLUSTER_NAME}-oadp --recursive
   $ aws s3api delete-bucket --bucket ${CLUSTER_NAME}-oadp

10. 将 Policy 从角色分离：

    $ aws iam detach-role-policy --role-name "${ROLE_NAME}" \
     --policy-arn "${POLICY_ARN}"

11. 删除角色：

    $ aws iam delete-role --role-name "${ROLE_NAME}"

1. 为 AWS Load Balancer Controller 创建 AWS IAM 策略：

   注意

   该策略 来自上游 AWS Load Balancer Controller 策略，以及在子网上创建标签的权限。Operator 需要它才能正常工作。

   $ oc new-project aws-load-balancer-operator
   $ POLICY_ARN=$(aws iam list-policies --query \
        "Policies[?PolicyName=='aws-load-balancer-operator-policy'].{ARN:Arn}" \
        --output text)
   $ if [[ -z "${POLICY_ARN}" ]]; then
       wget -O "${SCRATCH}/load-balancer-operator-policy.json" \
          https://raw.githubusercontent.com/rh-mobb/documentation/main/content/rosa/aws-load-balancer-operator/load-balancer-operator-policy.json
        POLICY_ARN=$(aws --region "$REGION" --query Policy.Arn \
        --output text iam create-policy \
        --policy-name aws-load-balancer-operator-policy \
        --policy-document "file://${SCRATCH}/load-balancer-operator-policy.json")
   fi
   $ echo $POLICY_ARN

2. 为 AWS Load Balancer Operator 创建 AWS IAM 信任策略：

   $ cat <<EOF > "${SCRATCH}/trust-policy.json"
   {
    "Version": "2012-10-17",
    "Statement": [
    {
    "Effect": "Allow",
    "Condition": {
      "StringEquals" : {
        "${OIDC_ENDPOINT}:sub": ["system:serviceaccount:aws-load-balancer-operator:aws-load-balancer-operator-controller-manager", "system:serviceaccount:aws-load-balancer-operator:aws-load-balancer-controller-cluster"]
      }
    },
    "Principal": {
      "Federated": "arn:aws:iam::$AWS_ACCOUNT_ID:oidc-provider/${OIDC_ENDPOINT}"
    },
    "Action": "sts:AssumeRoleWithWebIdentity"
    }
    ]
   }
   EOF

3. 为 AWS Load Balancer Operator 创建 AWS IAM 角色：

   $ ROLE_ARN=$(aws iam create-role --role-name "${ROSA_CLUSTER_NAME}-alb-operator" \
      --assume-role-policy-document "file://${SCRATCH}/trust-policy.json" \
      --query Role.Arn --output text)
   $ echo $ROLE_ARN
   
   $ aws iam attach-role-policy --role-name "${ROSA_CLUSTER_NAME}-alb-operator" \
        --policy-arn $POLICY_ARN

4. 为 AWS Load Balancer Operator 创建 secret，以假定我们新创建的 AWS IAM 角色：

   $ cat << EOF | oc apply -f -
   apiVersion: v1
   kind: Secret
   metadata:
     name: aws-load-balancer-operator
     namespace: aws-load-balancer-operator
   stringData:
     credentials: |
       [default]
       role_arn = $ROLE_ARN
       web_identity_token_file = /var/run/secrets/openshift/serviceaccount/token
   EOF

5. 安装 AWS Load Balancer Operator：

   $ cat << EOF | oc apply -f -
   apiVersion: operators.coreos.com/v1
   kind: OperatorGroup
   metadata:
     name: aws-load-balancer-operator
     namespace: aws-load-balancer-operator
   spec:
     upgradeStrategy: Default
   ---
   apiVersion: operators.coreos.com/v1alpha1
   kind: Subscription
   metadata:
     name: aws-load-balancer-operator
     namespace: aws-load-balancer-operator
   spec:
     channel: stable-v1.0
     installPlanApproval: Automatic
     name: aws-load-balancer-operator
     source: redhat-operators
     sourceNamespace: openshift-marketplace
     startingCSV: aws-load-balancer-operator.v1.0.0
   EOF

6. 使用 Operator 部署 AWS Load Balancer Controller 实例：

   注意

   如果您在此处收到错误并尝试重试，这意味着 Operator 还没有完成安装。

   $ cat << EOF | oc apply -f -
   apiVersion: networking.olm.openshift.io/v1
   kind: AWSLoadBalancerController
   metadata:
     name: cluster
   spec:
     credentials:
       name: aws-load-balancer-operator
   EOF

7. 检查 Operator 和控制器 pod 是否都在运行：

   $ oc -n aws-load-balancer-operator get pods

   如果没有等待片刻并重试，您应该看到以下内容：

   NAME                                                             READY   STATUS    RESTARTS   AGE
   aws-load-balancer-controller-cluster-6ddf658785-pdp5d            1/1     Running   0          99s
   aws-load-balancer-operator-controller-manager-577d9ffcb9-w6zqn   2/2     Running   0          2m4s

1. 创建一个新项目

   $ oc new-project hello-world

2. 部署 hello world 应用：

   $ oc new-app -n hello-world --image=docker.io/openshift/hello-openshift

3. 为 AWS ALB 配置 NodePort 服务以连接：

   $ cat << EOF | oc apply -f -
   apiVersion: v1
   kind: Service
   metadata:
     name: hello-openshift-nodeport
     namespace: hello-world
   spec:
     ports:
       - port: 80
         targetPort: 8080
         protocol: TCP
     type: NodePort
     selector:
       deployment: hello-openshift
   EOF

4. 使用 AWS Load Balancer Operator 部署 AWS ALB：

   $ cat << EOF | oc apply -f -
   apiVersion: networking.k8s.io/v1
   kind: Ingress
   metadata:
     name: hello-openshift-alb
     namespace: hello-world
     annotations:
       alb.ingress.kubernetes.io/scheme: internet-facing
   spec:
     ingressClassName: alb
     rules:
       - http:
           paths:
             - path: /
               pathType: Exact
               backend:
                 service:
                   name: hello-openshift-nodeport
                   port:
                     number: 80
   EOF

5. curl AWS ALB Ingress 端点，以验证 hello world 应用程序是否可访问：

   注意

   AWS ALB 置备需要几分钟。如果您收到显示 curl: (6) Could not resolve host 的错误，请等待再试一次。

   $ INGRESS=$(oc -n hello-world get ingress hello-openshift-alb \
       -o jsonpath='{.status.loadBalancer.ingress[0].hostname}')
   $ curl "http://${INGRESS}"

   输出示例

   Hello OpenShift!

6. 为您的 hello world 应用程序部署 AWS NLB ：

   $ cat << EOF | oc apply -f -
   apiVersion: v1
   kind: Service
   metadata:
     name: hello-openshift-nlb
     namespace: hello-world
     annotations:
       service.beta.kubernetes.io/aws-load-balancer-type: external
       service.beta.kubernetes.io/aws-load-balancer-nlb-target-type: instance
       service.beta.kubernetes.io/aws-load-balancer-scheme: internet-facing
   spec:
     ports:
       - port: 80
         targetPort: 8080
         protocol: TCP
     type: LoadBalancer
     selector:
       deployment: hello-openshift
   EOF

7. 测试 AWS NLB 端点：

   注意

   NLB 置备需要几分钟时间。如果您收到显示 curl: (6) Could not resolve host 的错误，请等待再试一次。

   $ NLB=$(oc -n hello-world get service hello-openshift-nlb \
     -o jsonpath='{.status.loadBalancer.ingress[0].hostname}')
   $ curl "http://${NLB}"

   输出示例

   Hello OpenShift!

1. 删除 hello world 应用命名空间（以及命名空间中的所有资源）：

   $ oc delete project hello-world

2. 删除 AWS Load Balancer Operator 和 AWS IAM 角色：

   $ oc delete subscription aws-load-balancer-operator -n aws-load-balancer-operator
   $ aws iam detach-role-policy \
     --role-name "${ROSA_CLUSTER_NAME}-alb-operator" \
     --policy-arn $POLICY_ARN
   $ aws iam delete-role \
     --role-name "${ROSA_CLUSTER_NAME}-alb-operator"

3. 删除 AWS IAM 策略：

   $ aws iam delete-policy --policy-arn $POLICY_ARN

流程

1. 通过更改指定的变量并运行以下命令来创建集群的 OAuth 回调 URL：

   注意

   请记住保存此回调 URL；之后需要用到。

   $ domain=$(rosa describe cluster -c <cluster_name> | grep "DNS" | grep -oE '\S+.openshiftapps.com')
   $ echo "OAuth callback URL: https://oauth-openshift.apps.$domain/oauth2callback/AAD"

   OAuth 回调 URL 末尾的"AAD"目录必须与稍后在此过程中设置的 OAuth 身份提供程序名称匹配。

2. 通过登录到 Azure 门户来创建 Entra ID 应用，然后选择 App registrations Blade。然后，选择 New registration 来创建新应用程序。

   

3. 将应用程序命名为，如 openshift-auth。
4. 从 Redirect URI 下拉菜单中选择 Web，并输入您在上一步中检索的 OAuth 回调 URL 的值。

5. 提供所需信息后，点 Register 创建应用程序。

   

6. 选择 Certificates & secrets sub-blade 并选择 New client secret。

   

7. 完成请求的详细信息，并存储生成的客户端 secret 值。此过程稍后需要此 secret。

   重要

   初始设置后，您无法看到客户端 secret。如果没有记录客户端 secret，则必须生成新的 secret。

   

8. 选择 Overview 子组合并记下 应用程序（客户端）ID 和目录 （租户）ID。以后的步骤中您将需要这些值。

   

1. 点 Token configuration sub-blade 并选择 Add optional claim 按钮。

   

2. 选择 ID 单选按钮。

   

3. 选中 电子邮件 声明复选框。

   

4. 选中 preferred_username 声明复选框。然后，点 Add 来配置 电子邮件和 preferred_username 声明您的 Entra ID 应用程序。

   

5. 页面的顶部会出现一个对话框。按照提示启用必要的 Microsoft Graph 权限。

   

流程

1. 在 Token configuration sub-blade 中点 Add groups claim。

   

2. 要为您的 Entra ID 应用程序配置组声明，请选择 Security groups，然后点 Add。

   注意

   在本例中，组声明包含用户所属的所有安全组。在真实生产环境中，确保组声明仅包含适用于 Red Hat OpenShift Service on AWS 的组。

   

流程

1. 运行以下命令来创建变量：

   $ CLUSTER_NAME=example-cluster 1
   $ IDP_NAME=AAD 2
   $ APP_ID=yyyyyyyy-yyyy-yyyy-yyyy-yyyyyyyyyyyy 3
   $ CLIENT_SECRET=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx 4
   $ TENANT_ID=zzzzzzzz-zzzz-zzzz-zzzz-zzzzzzzzzzzz 5

   1

   使用 ROSA 集群的名称替换它。

   2

   将此值替换为您之前在此过程中生成的 OAuth 回调 URL 中使用的名称。

   3

   使用应用程序（客户端）ID 替换它。

   4

   使用 Client Secret 替换它。

   5

   使用目录（租户）ID 替换它。

2. 运行以下命令来配置集群的 OAuth 提供程序。如果启用了组声明，请确保使用 --group-claims groups 参数。

   • 如果启用了组声明，请运行以下命令：

     $ rosa create idp \
     --cluster ${CLUSTER_NAME} \
     --type openid \
     --name ${IDP_NAME} \
     --client-id ${APP_ID} \
     --client-secret ${CLIENT_SECRET} \
     --issuer-url https://login.microsoftonline.com/${TENANT_ID}/v2.0 \
     --email-claims email \
     --name-claims name \
     --username-claims preferred_username \
     --extra-scopes email,profile \
     --groups-claims groups

   • 如果没有启用组声明，请运行以下命令：

     $ rosa create idp \
     --cluster ${CLUSTER_NAME} \
     --type openid \
     --name ${IDP_NAME} \
     --client-id ${APP_ID} \
     --client-secret ${CLIENT_SECRET} \
     --issuer-url https://login.microsoftonline.com/${TENANT_ID}/v2.0 \
     --email-claims email \
     --name-claims name \
     --username-claims preferred_username \
     --extra-scopes email,profile

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

   $ oc login --token=<your-token> --server=<your-server-url>

   您可以通过从 Red Hat OpenShift Cluster Manager 访问 pull secret 来查找您的登录令牌。

2. 运行以下命令，验证集群是否有 STS：

   $ oc get authentication.config.openshift.io cluster -o json \
     | jq .spec.serviceAccountIssuer

   输出示例

   "https://xxxxx.cloudfront.net/xxxxx"

   如果您的输出不同，请不要继续。在继续此过程前 ，请参阅创建 STS 集群的红帽文档。

3. 运行以下命令，将 SecurityContextConstraints 权限设置为允许 CSI 驱动程序运行：

   $ oc new-project csi-secrets-store
   $ oc adm policy add-scc-to-user privileged \
       system:serviceaccount:csi-secrets-store:secrets-store-csi-driver
   $ oc adm policy add-scc-to-user privileged \
       system:serviceaccount:csi-secrets-store:csi-secrets-store-provider-aws

4. 运行以下命令，创建环境变量以便稍后使用：

   $ export REGION=$(oc get infrastructure cluster -o=jsonpath="{.status.platformStatus.aws.region}")
   $ export OIDC_ENDPOINT=$(oc get authentication.config.openshift.io cluster \
      -o jsonpath='{.spec.serviceAccountIssuer}' | sed  's|^https://||')
   $ export AWS_ACCOUNT_ID=`aws sts get-caller-identity --query Account --output text`
   $ export AWS_PAGER=""

1. 运行以下命令，使用 Helm 注册 secret 存储 CSI 驱动程序：

   $ helm repo add secrets-store-csi-driver \
       https://kubernetes-sigs.github.io/secrets-store-csi-driver/charts

2. 运行以下命令来更新 Helm 仓库：

   $ helm repo update

3. 运行以下命令来安装 secret 存储 CSI 驱动程序：

   $ helm upgrade --install -n csi-secrets-store \
       csi-secrets-store-driver secrets-store-csi-driver/secrets-store-csi-driver

4. 运行以下命令来部署 AWS 供应商：

   $ oc -n csi-secrets-store apply -f \
       https://raw.githubusercontent.com/rh-mobb/documentation/main/content/misc/secrets-store-csi/aws-provider-installer.yaml

5. 运行以下命令，检查两个 Daemonsets 是否正在运行：

   $ oc -n csi-secrets-store get ds \
       csi-secrets-store-provider-aws \
       csi-secrets-store-driver-secrets-store-csi-driver

6. 运行以下命令，标记 Secrets Store CSI Driver 以允许与受限 pod 安全配置集一起使用：

   $ oc label csidriver.storage.k8s.io/secrets-store.csi.k8s.io security.openshift.io/csi-ephemeral-volume-profile=restricted

1. 运行以下命令，在 Secret Manager 中创建 secret：

   $ SECRET_ARN=$(aws --region "$REGION" secretsmanager create-secret \
       --name MySecret --secret-string \
       '{"username":"shadowman", "password":"hunter2"}' \
       --query ARN --output text); echo $SECRET_ARN

2. 运行以下命令来创建 IAM 访问策略文档：

   $ cat << EOF > policy.json
   {
      "Version": "2012-10-17",
      "Statement": [{
         "Effect": "Allow",
         "Action": [
           "secretsmanager:GetSecretValue",
           "secretsmanager:DescribeSecret"
         ],
         "Resource": ["$SECRET_ARN"]
         }]
   }
   EOF

3. 运行以下命令来创建 IAM 访问策略：

   $ POLICY_ARN=$(aws --region "$REGION" --query Policy.Arn \
   --output text iam create-policy \
   --policy-name openshift-access-to-mysecret-policy \
   --policy-document file://policy.json); echo $POLICY_ARN

4. 运行以下命令来创建 IAM 角色信任策略文档：

   注意

   信任策略被锁定到您稍后在此过程中创建的命名空间的默认服务帐户。

   $ cat <<EOF > trust-policy.json
   {
      "Version": "2012-10-17",
      "Statement": [
      {
      "Effect": "Allow",
      "Condition": {
        "StringEquals" : {
          "${OIDC_ENDPOINT}:sub": ["system:serviceaccount:my-application:default"]
         }
       },
       "Principal": {
          "Federated": "arn:aws:iam::$AWS_ACCOUNT_ID:oidc-provider/${OIDC_ENDPOINT}"
       },
       "Action": "sts:AssumeRoleWithWebIdentity"
       }
       ]
   }
   EOF

5. 运行以下命令来创建 IAM 角色：

   $ ROLE_ARN=$(aws iam create-role --role-name openshift-access-to-mysecret \
   --assume-role-policy-document file://trust-policy.json \
   --query Role.Arn --output text); echo $ROLE_ARN

6. 运行以下命令，将角色附加到策略：

   $ aws iam attach-role-policy --role-name openshift-access-to-mysecret \
       --policy-arn $POLICY_ARN

1. 运行以下命令来创建 OpenShift 项目：

   $ oc new-project my-application

2. 运行以下命令，注解 default 服务帐户以使用 STS 角色：

   $ oc annotate -n my-application serviceaccount default \
       eks.amazonaws.com/role-arn=$ROLE_ARN

3. 运行以下命令，创建 secret 供应商类以访问我们的 secret：

   $ cat << EOF | oc apply -f -
   apiVersion: secrets-store.csi.x-k8s.io/v1
   kind: SecretProviderClass
   metadata:
     name: my-application-aws-secrets
   spec:
     provider: aws
     parameters:
       objects: |
         - objectName: "MySecret"
           objectType: "secretsmanager"
   EOF

4. 使用以下命令中的 secret 创建部署：

   $ cat << EOF | oc apply -f -
   apiVersion: v1
   kind: Pod
   metadata:
     name: my-application
     labels:
       app: my-application
   spec:
     volumes:
     - name: secrets-store-inline
       csi:
         driver: secrets-store.csi.k8s.io
         readOnly: true
         volumeAttributes:
           secretProviderClass: "my-application-aws-secrets"
     containers:
     - name: my-application-deployment
       image: k8s.gcr.io/e2e-test-images/busybox:1.29
       command:
         - "/bin/sleep"
         - "10000"
       volumeMounts:
       - name: secrets-store-inline
         mountPath: "/mnt/secrets-store"
         readOnly: true
   EOF

5. 运行以下命令验证 pod 是否挂载了 secret：

   $ oc exec -it my-application -- cat /mnt/secrets-store/MySecret

1. 运行以下命令来删除应用程序：

   $ oc delete project my-application

2. 运行以下命令来删除 secret 存储 csi 驱动程序：

   $ helm delete -n csi-secrets-store csi-secrets-store-driver

3. 运行以下命令来删除安全性上下文约束：

   $ oc adm policy remove-scc-from-user privileged \
       system:serviceaccount:csi-secrets-store:secrets-store-csi-driver; oc adm policy remove-scc-from-user privileged \
       system:serviceaccount:csi-secrets-store:csi-secrets-store-provider-aws

4. 运行以下命令来删除 AWS 供应商：

   $ oc -n csi-secrets-store delete -f \
   https://raw.githubusercontent.com/rh-mobb/documentation/main/content/misc/secrets-store-csi/aws-provider-installer.yaml

5. 运行以下命令来删除 AWS 角色和策略：

   $ aws iam detach-role-policy --role-name openshift-access-to-mysecret \
       --policy-arn $POLICY_ARN; aws iam delete-role --role-name openshift-access-to-mysecret; aws iam delete-policy --policy-arn $POLICY_ARN

6. 运行以下命令来删除 Secrets Manager secret：

   $ aws secretsmanager --region $REGION delete-secret --secret-id $SECRET_ARN

1. 配置以下环境变量，将集群名称更改为适合您的集群：

   $ export CLUSTER_NAME=$(oc get infrastructure cluster -o=jsonpath="{.status.infrastructureName}"  | sed 's/-[a-z0-9]\{5\}$//')
   $ export REGION=$(rosa describe cluster -c ${ROSA_CLUSTER_NAME} --output json | jq -r .region.id)
   $ export OIDC_ENDPOINT=$(oc get authentication.config.openshift.io cluster -o json | jq -r .spec.serviceAccountIssuer | sed  's|^https://||')
   $ export AWS_ACCOUNT_ID=`aws sts get-caller-identity --query Account --output text`
   $ export ACK_SERVICE=s3
   $ export ACK_SERVICE_ACCOUNT=ack-${ACK_SERVICE}-controller
   $ export POLICY_ARN=arn:aws:iam::aws:policy/AmazonS3FullAccess
   $ export AWS_PAGER=""
   $ export SCRATCH="/tmp/${ROSA_CLUSTER_NAME}/ack"
   $ mkdir -p ${SCRATCH}

2. 在移动到下一部分前，请确定所有字段都正确输出：

   $ echo "Cluster: ${ROSA_CLUSTER_NAME}, Region: ${REGION}, OIDC Endpoint: ${OIDC_ENDPOINT}, AWS Account ID: ${AWS_ACCOUNT_ID}"

1. 为 ACK Operator 创建 AWS Identity Access Management (IAM)信任策略：

   $ cat <<EOF > "${SCRATCH}/trust-policy.json"
   {
    "Version": "2012-10-17",
    "Statement": [
    {
    "Effect": "Allow",
    "Condition": {
      "StringEquals" : {
        "${OIDC_ENDPOINT}:sub": "system:serviceaccount:ack-system:${ACK_SERVICE_ACCOUNT}"
      }
    },
    "Principal": {
      "Federated": "arn:aws:iam::$AWS_ACCOUNT_ID:oidc-provider/${OIDC_ENDPOINT}"
    },
    "Action": "sts:AssumeRoleWithWebIdentity"
    }
    ]
   }
   EOF

2. 为 ACK Operator 创建 AWS IAM 角色，以假设附加 AmazonS3FullAccess 策略：

   注意

   您可以在每个项目的 GitHub 仓库中找到推荐的策略，例如 https://github.com/aws-controllers-k8s/s3-controller/blob/main/config/iam/recommended-policy-arn。

   $ ROLE_ARN=$(aws iam create-role --role-name "ack-${ACK_SERVICE}-controller" \
      --assume-role-policy-document "file://${SCRATCH}/trust-policy.json" \
      --query Role.Arn --output text)
   $ echo $ROLE_ARN
   
   $ aws iam attach-role-policy --role-name "ack-${ACK_SERVICE}-controller" \
        --policy-arn ${POLICY_ARN}

1. 创建一个项目，将 ACK S3 Operator 安装到：

   $ oc new-project ack-system

2. 使用 ACK S3 Operator 配置创建文件：

   注意

   ACK_WATCH_NAMESPACE 被视为空白，以便控制器可以正确地监视集群中的所有命名空间。

   $ cat <<EOF > "${SCRATCH}/config.txt"
   ACK_ENABLE_DEVELOPMENT_LOGGING=true
   ACK_LOG_LEVEL=debug
   ACK_WATCH_NAMESPACE=
   AWS_REGION=${REGION}
   AWS_ENDPOINT_URL=
   ACK_RESOURCE_TAGS=${CLUSTER_NAME}
   ENABLE_LEADER_ELECTION=true
   LEADER_ELECTION_NAMESPACE=
   EOF

3. 使用上一步中的文件来创建 ConfigMap：

   $ oc -n ack-system create configmap \
     --from-env-file=${SCRATCH}/config.txt ack-${ACK_SERVICE}-user-config

4. 从 OperatorHub 安装 ACK S3 Operator：

   $ cat << EOF | oc apply -f -
   apiVersion: operators.coreos.com/v1
   kind: OperatorGroup
   metadata:
     name: ack-${ACK_SERVICE}-controller
     namespace: ack-system
   spec:
     upgradeStrategy: Default
   ---
   apiVersion: operators.coreos.com/v1alpha1
   kind: Subscription
   metadata:
     name: ack-${ACK_SERVICE}-controller
     namespace: ack-system
   spec:
     channel: alpha
     installPlanApproval: Automatic
     name: ack-${ACK_SERVICE}-controller
     source: community-operators
     sourceNamespace: openshift-marketplace
   EOF

5. 使用 AWS IAM 角色注解 ACK S3 Operator 服务帐户，以假定和重启部署：

   $ oc -n ack-system annotate serviceaccount ${ACK_SERVICE_ACCOUNT} \
     eks.amazonaws.com/role-arn=${ROLE_ARN} && \
     oc -n ack-system rollout restart deployment ack-${ACK_SERVICE}-controller

6. 验证 ACK S3 Operator 是否正在运行：

   $ oc -n ack-system get pods

   输出示例

   NAME                                 READY   STATUS    RESTARTS   AGE
   ack-s3-controller-585f6775db-s4lfz   1/1     Running   0          51s

1. 部署 S3 存储桶资源：

   $ cat << EOF | oc apply -f -
   apiVersion: s3.services.k8s.aws/v1alpha1
   kind: Bucket
   metadata:
      name: ${CLUSTER-NAME}-bucket
      namespace: ack-system
   spec:
      name: ${CLUSTER-NAME}-bucket
   EOF

2. 验证 AWS 中 S3 存储桶是否已创建：

   $ aws s3 ls | grep ${CLUSTER_NAME}-bucket

   输出示例

   2023-10-04 14:51:45 mrmc-test-maz-bucket

1. 删除 S3 存储桶资源：

   $ oc -n ack-system delete bucket.s3.services.k8s.aws/${CLUSTER-NAME}-bucket

2. 删除 ACK S3 Operator 和 AWS IAM 角色：

   $ oc -n ack-system delete subscription ack-${ACK_SERVICE}-controller
   $ aws iam detach-role-policy \
     --role-name "ack-${ACK_SERVICE}-controller" \
     --policy-arn ${POLICY_ARN}
   $ aws iam delete-role \
     --role-name "ack-${ACK_SERVICE}-controller"

3. 删除 ack-system 项目：

   $ oc delete project ack-system

1. 配置以下环境变量：

   $ export DOMAIN=<apps.example.com> 1
   $ export AWS_PAGER=""
   $ export CLUSTER=$(oc get infrastructure cluster -o=jsonpath="{.status.infrastructureName}"  | sed 's/-[a-z0-9]\{5\}$//')
   $ export REGION=$(oc get infrastructure cluster -o=jsonpath="{.status.platformStatus.aws.region}")
   $ export AWS_ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)
   $ export SCRATCH="/tmp/${CLUSTER}/external-dns"
   $ mkdir -p ${SCRATCH}

   1

   使用您要用于 IngressController 的自定义域替换。

2. 在移动到下一部分前，请确定所有字段都正确输出：

   $ echo "Cluster: ${CLUSTER}, Region: ${REGION}, AWS Account ID: ${AWS_ACCOUNT_ID}"

   注意

   上一命令中的"Cluster"输出可以是集群名称、集群的内部 ID 或集群的域前缀。如果要使用另一个标识符，您可以通过运行以下命令来手动设置这个值：

   $ export CLUSTER=my-custom-value

流程

1. 从私钥和公共证书创建一个新的 TLS secret，其中 fullchain.pem 是您的完整的通配符证书链（包括任何中间）和 privkey.pem 是您的通配符证书：

   $ oc -n openshift-ingress create secret tls external-dns-tls --cert=fullchain.pem --key=privkey.pem

2. 创建新的 IngressController 资源：

   $ cat << EOF | oc apply -f -
   apiVersion: operator.openshift.io/v1
   kind: IngressController
   metadata:
     name: external-dns-ingress
     namespace: openshift-ingress-operator
   spec:
     domain: ${DOMAIN}
     defaultCertificate:
       name: external-dns-tls
     endpointPublishingStrategy:
       loadBalancer:
         dnsManagementPolicy: Unmanaged
         providerParameters:
           aws:
             type: NLB
           type: AWS
         scope: External
       type: LoadBalancerService
   EOF

   警告

   此 IngressController 示例将在 AWS 帐户中创建可访问互联网的 Network Load Balancer (NLB)。要置备内部 NLB，请在创建 IngressController 资源前将 .spec.endpointPublishingStrategy.loadBalancer.scope 参数设置为 Internal。

3. 验证自定义域 IngressController 是否已成功创建了外部负载均衡器：

   $ oc -n openshift-ingress get service/router-external-dns-ingress

   输出示例

   NAME                          TYPE           CLUSTER-IP      EXTERNAL-IP                                                                     PORT(S)                      AGE
   router-external-dns-ingress   LoadBalancer   172.30.71.250   a4838bb991c6748439134ab89f132a43-aeae124077b50c01.elb.us-east-1.amazonaws.com   80:32227/TCP,443:30310/TCP   43s

1. 检索 Amazon Route 53 公共托管区 ID：

   $ export ZONE_ID=$(aws route53 list-hosted-zones-by-name --output json \
     --dns-name "${DOMAIN}." --query 'HostedZones[0]'.Id --out text | sed 's/\/hostedzone\///')

2. 准备包含所需 DNS 更改的文档，以便为 Ingress Controller 的规范域启用 DNS 解析：

   $ NLB_HOST=$(oc -n openshift-ingress get service/router-external-dns-ingress -ojsonpath="{.status.loadBalancer.ingress[0].hostname}")
   $ cat << EOF > "${SCRATCH}/create-cname.json"
   {
     "Comment":"Add CNAME to ingress controller canonical domain",
     "Changes":[{
         "Action":"CREATE",
         "ResourceRecordSet":{
           "Name": "router-external-dns-ingress.${DOMAIN}",
         "Type":"CNAME",
         "TTL":30,
         "ResourceRecords":[{
           "Value": "${NLB_HOST}"
         }]
       }
     }]
   }
   EOF

   External DNS Operator 使用这个规范域作为 CNAME 记录的目标。

3. 提交您对 Amazon Route 53 的更改以进行传播：

   aws route53 change-resource-record-sets \
     --hosted-zone-id ${ZONE_ID} \
     --change-batch file://${SCRATCH}/create-cname.json

4. 创建一个 AWS IAM 策略文档，允许 外部 DNS Operator 仅 更新自定义域公共托管区：

   $ cat << EOF > "${SCRATCH}/external-dns-policy.json"
   {
     "Version": "2012-10-17",
     "Statement": [
       {
         "Effect": "Allow",
         "Action": [
           "route53:ChangeResourceRecordSets"
         ],
         "Resource": [
           "arn:aws:route53:::hostedzone/${ZONE_ID}"
         ]
       },
       {
         "Effect": "Allow",
         "Action": [
           "route53:ListHostedZones",
           "route53:ListResourceRecordSets"
         ],
         "Resource": [
           "*"
         ]
       }
     ]
   }
   EOF

5. 创建 AWS IAM 用户：

   $ aws iam create-user --user-name "${CLUSTER}-external-dns-operator"

6. 附加策略：

   $ aws iam attach-user-policy --user-name "${CLUSTER}-external-dns-operator" --policy-arn $POLICY_ARN

   注意

   这将在以后的版本中使用 IRSA 改为 STS。

7. 为 IAM 用户创建 AWS 密钥：

   $ SECRET_ACCESS_KEY=$(aws iam create-access-key --user-name "${CLUSTER}-external-dns-operator")

8. 创建静态凭证：

   $ cat << EOF > "${SCRATCH}/credentials"
   [default]
   aws_access_key_id = $(echo $SECRET_ACCESS_KEY | jq -r '.AccessKey.AccessKeyId')
   aws_secret_access_key = $(echo $SECRET_ACCESS_KEY | jq -r '.AccessKey.SecretAccessKey')
   EOF

1. 创建一个新项目

   $ oc new-project external-dns-operator

2. 从 OperatorHub 安装 外部 DNS Operator：

   $ cat << EOF | oc apply -f -
   apiVersion: operators.coreos.com/v1
   kind: OperatorGroup
   metadata:
     name: external-dns-group
     namespace: external-dns-operator
   spec:
     targetNamespaces:
     - external-dns-operator
   ---
   apiVersion: operators.coreos.com/v1alpha1
   kind: Subscription
   metadata:
     name: external-dns-operator
     namespace: external-dns-operator
   spec:
     channel: stable-v1.1
     installPlanApproval: Automatic
     name: external-dns-operator
     source: redhat-operators
     sourceNamespace: openshift-marketplace
   EOF

3. 等待 外部 DNS Operator 正在运行：

   $ oc rollout status deploy external-dns-operator --timeout=300s

4. 从 AWS IAM 用户凭证创建 secret：

   $ oc -n external-dns-operator create secret generic external-dns \
     --from-file "${SCRATCH}/credentials"

5. 部署 ExternalDNS 控制器：

   $ cat << EOF | oc apply -f -
   apiVersion: externaldns.olm.openshift.io/v1beta1
   kind: ExternalDNS
   metadata:
     name: ${DOMAIN}
   spec:
     domains:
       - filterType: Include
         matchType: Exact
         name: ${DOMAIN}
     provider:
       aws:
         credentials:
           name: external-dns
       type: AWS
     source:
       openshiftRouteOptions:
         routerName: external-dns-ingress
       type: OpenShiftRoute
     zones:
       - ${ZONE_ID}
   EOF

6. 等待控制器运行：

   $ oc rollout status deploy external-dns-${DOMAIN} --timeout=300s

1. 为您的示例应用程序创建一个新项目：

   $ oc new-project hello-world

2. 部署 hello world 应用：

   $ oc new-app -n hello-world --image=docker.io/openshift/hello-openshift

3. 为应用程序创建指定自定义域名的路由：

   $ oc -n hello-world create route edge --service=hello-openshift hello-openshift-tls \
   --hostname hello-openshift.${DOMAIN}

4. 检查 ExternalDNS 会自动创建 DNS 记录：

   注意

   记录可能需要几分钟时间才会出现在 Amazon Route 53 中。

   $ aws route53 list-resource-record-sets --hosted-zone-id ${ZONE_ID} \
      --query "ResourceRecordSets[?Type == 'CNAME']" | grep hello-openshift

5. 可选： 您还可以查看 ExternalDNS 创建的 TXT 记录：

   $ aws route53 list-resource-record-sets --hosted-zone-id ${ZONE_ID} \
      --query "ResourceRecordSets[?Type == 'TXT']" | grep ${DOMAIN}

6. curl 新创建的 DNS 记录到示例应用程序，以验证可以访问 hello world 应用程序：

   $ curl https://hello-openshift.${DOMAIN}

   输出示例

   Hello OpenShift!

1. 配置以下环境变量：

   $ export DOMAIN=apps.example.com 1
   $ export EMAIL=email@example.com 2
   $ export AWS_PAGER=""
   $ export CLUSTER=$(oc get infrastructure cluster -o=jsonpath="{.status.infrastructureName}"  | sed 's/-[a-z0-9]\{5\}$//')
   $ export OIDC_ENDPOINT=$(oc get authentication.config.openshift.io cluster -o json | jq -r .spec.serviceAccountIssuer | sed  's|^https://||')
   $ export REGION=$(oc get infrastructure cluster -o=jsonpath="{.status.platformStatus.aws.region}")
   $ export AWS_ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)
   $ export SCRATCH="/tmp/${CLUSTER}/dynamic-certs"
   $ mkdir -p ${SCRATCH}

   1

   使用您要用于 IngressController 的自定义域替换。

   2

   使用您希望 Let 的 Encrypt 用于向您的证书发送通知的电子邮件替换。

2. 在移动到下一部分前，请确定所有字段都正确输出：

   $ echo "Cluster: ${CLUSTER}, Region: ${REGION}, OIDC Endpoint: ${OIDC_ENDPOINT}, AWS Account ID: ${AWS_ACCOUNT_ID}"

   注意

   上一命令中的"Cluster"输出可以是集群名称、集群的内部 ID 或集群的域前缀。如果要使用另一个标识符，您可以通过运行以下命令来手动设置这个值：

   $ export CLUSTER=my-custom-value

1. 检索 Amazon Route 53 公共托管区 ID：

   注意

   此命令查找与之前作为 DOMAIN 环境变量指定的自定义域匹配的公共托管区。您可以通过运行 export ZONE_ID=<zone_ID > 来手动指定 Amazon Route 53 公共托管区，将 &lt ;zone_ID& gt; 替换为您的特定的 Amazon Route 53 公共托管区 ID。

   $ export ZONE_ID=$(aws route53 list-hosted-zones-by-name --output json \
     --dns-name "${DOMAIN}." --query 'HostedZones[0]'.Id --out text | sed 's/\/hostedzone\///')

2. 为 cert-manager Operator 创建 AWS IAM 策略文档，它提供 只 更新指定的公共托管区的功能：

   $ cat <<EOF > "${SCRATCH}/cert-manager-policy.json"
   {
     "Version": "2012-10-17",
     "Statement": [
       {
         "Effect": "Allow",
         "Action": "route53:GetChange",
         "Resource": "arn:aws:route53:::change/*"
       },
       {
         "Effect": "Allow",
         "Action": [
           "route53:ChangeResourceRecordSets",
           "route53:ListResourceRecordSets"
         ],
         "Resource": "arn:aws:route53:::hostedzone/${ZONE_ID}"
       },
       {
         "Effect": "Allow",
         "Action": "route53:ListHostedZonesByName",
         "Resource": "*"
       }
     ]
   }
   EOF

3. 使用您在上一步中创建的文件创建 IAM 策略：

   $ POLICY_ARN=$(aws iam create-policy --policy-name "${CLUSTER}-cert-manager-policy" \
     --policy-document file://${SCRATCH}/cert-manager-policy.json \
     --query 'Policy.Arn' --output text)

4. 为 cert-manager Operator 创建 AWS IAM 信任策略：

   $ cat <<EOF > "${SCRATCH}/trust-policy.json"
   {
    "Version": "2012-10-17",
    "Statement": [
    {
    "Effect": "Allow",
    "Condition": {
      "StringEquals" : {
        "${OIDC_ENDPOINT}:sub": "system:serviceaccount:cert-manager:cert-manager"
      }
    },
    "Principal": {
      "Federated": "arn:aws:iam::$AWS_ACCOUNT_ID:oidc-provider/${OIDC_ENDPOINT}"
    },
    "Action": "sts:AssumeRoleWithWebIdentity"
    }
    ]
   }
   EOF

5. 使用您在上一步中创建的信任策略，为 cert-manager Operator 创建 IAM 角色：

   $ ROLE_ARN=$(aws iam create-role --role-name "${CLUSTER}-cert-manager-operator" \
      --assume-role-policy-document "file://${SCRATCH}/trust-policy.json" \
      --query Role.Arn --output text)

6. 将权限策略附加到角色：

   $ aws iam attach-role-policy --role-name "${CLUSTER}-cert-manager-operator" \
     --policy-arn ${POLICY_ARN}

1. 创建一个项目，将 cert-manager Operator 安装到其中：

   $ oc new-project cert-manager-operator

   重要

   不要试图在集群中使用多个 cert-manager Operator。如果在集群中安装了社区 cert-manager Operator，则必须在为 Red Hat OpenShift 安装 cert-manager Operator 前卸载它。

2. 为 Red Hat OpenShift 安装 cert-manager Operator：

   $ cat << EOF | oc apply -f -
   apiVersion: operators.coreos.com/v1
   kind: OperatorGroup
   metadata:
     name: openshift-cert-manager-operator-group
     namespace: cert-manager-operator
   spec:
     targetNamespaces:
     - cert-manager-operator
   ---
   apiVersion: operators.coreos.com/v1alpha1
   kind: Subscription
   metadata:
     name: openshift-cert-manager-operator
     namespace: cert-manager-operator
   spec:
     channel: stable-v1
     installPlanApproval: Automatic
     name: openshift-cert-manager-operator
     source: redhat-operators
     sourceNamespace: openshift-marketplace
   EOF

   注意

   此 Operator 需要几分钟时间来安装并完成它的设置。

3. 验证 cert-manager Operator 是否正在运行：

   $ oc -n cert-manager-operator get pods

   输出示例

   NAME                                                        READY   STATUS    RESTARTS   AGE
   cert-manager-operator-controller-manager-84b8799db5-gv8mx   2/2     Running   0          12s

4. 使用之前创建的 AWS IAM 角色注解 cert-manager pod 使用的服务帐户：

   $ oc -n cert-manager annotate serviceaccount cert-manager eks.amazonaws.com/role-arn=${ROLE_ARN}

5. 运行以下命令重启现有的 cert-manager 控制器 pod：

   $ oc -n cert-manager delete pods -l app.kubernetes.io/name=cert-manager

6. 修补 Operator 配置以使用外部名称服务器以防止 DNS-01 质询问题：

   $ oc patch certmanager.operator.openshift.io/cluster --type merge \
     -p '{"spec":{"controllerConfig":{"overrideArgs":["--dns01-recursive-nameservers-only","--dns01-recursive-nameservers=1.1.1.1:53"]}}}'

7. 运行以下命令，创建一个 ClusterIssuer 资源以使用 Let 的 Encrypt ：

   $ cat << EOF | oc apply -f -
   apiVersion: cert-manager.io/v1
   kind: ClusterIssuer
   metadata:
     name: letsencrypt-production
   spec:
     acme:
       server: https://acme-v02.api.letsencrypt.org/directory
       email: ${EMAIL}
       # This key doesn't exist, cert-manager creates it
       privateKeySecretRef:
         name: prod-letsencrypt-issuer-account-key
       solvers:
       - dns01:
           route53:
            hostedZoneID: ${ZONE_ID}
            region: ${REGION}
            secretAccessKeySecretRef:
              name: ''
   EOF

8. 验证 ClusterIssuer 资源是否已就绪：

   $ oc get clusterissuer.cert-manager.io/letsencrypt-production

   输出示例

   NAME                     READY   AGE
   letsencrypt-production   True    47s

1. 创建并配置证书资源来为自定义域 Ingress Controller 置备证书：

   注意

   以下示例使用单个域证书。还支持 SAN 和通配符证书。

   $ cat << EOF | oc apply -f -
   apiVersion: cert-manager.io/v1
   kind: Certificate
   metadata:
     name: custom-domain-ingress-cert
     namespace: openshift-ingress
   spec:
     secretName: custom-domain-ingress-cert-tls
     issuerRef:
        name: letsencrypt-production
        kind: ClusterIssuer
     commonName: "${DOMAIN}"
     dnsNames:
     - "${DOMAIN}"
   EOF

2. 验证证书是否已发布：

   注意

   Let's Encrypt 发布此证书需要几分钟时间。如果用时超过 5 分钟，请运行 oc -n openshift-ingress describe certificate.cert-manager.io/custom-domain-ingress-cert 来查看 cert-manager 报告的问题。

   $ oc -n openshift-ingress get certificate.cert-manager.io/custom-domain-ingress-cert

   输出示例

   NAME                         READY   SECRET                           AGE
   custom-domain-ingress-cert   True    custom-domain-ingress-cert-tls   9m53s

3. 创建新的 IngressController 资源：

   $ cat << EOF | oc apply -f -
   apiVersion: operator.openshift.io/v1
   kind: IngressController
   metadata:
     name: custom-domain-ingress
     namespace: openshift-ingress-operator
   spec:
     domain: ${DOMAIN}
     defaultCertificate:
       name: custom-domain-ingress-cert-tls
     endpointPublishingStrategy:
       loadBalancer:
         dnsManagementPolicy: Unmanaged
         providerParameters:
           aws:
             type: NLB
           type: AWS
         scope: External
       type: LoadBalancerService
   EOF

   警告

   此 IngressController 示例将在 AWS 帐户中创建可访问互联网的 Network Load Balancer (NLB)。要置备内部 NLB，请在创建 IngressController 资源前将 .spec.endpointPublishingStrategy.loadBalancer.scope 参数设置为 Internal。

4. 验证自定义域 IngressController 是否已成功创建了外部负载均衡器：

   $ oc -n openshift-ingress get service/router-custom-domain-ingress

   输出示例

   NAME                           TYPE           CLUSTER-IP      EXTERNAL-IP                                                                     PORT(S)                      AGE
   router-custom-domain-ingress   LoadBalancer   172.30.174.34   a309962c3bd6e42c08cadb9202eca683-1f5bbb64a1f1ec65.elb.us-east-1.amazonaws.com   80:31342/TCP,443:31821/TCP   7m28s

5. 准备带有所需 DNS 更改的文档，为您的自定义域 Ingress Controller 启用 DNS 解析：

   $ INGRESS=$(oc -n openshift-ingress get service/router-custom-domain-ingress -ojsonpath="{.status.loadBalancer.ingress[0].hostname}")
   $ cat << EOF > "${SCRATCH}/create-cname.json"
   {
     "Comment":"Add CNAME to custom domain endpoint",
     "Changes":[{
         "Action":"CREATE",
         "ResourceRecordSet":{
           "Name": "*.${DOMAIN}",
         "Type":"CNAME",
         "TTL":30,
         "ResourceRecords":[{
           "Value": "${INGRESS}"
         }]
       }
     }]
   }
   EOF

6. 提交您对 Amazon Route 53 的更改以进行传播：

   $ aws route53 change-resource-record-sets \
     --hosted-zone-id ${ZONE_ID} \
     --change-batch file://${SCRATCH}/create-cname.json

   注意

   虽然通配符 CNAME 记录避免需要为每个使用自定义域 Ingress Controller 部署的新应用程序创建新记录，但这些应用程序使用的证书 都不是 通配符证书。

1. 创建必要的 OpenShift 资源 cert-manager 需要管理 OpenShift 路由的证书。

   此步骤会创建一个新的部署（以及 pod），该部署专门监控集群中注解的路由。如果在新路由中找到 issuer-kind 和 issuer-name 注解，则会为这个路由唯一的新证书请求 Issuer （本例中为ClusterIssuer），这将遵循创建路由时指定的主机名。

   注意

   如果集群无法访问 GitHub，您可以在本地保存原始内容，并运行 oc apply -f localfilename.yaml -n cert-manager。

   $ oc -n cert-manager apply -f https://github.com/cert-manager/openshift-routes/releases/latest/download/cert-manager-openshift-routes.yaml

   此步骤中也会创建以下额外 OpenShift 资源：

   • ClusterRole - 授予在集群中监控和更新路由的权限
   • ServiceAccount - 使用权限运行新创建的 pod
   • ClusterRoleBinding - 绑定这两个资源

2. 确保新的 cert-manager-openshift-routes pod 成功运行：

   $ oc -n cert-manager get pods

   结果示例

   NAME                                             READY   STATUS    RESTARTS   AGE
   cert-manager-866d8f788c-9kspc                    1/1     Running   0          4h21m
   cert-manager-cainjector-6885c585bd-znws8         1/1     Running   0          4h41m
   cert-manager-openshift-routes-75b6bb44cd-f8kd5   1/1     Running   0          6s
   cert-manager-webhook-8498785dd9-bvfdf            1/1     Running   0          4h41m

1. 为您的示例应用程序创建一个新项目：

   $ oc new-project hello-world

2. 部署 hello world 应用：

   $ oc -n hello-world new-app --image=docker.io/openshift/hello-openshift

3. 创建路由从集群外部公开应用程序：

   $ oc -n hello-world create route edge --service=hello-openshift hello-openshift-tls --hostname hello.${DOMAIN}

4. 验证路由的证书是否不被信任：

   $ curl -I https://hello.${DOMAIN}

   输出示例

   curl: (60) SSL: no alternative certificate subject name matches target host name 'hello.example.com'
   More details here: https://curl.se/docs/sslcerts.html
   
   curl failed to verify the legitimacy of the server and therefore could not
   establish a secure connection to it. To learn more about this situation and
   how to fix it, please visit the web page mentioned above.

5. 注解路由以触发 cert-manager 为自定义域置备证书：

   $ oc -n hello-world annotate route hello-openshift-tls cert-manager.io/issuer-kind=ClusterIssuer cert-manager.io/issuer-name=letsencrypt-production

   注意

   创建证书需要 2-3 分钟。证书续订将由 cert-manager Operator 自动管理，因为它接近到期。

6. 验证路由的证书现在是否被信任：

   $ curl -I https://hello.${DOMAIN}

   输出示例

   HTTP/2 200
   date: Thu, 05 Oct 2023 23:45:33 GMT
   content-length: 17
   content-type: text/plain; charset=utf-8
   set-cookie: 52e4465485b6fb4f8a1b1bed128d0f3b=68676068bb32d24f0f558f094ed8e4d7; path=/; HttpOnly; Secure; SameSite=None
   cache-control: private

1. 在创建出口 IP 规则前，请确定您要使用的出口 IP。

   注意

   您选择的出口 IP 应该作为置备 worker 节点的子网的一部分存在。

2. 可选 ：保留您请求的出口 IP，以避免与 AWS Virtual Private Cloud (VPC) Dynamic Host Configuration Protocol (DHCP)服务冲突。

   在 AWS 文档中为 CIDR 保留页面请求显式 IP 保留。

1. 运行以下命令来创建新项目：

   $ oc new-project demo-egress-ns

2. 运行以下命令，为命名空间中的所有 pod 创建出口规则：

   $ cat <<EOF | oc apply -f -
   apiVersion: k8s.ovn.org/v1
   kind: EgressIP
   metadata:
     name: demo-egress-ns
   spec:
     # NOTE: these egress IPs are within the subnet range(s) in which my worker nodes
     #       are deployed.
     egressIPs:
       - 10.10.100.253
       - 10.10.150.253
       - 10.10.200.253
     namespaceSelector:
       matchLabels:
         kubernetes.io/metadata.name: demo-egress-ns
   EOF

1. 运行以下命令来创建新项目：

   $ oc new-project demo-egress-pod

2. 运行以下命令，为 pod 创建出口规则：

   注意

   spec.namespaceSelector 是一个强制字段。

   $ cat <<EOF | oc apply -f -
   apiVersion: k8s.ovn.org/v1
   kind: EgressIP
   metadata:
     name: demo-egress-pod
   spec:
     # NOTE: these egress IPs are within the subnet range(s) in which my worker nodes
     #       are deployed.
     egressIPs:
       - 10.10.100.254
       - 10.10.150.254
       - 10.10.200.254
     namespaceSelector:
       matchLabels:
         kubernetes.io/metadata.name: demo-egress-pod
     podSelector:
       matchLabels:
         run: demo-egress-pod
   EOF

1. 运行以下命令来清理集群：

   $ oc delete svc demo-service -n default; \
   $ oc delete pod demo-service -n default; \
   $ oc delete project demo-egress-ns; \
   $ oc delete project demo-egress-pod; \
   $ oc delete egressip demo-egress-ns; \
   $ oc delete egressip demo-egress-pod

2. 运行以下命令来清理分配的节点标签：

   警告

   如果您依赖机器池的节点标签，这个命令会替换这些标签。在 --labels 字段中输入所需标签，以确保您的节点标签保留。

   $ rosa update machinepool ${ROSA_MACHINE_POOL_NAME} \
     --cluster="${ROSA_CLUSTER_NAME}" \
     --labels ""

1. 使用具有 cluster-admin 权限的账户登录集群。

2. 为集群名称配置环境变量：

   $ export CLUSTER_NAME=$(oc get infrastructure cluster -o=jsonpath="{.status.infrastructureName}"  | sed 's/-[a-z0-9]\{5\}$//')

3. 在移动到下一部分前，请确定所有字段都正确输出：

   $ echo "Cluster: ${CLUSTER_NAME}"

   输出示例

   Cluster: my-rosa-cluster

1. 验证您是否可以访问其默认主机名上的组件路由。

   您可以通过查询 openshift-console 和 openshift-authentication 项目中的路由列表来查找主机名。

   $ oc get routes -n openshift-console
   $ oc get routes -n openshift-authentication

   输出示例

   NAME        HOST/PORT                                                                          PATH       SERVICES    PORT    TERMINATION          WILDCARD
   console     console-openshift-console.apps.my-example-cluster-aws.z9a9.p1.openshiftapps.com    ... 1 more  console    https   reencrypt/Redirect   None
   downloads   downloads-openshift-console.apps.my-example-cluster-aws.z9a9.p1.openshiftapps.com  ... 1 more  downloads  http    edge/Redirect        None
   NAME              HOST/PORT                                                             PATH        SERVICES          PORT   TERMINATION            WILDCARD
   oauth-openshift   oauth-openshift.apps.my-example-cluster-aws.z9a9.p1.openshiftapps.com ... 1 more  oauth-openshift   6443   passthrough/Redirect   None

   在这个输出中，您可以看到我们的基本主机名为 z9a9.p1.openshiftapps.com。

2. 运行以下命令，获取默认入口的 ID：

   $ export INGRESS_ID=$(rosa list ingress -c ${CLUSTER_NAME} -o json | jq -r '.[] | select(.default == true) | .id')

3. 在移动到下一部分前，请确定所有字段都正确输出：

   $ echo "Ingress ID: ${INGRESS_ID}"

   输出示例

   Ingress ID: r3l6

   通过运行这些命令，您可以看到集群的默认组件路由是：

   • console-openshift-console.apps.my-example-cluster-aws.z9a9.p1.openshiftapps.com for Console
   • downloads-openshift-console.apps.my-example-cluster-aws.z9a9.p1.openshiftapps.com for Downloads
   • oauth-openshift.apps.my-example-cluster-aws.z9a9.p1.openshiftapps.com for OAuth

1. 为每个组件路由生成一个证书，注意将证书的主题(-subj)设置为您要使用的组件路由的自定义域：

   示例

   $ openssl req -newkey rsa:2048 -new -nodes -x509 -days 365 -keyout key-console.pem -out cert-console.pem -subj "/CN=console.my-new-domain.dev"
   $ openssl req -newkey rsa:2048 -new -nodes -x509 -days 365 -keyout key-downloads.pem -out cert-downloads.pem -subj "/CN=downloads.my-new-domain.dev"
   $ openssl req -newkey rsa:2048 -new -nodes -x509 -days 365 -keyout key-oauth.pem -out cert-oauth.pem -subj "/CN=oauth.my-new-domain.dev"

   这会生成三对 .pem 文件、key-<component>.pem 和 cert-<component>.pem。

1. 在 openshift-config 命名空间中创建三个 TLS secret。

   在本指南的稍后更新组件路由时，这些 secret 将成为您的 secret 引用。

   $ oc create secret tls console-tls --cert=cert-console.pem --key=key-console.pem -n openshift-config
   $ oc create secret tls downloads-tls --cert=cert-downloads.pem --key=key-downloads.pem -n openshift-config
   $ oc create secret tls oauth-tls --cert=cert-oauth.pem --key=key-oauth.pem -n openshift-config

1. 使用 rosa edit ingress 命令，使用新的基域和与其关联的 secret 引用更新默认入口路由，需要小心更新每个组件路由的主机名。

   $ rosa edit ingress -c ${CLUSTER_NAME} ${INGRESS_ID} --component-routes 'console: hostname=console.my-new-domain.dev;tlsSecretRef=console-tls,downloads: hostname=downloads.my-new-domain.dev;tlsSecretRef=downloads-tls,oauth: hostname=oauth.my-new-domain.dev;tlsSecretRef=oauth-tls'

   注意

   您还可以通过保留您不想更改设置为空字符串的组件路由来只编辑组件路由的子集。例如，如果您只想更改 Console 和 OAuth 服务器主机名和 TLS 证书，您将运行以下命令：

   $ rosa edit ingress -c ${CLUSTER_NAME} ${INGRESS_ID} --component-routes 'console: hostname=console.my-new-domain.dev;tlsSecretRef=console-tls,downloads: hostname="";tlsSecretRef="", oauth: hostname=oauth.my-new-domain.dev;tlsSecretRef=oauth-tls'

2. 运行 rosa list ingress 命令来验证您的更改是否成功：

   $ rosa list ingress -c ${CLUSTER_NAME} -ojson | jq ".[] | select(.id == \"${INGRESS_ID}\") | .component_routes"

   输出示例

   {
     "console": {
       "kind": "ComponentRoute",
       "hostname": "console.my-new-domain.dev",
       "tls_secret_ref": "console-tls"
     },
     "downloads": {
       "kind": "ComponentRoute",
       "hostname": "downloads.my-new-domain.dev",
       "tls_secret_ref": "downloads-tls"
     },
     "oauth": {
       "kind": "ComponentRoute",
       "hostname": "oauth.my-new-domain.dev",
       "tls_secret_ref": "oauth-tls"
     }
   }

3. 将您的证书添加到本地系统上的信任存储中，然后确认您可以使用本地 Web 浏览器通过新路由访问组件。

1. 运行以下命令来创建 admin 用户：

   rosa create admin --cluster=<cluster-name>

   输出示例

   W: It is recommended to add an identity provider to login to this cluster. See 'rosa create idp --help' for more information.
   I: Admin account has been added to cluster 'my-rosa-cluster'. It may take up to a minute for the account to become active.
   I: To login, run the following command:
   oc login https://api.my-rosa-cluster.abcd.p1.openshiftapps.com:6443 \
   --username cluster-admin \
   --password FWGYL-2mkJI-00000-00000

2. 复制上一步中返回到的登录命令，并将它粘贴到终端中。这将使用 CLI 登录集群，以便您可以开始使用集群。

   $ oc login https://api.my-rosa-cluster.abcd.p1.openshiftapps.com:6443 \
   >    --username cluster-admin \
   >    --password FWGYL-2mkJI-00000-00000

   输出示例

   Login successful.
   
   You have access to 79 projects, the list has been suppressed. You can list all projects with ' projects'
   
   Using project "default".

3. 要检查您是否已以 admin 用户身份登录，请运行以下命令之一：

   • 选项 1：

     $ oc whoami

     输出示例

     cluster-admin

   • 选项 2：

     oc get all -n openshift-apiserver

     只有 admin 用户可以在不出错的情况下运行此命令。

4. 现在，您可以使用集群作为 admin 用户，这将满足本教程的需要。对于实际部署，强烈建议设置身份提供程序，具体参见 下一教程。

流程

1. 要获取 GitHub webhook 触发器 secret，请在终端中运行以下命令：

   $ oc get bc/ostoy-microservice -o=jsonpath='{.spec.triggers..github.secret}'

   输出示例

   `o_3x9M1qoI2Wj_cz1WiK`

   重要

   此过程的后续步骤中需要使用此机密。

2. 要从 OSToy 的 buildconfig 获取 GitHub webhook 触发器 URL，请运行以下命令：

   $ oc describe bc/ostoy-microservice

   输出示例

   [...]
   Webhook GitHub:
   	URL:	https://api.demo1234.openshift.com:443/apis/build.openshift.io/v1/namespaces/ostoy-s2i/buildconfigs/ostoy/webhooks/<secret>/github
   [...]

3. 在 GitHub Webhook URL 中，将 & lt;secret& gt; 文本替换为您检索到的 secret。您的 URL 将类似以下示例的输出：

   输出示例

   https://api.demo1234.openshift.com:443/apis/build.openshift.io/v1/namespaces/ostoy-s2i/buildconfigs/ostoy-microservice/webhooks/o_3x9M1qoI2Wj_czR1WiK/github

4. 在 GitHub 仓库中设置 Webhook URL。

   1. 在存储库中，点 Settings > Webhooks > Add webhook。

      
   2. 将包含 Secret 的 GitHub Webhook URL 粘贴到 "Payload URL" 字段中。
   3. 将 "Content type" 更改为 application/json。

   4. 点 Add webhook 按钮。

      

      您应该看到一条来自 GitHub 的消息，说明您的 Webhook 已配置成功。现在，每当您将更改推送到 GitHub 存储库时，新构建都会自动启动，成功构建后都会启动新部署。

5. 现在，在源代码中进行更改。任何更改都会自动触发构建和部署。在本例中，表示 OSToy 应用程序状态的颜色会随机选择。要测试配置，请将框更改为仅显示 grayscale。

   1. 进入存储库 https://github.com/<username>/ostoy/blob/master/microservice/app.js 中的源代码。
   2. 编辑该文件。
   3. 注释掉第 8 行（包含 randomColor = getRandomColor （）;）。

   4. 取消注释第 9 行（包含 randomColor = getRandomGrayScaleColor （）;）。

      7   app.get('/', function(request, response) {
      8   //let randomColor = getRandomColor(); // <-- comment this
      9   let randomColor = getRandomGrayScaleColor(); // <-- uncomment this
      10
      11  response.writeHead(200, {'Content-Type': 'application/json'});

   5. 输入更新的消息，如"changed box to grayscale colors"。
   6. 单击底部的 Commit，将更改提交到 main 分支。

6. 在集群的 Web UI 中，点 Builds > Builds 来确定构建的状态。构建完成后，部署将开始。您还可以通过在终端中运行 oc status 来检查状态。

   

7. 部署完成后，返回到浏览器中的 OSToy 应用程序。访问左侧的 Networking 菜单项。box 颜色现在限制为灰色。