1. 시작하기 버튼을 클릭하여 AWS 콘솔 페이지에서 HCP 제품으로 ROSA를 활성화합니다.

   

   ROSA를 이전에 활성화했지만 프로세스를 완료하지 않은 경우 버튼을 클릭하고 다음 단계에 설명된 대로 계정 링크를 완료할 수 있습니다.

2. 연락처 정보를 Red Hat과 공유하도록 확인하고 서비스를 활성화합니다.

   
   • 이 단계에서 서비스를 활성화하면 부과되지 않습니다. 첫 번째 클러스터를 배포한 후에만 발생하는 청구 및 미터링에 대한 연결이 수행됩니다. 이 작업은 몇 분 정도 걸릴 수 있습니다.

3. 프로세스가 완료되면 확인이 표시됩니다.

   

4. 이 확인 페이지의 다른 섹션에는 추가 사전 요구 사항의 상태가 표시됩니다. 이러한 사전 요구 사항 중 하나라도 충족되지 않으면 각 메시지가 표시됩니다. 다음은 선택한 리전에서 할당량 부족의 예입니다.

   
   1. Increase 서비스 할당량 버튼을 클릭하거나 자세히 알아보기 링크를 사용하여 서비스 할당량 관리 방법에 대한 자세한 정보를 가져옵니다. 할당량이 충분하지 않은 경우 할당량은 지역에 따라 다릅니다. 웹 콘솔의 오른쪽 상단에 있는 지역 전환기를 사용하여 관심 있는 모든 지역에 대한 할당량 검사를 다시 실행한 다음 필요에 따라 서비스 할당량 증가 요청을 제출할 수 있습니다.

5. 사전 요구 사항이 모두 충족되면 페이지가 다음과 같이 표시됩니다.

   

   ELB 서비스 연결 역할이 자동으로 생성됩니다. 작은 Info Blue 링크를 클릭하면 상황에 맞는 도움말과 리소스를 얻을 수 있습니다.

1. 주황색 계속 Red Hat 버튼을 클릭하여 계정 연결을 진행합니다.

   

2. 현재 브라우저 세션에서 Red Hat 계정에 로그인하지 않은 경우 계정에 로그인하라는 메시지가 표시됩니다.

   
   • 새 Red Hat 계정에 등록하거나 이 페이지에서 비밀번호를 재설정할 수도 있습니다.
   • 이전 단계에서 ROSA를 HCP와 활성화한 AWS 계정과 연결하려는 Red Hat 계정에 로그인하십시오.
   • 서비스 청구에 사용할 단일 AWS 계정만 Red Hat 계정과 연결할 수 있습니다. 일반적으로 개발자 계정과 연결된 다른 AWS 계정이 있는 조직의 AWS 계정은 개별 AWS 최종 사용자 계정이 아닌 청구해야 하는 계정입니다.
   • 동일한 Red Hat 조직에 속하는 Red Hat 계정이 동일한 AWS 계정에 연결됩니다. 따라서 Red Hat 조직 계정 수준에서 HCP 클러스터를 사용하여 ROSA를 생성할 수 있는 사용자를 관리할 수 있습니다.

3. 사용 약관을 검토한 후 Red Hat 계정 연결을 완료합니다.

   참고

   이 단계는 로그인한 Red Hat 계정 또는 Red Hat 계정을 관리하는 Red Hat 조직이 이전에 AWS 계정에 연결되지 않은 경우에만 사용할 수 있습니다.

   

   이 화면에 Red Hat 및 AWS 계정 번호가 모두 표시됩니다.

4. 서비스 약관에 동의한 경우 계정 연결 버튼을 클릭합니다.

   Red Hat Hybrid Cloud Console을 처음 사용하는 경우 첫 번째 ROSA 클러스터를 생성하기 전에 일반 관리 서비스 사용 약관에 동의하라는 메시지가 표시됩니다.

   

   약관 보기 버튼을 클릭하면 검토 및 수락이 필요한 추가 조건이 표시됩니다.

   

   현재 메시지가 표시되면 추가 약관을 검토한 후 계약을 제출하십시오.

