호스팅된 컨트롤 플레인

프로세스

1. 다음 명령을 입력하여 etcd pod에 로그인합니다.

   $ oc rsh -n openshift-etcd -c etcd <etcd_pod_name>

2. 다음 명령을 입력하여 etcd 클러스터의 상태를 출력합니다.

   sh-4.4# etcdctl endpoint status -w table

   출력 예

   +------------------------------+-----------------+---------+---------+-----------+------------+-----------+------------+--------------------+--------+
   |          ENDPOINT            |       ID        | VERSION | DB SIZE | IS LEADER | IS LEARNER | RAFT TERM | RAFT INDEX | RAFT APPLIED INDEX | ERRORS |
   +------------------------------+-----------------+---------+---------+-----------+------------+-----------+------------+--------------------+--------+
   | https://192.168.1xxx.20:2379 | 8fxxxxxxxxxx    |  3.5.12 |  123 MB |     false |      false |        10 |     180156 |             180156 |        |
   | https://192.168.1xxx.21:2379 | a5xxxxxxxxxx    |  3.5.12 |  122 MB |     false |      false |        10 |     180156 |             180156 |        |
   | https://192.168.1xxx.22:2379 | 7cxxxxxxxxxx    |  3.5.12 |  124 MB |      true |      false |        10 |     180156 |             180156 |        |
   +-----------------------------+------------------+---------+---------+-----------+------------+-----------+------------+--------------------+--------+

프로세스

1. etcd pod가 실패했는지 확인하려면 다음 명령을 입력합니다.

   $ oc get pods -l app=etcd -n openshift-etcd

   출력 예

   NAME     READY   STATUS             RESTARTS     AGE
   etcd-0   2/2     Running            0            64m
   etcd-1   2/2     Running            0            45m
   etcd-2   1/2     CrashLoopBackOff   1 (5s ago)   64m

   실패한 etcd pod는 CrashLoopBackOff 또는 Error 상태가 될 수 있습니다.

2. 다음 명령을 입력하여 실패한 Pod 및 해당 PVC를 삭제합니다.

   $ oc delete pods etcd-2 -n openshift-etcd

절차

1. 먼저 환경 변수를 설정하고 API 서버를 축소합니다.

   1. 다음 명령을 입력하여 호스팅된 클러스터에 대한 환경 변수를 설정하여 필요에 따라 값을 바꿉니다.

      $ CLUSTER_NAME=my-cluster

      $ HOSTED_CLUSTER_NAMESPACE=clusters

      $ CONTROL_PLANE_NAMESPACE="${HOSTED_CLUSTER_NAMESPACE}-${CLUSTER_NAME}"

   2. 다음 명령을 입력하여 호스팅 클러스터의 조정을 일시 중지하여 필요에 따라 값을 교체합니다.

      $ oc patch -n ${HOSTED_CLUSTER_NAMESPACE} hostedclusters/${CLUSTER_NAME} -p '{"spec":{"pausedUntil":"true"}}' --type=merge

   3. 다음 명령을 입력하여 API 서버를 축소합니다.

      1. kube-apiserver 를 축소합니다.

         $ oc scale -n ${CONTROL_PLANE_NAMESPACE} deployment/kube-apiserver --replicas=0

      2. openshift-apiserver 를 축소합니다.

         $ oc scale -n ${CONTROL_PLANE_NAMESPACE} deployment/openshift-apiserver --replicas=0

      3. openshift-oauth-apiserver 를 축소 :

         $ oc scale -n ${CONTROL_PLANE_NAMESPACE} deployment/openshift-oauth-apiserver --replicas=0

2. 다음으로 다음 방법 중 하나를 사용하여 etcd의 스냅샷을 만듭니다.

   1. 이전에 백업한 etcd 스냅샷을 사용합니다.

   2. 사용 가능한 etcd pod가 있는 경우 다음 단계를 완료하여 활성 etcd pod에서 스냅샷을 만듭니다.

      1. 다음 명령을 입력하여 etcd pod를 나열합니다.

         $ oc get -n ${CONTROL_PLANE_NAMESPACE} pods -l app=etcd

      2. Pod 데이터베이스의 스냅샷을 가져와서 다음 명령을 입력하여 시스템에 로컬로 저장합니다.

         $ ETCD_POD=etcd-0

         $ oc exec -n ${CONTROL_PLANE_NAMESPACE} -c etcd -t ${ETCD_POD} -- env ETCDCTL_API=3 /usr/bin/etcdctl \
         --cacert /etc/etcd/tls/etcd-ca/ca.crt \
         --cert /etc/etcd/tls/client/etcd-client.crt \
         --key /etc/etcd/tls/client/etcd-client.key \
         --endpoints=https://localhost:2379 \
         snapshot save /var/lib/snapshot.db

      3. 다음 명령을 입력하여 스냅샷이 성공했는지 확인합니다.

         $ oc exec -n ${CONTROL_PLANE_NAMESPACE} -c etcd -t ${ETCD_POD} -- env ETCDCTL_API=3 /usr/bin/etcdctl -w table snapshot status /var/lib/snapshot.db

   3. 다음 명령을 입력하여 스냅샷의 로컬 사본을 만듭니다.

      $ oc cp -c etcd ${CONTROL_PLANE_NAMESPACE}/${ETCD_POD}:/var/lib/snapshot.db /tmp/etcd.snapshot.db

      1. etcd 영구 스토리지에서 스냅샷 데이터베이스의 사본을 만듭니다.

         1. 다음 명령을 입력하여 etcd pod를 나열합니다.

            $ oc get -n ${CONTROL_PLANE_NAMESPACE} pods -l app=etcd

         2. 실행 중인 Pod를 찾아 ETCD_POD: ETCD_POD=etcd-0 의 값으로 설정한 다음 다음 명령을 입력하여 스냅샷 데이터베이스를 복사합니다.

            $ oc cp -c etcd ${CONTROL_PLANE_NAMESPACE}/${ETCD_POD}:/var/lib/data/member/snap/db /tmp/etcd.snapshot.db

