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

   

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

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

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

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

   

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

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

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

   

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

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

   

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

   
   • 您还可以注册新的红帽帐户或在此页面中重置密码。
   • 确保登录到您计划与在前面的步骤中激活 ROSA 和 HCP 的 AWS 帐户关联的红帽帐户。
   • 只能将用于服务账单的 AWS 帐户与红帽帐户相关联。通常，具有其他 AWS 帐户（如开发人员帐户）的机构 AWS 帐户通常是被计费的，而不是单独的 AWS 最终用户帐户。
   • 属于同一红帽机构的红帽帐户将与同一 AWS 帐户相关联。因此，您可以管理谁有权使用红帽机构帐户级别使用 HCP 集群创建 ROSA。

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

   注意

   只有在已登录的红帽帐户或管理红帽帐户的红帽机构之前没有链接到 AWS 帐户时，才提供这个步骤。

   

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

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

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

   

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

   

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

5. Hybrid Cloud Console 提供一个确认 AWS 的先决条件已完成，并列出了集群部署所需的第一步：

   

6. 与集群的技术部署相关的以下步骤：

   
   • 这些步骤可能在不同于服务启用和帐户链接完成的不同机器上执行。

   • 如前文所述，任何属于红帽机构（属于激活 ROSA 服务的 AWS 帐户）的红帽帐户都可以访问创建集群，并可以选择之前在 Red Hat 机构下链接的账单 AWS 帐户。

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

     
   • 以下步骤使用 rosa CLI 描述集群部署。
   • 如果您只对使用 Web 控制台进行部署感兴趣，您可以使用 web 控制台部分跳过使用 HCP 集群部署的 ROSA。但请注意，某些任务需要 rosa CLI，如创建帐户角色。如果您要第一次部署 ROSA，请按照此 CLI 步骤操作，直到运行 rosa whoami 命令，然后再跳到 web 控制台部署步骤。

1. 点 Download the ROSA CLI 按钮下载您的操作系统的 ROSA 命令行界面(CLI)，并设置它，如使用 ROSA CLI 设置的帮助 中所述。

   重要

   确保安装了最新的 AWS CLI。如需更多信息，请参阅安装 AWS CLI。

2. 完成前面的步骤后，您可以通过运行 rosa 版本 来验证两个 CLI 都可用。如果您在终端中使用旧版本和 aws -version 命令，这个命令会显示更新通知。

3. 使用 HCP 集群创建 ROSA 的先决条件是通过个人化命令使用 rosa cli 登录，并在第 2.1 步中显示的唯一令牌。要进行身份验证，请在 web 控制台中运行这个命令。使用 复制 按钮轻松复制和粘贴带有完整令牌的命令：

   

   不要共享您的唯一令牌。

4. 在第一个集群部署前的最后一个先决条件，确保创建了必要的集群范围的角色和策略。rosa CLI 可以使用第 2.2 步下显示的命令来解决此问题。在 web 控制台中快速创建必要的集群范围的角色和策略…。手动创建这些角色和策略的替代选择。

5. 登录后，创建帐户角色并使用 rosa whoami 命令验证您的身份，您的终端将类似如下：

   

6. 使用提供的命令启动集群部署。您可以再次点 复制 按钮，并在终端中粘贴命令：

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

8. 输入集群名称后，将要求您使用托管的 control plane。选择 yes ：

   

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

   
   • 只有链接到当前使用的红帽机构的 AWS 帐户才会显示。
   • 指定 AWS 帐户将使用 ROSA 服务，无论基础架构 AWS 帐户是否在同一 AWS 机构中链接到它。
   • 您可以看到是否为给定的 AWS 计费帐户启用 ROSA 合同的指标。
   • 要选择没有启用合同的 AWS 帐户，请参阅本教程中的前几个步骤来启用合同，并允许服务计费，这是成功集群部署所需的。

10. 在以下步骤中，您将指定要部署的集群的技术详情：

    
    • 这些步骤超出了本教程的范围。如需有关如何使用 CLI 完成使用 HCP 集群部署的 ROSA 的详情，请参阅使用默认选项 创建 ROSA。

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

   

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

   

3. 下一步帐户和 角色 允许您指定基础架构 AWS 帐户，将部署到其中，以及资源将被消耗和管理的位置：

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

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

   
   • 只有链接到当前使用的红帽机构的 AWS 帐户才会显示。
   • 指定 AWS 帐户将使用 ROSA 服务，无论基础架构 AWS 帐户是否在同一 AWS 机构中链接到它。
   • 您可以看到是否为给定的 AWS 计费帐户启用 ROSA 合同的指示器。
   • 如果您要使用尚未启用合同的 AWS 帐户，您可以使用 Connect ROSA to a new AWS billing 帐户 来访问 ROSA AWS 控制台页面，您可以在其中按照本教程中描述的步骤使用相应 AWS 帐户登录后激活它。

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 ROSA_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 AWS_PAGER=""
   $ export SCRATCH="/tmp/${ROSA_CLUSTER_NAME}/clf-cloudwatch-sts"
   $ mkdir -p ${SCRATCH}

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

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