5. Hybrid Cloud Console은 AWS 사전 요구 사항이 완료되었음을 확인하고 클러스터 배포에 필요한 첫 번째 단계를 나열합니다.

   

6. 다음 단계는 클러스터의 기술 배포에 적용됩니다.

   
   • 이러한 단계는 서비스 사용 및 계정 연결이 완료된 위치와 다른 시스템에서 수행될 수 있습니다.

   • 이전에 언급했듯이 ROSA 서비스를 활성화한 AWS 계정과 연결된 Red Hat 조직에 속하는 모든 Red Hat 계정은 클러스터를 생성할 수 있으며 이전에 이 Red Hat 조직에서 연결된 청구 AWS 계정을 선택할 수 있습니다.

     이 페이지의 마지막 섹션에는 rosa CLI를 사용하거나 웹 콘솔을 통해 클러스터 배포 옵션이 표시됩니다.

     
   • 다음 단계에서는 rosa CLI를 사용한 클러스터 배포를 설명합니다.
   • 웹 콘솔만 사용하여 배포에 관심이 있는 경우 웹 콘솔 섹션을 사용하여 HCP 클러스터 배포를 통해 ROSA로 건너뛸 수 있습니다. 그러나 계정 역할 생성과 같은 특정 작업에는 rosa CLI가 필요합니다. ROSA를 처음 배포하는 경우 웹 콘솔 배포 단계를 건너뛰기 전에 rosa whoami 명령을 실행할 때까지 CLI 단계를 수행합니다.

1. ROSA CLI 다운로드 버튼을 클릭하여 운영 체제의 ROSA CLI(명령줄 인터페이스)를 다운로드하고 ROSA CLI 설정을 사용하여 도움말 에 설명된 대로 설정합니다.

   중요

   최신 AWS CLI가 설치되어 있는지 확인합니다. 자세한 내용은 AWS CLI를 설치하는 지침을 참조하십시오.

2. 이전 단계가 완료되면 rosa 버전을 실행하여 두 CLI를 모두 사용할 수 있는지 확인할 수 있습니다. 터미널에서 이전 버전과 aws -version 명령을 사용하는 경우 이 명령은 업데이트 알림을 표시합니다.

3. HCP 클러스터를 사용하여 ROSA를 생성하는 전제 조건은 2.1 단계에 표시된 고유한 토큰과 함께 개인화된 명령으로 rosa cli를 사용하여 로그인하는 것입니다. 인증하려면 웹 콘솔에서 이 명령 을 실행합니다. 복사 버튼을 사용하여 전체 토큰을 사용하여 명령을 터미널에 쉽게 복사하고 붙여넣을 수 있습니다.

   

   고유한 토큰을 공유하지 마십시오.

4. 첫 번째 클러스터 배포 전에 최종 사전 요구 사항으로 필요한 계정 전체 역할 및 정책이 생성되었는지 확인합니다. rosa CLI는 2.2 단계에 표시된 명령을 사용하여 이를 지원할 수 있습니다. 웹 콘솔에서 필요한 계정 전체 역할 및 정책을 빠르게 생성하려면 다음을 수행합니다. 이에 대한 대안은 이러한 역할 및 정책을 수동으로 생성하는 것입니다.

5. 로그인한 후 계정 역할을 만들고 rosa whoami 명령을 사용하여 ID를 확인하면 터미널이 다음과 유사합니다.

   