3. 다음으로 다음 명령을 입력하여 etcd 상태 저장 세트를 축소합니다.

   $ oc scale -n ${CONTROL_PLANE_NAMESPACE} statefulset/etcd --replicas=0

   1. 다음 명령을 입력하여 두 번째 및 세 번째 멤버의 볼륨을 삭제합니다.

      $ oc delete -n ${CONTROL_PLANE_NAMESPACE} pvc/data-etcd-1 pvc/data-etcd-2

   2. pod를 생성하여 첫 번째 etcd 멤버의 데이터에 액세스합니다.

      1. 다음 명령을 입력하여 etcd 이미지를 가져옵니다.

         $ ETCD_IMAGE=$(oc get -n ${CONTROL_PLANE_NAMESPACE} statefulset/etcd -o jsonpath='{ .spec.template.spec.containers[0].image }')

      2. etcd 데이터에 액세스할 수 있는 pod를 만듭니다.

         $ cat << EOF | oc apply -n ${CONTROL_PLANE_NAMESPACE} -f -
         apiVersion: apps/v1
         kind: Deployment
         metadata:
           name: etcd-data
         spec:
           replicas: 1
           selector:
             matchLabels:
               app: etcd-data
           template:
             metadata:
               labels:
                 app: etcd-data
             spec:
               containers:
               - name: access
                 image: $ETCD_IMAGE
                 volumeMounts:
                 - name: data
                   mountPath: /var/lib
                 command:
                 - /usr/bin/bash
                 args:
                 - -c
                 - |-
                   while true; do
                     sleep 1000
                   done
               volumes:
               - name: data
                 persistentVolumeClaim:
                   claimName: data-etcd-0
         EOF

      3. etcd-data pod의 상태를 확인하고 다음 명령을 입력하여 실행할 때까지 기다립니다.

         $ oc get -n ${CONTROL_PLANE_NAMESPACE} pods -l app=etcd-data

      4. 다음 명령을 입력하여 etcd-data pod의 이름을 가져옵니다.

         $ DATA_POD=$(oc get -n ${CONTROL_PLANE_NAMESPACE} pods --no-headers -l app=etcd-data -o name | cut -d/ -f2)

   3. 다음 명령을 입력하여 etcd 스냅샷을 포드에 복사합니다.

      $ oc cp /tmp/etcd.snapshot.db ${CONTROL_PLANE_NAMESPACE}/${DATA_POD}:/var/lib/restored.snap.db

   4. 다음 명령을 입력하여 etcd-data 포드에서 이전 데이터를 제거합니다.

      $ oc exec -n ${CONTROL_PLANE_NAMESPACE} ${DATA_POD} -- rm -rf /var/lib/data

      $ oc exec -n ${CONTROL_PLANE_NAMESPACE} ${DATA_POD} -- mkdir -p /var/lib/data

   5. 다음 명령을 입력하여 etcd 스냅샷을 복원합니다.

      $ oc exec -n ${CONTROL_PLANE_NAMESPACE} ${DATA_POD} -- etcdutl snapshot restore /var/lib/restored.snap.db \
           --data-dir=/var/lib/data --skip-hash-check \
           --name etcd-0 \
           --initial-cluster-token=etcd-cluster \
           --initial-cluster etcd-0=https://etcd-0.etcd-discovery.${CONTROL_PLANE_NAMESPACE}.svc:2380,etcd-1=https://etcd-1.etcd-discovery.${CONTROL_PLANE_NAMESPACE}.svc:2380,etcd-2=https://etcd-2.etcd-discovery.${CONTROL_PLANE_NAMESPACE}.svc:2380 \
           --initial-advertise-peer-urls https://etcd-0.etcd-discovery.${CONTROL_PLANE_NAMESPACE}.svc:2380

   6. 다음 명령을 입력하여 포드에서 임시 etcd 스냅샷을 제거하십시오.

      $ oc exec -n ${CONTROL_PLANE_NAMESPACE} ${DATA_POD} -- rm /var/lib/restored.snap.db

   7. 다음 명령을 입력하여 데이터 액세스 배포를 삭제합니다.

      $ oc delete -n ${CONTROL_PLANE_NAMESPACE} deployment/etcd-data

   8. 다음 명령을 입력하여 etcd 클러스터를 확장합니다.

      $ oc scale -n ${CONTROL_PLANE_NAMESPACE} statefulset/etcd --replicas=3

   9. etcd 멤버 pod가 반환되고 다음 명령을 입력하여 사용 가능한 것으로 보고할 때까지 기다립니다.

      $ oc get -n ${CONTROL_PLANE_NAMESPACE} pods -l app=etcd -w

   10. 다음 명령을 입력하여 모든 etcd-writer 배포를 확장합니다.

       $ oc scale deployment -n ${CONTROL_PLANE_NAMESPACE} --replicas=3 kube-apiserver openshift-apiserver openshift-oauth-apiserver

4. 다음 명령을 입력하여 호스팅 클러스터의 조정을 복원합니다.

   $ oc patch -n ${CLUSTER_NAMESPACE} hostedclusters/${CLUSTER_NAME} -p '{"spec":{"pausedUntil":""}}' --type=merge

프로세스

1. 다음 명령을 입력하여 호스트 클러스터의 조정을 일시 중지합니다.

   $ oc patch -n clusters hostedclusters/<hosted_cluster_name> -p '{"spec":{"pausedUntil":"true"}}' --type=merge

2. 다음 명령을 입력하여 모든 etcd-writer 배포를 중지합니다.

   $ oc scale deployment -n <hosted_cluster_namespace> --replicas=0 kube-apiserver openshift-apiserver openshift-oauth-apiserver

3. etcd 스냅샷을 만들려면 다음 명령을 입력하여 각 etcd 컨테이너에서 exec 명령을 사용하십시오.

   $ oc exec -it <etcd_pod_name> -n <hosted_cluster_namespace> -- env ETCDCTL_API=3 /usr/bin/etcdctl --cacert /etc/etcd/tls/etcd-ca/ca.crt --cert /etc/etcd/tls/client/etcd-client.crt --key /etc/etcd/tls/client/etcd-client.key --endpoints=localhost:2379 snapshot save /var/lib/data/snapshot.db

4. 스냅샷 상태를 확인하려면 다음 명령을 실행하여 각 etcd 컨테이너에서 exec 명령을 사용하십시오.

   $ oc exec -it <etcd_pod_name> -n <hosted_cluster_namespace> -- env ETCDCTL_API=3 /usr/bin/etcdctl -w table snapshot status /var/lib/data/snapshot.db

5. 스냅샷 데이터를 S3 버킷과 같이 나중에 검색할 수 있는 위치에 복사합니다. 다음 예제를 참조하십시오.

   참고

   다음 예제에서는 서명 버전 2를 사용합니다. 서명 버전 4를 지원하는 리전에 있는 경우 us-east-2 리전과 같이 서명 버전 4를 사용합니다. 그렇지 않으면 스냅샷을 S3 버킷에 복사할 때 업로드가 실패합니다.

   예

   BUCKET_NAME=somebucket
   FILEPATH="/${BUCKET_NAME}/${CLUSTER_NAME}-snapshot.db"
   CONTENT_TYPE="application/x-compressed-tar"
   DATE_VALUE=`date -R`
   SIGNATURE_STRING="PUT\n\n${CONTENT_TYPE}\n${DATE_VALUE}\n${FILEPATH}"
   ACCESS_KEY=accesskey
   SECRET_KEY=secret
   SIGNATURE_HASH=`echo -en ${SIGNATURE_STRING} | openssl sha1 -hmac ${SECRET_KEY} -binary | base64`
   
   oc exec -it etcd-0 -n ${HOSTED_CLUSTER_NAMESPACE} -- curl -X PUT -T "/var/lib/data/snapshot.db" \
     -H "Host: ${BUCKET_NAME}.s3.amazonaws.com" \
     -H "Date: ${DATE_VALUE}" \
     -H "Content-Type: ${CONTENT_TYPE}" \
     -H "Authorization: AWS ${ACCESS_KEY}:${SIGNATURE_HASH}" \
     https://${BUCKET_NAME}.s3.amazonaws.com/${CLUSTER_NAME}-snapshot.db