1. 为日志记录创建 Identity Access Management (IAM)策略：

   $ POLICY_ARN=$(aws iam list-policies --query "Policies[?PolicyName=='RosaCloudWatch'].{ARN:Arn}" --output text)
   $ if [[ -z "${POLICY_ARN}" ]]; then
   cat << EOF > ${SCRATCH}/policy.json
   {
     "Version": "2012-10-17",
     "Statement": [
        {
              "Effect": "Allow",
              "Action": [
                 "logs:CreateLogGroup",
                 "logs:CreateLogStream",
                 "logs:DescribeLogGroups",
                 "logs:DescribeLogStreams",
                 "logs:PutLogEvents",
                 "logs:PutRetentionPolicy"
              ],
              "Resource": "arn:aws:logs:*:*:*"
        }
   ]
   }
   EOF
   POLICY_ARN=$(aws iam create-policy --policy-name "RosaCloudWatch" \
   --policy-document file:///${SCRATCH}/policy.json --query Policy.Arn --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-logging:logcollector"
          }
        }
      }]
   }
   EOF
   $ ROLE_ARN=$(aws iam create-role --role-name "${ROSA_CLUSTER_NAME}-RosaCloudWatch" \
         --assume-role-policy-document file://${SCRATCH}/trust-policy.json \
         --query Role.Arn --output text)
   $ echo ${ROLE_ARN}

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

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

1. 部署 Red Hat OpenShift Logging Operator：

   $  cat << EOF | oc apply -f -
      apiVersion: operators.coreos.com/v1alpha1
      kind: Subscription
      metadata:
        labels:
         operators.coreos.com/cluster-logging.openshift-logging: ""
        name: cluster-logging
        namespace: openshift-logging
      spec:
        channel: stable
        installPlanApproval: Automatic
        name: cluster-logging
        source: redhat-operators
        sourceNamespace: openshift-marketplace
   EOF

2. 创建 secret：

   $  cat << EOF | oc apply -f -
     apiVersion: v1
     kind: Secret
     metadata:
       name: cloudwatch-credentials
       namespace: openshift-logging
     stringData:
       role_arn: $ROLE_ARN
   EOF

1. 创建 ClusterLogForwarder 自定义资源(CR)：

   $ cat << EOF | oc apply -f -
     apiVersion: "logging.openshift.io/v1"
     kind: ClusterLogForwarder
     metadata:
       name: instance
       namespace: openshift-logging
     spec:
       outputs:
         - name: cw
           type: cloudwatch
           cloudwatch:
             groupBy: namespaceName
             groupPrefix: rosa-${ROSA_CLUSTER_NAME}
             region: ${REGION}
           secret:
             name: cloudwatch-credentials
       pipelines:
         - name: to-cloudwatch
           inputRefs:
             - infrastructure
             - audit
             - application
           outputRefs:
             - cw
   EOF

2. 创建 ClusterLogging CR：

   $ cat << EOF | oc apply -f -
     apiVersion: logging.openshift.io/v1
     kind: ClusterLogging
     metadata:
       name: instance
       namespace: openshift-logging
     spec:
       collection:
         logs:
            type: vector
       managementState: Managed
   EOF

1. 删除 ClusterLogForwarder CR：

   $ oc delete -n openshift-logging clusterlogforwarder instance

2. 删除 ClusterLogging CR：

   $ oc delete -n openshift-logging clusterlogging instance

3. 将 IAM 策略分离到 IAM 角色：

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

4. 删除 IAM 角色：

   $ aws iam delete-role --role-name "${ROSA_CLUSTER_NAME}-RosaCloudWatch"

5. 删除 IAM 策略：

   重要

   只有没有使用该策略的其他资源时，才删除 IAM 策略。

   $ aws iam delete-policy --policy-arn "${POLICY_ARN}"

6. 删除 CloudWatch 日志组：

   $ aws logs delete-log-group --log-group-name "rosa-${ROSA_CLUSTER_NAME}.audit"
   $ aws logs delete-log-group --log-group-name "rosa-${ROSA_CLUSTER_NAME}.infrastructure"

流程

1. 创建新项目

   $ oc new-project waf-demo

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

   示例

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

3. 创建新的 CustomDomain 自定义资源(CR)：

   waf-custom-domain.yaml示例

   apiVersion: managed.openshift.io/v1alpha1
   kind: CustomDomain
   metadata:
     name: cloudfront-waf
   spec:
     domain: apps.<company_name>.io 1
     scope: External
     loadBalancerType: NLB
     certificate:
       name: waf-tls
       namespace: waf-demo
     routeSelector: 2
       matchLabels:
        route: waf

   1

   自定义域。

   2

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

4. 应用 CR：

   示例

   $ oc apply -f waf-custom-domain.yaml