6. 제공된 명령을 사용하여 클러스터 배포를 시작합니다. 복사 버튼을 다시 클릭하고 터미널에 명령을 붙여넣을 수 있습니다.

   
7. ~/.aws/credentials 에 지정된 기본이 아닌 프로필 중 하나인 사용자 지정 AWS 프로필을 사용하려면 명령이 rosa create cluster -profile stage 와 같이 표시되도록 -profile <profile_name > 선택기를 rosa create cluster 명령에 추가할 수 있습니다. 이 옵션을 사용하여 AWS CLI 프로필을 지정하지 않으면 기본 AWS CLI 프로파일에서 클러스터가 배포된 AWS 인프라 프로필이 결정됩니다. 다음 단계 중 하나에서 청구 AWS 프로파일이 선택됩니다.

8. 클러스터 이름을 입력하면 호스팅된 컨트롤 플레인 사용 여부를 묻는 메시지가 표시됩니다. 예 선택 :

   

9. HCP 클러스터를 사용하여 ROSA를 배포할 때 청구 AWS 계정을 지정해야 합니다.

   
   • 현재 사용되는 Red Hat 조직에 연결된 AWS 계정만 표시됩니다.
   • 인프라 AWS 계정이 동일한 AWS 조직에 연결되어 있는지 여부와 관계없이 지정된 AWS 계정은 ROSA 서비스 사용에 대한 비용이 청구됩니다.
   • ROSA 계약이 지정된 AWS 청구 계정에 대해 활성화되어 있는지 여부에 대한 표시기를 확인할 수 있습니다.
   • 계약이 활성화되어 있지 않은 AWS 계정을 선택하려면 이 튜토리얼의 처음 몇 가지 단계를 참조하여 계약을 활성화하고 성공적으로 클러스터 배포에 필요한 서비스 요금을 허용합니다.

10. 다음 단계에서는 배포할 클러스터의 기술 세부 정보를 지정합니다.

    
    • 이러한 단계는 이 튜토리얼의 범위를 벗어납니다. CLI를 사용하여 HCP 클러스터 배포를 사용하여 ROSA를 완료하는 방법에 대한 자세한 내용은 기본 옵션을 사용하여 HCP 클러스터 생성 을 참조하십시오.

1. 기본 설정 ROSA 페이지의 하단 섹션에서 두 번째 옵션을 선택하여 웹 콘솔을 사용하여 클러스터를 생성할 수 있습니다.

   

2. 웹 콘솔을 사용하여 ROSA 클러스터를 생성할 때 첫 번째 단계는 컨트롤 플레인 선택입니다. Next 버튼을 클릭하기 전에 Hosted 옵션이 선택되어 있는지 확인합니다.

   

3. 다음 단계 의 계정 및 역할을 사용하면 ROSA 클러스터가 배포될 인프라 AWS 계정과 리소스가 소비 및 관리될 위치를 지정할 수 있습니다.

   
   • 이 연결에 대한 계정 역할을 생성하거나 연결하는 방법에 대한 자세한 내용은 ROSA 클러스터를 배포하려는 계정이 표시되지 않는 경우 새 AWS 계정을 연결하는 방법을 클릭합니다.
   • rosa CLI는 이를 위해 사용됩니다.
   • 여러 AWS 계정을 사용하고 AWS CLI에 대한 해당 프로필이 구성된 경우 --profile 선택기를 사용하여 rosa CLI 명령으로 작업할 때 AWS 프로필을 지정할 수 있습니다.

4. 다음 섹션에서 청구 AWS 계정이 선택됩니다.

   
   • 현재 사용되는 Red Hat 조직에 연결된 AWS 계정만 표시됩니다.
   • 인프라 AWS 계정이 동일한 AWS 조직에 연결되어 있는지 여부와 관계없이 지정된 AWS 계정은 ROSA 서비스 사용에 대한 비용이 청구됩니다.
   • ROSA 계약이 지정된 AWS 청구 계정에 대해 활성화되어 있는지 여부를 나타내는 표시기를 확인할 수 있습니다.
   • 아직 계약이 활성화되어 있지 않은 AWS 계정을 사용하려는 경우, 새 AWS 결제 계정에 연결 ROSA를 사용하여 ROSA AWS 콘솔 페이지에 도달할 수 있습니다. 이 페이지에서 해당 AWS 계정을 사용하여 로그인한 후 해당 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에서 제공한 오류를 검토하고 관리자에게 문의하여 필요한 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. 로깅을 위한 IAM(Identity Access Management) 정책을 생성합니다.

   $ 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. 보안을 생성합니다.

   $  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. CloudMonitor 로그 그룹을 삭제합니다.

   $ 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 시크릿을 만듭니다. 여기서 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 인그레스에서 서비스를 제공하는 경로 집합을 필터링합니다. 이 튜토리얼에서는 waf 경로 선택기를 사용하지만 값이 제공되지 않으면 필터링이 발생하지 않습니다.