6. 나중에 새 클러스터에서 스냅샷을 복원하려면 호스팅된 클러스터가 참조하는 암호화 시크릿을 저장합니다.

   1. 다음 명령을 입력하여 보안 암호화 키를 가져옵니다.

      $ oc get hostedcluster <hosted_cluster_name> -o=jsonpath='{.spec.secretEncryption.aescbc}'
      {"activeKey":{"name":"<hosted_cluster_name>-etcd-encryption-key"}}

   2. 다음 명령을 입력하여 보안 암호화 키를 저장합니다.

      $ oc get secret <hosted_cluster_name>-etcd-encryption-key -o=jsonpath='{.data.key}'

      새 클러스터에서 스냅샷을 복원할 때 이 키의 암호를 해독할 수 있습니다.

절차

1. aws CLI(명령줄 인터페이스)에서 인증 정보를 etcd 배포에 전달하지 않고 S3에서 etcd 스냅샷을 다운로드할 수 있도록 사전 서명된 URL을 생성합니다.

   ETCD_SNAPSHOT=${ETCD_SNAPSHOT:-"s3://${BUCKET_NAME}/${CLUSTER_NAME}-snapshot.db"}
   ETCD_SNAPSHOT_URL=$(aws s3 presign ${ETCD_SNAPSHOT})

2. URL을 참조하도록 HostedCluster 사양을 수정합니다.

   spec:
     etcd:
       managed:
         storage:
           persistentVolume:
             size: 4Gi
           type: PersistentVolume
           restoreSnapshotURL:
           - "${ETCD_SNAPSHOT_URL}"
       managementType: Managed

3. spec.secretEncryption.aescbc 값에서 참조한 보안에 이전 단계에서 저장한 것과 동일한 AES 키가 포함되어 있는지 확인합니다.

1. 관리 클러스터 1에서 소스 관리 클러스터로 간주할 수 있는 컨트롤 플레인 및 작업자는 외부 DNS API를 사용하여 상호 작용합니다. 외부 DNS API에 액세스할 수 있으며 로드 밸런서는 관리 클러스터 간에 위치합니다.

   

2. etcd, 컨트롤 플레인 및 작업자 노드가 포함된 호스팅 클러스터의 스냅샷을 생성합니다. 이 프로세스 중에 작업자 노드는 액세스할 수 없는 경우에도 외부 DNS API에 계속 액세스하려고 합니다. 워크로드가 실행 중이고 컨트롤 플레인은 로컬 매니페스트 파일에 저장되고 etcd는 S3 버킷으로 백업됩니다. 데이터 플레인이 활성 상태이고 컨트롤 플레인이 일시 중지되었습니다.

   

3. 대상 관리 클러스터 2로 간주할 수 있는 관리 클러스터 2에서는 S3 버킷에서 etcd를 복원하고 로컬 매니페스트 파일에서 컨트롤 플레인을 복원합니다. 이 프로세스 중에 외부 DNS API가 중지되고 호스팅된 클러스터 API에 액세스할 수 없게 되고 API를 사용하는 모든 작업자는 매니페스트 파일을 업데이트할 수 없지만 워크로드는 여전히 실행 중입니다.

   

4. 외부 DNS API에 다시 액세스할 수 있으며 작업자 노드는 이를 사용하여 관리 클러스터 2로 이동합니다. 외부 DNS API는 컨트롤 플레인을 가리키는 로드 밸런서에 액세스할 수 있습니다.

   

5. 관리 클러스터 2에서 컨트롤 플레인 및 작업자 노드는 외부 DNS API를 사용하여 상호 작용합니다. etcd의 S3 백업을 제외하고 관리 클러스터 1에서 리소스가 삭제됩니다. 관리 클러스터 1에서 호스트 클러스터를 다시 설정하려고 하면 작동하지 않습니다.

   

절차

1. 다음 명령을 입력하여 소스 관리 클러스터를 선언할 configmap 파일을 생성합니다.

   $ oc create configmap mgmt-parent-cluster -n default --from-literal=from=${MGMT_CLUSTER_NAME}

2. 다음 명령을 입력하여 호스팅된 클러스터 및 노드 풀에서 조정을 종료합니다.

   $ PAUSED_UNTIL="true"
   $ oc patch -n ${HC_CLUSTER_NS} hostedclusters/${HC_CLUSTER_NAME} -p '{"spec":{"pausedUntil":"'${PAUSED_UNTIL}'"}}' --type=merge
   $ oc scale deployment -n ${HC_CLUSTER_NS}-${HC_CLUSTER_NAME} --replicas=0 kube-apiserver openshift-apiserver openshift-oauth-apiserver control-plane-operator

   $ PAUSED_UNTIL="true"
   $ oc patch -n ${HC_CLUSTER_NS} hostedclusters/${HC_CLUSTER_NAME} -p '{"spec":{"pausedUntil":"'${PAUSED_UNTIL}'"}}' --type=merge
   $ oc patch -n ${HC_CLUSTER_NS} nodepools/${NODEPOOLS} -p '{"spec":{"pausedUntil":"'${PAUSED_UNTIL}'"}}' --type=merge
   $ oc scale deployment -n ${HC_CLUSTER_NS}-${HC_CLUSTER_NAME} --replicas=0 kube-apiserver openshift-apiserver openshift-oauth-apiserver control-plane-operator