5. 验证您的自定义域入口控制器是否已部署并处于 Ready ：

   $ oc get customdomains

   输出示例

   NAME               ENDPOINT                                                    DOMAIN                       STATUS
   cloudfront-waf     xxrywp.<company_name>.cluster-01.opln.s1.openshiftapps.com  *.apps.<company_name>.io     Ready

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

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

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.<company_name>.io [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.<company_name>.io CNAME d1b2c3d4e5f6g7.cloudfront.net

1. 部署 hello world 应用：

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

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

   示例

   $ oc -n waf-demo create route edge --service=hello-openshift hello-openshift-tls \
   --hostname hello-openshift.apps.<company_name>.io

3. 标记路由以接受您的自定义域入口控制器：

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

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

   示例

   $ curl "https://hello-openshift.apps.<company_name>.io"

   输出示例

   Hello OpenShift!

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

   示例

   $ curl -X POST "https://hello-openshift.apps.<company_name>.io" \
     -F "user='<script><alert>Hello></alert></script>'"

   输出示例

   <html>
   <head><title>403 Forbidden</title></head>
   <body>
   <center><h1>403 Forbidden</h1></center>
   </body>
   </html

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

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 "${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 "${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. 安装 Red Hat 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
     enabledAddons:
       - AWSWAFv2
   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. 将预先创建的服务资源转换为 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
   EOF
   $ oc -n openshift-adp create secret generic cloud-credentials \
    --from-file=${SCRATCH}/credentials

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 backup hello-world
   $ oc delete restore 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. 安装 Red Hat 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 创建 Deployment：

   $ 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. 配置以下环境变量，将 CLUSTER_NAME 替换为集群的名称：

   $ export DOMAIN=apps.<company_name>.io 1
   $ export AWS_PAGER=""
   $ export CLUSTER_NAME=$(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_NAME}/external-dns"
   $ mkdir -p ${SCRATCH}

   1

   自定义域。

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

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

流程

1. 创建一个新项目

   $ oc new-project external-dns-operator

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

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

3. 创建新的 CustomDomain 自定义资源(CR)：

   external-dns-custom-domain.yaml示例

   apiVersion: managed.openshift.io/v1alpha1
   kind: CustomDomain
   metadata:
     name: external-dns
   spec:
     domain: apps.<company_name>.io 1
     scope: External
     loadBalancerType: NLB
     certificate:
       name: external-dns-tls
       namespace: external-dns-operator

   1

   自定义域。

4. 应用 CR：

   $ oc apply -f external-dns-custom-domain.yaml

5. 验证您的自定义域 Ingress Controller 是否已部署并处于 Ready 状态：

   $ oc get customdomains

   输出示例

   NAME               ENDPOINT                                                    DOMAIN                       STATUS
   external-dns       xxrywp.<company_name>.cluster-01.opln.s1.openshiftapps.com  *.apps.<company_name>.io     Ready

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

3. 创建 AWS IAM 策略：

   $ export POLICY_ARN=$(aws iam create-policy --policy-name "${CLUSTER_NAME}-AllowExternalDNSUpdates" \
     --policy-document file://${SCRATCH}/external-dns-policy.json \
     --query 'Policy.Arn' --output text)

4. 创建 AWS IAM 用户：

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

5. 附加策略：

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

   注意

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

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

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

7. 创建静态凭证：

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

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

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

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

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

4. 部署 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
       type: OpenShiftRoute
     zones:
       - ${ZONE_ID}
   EOF

5. 等待控制器运行：

   $ 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. 在您看到 OpenShift 登录的浏览器中导航到自定义控制台域：

   $ echo console.${DOMAIN}

1. 配置以下环境变量：

   $ export DOMAIN=apps.<company_name>.io 1
   $ export EMAIL=<youremail@company_name.io> 2
   $ export AWS_PAGER=""
   $ export CLUSTER_NAME=$(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_NAME}/dynamic-certs"
   $ mkdir -p ${SCRATCH}

   1

   自定义域。

   2

   电子邮件 Let's Encrypt 将用来发送有关您的证书的通知。

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

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

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_NAME}-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_NAME}-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_NAME}-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. 创建一个新项目

   $ oc new-project custom-domain-ingress

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

   注意

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

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

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

   注意

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

   $ oc -n custom-domain-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

4. 创建新的 CustomDomain 自定义资源(CR)：

   $ cat << EOF | oc apply -f -
   apiVersion: managed.openshift.io/v1alpha1
   kind: CustomDomain
   metadata:
     name: custom-domain-ingress
   spec:
     domain: ${DOMAIN}
     scope: External
     loadBalancerType: NLB
     certificate:
       name: custom-domain-ingress-cert-tls
       namespace: custom-domain-ingress
   EOF

5. 验证您的自定义域 Ingress Controller 是否已部署并处于 Ready 状态：

   $ oc get customdomains

   输出示例

   NAME                    ENDPOINT                                                               DOMAIN            STATUS
   custom-domain-ingress   tfoxdx.custom-domain-ingress.cluster.1234.p1.openshiftapps.com         example.com       Ready

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

   $ INGRESS=$(oc get customdomain.managed.openshift.io/custom-domain-ingress --template={{.status.endpoint}})
   $ 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

7. 提交您对 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. 运行以下命令来创建 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 用户，这将满足本教程的需要。对于实际部署，强烈建议设置身份提供程序，具体参见 下一教程。