4. CR을 적용합니다.

   예제

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

5. 사용자 정의 도메인 Ingress 컨트롤러가 배포되었으며 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 Certificate Manager로 가져옵니다. 여기서 cert.pem 은 와일드카드 인증서인 fullchain.pem 은 와일드카드 인증서의 체인이고 privkey.pem 은 와일드카드 인증서의 개인 키입니다.

   참고

   클러스터가 배포된 리전에 관계없이 Amazon CloudFront가 글로벌 AWS 서비스이므로 이 인증서를 us-east-1 로 가져와야 합니다.

   예제

   $ 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]
   이름	rosa-waf-ingress [2]
   뷰어 프로토콜 정책	HTTP를 HTTPS로 리디렉션
   허용되는 HTTP 메서드	GET, HEAD, OPTIONS, PUT, POST, PATCH, DELETE
   캐시 정책	CachingDisabled
   원본 요청 정책	AllViewer
   웹 애플리케이션 방화벽(WAF)	보안 보호 활성화
   기존 WAF 구성 사용	true
   웹 ACL 선택	cloudfront-waf
   대체 도메인 이름(CNAME)	*.apps.<company_name>.io [3]
   사용자 정의 SSL 인증서	위 단계에서 가져온 인증서를 선택합니다 [4]

   1. echo ${NLB} 를 실행하여 원본 도메인을 가져옵니다.
   2. 클러스터가 여러 개인 경우 원본 이름이 고유해야 합니다.
   3. 사용자 정의 도메인 인그레스 컨트롤러를 생성하는 데 사용한 와일드카드 도메인과 일치해야 합니다.
   4. 이는 위에서 입력한 대체 도메인 이름과 일치해야 합니다.

5. Amazon CloudFront 배포 끝점을 검색합니다.

   $ 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 컨트롤러 정책과 서브넷에 태그를 생성할 수 있는 권한을 통해 제공됩니다. 이 작업은 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가 새로 생성된 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 컨트롤러 인스턴스를 배포합니다.

   참고

   여기에서 오류가 발생하면 1분 정도 기다린 후 다시 시도하면 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. AWS ALB Ingress 끝점을 curl하여 hello world 애플리케이션에 액세스할 수 있는지 확인합니다.

   참고

   AWS ALB 프로비저닝에는 몇 분이 걸립니다. curl: (6) 호스트를 해결할 수 없는 오류가 발생하면 기다렸다가 다시 시도하십시오.

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

   출력 예

   Hello OpenShift!

1. S3 액세스를 위해 허용할 IAM 정책을 생성합니다.

   $ 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. 인증 정보 시크릿을 생성합니다.

   $ 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를 배포합니다.

   참고

   현재 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 중 하나를 사용합니다. 백업 중인 애플리케이션이 모두 PV의 CSI를 사용하는 경우 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. 데모 워크로드를 삭제합니다.

   $ 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. 복원이 완료될 때까지 기다립니다.

   $ 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 버킷을 삭제합니다.

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