3. 이 bash 스크립트를 실행하여 etcd를 백업하고 S3 버킷에 데이터를 업로드합니다.

   작은 정보

   이 스크립트를 함수로 래핑하고 기본 함수에서 호출합니다.

   # ETCD Backup
   ETCD_PODS="etcd-0"
   if [ "${CONTROL_PLANE_AVAILABILITY_POLICY}" = "HighlyAvailable" ]; then
     ETCD_PODS="etcd-0 etcd-1 etcd-2"
   fi
   
   for POD in ${ETCD_PODS}; do
     # Create an etcd snapshot
     oc exec -it ${POD} -n ${HC_CLUSTER_NS}-${HC_CLUSTER_NAME} -- env ETCDCTL_API=3 /usr/bin/etcdctl --cacert /etc/etcd/tls/client/etcd-client-ca.crt --cert /etc/etcd/tls/client/etcd-client.crt --key /etc/etcd/tls/client/etcd-client.key --endpoints=localhost:2379 snapshot save /var/lib/data/snapshot.db
     oc exec -it ${POD} -n ${HC_CLUSTER_NS}-${HC_CLUSTER_NAME} -- env ETCDCTL_API=3 /usr/bin/etcdctl -w table snapshot status /var/lib/data/snapshot.db
   
     FILEPATH="/${BUCKET_NAME}/${HC_CLUSTER_NAME}-${POD}-snapshot.db"
     CONTENT_TYPE="application/x-compressed-tar"
     DATE_VALUE=`date -R`
     SIGNATURE_STRING="PUT\n\n${CONTENT_TYPE}\n${DATE_VALUE}\n${FILEPATH}"
   
     set +x
     ACCESS_KEY=$(grep aws_access_key_id ${AWS_CREDS} | head -n1 | cut -d= -f2 | sed "s/ //g")
     SECRET_KEY=$(grep aws_secret_access_key ${AWS_CREDS} | head -n1 | cut -d= -f2 | sed "s/ //g")
     SIGNATURE_HASH=$(echo -en ${SIGNATURE_STRING} | openssl sha1 -hmac "${SECRET_KEY}" -binary | base64)
     set -x
   
     # FIXME: this is pushing to the OIDC bucket
     oc exec -it etcd-0 -n ${HC_CLUSTER_NS}-${HC_CLUSTER_NAME} -- curl -X PUT -T "/var/lib/data/snapshot.db" \
       -H "Host: ${BUCKET_NAME}.s3.amazonaws.com" \
       -H "Date: ${DATE_VALUE}" \
       -H "Content-Type: ${CONTENT_TYPE}" \
       -H "Authorization: AWS ${ACCESS_KEY}:${SIGNATURE_HASH}" \
       https://${BUCKET_NAME}.s3.amazonaws.com/${HC_CLUSTER_NAME}-${POD}-snapshot.db
   done

   etcd 백업에 대한 자세한 내용은 "호스트 클러스터에서 etcd 백업 및 복원"을 참조하십시오.

4. 다음 명령을 입력하여 Kubernetes 및 OpenShift Container Platform 오브젝트를 백업합니다. 다음 오브젝트를 백업해야 합니다.

   • HostedCluster 네임스페이스의 HostedCluster 및 NodePool 오브젝트
   • HostedCluster 네임스페이스의 HostedCluster 시크릿
   • HostedControl Plane 네임 스페이스의 HostedControlPlane
   • 호스팅 컨트롤 플레인 네임스페이스의 Cluster
   • 호스팅된 컨트롤 플레인 네임스페이스에서 AWSCluster,AWSMachineTemplate, AWSMachine
   • Hosted Control Plane 네임스페이스에서 MachineDeployments, MachineSets, Machines

   • 호스팅된 컨트롤 플레인 네임스페이스의 ControlPlane 시크릿

     $ mkdir -p ${BACKUP_DIR}/namespaces/${HC_CLUSTER_NS} ${BACKUP_DIR}/namespaces/${HC_CLUSTER_NS}-${HC_CLUSTER_NAME}
     $ chmod 700 ${BACKUP_DIR}/namespaces/
     
     # HostedCluster
     $ echo "Backing Up HostedCluster Objects:"
     $ oc get hc ${HC_CLUSTER_NAME} -n ${HC_CLUSTER_NS} -o yaml > ${BACKUP_DIR}/namespaces/${HC_CLUSTER_NS}/hc-${HC_CLUSTER_NAME}.yaml
     $ echo "--> HostedCluster"
     $ sed -i '' -e '/^status:$/,$d' ${BACKUP_DIR}/namespaces/${HC_CLUSTER_NS}/hc-${HC_CLUSTER_NAME}.yaml
     
     # NodePool
     $ oc get np ${NODEPOOLS} -n ${HC_CLUSTER_NS} -o yaml > ${BACKUP_DIR}/namespaces/${HC_CLUSTER_NS}/np-${NODEPOOLS}.yaml
     $ echo "--> NodePool"
     $ sed -i '' -e '/^status:$/,$ d' ${BACKUP_DIR}/namespaces/${HC_CLUSTER_NS}/np-${NODEPOOLS}.yaml
     
     # Secrets in the HC Namespace
     $ echo "--> HostedCluster Secrets:"
     for s in $(oc get secret -n ${HC_CLUSTER_NS} | grep "^${HC_CLUSTER_NAME}" | awk '{print $1}'); do
         oc get secret -n ${HC_CLUSTER_NS} $s -o yaml > ${BACKUP_DIR}/namespaces/${HC_CLUSTER_NS}/secret-${s}.yaml
     done
     
     # Secrets in the HC Control Plane Namespace
     $ echo "--> HostedCluster ControlPlane Secrets:"
     for s in $(oc get secret -n ${HC_CLUSTER_NS}-${HC_CLUSTER_NAME} | egrep -v "docker|service-account-token|oauth-openshift|NAME|token-${HC_CLUSTER_NAME}" | awk '{print $1}'); do
         oc get secret -n ${HC_CLUSTER_NS}-${HC_CLUSTER_NAME} $s -o yaml > ${BACKUP_DIR}/namespaces/${HC_CLUSTER_NS}-${HC_CLUSTER_NAME}/secret-${s}.yaml
     done
     
     # Hosted Control Plane
     $ echo "--> HostedControlPlane:"
     $ oc get hcp ${HC_CLUSTER_NAME} -n ${HC_CLUSTER_NS}-${HC_CLUSTER_NAME} -o yaml > ${BACKUP_DIR}/namespaces/${HC_CLUSTER_NS}-${HC_CLUSTER_NAME}/hcp-${HC_CLUSTER_NAME}.yaml
     
     # Cluster
     $ echo "--> Cluster:"
     $ CL_NAME=$(oc get hcp ${HC_CLUSTER_NAME} -n ${HC_CLUSTER_NS}-${HC_CLUSTER_NAME} -o jsonpath={.metadata.labels.\*} | grep ${HC_CLUSTER_NAME})
     $ oc get cluster ${CL_NAME} -n ${HC_CLUSTER_NS}-${HC_CLUSTER_NAME} -o yaml > ${BACKUP_DIR}/namespaces/${HC_CLUSTER_NS}-${HC_CLUSTER_NAME}/cl-${HC_CLUSTER_NAME}.yaml
     
     # AWS Cluster
     $ echo "--> AWS Cluster:"
     $ oc get awscluster ${HC_CLUSTER_NAME} -n ${HC_CLUSTER_NS}-${HC_CLUSTER_NAME} -o yaml > ${BACKUP_DIR}/namespaces/${HC_CLUSTER_NS}-${HC_CLUSTER_NAME}/awscl-${HC_CLUSTER_NAME}.yaml
     
     # AWS MachineTemplate
     $ echo "--> AWS Machine Template:"
     $ oc get awsmachinetemplate ${NODEPOOLS} -n ${HC_CLUSTER_NS}-${HC_CLUSTER_NAME} -o yaml > ${BACKUP_DIR}/namespaces/${HC_CLUSTER_NS}-${HC_CLUSTER_NAME}/awsmt-${HC_CLUSTER_NAME}.yaml
     
     # AWS Machines
     $ echo "--> AWS Machine:"
     $ CL_NAME=$(oc get hcp ${HC_CLUSTER_NAME} -n ${HC_CLUSTER_NS}-${HC_CLUSTER_NAME} -o jsonpath={.metadata.labels.\*} | grep ${HC_CLUSTER_NAME})
     for s in $(oc get awsmachines -n ${HC_CLUSTER_NS}-${HC_CLUSTER_NAME} --no-headers | grep ${CL_NAME} | cut -f1 -d\ ); do
         oc get -n ${HC_CLUSTER_NS}-${HC_CLUSTER_NAME} awsmachines $s -o yaml > ${BACKUP_DIR}/namespaces/${HC_CLUSTER_NS}-${HC_CLUSTER_NAME}/awsm-${s}.yaml
     done
     
     # MachineDeployments
     $ echo "--> HostedCluster MachineDeployments:"
     for s in $(oc get machinedeployment -n ${HC_CLUSTER_NS}-${HC_CLUSTER_NAME} -o name); do
         mdp_name=$(echo ${s} | cut -f 2 -d /)
         oc get -n ${HC_CLUSTER_NS}-${HC_CLUSTER_NAME} $s -o yaml > ${BACKUP_DIR}/namespaces/${HC_CLUSTER_NS}-${HC_CLUSTER_NAME}/machinedeployment-${mdp_name}.yaml
     done
     
     # MachineSets
     $ echo "--> HostedCluster MachineSets:"
     for s in $(oc get machineset -n ${HC_CLUSTER_NS}-${HC_CLUSTER_NAME} -o name); do
         ms_name=$(echo ${s} | cut -f 2 -d /)
         oc get -n ${HC_CLUSTER_NS}-${HC_CLUSTER_NAME} $s -o yaml > ${BACKUP_DIR}/namespaces/${HC_CLUSTER_NS}-${HC_CLUSTER_NAME}/machineset-${ms_name}.yaml
     done
     
     # Machines
     $ echo "--> HostedCluster Machine:"
     for s in $(oc get machine -n ${HC_CLUSTER_NS}-${HC_CLUSTER_NAME} -o name); do
         m_name=$(echo ${s} | cut -f 2 -d /)
         oc get -n ${HC_CLUSTER_NS}-${HC_CLUSTER_NAME} $s -o yaml > ${BACKUP_DIR}/namespaces/${HC_CLUSTER_NS}-${HC_CLUSTER_NAME}/machine-${m_name}.yaml
     done

5. 다음 명령을 입력하여 ControlPlane 경로를 정리합니다.

   $ oc delete routes -n ${HC_CLUSTER_NS}-${HC_CLUSTER_NAME} --all

   해당 명령을 입력하면 ExternalDNS Operator가 Route53 항목을 삭제할 수 있습니다.

6. 이 스크립트를 실행하여 Route53 항목이 정리되었는지 확인합니다.

   function clean_routes() {
   
       if [[ -z "${1}" ]];then
           echo "Give me the NS where to clean the routes"
           exit 1
       fi
   
       # Constants
       if [[ -z "${2}" ]];then
           echo "Give me the Route53 zone ID"
           exit 1
       fi
   
       ZONE_ID=${2}
       ROUTES=10
       timeout=40
       count=0
   
       # This allows us to remove the ownership in the AWS for the API route
       oc delete route -n ${1} --all
   
       while [ ${ROUTES} -gt 2 ]
       do
           echo "Waiting for ExternalDNS Operator to clean the DNS Records in AWS Route53 where the zone id is: ${ZONE_ID}..."
           echo "Try: (${count}/${timeout})"
           sleep 10
           if [[ $count -eq timeout ]];then
               echo "Timeout waiting for cleaning the Route53 DNS records"
               exit 1
           fi
           count=$((count+1))
           ROUTES=$(aws route53 list-resource-record-sets --hosted-zone-id ${ZONE_ID} --max-items 10000 --output json | grep -c ${EXTERNAL_DNS_DOMAIN})
       done
   }
   
   # SAMPLE: clean_routes "<HC ControlPlane Namespace>" "<AWS_ZONE_ID>"
   clean_routes "${HC_CLUSTER_NS}-${HC_CLUSTER_NAME}" "${AWS_ZONE_ID}"

절차

1. 다음 명령을 입력하여 복원 중인 클러스터의 네임스페이스가 새 관리 클러스터에 포함되어 있지 않은지 확인합니다.

   # Just in case
   $ export KUBECONFIG=${MGMT2_KUBECONFIG}
   $ BACKUP_DIR=${HC_CLUSTER_DIR}/backup
   
   # Namespace deletion in the destination Management cluster
   $ oc delete ns ${HC_CLUSTER_NS} || true
   $ oc delete ns ${HC_CLUSTER_NS}-{HC_CLUSTER_NAME} || true

2. 다음 명령을 입력하여 삭제된 네임스페이스를 다시 생성합니다.

   # Namespace creation
   $ oc new-project ${HC_CLUSTER_NS}
   $ oc new-project ${HC_CLUSTER_NS}-${HC_CLUSTER_NAME}

3. 다음 명령을 입력하여 HC 네임스페이스에 보안을 복원합니다.

   $ oc apply -f ${BACKUP_DIR}/namespaces/${HC_CLUSTER_NS}/secret-*

4. 다음 명령을 입력하여 HostedCluster 컨트롤 플레인 네임스페이스에서 오브젝트를 복원합니다.

   # Secrets
   $ oc apply -f ${BACKUP_DIR}/namespaces/${HC_CLUSTER_NS}-${HC_CLUSTER_NAME}/secret-*
   
   # Cluster
   $ oc apply -f ${BACKUP_DIR}/namespaces/${HC_CLUSTER_NS}-${HC_CLUSTER_NAME}/hcp-*
   $ oc apply -f ${BACKUP_DIR}/namespaces/${HC_CLUSTER_NS}-${HC_CLUSTER_NAME}/cl-*