10. 역할에서 정책을 분리합니다.

    $ 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 컨트롤러 정책과 서브넷에 태그를 생성할 수 있는 권한을 통해 제공됩니다. 이 작업은 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가 새로 생성된 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 컨트롤러 인스턴스를 배포합니다.

   참고

   여기에서 오류가 발생하면 1분 정도 기다린 후 다시 시도하면 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. AWS ALB Ingress 끝점을 curl하여 hello world 애플리케이션에 액세스할 수 있는지 확인합니다.

   참고

   AWS ALB 프로비저닝에는 몇 분이 걸립니다. curl: (6) 호스트를 해결할 수 없는 오류가 발생하면 기다렸다가 다시 시도하십시오.

   $ 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) 호스트를 해결할 수 없는 오류가 발생하면 기다렸다가 다시 시도하십시오.

   $ 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 ID 공급자 이름과 일치해야 합니다.

2. Azure 포털에 로그인하여 Entra ID 애플리케이션을 만들고 앱 등록 블레이드 를 선택합니다. 그런 다음 새 등록을 선택하여 새 애플리케이션을 생성합니다.

   

3. 애플리케이션 이름을 openshift-auth 로 지정합니다.
4. 리디렉션 URI 드롭다운에서 Web 을 선택하고 이전 단계에서 검색한 OAuth 콜백 URL 값을 입력합니다.

5. 필요한 정보를 제공한 후 등록을 클릭하여 애플리케이션을 생성합니다.

   

6. 인증서 및 시크릿 하위 블록을 선택하고 새 클라이언트 시크릿을 선택합니다.

   

7. 요청된 세부 정보를 작성하고 생성된 클라이언트 시크릿 값을 저장합니다. 이 시크릿은 이 프로세스의 뒷부분에서 필요합니다.

   중요

   초기 설정 후에는 클라이언트 시크릿을 볼 수 없습니다. 클라이언트 시크릿을 기록하지 않은 경우 새 시크릿을 생성해야 합니다.

   

8. 개요 하위 블록을 선택하고 애플리케이션(클라이언트) ID 및 디렉터리 (테넌트) ID 를 기록해 둡니다. 향후 단계에서 이러한 값이 필요합니다.

   

1. Token configuration sub-blade를 클릭하고 Add optional claim 버튼을 선택합니다.

   

2. ID 라디오 버튼을 선택합니다.

   

3. 이메일 클레임 확인란을 선택합니다.

   

4. preferred_username 클레임 확인란을 선택합니다. 그런 다음 추가 를 클릭하여 이메일 및 preferred_username 이 Entra ID 애플리케이션을 클레임합니다.

   

5. 페이지 상단에 대화 상자가 표시됩니다. 프롬프트에 따라 필요한 Microsoft Graph 권한을 활성화합니다.

   

프로세스

1. 토큰 구성 하위 블록에서 그룹 클레임 추가 를 클릭합니다.

   

2. Entra ID 애플리케이션에 대한 그룹 클레임을 구성하려면 보안 그룹을 선택한 다음 추가 를 클릭합니다.

   참고

   이 예에서 그룹 클레임에는 사용자가 멤버인 모든 보안 그룹이 포함됩니다. 실제 프로덕션 환경에서는 그룹 클레임에 AWS의 Red Hat OpenShift Service에 적용되는 그룹만 포함되어 있는지 확인합니다.

   

프로세스

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

   이를 클라이언트 시크릿으로 교체합니다.

   5

   이 ID를 디렉터리(테넌트) 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에서 풀 시크릿 으로 클러스터에 액세스하여 로그인 토큰을 찾을 수 있습니다.

2. 다음 명령을 실행하여 클러스터에 STS가 있는지 확인합니다.

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

   출력 예

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

   출력이 다르면 계속 진행하지 마십시오. 이 프로세스를 계속하기 전에 STS 클러스터 생성에 대한 Red Hat 설명서 를 참조하십시오.

3. 다음 명령을 실행하여 CSI 드라이버를 실행할 수 있도록 SecurityContextConstraints 권한을 설정합니다.

   $ 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. 다음 명령을 실행하여 보안 저장소 CSI 드라이버를 등록하려면 Helm을 사용합니다.

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