5. 노드와 노드 풀을 복구하여 AWS 인스턴스를 재사용하는 경우 다음 명령을 입력하여 HC 컨트롤 플레인 네임스페이스에서 오브젝트를 복원합니다.

   # AWS
   $ oc apply -f ${BACKUP_DIR}/namespaces/${HC_CLUSTER_NS}-${HC_CLUSTER_NAME}/awscl-*
   $ oc apply -f ${BACKUP_DIR}/namespaces/${HC_CLUSTER_NS}-${HC_CLUSTER_NAME}/awsmt-*
   $ oc apply -f ${BACKUP_DIR}/namespaces/${HC_CLUSTER_NS}-${HC_CLUSTER_NAME}/awsm-*
   
   # Machines
   $ oc apply -f ${BACKUP_DIR}/namespaces/${HC_CLUSTER_NS}-${HC_CLUSTER_NAME}/machinedeployment-*
   $ oc apply -f ${BACKUP_DIR}/namespaces/${HC_CLUSTER_NS}-${HC_CLUSTER_NAME}/machineset-*
   $ oc apply -f ${BACKUP_DIR}/namespaces/${HC_CLUSTER_NS}-${HC_CLUSTER_NAME}/machine-*

6. 이 bash 스크립트를 실행하여 etcd 데이터 및 호스팅 클러스터를 복원합니다.

   ETCD_PODS="etcd-0"
   if [ "${CONTROL_PLANE_AVAILABILITY_POLICY}" = "HighlyAvailable" ]; then
     ETCD_PODS="etcd-0 etcd-1 etcd-2"
   fi
   
   HC_RESTORE_FILE=${BACKUP_DIR}/namespaces/${HC_CLUSTER_NS}/hc-${HC_CLUSTER_NAME}-restore.yaml
   HC_BACKUP_FILE=${BACKUP_DIR}/namespaces/${HC_CLUSTER_NS}/hc-${HC_CLUSTER_NAME}.yaml
   HC_NEW_FILE=${BACKUP_DIR}/namespaces/${HC_CLUSTER_NS}/hc-${HC_CLUSTER_NAME}-new.yaml
   cat ${HC_BACKUP_FILE} > ${HC_NEW_FILE}
   cat > ${HC_RESTORE_FILE} <<EOF
       restoreSnapshotURL:
   EOF
   
   for POD in ${ETCD_PODS}; do
     # Create a pre-signed URL for the etcd snapshot
     ETCD_SNAPSHOT="s3://${BUCKET_NAME}/${HC_CLUSTER_NAME}-${POD}-snapshot.db"
     ETCD_SNAPSHOT_URL=$(AWS_DEFAULT_REGION=${MGMT2_REGION} aws s3 presign ${ETCD_SNAPSHOT})
   
     # FIXME no CLI support for restoreSnapshotURL yet
     cat >> ${HC_RESTORE_FILE} <<EOF
       - "${ETCD_SNAPSHOT_URL}"
   EOF
   done
   
   cat ${HC_RESTORE_FILE}
   
   if ! grep ${HC_CLUSTER_NAME}-snapshot.db ${HC_NEW_FILE}; then
     sed -i '' -e "/type: PersistentVolume/r ${HC_RESTORE_FILE}" ${HC_NEW_FILE}
     sed -i '' -e '/pausedUntil:/d' ${HC_NEW_FILE}
   fi
   
   HC=$(oc get hc -n ${HC_CLUSTER_NS} ${HC_CLUSTER_NAME} -o name || true)
   if [[ ${HC} == "" ]];then
       echo "Deploying HC Cluster: ${HC_CLUSTER_NAME} in ${HC_CLUSTER_NS} namespace"
       oc apply -f ${HC_NEW_FILE}
   else
       echo "HC Cluster ${HC_CLUSTER_NAME} already exists, avoiding step"
   fi

7. 노드와 노드 풀을 복구하여 AWS 인스턴스를 재사용하는 경우 다음 명령을 입력하여 노드 풀을 복원합니다.

   $ oc apply -f ${BACKUP_DIR}/namespaces/${HC_CLUSTER_NS}/np-*

절차

1. 다음 명령을 입력하여 deployment 및 statefulset 오브젝트를 확장합니다.

   중요

   spec.persistentVolumeClaimRetentionPolicy.whenScaled 필드의 값이 Delete 로 설정된 경우 데이터 손실이 발생할 수 있으므로 상태 저장 세트를 스케일링하지 마십시오.

   이 문제를 해결하려면 spec.persistentVolumeClaimRetentionPolicy.whenScaled 필드의 값을 Retain 으로 업데이트합니다. 상태 저장 세트를 조정하는 컨트롤러가 없는지 확인하고 값을 Delete 로 다시 반환하여 데이터가 손실될 수 있습니다.

   # Just in case
   $ export KUBECONFIG=${MGMT_KUBECONFIG}
   
   # Scale down deployments
   $ oc scale deployment -n ${HC_CLUSTER_NS}-${HC_CLUSTER_NAME} --replicas=0 --all
   $ oc scale statefulset.apps -n ${HC_CLUSTER_NS}-${HC_CLUSTER_NAME} --replicas=0 --all
   $ sleep 15

2. 다음 명령을 입력하여 NodePool 오브젝트를 삭제합니다.

   NODEPOOLS=$(oc get nodepools -n ${HC_CLUSTER_NS} -o=jsonpath='{.items[?(@.spec.clusterName=="'${HC_CLUSTER_NAME}'")].metadata.name}')
   if [[ ! -z "${NODEPOOLS}" ]];then
       oc patch -n "${HC_CLUSTER_NS}" nodepool ${NODEPOOLS} --type=json --patch='[ { "op":"remove", "path": "/metadata/finalizers" }]'
       oc delete np -n ${HC_CLUSTER_NS} ${NODEPOOLS}
   fi

3. 다음 명령을 입력하여 machine 및 machineset 오브젝트를 삭제합니다.

   # Machines
   for m in $(oc get machines -n ${HC_CLUSTER_NS}-${HC_CLUSTER_NAME} -o name); do
       oc patch -n ${HC_CLUSTER_NS}-${HC_CLUSTER_NAME} ${m} --type=json --patch='[ { "op":"remove", "path": "/metadata/finalizers" }]' || true
       oc delete -n ${HC_CLUSTER_NS}-${HC_CLUSTER_NAME} ${m} || true
   done
   
   $ oc delete machineset -n ${HC_CLUSTER_NS}-${HC_CLUSTER_NAME} --all || true