2. 다음 명령을 실행하여 Helm 리포지터리를 업데이트합니다.

   $ helm repo update

3. 다음 명령을 실행하여 보안 저장소 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. 다음 명령을 실행하여 두 데몬 세트 모두 실행 중인지 확인합니다.

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

6. 다음 명령을 실행하여 제한된 Pod 보안 프로필과 함께 사용할 수 있도록 Secrets Store CSI 드라이버에 레이블을 지정합니다.

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

1. 다음 명령을 실행하여 Secrets Manager에 보안을 생성합니다.

   $ 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. 다음 명령을 실행하여 STS 역할을 사용하도록 기본 서비스 계정에 주석을 답니다.

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

3. 다음 명령을 실행하여 시크릿에 액세스할 시크릿 공급자 클래스를 생성합니다.

   $ 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. 다음 명령에서 시크릿을 사용하여 배포를 생성합니다.

   $ 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. 다음 commandv를 실행하여 Pod에 보안이 마운트되었는지 확인합니다.

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

1. 다음 명령을 실행하여 애플리케이션을 삭제합니다.

   $ oc delete project my-application

2. 다음 명령을 실행하여 보안 저장소 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 시크릿을 삭제합니다.

   $ 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 IAM(Identity Access Management) 신뢰 정책을 생성합니다.

   $ 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가 연결된 AmazonS3FullAccess 정책을 사용하여 가정할 AWS IAM 역할을 생성합니다.

   참고

   각 프로젝트의 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. S3 버킷이 AWS에서 생성되었는지 확인합니다.

   $ 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 시크릿을 만듭니다. 여기서 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 컨트롤러가 배포되었으며 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. 외부 DNS Operator가 사용자 정의 도메인 공용 호스팅 영역 만 업데이트할 수 있는 AWS IAM 정책 문서를 생성합니다.

   $ 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 사용자 인증 정보에서 시크릿을 생성합니다.

   $ 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 환경 변수로 지정한 사용자 정의 도메인과 일치하는 공개 호스팅 영역을 찾습니다. 내보내기 ZONE_ID=<zone_ID>를 실행하여 Amazon Route 53 공개 호스팅 영역을 수동으로 지정하여 < zone_ID >를 특정 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가 클러스터에 설치되어 있는 경우 cert-manager Operator for Red Hat OpenShift를 설치하기 전에 이를 제거해야 합니다.

2. cert-manager Operator for Red Hat OpenShift를 설치합니다.

   $ 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. 다음 명령을 실행하여 Let's Encrypt를 사용하도록 ClusterIssuer 리소스를 만듭니다.

   $ 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 컨트롤러의 인증서를 프로비저닝하도록 인증서 리소스를 생성하고 구성합니다.

   참고

   다음 예제에서는 단일 도메인 인증서를 사용합니다. 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 컨트롤러가 배포되었으며 Ready 상태가 있는지 확인합니다.

   $ oc get customdomains

   출력 예

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

6. 사용자 정의 도메인 Ingress 컨트롤러에 대한 DNS 확인을 활성화하기 위해 필요한 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 컨트롤러를 사용하여 배포하는 모든 새 애플리케이션에 대해 새 레코드를 생성할 필요가 없지만 이러한 각 애플리케이션에서 사용하는 인증서는 와일드카드 인증서가 아닙니다.

1. OpenShift 경로에 대한 인증서를 관리하는 데 필요한 필수 OpenShift 리소스 cert-manager를 생성합니다.

   이 단계에서는 클러스터의 주석이 달린 경로를 구체적으로 모니터링하는 새 배포(및 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분 정도 걸립니다. 인증서 갱신은 expiration에 따라 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

     관리자만 오류 없이 이 명령을 실행할 수 있습니다.

4. 이제 이 튜토리얼에 충분한 관리자 사용자로 클러스터를 사용할 수 있습니다. 실제 배포의 경우 다음 튜토리얼에서 설명하는 ID 공급자를 설정하는 것이 좋습니다.