4. 다음 명령을 입력하여 클러스터 오브젝트를 삭제합니다.

   # Cluster
   $ C_NAME=$(oc get cluster -n ${HC_CLUSTER_NS}-${HC_CLUSTER_NAME} -o name)
   $ oc patch -n ${HC_CLUSTER_NS}-${HC_CLUSTER_NAME} ${C_NAME} --type=json --patch='[ { "op":"remove", "path": "/metadata/finalizers" }]'
   $ oc delete cluster.cluster.x-k8s.io -n ${HC_CLUSTER_NS}-${HC_CLUSTER_NAME} --all

5. 이러한 명령을 입력하여 AWS 머신(Kubernetes 오브젝트)을 삭제합니다. 실제 AWS 머신 삭제에 대해 우려하지 마십시오. 클라우드 인스턴스는 영향을 받지 않습니다.

   # AWS Machines
   for m in $(oc get awsmachine.infrastructure.cluster.x-k8s.io -n ${HC_CLUSTER_NS}-${HC_CLUSTER_NAME} -o name)
   do
       oc patch -n ${HC_CLUSTER_NS}-${HC_CLUSTER_NAME} ${m} --type=json --patch='[ { "op":"remove", "path": "/metadata/finalizers" }]' || true
       oc delete -n ${HC_CLUSTER_NS}-${HC_CLUSTER_NAME} ${m} || true
   done

6. 다음 명령을 입력하여 HostedControlPlane 및 ControlPlane HC 네임스페이스 오브젝트를 삭제합니다.

   # Delete HCP and ControlPlane HC NS
   $ oc patch -n ${HC_CLUSTER_NS}-${HC_CLUSTER_NAME} hostedcontrolplane.hypershift.openshift.io ${HC_CLUSTER_NAME} --type=json --patch='[ { "op":"remove", "path": "/metadata/finalizers" }]'
   $ oc delete hostedcontrolplane.hypershift.openshift.io -n ${HC_CLUSTER_NS}-${HC_CLUSTER_NAME} --all
   $ oc delete ns ${HC_CLUSTER_NS}-${HC_CLUSTER_NAME} || true

7. 다음 명령을 입력하여 HostedCluster 및 HC 네임스페이스 오브젝트를 삭제합니다.

   # Delete HC and HC Namespace
   $ oc -n ${HC_CLUSTER_NS} patch hostedclusters ${HC_CLUSTER_NAME} -p '{"metadata":{"finalizers":null}}' --type merge || true
   $ oc delete hc -n ${HC_CLUSTER_NS} ${HC_CLUSTER_NAME}  || true
   $ oc delete ns ${HC_CLUSTER_NS} || true

1. 호스팅 클러스터의 kubeconfig 경로를 사용하여 KUBECONFIG 환경 변수를 로드합니다.

2. 다음 명령을 입력합니다.

   $ oc delete pod -n openshift-ovn-kubernetes --all

프로세스

1. 다음 명령을 실행하여 HostedCluster 리소스의 조정을 일시 중지합니다.

   $ oc --kubeconfig <management_cluster_kubeconfig_file> \
     patch hostedcluster -n <hosted_cluster_namespace> <hosted_cluster_name> \
     --type json -p '[{"op": "add", "path": "/spec/pausedUntil", "value": "true"}]'

2. 다음 명령을 실행하여 NodePool 리소스의 조정을 일시 중지합니다.

   $ oc --kubeconfig <management_cluster_kubeconfig_file> \
     patch nodepool -n <hosted_cluster_namespace> <node_pool_name> \
     --type json -p '[{"op": "add", "path": "/spec/pausedUntil", "value": "true"}]'

3. 다음 명령을 실행하여 AgentCluster 리소스의 조정을 일시 중지합니다.

   $ oc --kubeconfig <management_cluster_kubeconfig_file> \
     annotate agentcluster -n <hosted_control_plane_namespace>  \
     cluster.x-k8s.io/paused=true --all'

4. 다음 명령을 실행하여 AgentMachine 리소스의 조정을 일시 중지합니다.

   $ oc --kubeconfig <management_cluster_kubeconfig_file> \
     annotate agentmachine -n <hosted_control_plane_namespace>  \
     cluster.x-k8s.io/paused=true --all'

5. 다음 명령을 실행하여 호스팅된 컨트롤 플레인 네임스페이스를 삭제하지 않도록 HostedCluster 리소스에 주석을 답니다.

   $ oc --kubeconfig <management_cluster_kubeconfig_file> \
     annotate hostedcluster -n <hosted_cluster_namespace> <hosted_cluster_name> \
     hypershift.openshift.io/skip-delete-hosted-controlplane-namespace=true

6. Backup CR을 정의하는 YAML 파일을 생성합니다.

   예 8.1. backup-control-plane.yaml 파일 예

   apiVersion: velero.io/v1
   kind: Backup
   metadata:
     name: <backup_resource_name> 1
     namespace: openshift-adp
     labels:
       velero.io/storage-location: default
   spec:
     hooks: {}
     includedNamespaces: 2
     - <hosted_cluster_namespace> 3
     - <hosted_control_plane_namespace> 4
     includedResources:
     - sa
     - role
     - rolebinding
     - pod
     - pvc
     - pv
     - bmh
     - configmap
     - infraenv 5
     - priorityclasses
     - pdb
     - agents
     - hostedcluster
     - nodepool
     - secrets
     - services
     - deployments
     - hostedcontrolplane
     - cluster
     - agentcluster
     - agentmachinetemplate
     - agentmachine
     - machinedeployment
     - machineset
     - machine
     excludedResources: []
     storageLocation: default
     ttl: 2h0m0s
     snapshotMoveData: true 6
     datamover: "velero" 7
     defaultVolumesToFsBackup: true 8

   1

   backup_resource_name 을 Backup 리소스의 이름으로 교체합니다.

   2

   특정 네임스페이스를 선택하여 오브젝트를 백업합니다. 호스팅 클러스터 네임스페이스와 호스팅된 컨트롤 플레인 네임스페이스를 포함해야 합니다.

   3

   <hosted_cluster_namespace> 를 호스트된 클러스터 네임스페이스의 이름으로 바꿉니다(예: 클러스터 ).

   4

   <hosted_control_plane_namespace>를 호스트된 컨트롤 플레인 네임스페이스의 이름으로 바꿉니다(예: 클러스터 호스팅 ).

   5

   별도의 네임스페이스에 infraenv 리소스를 생성해야 합니다. 백업 프로세스 중에 infraenv 리소스를 삭제하지 마십시오.

   6 7

   CSI 볼륨 스냅샷을 활성화하고 컨트롤 플레인 워크로드를 클라우드 스토리지에 자동으로 업로드합니다.

   8

   PV(영구 볼륨)의 fs-backup 방법을 기본값으로 설정합니다. 이 설정은 CSI(Container Storage Interface) 볼륨 스냅샷과 fs-backup 방법을 조합할 때 유용합니다.

   참고

   CSI 볼륨 스냅샷을 사용하려면 backup.velero.io/backup-volumes-excludes=<pv_name> 주석을 PV에 추가해야 합니다.

7. 다음 명령을 실행하여 Backup CR을 적용합니다.

   $ oc apply -f backup-control-plane.yaml

프로세스

1. 다음 명령을 실행하여 호스팅된 컨트롤 플레인 네임스페이스에 Pod 및 PVC(영구 볼륨 클레임)가 없는지 확인합니다.

   $ oc get pod pvc -n <hosted_control_plane_namespace>

   예상 출력

   No resources found

2. Restore CR을 정의하는 YAML 파일을 생성합니다.

   restore-hosted-cluster.yaml 파일의 예

   apiVersion: velero.io/v1
   kind: Restore
   metadata:
     name: <restore_resource_name> 1
     namespace: openshift-adp
   spec:
     backupName: <backup_resource_name> 2
     restorePVs: true 3
     existingResourcePolicy: update 4
     excludedResources:
     - nodes
     - events
     - events.events.k8s.io
     - backups.velero.io
     - restores.velero.io
     - resticrepositories.velero.io

   1

   <restore_resource_name>을 Restore 리소스의 이름으로 바꿉니다.

   2

   <backup_resource_name>을 Backup 리소스의 이름으로 바꿉니다.

   3

   PV(영구 볼륨) 및 해당 Pod의 복구를 시작합니다.

   4

   백업된 콘텐츠를 사용하여 기존 오브젝트를 덮어쓰는지 확인합니다.

   중요

   별도의 네임스페이스에 infraenv 리소스를 생성해야 합니다. 복원 프로세스 중에 infraenv 리소스를 삭제하지 마십시오. 새 노드를 다시 프로비저닝하려면 infraenv 리소스가 필요합니다.

3. 다음 명령을 실행하여 Restore CR을 적용합니다.

   $ oc apply -f restore-hosted-cluster.yaml

4. 다음 명령을 실행하여 status.phase 의 값이 완료되었는지 확인합니다.

   $ oc get hostedcluster <hosted_cluster_name> -n <hosted_cluster_namespace> -o jsonpath='{.status.phase}'

5. 복원 프로세스가 완료되면 컨트롤 플레인 워크로드를 백업하는 동안 일시 중지된 HostedCluster 및 NodePool 리소스의 조정을 시작합니다.

   1. 다음 명령을 실행하여 HostedCluster 리소스의 조정을 시작합니다.

      $ oc --kubeconfig <management_cluster_kubeconfig_file> \
        patch hostedcluster -n <hosted_cluster_namespace> <hosted_cluster_name> \
        --type json -p '[{"op": "add", "path": "/spec/pausedUntil", "value": "false"}]'

   2. 다음 명령을 실행하여 NodePool 리소스의 조정을 시작합니다.

      $ oc --kubeconfig <management_cluster_kubeconfig_file> \
        patch nodepool -n <hosted_cluster_namespace> <node_pool_name> \
        --type json -p '[{"op": "add", "path": "/spec/pausedUntil", "value": "false"}]'

6. 컨트롤 플레인 워크로드를 백업하는 동안 일시 중지된 에이전트 공급자 리소스의 조정을 시작합니다.

   1. 다음 명령을 실행하여 AgentCluster 리소스의 조정을 시작합니다.

      $ oc --kubeconfig <management_cluster_kubeconfig_file> \
        annotate agentcluster -n <hosted_control_plane_namespace>  \
        cluster.x-k8s.io/paused- --overwrite=true --all

   2. 다음 명령을 실행하여 AgentMachine 리소스의 조정을 시작합니다.

      $ oc --kubeconfig <management_cluster_kubeconfig_file> \
        annotate agentmachine -n <hosted_control_plane_namespace>  \
        cluster.x-k8s.io/paused- --overwrite=true --all

7. 다음 명령을 실행하여 호스팅된 컨트롤 플레인 네임스페이스를 수동으로 삭제하지 않도록 HostedCluster 리소스에서 hypershift.openshift.io/skip-delete-hosted-controlplane-namespace- annotations을 제거합니다.

   $ oc --kubeconfig <management_cluster_kubeconfig_file> \
     annotate hostedcluster -n <hosted_cluster_namespace> <hosted_cluster_name> \
     hypershift.openshift.io/skip-delete-hosted-controlplane-namespace- \
     --overwrite=true --all

8. 다음 명령을 실행하여 NodePool 리소스를 원하는 복제본 수로 조정합니다.

   $ oc --kubeconfig <management_cluster_kubeconfig_file> \
     scale nodepool -n <hosted_cluster_namespace> <node_pool_name> \
     --replicas <replica_count> 1

   1

   <replica_count>를 정수 값으로 바꿉니다(예: 3 ).

프로세스

1. 다음 명령을 실행하여 백업 프로세스를 관찰합니다.

   $ watch "oc get backups.velero.io -n openshift-adp <backup_resource_name> -o jsonpath='{.status}'"

2. 다음 명령을 실행하여 복원 프로세스를 관찰합니다.

   $ watch "oc get restores.velero.io -n openshift-adp <backup_resource_name> -o jsonpath='{.status}'"

3. 다음 명령을 실행하여 Velero 로그를 관찰합니다.

   $ oc logs -n openshift-adp -ldeploy=velero -f

4. 다음 명령을 실행하여 모든 OADP 오브젝트의 진행 상황을 확인합니다.

   $ watch "echo BackupRepositories:;echo;oc get backuprepositories.velero.io -A;echo; echo BackupStorageLocations: ;echo; oc get backupstoragelocations.velero.io -A;echo;echo DataUploads: ;echo;oc get datauploads.velero.io -A;echo;echo DataDownloads: ;echo;oc get datadownloads.velero.io -n openshift-adp; echo;echo VolumeSnapshotLocations: ;echo;oc get volumesnapshotlocations.velero.io -A;echo;echo Backups:;echo;oc get backup -A; echo;echo Restores:;echo;oc get restore -A"

프로세스

1. 다음 명령을 실행하여 컨테이너에서 velero CLI를 사용하도록 별칭을 생성합니다.

   $ alias velero='oc -n openshift-adp exec deployment/velero -c velero -it -- ./velero'

2. 다음 명령을 실행하여 Restore CR(사용자 정의 리소스)에 대한 세부 정보를 가져옵니다.

   $ velero restore describe <restore_resource_name> --details 1

   1

   <restore_resource_name>을 Restore 리소스의 이름으로 바꿉니다.

3. 다음 명령을 실행하여 Backup CR에 대한 세부 정보를 가져옵니다.

   $ velero restore describe <backup_resource_name> --details 1

   1

   <backup_resource_name>을 Backup 리소스의 이름으로 바꿉니다.