> For the complete documentation index, see [llms.txt](https://kubernetes.youngwjung.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://kubernetes.youngwjung.com/core-concepts/rbac/lab.md).

# 실습

### Authentication - EKS

1. kubeconfig 파일 리뷰

   ```
   kubectl config view
   ```
2. kubeconfig에 명시된 users 확인 - <https://kubernetes.io/docs/reference/access-authn-authz/authentication/#client-go-credential-plugins>

   ```
   kubectl config view | yq e '.users' -
   ```
3. user에 명시된 명령어 실행

   ```
   $(kubectl config view \
   -o=jsonpath='{.users[0].user.exec.command} {.users[0].user.exec.args[*]}')
   ```
4. 토큰값을 환경변수로 지정 - Base64로 인코딩된 부분만 캡쳐

   ```
   {
       export TOKEN=$($(kubectl config view \
       -o=jsonpath='{.users[0].user.exec.command} {.users[0].user.exec.args[*]}') \
       | jq -r '.status.token' | grep -oP '(?<=k8s-aws-v1.).*')
       echo $TOKEN
   }
   ```
5. Base64URL 유틸리티 설치

   ```
   npm install -g base64-url-cli
   ```
6. 토큰값을 디코딩해서 환경변수로 지정

   ```
   {
       export DECODED_URL=$(base64url decode $TOKEN)
       echo $DECODED_URL 
   }
   ```
7. Node에 부여된 Label을 통해서 EKS 클러스터 이름 확인하고 환경변수로 저장

   ```
   {
       export CLUSTER_NAME=$(kubectl get node \
       -o=jsonpath='{.items[0].metadata.labels.alpha\.eksctl\.io\/cluster-name}')
       echo $CLUSTER_NAME
   }
   ```
8. 디코딩한 URL 호출

   ```
   curl -H "x-k8s-aws-id: $CLUSTER_NAME" $DECODED_URL
   ```
9. 현재 설정된 AWS 자격증명을 확인  &#x20;

   ```
   aws sts get-caller-identity
   ```
10. API 서버 주소를 확인하고 환경변수로 지정&#x20;

    ```
    {
        export K8S_SERVER=$(kubectl config view \
        -o=jsonpath='{.clusters[*].cluster.server}')
        echo $K8S_SERVER
    }
    ```
11. Node 목록을 보는 API 호출

    ```
    curl -k -X GET \
    -H "Authorization: Bearer $TOKEN" \
    -H "Content-Type: application/json" \
    $K8S_SERVER/api/v1/nodes
    ```
12. 토큰값을 환경변수로 지정

    ```
    {
        export TOKEN=$($(kubectl config view \
        -o=jsonpath='{.users[0].user.exec.command} {.users[0].user.exec.args[*]}') \
        | jq -r '.status.token')
        
        echo $TOKEN
    }
    ```
13. Node 목록을 보는 API 호출

    ```
    curl -k -X GET \
    -H "Authorization: Bearer $TOKEN" \
    -H "Content-Type: application/json" \
    $K8S_SERVER/api/v1/nodes
    ```
14. IAM 유저 생성

    ```
    aws iam create-user --user-name john
    ```
15. 위에서 생성한 IAM 유저의 Access Key 생성

    ```
    aws iam create-access-key --user-name john > key.txt
    ```
16. Access Key가 정상적으로 생성되었는지 확인

    ```
    cat key.txt
    ```
17. AWS CLI 자격증명 파일 및 설정 파일 백업

    ```
    {
        cp ~/.aws/credentials ~/.aws/credentials_backup
        cp ~/.aws/config ~/.aws/config_backup
    }
    ```
18. 위에서 생성한 Access Key를 AWS CLI 자격증명 파일에 반영

    ```
    {
    cat <<EOF >> ~/.aws/credentials

    [john]
    aws_access_key_id=$(cat key.txt | jq -r '.AccessKey.AccessKeyId')
    aws_secret_access_key=$(cat key.txt | jq -r '.AccessKey.SecretAccessKey')
    EOF

    cat <<EOF >> ~/.aws/config

    [profile john]
    region = ap-northeast-2
    EOF
    }
    ```
19. 위에서 명시한 프로필을 통해서 AWS API 호출

    ```
    aws sts get-caller-identity --profile john
    ```
20. kubeconfig 파일 삭제

    ```
    rm -rf ~/.kube/config
    ```
21. 쿠버네티스 API 호출 시도

    ```
    kubectl get pod -A
    ```
22. 새로 생성한 IAM 유저의 자격증명으로 AWS CLI를 이용해서 kubeconfig 파일 생성

    ```
    aws eks update-kubeconfig --name $CLUSTER_NAME --profile john
    ```
23. IAM 유저에서 *eks:DescribeCluster* 권한 부여

    ```
    aws iam put-user-policy --user-name john --policy-name eks-admin --policy-document \
    '{
        "Version": "2012-10-17",
        "Statement": [
            {
                "Action": [
                    "eks:DescribeCluster"
                ],
                "Resource": "*",
                "Effect": "Allow"
            }
        ]
    }'
    ```
24. IAM 정책이 부여되었는지 확인

    ```
    {
        aws iam list-user-policies --user-name john
        aws iam get-user-policy --user-name john --policy-name eks-admin
    }
    ```
25. 새로 생성한 IAM 유저의 자격증명으로 AWS CLI를 이용해서 kubeconfig 파일 생성 - *정책 적용까지 시간이 걸릴수 있음*

    ```
    aws eks update-kubeconfig --name $CLUSTER_NAME --profile john
    ```
26. 새로 생성된 kubeconfig 파일 리뷰

    ```
    kubectl config view
    ```
27. 쿠버네티스 API 호출 시도

    ```
    kubectl get pod -A
    ```
28. user에 명시된 명령어 실행

    ```
    {
        export $(kubectl config view -o=jsonpath='{.users[0].user.exec.env[0].name}={.users[0].user.exec.env[0].value}')
        $(kubectl config view \
        -o=jsonpath='{.users[0].user.exec.command} {.users[0].user.exec.args[*]}')
    }
    ```
29. 토큰값을 환경변수로 지정 - Base64로 인코딩된 부분만 캡쳐

    ```
    {
        export TOKEN=$($(kubectl config view \
        -o=jsonpath='{.users[0].user.exec.command} {.users[0].user.exec.args[*]}') \
        | jq -r '.status.token' | grep -oP '(?<=k8s-aws-v1.).*')
        echo $TOKEN
    }
    ```
30. 토큰값을 디코딩해서 환경변수로 지정

    ```
    {
        export DECODED_URL=$(base64url decode $TOKEN)
        echo $DECODED_URL 
    }
    ```
31. 디코딩한 URL 호출

    ```
    curl -H "x-k8s-aws-id: $CLUSTER_NAME" $DECODED_URL
    ```
32. 어드민 IAM 유저의 자격증명으로 AWS CLI를 이용해서 kubeconfig 파일 업데이트&#x20;

    ```
    {
        rm -rf ~/.kube/config
        unset AWS_PROFILE
        aws eks update-kubeconfig --name $CLUSTER_NAME
    }
    ```

### Authorization

1. *aws-auth* ConfigMap 리뷰 - <https://docs.aws.amazon.com/eks/latest/userguide/add-user-role.html>, [https://aws.amazon.com/premiumsupport/knowledge-center/amazon-eks-cluster-access](https://aws.amazon.com/premiumsupport/knowledge-center/amazon-eks-cluster-access/)

   ```
   kubectl -n kube-system get configmap aws-auth -o yaml
   ```
2. ClusterRole 목록 확인

   ```
   kubectl get clusterrole
   ```
3. *cluster-admin* ClusterRole 리뷰

   ```
   kubectl get clusterrole cluster-admin -o yaml
   ```
4. ClusterRoleBinding 목록 확인

   ```
   kubectl get clusterrolebinding
   ```
5. *cluster-admin* ClusterRoleBinding 리뷰

   ```
   kubectl get clusterrolebinding cluster-admin -o yaml
   ```
6. 현재 kubeconfig에 설정된 유저의 자격증명으로 수행할수 있는 API 목록 확인

   ```
   kubectl auth can-i --list
   ```
7. *aws-auth* ConfigMap에 명시된 MapRoles 내용 확인 - <https://kubernetes.io/docs/reference/access-authn-authz/node/>

   ```
   kubectl -n kube-system get configmap aws-auth -o yaml | yq e '.data' -
   ```
8. 한개의 Node의 인스턴스 ID를 확인하고 환경변수로 지정

   ```
   {
       export INSTANCE_ID=$(kubectl get node -o jsonpath='{.items[0].spec.providerID}' \
       | grep -oE "i-[a-z0-9]+")
       echo $INSTANCE_ID
   }
   ```
9. Node에 부여된 IAM 인스턴스 프로필을 확인하고 환경변수로 지정

   ```
   {
       export INSTANCE_PROFILE=$(aws ec2 describe-instances --instance-ids $INSTANCE_ID \
       --query 'Reservations[0].Instances[0].IamInstanceProfile.Arn' \
       --output text | grep -oE "[a-z0-9-]+$")
       echo $INSTANCE_PROFILE
   }
   ```
10. 위에서 확인한 인스턴스 프로필에 연동된 IAM 역할 확인

    ```
    aws iam get-instance-profile --instance-profile-name $INSTANCE_PROFILE \
    --query 'InstanceProfile.Roles[0].Arn' --output text
    ```
11. *view* ClusterRole 리뷰

    ```
    kubectl get clusterrole view -o yaml
    ```
12. ClusterRoleBinding 생성

    ```
    cat <<EOF | kubectl apply -f -
    kind: ClusterRoleBinding
    apiVersion: rbac.authorization.k8s.io/v1
    metadata:
      name: readonly
    subjects:
    - kind: Group
      name: readonly
      apiGroup: rbac.authorization.k8s.io
    roleRef:
      kind: ClusterRole
      name: view
      apiGroup: rbac.authorization.k8s.io
    EOF
    ```
13. Node에 부여된 Label을 통해서 EKS 클러스터 이름을 확인하고 환경변수로 저장

    ```
    {
        export CLUSTER_NAME=$(kubectl get node \
        -o=jsonpath='{.items[0].metadata.labels.alpha\.eksctl\.io\/cluster-name}')
        echo $CLUSTER_NAME
    }
    ```
14. EKS 클러스터가 생성되어 있는 AWS 계정번호 확인하고 환경변수로 저장

    ```
    {
        export ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)
        echo $ACCOUNT_ID
    }
    ```
15. *aws-auth* ConfigMap에 규칙 추가&#x20;

    ```
    eksctl create iamidentitymapping --cluster $CLUSTER_NAME \
    --arn arn:aws:iam::$ACCOUNT_ID:user/john \
    --username arn:aws:iam::$ACCOUNT_ID:user/john \
    --group readonly
    ```
16. *aws-auth* ConfigMap 변경분 확인

    ```
    kubectl -n kube-system get configmap aws-auth -o yaml
    ```
17. *john* IAM 유저의 자격증명으로 AWS CLI를 이용해서 kubeconfig 파일 업데이트&#x20;

    ```
    {
        rm -rf ~/.kube/config
        aws eks update-kubeconfig --name $CLUSTER_NAME --profile john
    }
    ```
18. 현재 kubeconfig에 설정된 유저의 자격증명으로 수행할수 있는 API 목록 확인

    ```
    kubectl auth can-i --list
    ```
19. 클러스터에 생성된 Pod 목록 확인

    ```
    kubectl get pod -A 
    ```
20. Pod 생성 시도&#x20;

    ```
    kubectl run nginx --image=nginx
    ```
21. IAM 역할 생성

    ```
    {
    cat > trust-policy.json <<EOF
    {
        "Version": "2012-10-17",
        "Statement": [
            {
                "Effect": "Allow",
                "Principal": {
                    "AWS": [
                        "arn:aws:iam::$ACCOUNT_ID:root"
                    ]
                },
                "Action": "sts:AssumeRole"
            }
        ]
    }
    EOF
    aws iam create-role --role-name eks-admin-role \
    --assume-role-policy-document file://trust-policy.json
    }
    ```
22. *aws-auth* ConfigMap에 규칙 추가&#x20;

    ```
    eksctl create iamidentitymapping --cluster $CLUSTER_NAME \
    --arn arn:aws:iam::$ACCOUNT_ID:role/eks-admin-role \
    --username devops \
    --group system:masters
    ```
23. *aws-auth* ConfigMap 변경분 확인

    ```
    kubectl -n kube-system get configmap aws-auth -o yaml
    ```
24. *john* IAM 유저의 자격증명으로 위에서 생성한 IAM 역할 전환하는 설정 추가해서 kubeconfig 파일 업데이트&#x20;

    ```
    {
        rm -rf ~/.kube/config
        aws eks update-kubeconfig --name $CLUSTER_NAME --profile john \
        --role-arn arn:aws:iam::$ACCOUNT_ID:role/eks-admin-role
    }
    ```
25. 새로 생성된 kubeconfig 파일 리뷰

    ```
    kubectl config view
    ```
26. 쿠버네티스 API 호출 시도

    ```
    kubectl get pod -A
    ```
27. *john* IAM 유저에서 *sts:AssumeRole* 권한 부여

    ```
    aws iam put-user-policy --user-name john --policy-name assume-role --policy-document \
    '{
        "Version": "2012-10-17",
        "Statement": [
            {
                "Action": [
                    "sts:AssumeRole"
                ],
                "Resource": "*",
                "Effect": "Allow"
            }
        ]
    }'
    ```
28. IAM 정책이 부여되었는지 확인

    ```
    {
        aws iam list-user-policies --user-name john
        aws iam get-user-policy --user-name john --policy-name assume-role
    }
    ```
29. 쿠버네티스 API 호출 시도 - *정책 적용까지 시간이 걸릴수 있음*

    ```
    kubectl get pod -A
    ```
30. user에 명시된 명령어 실행

    ```
    {
        export $(kubectl config view -o=jsonpath='{.users[0].user.exec.env[0].name}={.users[0].user.exec.env[0].value}')
        $(kubectl config view \
        -o=jsonpath='{.users[0].user.exec.command} {.users[0].user.exec.args[*]}')
    }
    ```
31. 토큰값을 환경변수로 지정 - Base64로 인코딩된 부분만 캡쳐

    ```
    {
        export TOKEN=$($(kubectl config view \
        -o=jsonpath='{.users[0].user.exec.command} {.users[0].user.exec.args[*]}') \
        | jq -r '.status.token' | grep -oP '(?<=k8s-aws-v1.).*')
        echo $TOKEN
    }
    ```
32. 토큰값을 디코딩해서 환경변수로 지정

    ```
    {
        export DECODED_URL=$(base64url decode $TOKEN)
        echo $DECODED_URL 
    }
    ```
33. 디코딩한 URL 호출

    ```
    curl -H "x-k8s-aws-id: $CLUSTER_NAME" $DECODED_URL
    ```
34. 어드민 IAM 유저의 자격증명으로 AWS CLI를 이용해서 kubeconfig 파일 업데이트&#x20;

    ```
    {
        rm -rf ~/.kube/config
        unset AWS_PROFILE
        aws eks update-kubeconfig --name $CLUSTER_NAME
    }
    ```
35. 리소스 삭제

    ```
    {
        aws iam delete-access-key --user-name john --access-key-id $(cat key.txt | jq -r '.AccessKey.AccessKeyId')
        aws iam delete-user-policy --user-name john --policy-name eks-admin
        aws iam delete-user-policy --user-name john --policy-name assume-role
        aws iam delete-user --user-name john
        kubectl delete clusterrolebinding readonly
        aws iam delete-role --role-name eks-admin-role
        eksctl delete iamidentitymapping --cluster $CLUSTER_NAME --arn arn:aws:iam::$ACCOUNT_ID:role/eks-admin-role
        eksctl delete iamidentitymapping --cluster $CLUSTER_NAME --arn arn:aws:iam::$ACCOUNT_ID:user/john
        mv ~/.aws/credentials_backup ~/.aws/credentials
        mv ~/.aws/config_backup ~/.aws/config
        rm key.txt trust-policy.json
    }
    ```

### Service Account

1. Pod 생성

   ```
   kubectl run nginx --image=nginx
   ```
2. Pod 생성 확인

   ```
   kubectl get pod nginx
   ```
3. Pod에 부여된 ServiceAccount 확인

   ```
   kubectl get pod nginx -o=jsonpath='{.spec.serviceAccountName}{"\n"}'
   ```
4. *default* 네임스페이스에 존재하는 ServiceAccount 목록 확인

   ```
   kubectl get sa
   ```
5. ServiceAccount 생성 &#x20;

   ```
   kubectl create sa kubectl-access
   ```
6. Pod 생성 &#x20;

   ```
   cat <<EOF | kubectl apply -f -
   apiVersion: v1
   kind: Pod
   metadata:
     name: kubectl
   spec:
     serviceAccountName: kubectl-access
     containers:
     - image: bitnami/kubectl
       name: kubectl
       command: ["sleep", "3600"]
   EOF
   ```
7. 생성된 Pod 안에서 포함된 kubectl을 통해서 *kube-system* 네임스페이스에 있는 Pod 목록 확인&#x20;

   ```
   kubectl exec kubectl -- kubectl get pod -n kube-system
   ```
8. 위에서 생성한 ServiceAccount에 부여된 권한 확인

   ```
   kubectl auth can-i --list --as system:serviceaccount:default:kubectl-access
   ```
9. ClusterRole 생성 &#x20;

   ```
   cat <<EOF | kubectl apply -f -
   kind: ClusterRole
   apiVersion: rbac.authorization.k8s.io/v1
   metadata:
     name: pod-access
   rules:
   - apiGroups: [""]
     resources: ["pods"]
     verbs: ["get", "list", "watch"]
   EOF
   ```
10. RoleBinding 생성&#x20;

    ```
    cat <<EOF | kubectl apply -f -
    kind: RoleBinding
    apiVersion: rbac.authorization.k8s.io/v1
    metadata:
      name: pod-access
      namespace: kube-system
    subjects:
    - kind: ServiceAccount
      name: kubectl-access
      namespace: default
    roleRef:
      kind: ClusterRole
      name: pod-access
      apiGroup: rbac.authorization.k8s.io
    EOF
    ```
11. 생성된 Pod 안에서 포함된 kubectl을 통해서 *kube-system* 네임스페이스에 있는 Pod 목록 확인&#x20;

    ```
    kubectl exec kubectl -- kubectl get pod -n kube-system
    ```
12. 생성된 Pod 안에서 포함된 kubectl을 통해서 *default* 네임스페이스에 있는 Pod 목록 확인&#x20;

    ```
    kubectl exec kubectl -- kubectl get pod
    ```
13. 위에서 생성한 ServiceAccount에 부여된 권한 확인

    ```
    kubectl auth can-i --list --as system:serviceaccount:default:kubectl-access
    ```
14. 위에서 생성한 ServiceAccount에 *kube-system* 네임스페이스에 대해서 부여된 권한 확인

    ```
    kubectl auth can-i --list -n kube-system \
    --as system:serviceaccount:default:kubectl-access
    ```
15. 리소스 삭제

    ```
    {
        kubectl delete pod kubectl nginx
        kubectl delete rolebinding pod-access -n kube-system
        kubectl delete clusterrole pod-access
        kubectl delete sa kubectl-access
    }
    ```

### IAM roles for service accounts <a href="#iam-roles-for-service-accounts" id="iam-roles-for-service-accounts"></a>

1. Pod 생성

   ```
   kubectl run aws-cli --image=amazon/aws-cli --command -- sleep 3600
   ```
2. Pod 생성 확인

   ```
   kubectl get pod aws-cli
   ```
3. 생성된 Pod에 부여된 AWS 자격증명 확인

   ```
   kubectl exec aws-cli -- aws sts get-caller-identity
   ```
4. Pod가 배포된 Node 확인&#x20;

   ```
   kubectl get pod aws-cli -o wide
   ```
5. Pod가 배포된 Node의 인스턴스 ID를 확인하고 환경변수로 지정

   ```
   {
       export INSTANCE_ID=$(kubectl get node $(kubectl get pod aws-cli -o=jsonpath='{.spec.nodeName}') \
       -o jsonpath='{.spec.providerID}{"\n"}' | grep -oE "i-[a-z0-9]+")
       echo $INSTANCE_ID
   }
   ```
6. Node에 부여된 IAM 인스턴스 프로필을 확인하고 환경변수로 지정

   ```
   {
       export INSTANCE_PROFILE=$(aws ec2 describe-instances --instance-ids $INSTANCE_ID \
       --query 'Reservations[0].Instances[0].IamInstanceProfile.Arn' \
       --output text | grep -oE "[a-z0-9-]+$")
       echo $INSTANCE_PROFILE
   }
   ```
7. 위에서 확인한 인스턴스 프로필에 연동된 IAM 역할 확인

   ```
   aws iam get-instance-profile --instance-profile-name $INSTANCE_PROFILE \
   --query 'InstanceProfile.Roles[0].Arn' --output text
   ```
8. Pod에 부여된 AWS 자격증명 확인

   ```
   kubectl exec aws-cli -- aws sts get-caller-identity
   ```
9. Pod에서 EC2 인스턴스 메타데이터를 통해서 상속받는 자격증명 확인

   ```
   kubectl exec aws-cli -- \
   curl -s -w "\n" http://169.254.169.254/latest/meta-data/iam/security-credentials
   ```
10. 위에서 확인한 자격증명에 부여된 Access Key 확인

    ```
    kubectl exec aws-cli -- bash -c \
    'curl -s -w "\n" http://169.254.169.254/latest/meta-data/iam/security-credentials/$(curl -s http://169.254.169.254/latest/meta-data/iam/security-credentials)'
    ```
11. AWS CLI가 자격증명을 불러오는 순서 확인

    ```
    kubectl exec aws-cli -- aws sts get-caller-identity --debug
    ```
12. Node에 부여된 Label을 통해서 EKS 클러스터 이름을 확인하고 환경변수로 저장

    ```
    {
        export CLUSTER_NAME=$(kubectl get node \
        -o=jsonpath='{.items[0].metadata.labels.alpha\.eksctl\.io\/cluster-name}')
        echo $CLUSTER_NAME
    }
    ```
13. ServiceAccount 생성

    ```
    eksctl create iamserviceaccount \
    --cluster=$CLUSTER_NAME \
    --namespace=default \
    --name=aws-cli \
    --attach-policy-arn=arn:aws:iam::aws:policy/AmazonS3ReadOnlyAccess \
    --override-existing-serviceaccounts \
    --approve
    ```
14. 생성된 ServiceAccount 확인

    ```
    kubectl get sa aws-cli
    ```
15. ServiceAccount에 명시된 IAM 역할 이을 확인하고 환경변수로 지정

    ```
    {
       IAM_ROLE_NAME=$(kubectl get sa aws-cli \
       -o=jsonpath='{.metadata.annotations.eks\.amazonaws\.com\/role-arn}' \
       | grep -oP '(?<=role.).*')
       echo $IAM_ROLE_NAME
    }
    ```
16. ServiceAccount와 연동된 IAM 역할에 부여된 IAM 정책 확인

    ```
    aws iam list-attached-role-policies --role-name $IAM_ROLE_NAME
    ```
17. ServiceAccount와 연동된 IAM 역할에 부여된 신뢰관계 정책 확인

    ```
    aws iam get-role --role-name $IAM_ROLE_NAME
    ```
18. EKS 클러스터에 연동된 OIDC 제공자 확인

    ```
    aws eks describe-cluster --name $CLUSTER_NAME \
    --query "cluster.identity.oidc.issuer" --output text
    ```
19. Pod를 재생성하고 위에서 생성한 ServiceAccount 부여

    ```
    cat <<EOF | kubectl replace --force -f -
    apiVersion: v1
    kind: Pod
    metadata:
      name: aws-cli
    spec:
      serviceAccountName: aws-cli
      containers:
      - name: aws-cli
        image: amazon/aws-cli
        command: ["sleep", "3600"]
    EOF
    ```
20. Pod에 부여된 AWS 자격증명 확인

    ```
    kubectl exec aws-cli -- aws sts get-caller-identity
    ```
21. Pod에서 EC2 인스턴스 메타데이터를 통해서 상속받는 자격증명 확인

    ```
    kubectl exec aws-cli -- \
    curl -s -w "\n" http://169.254.169.254/latest/meta-data/iam/security-credentials
    ```
22. AWS CLI가 자격증명을 불러오는 순서 확인

    ```
    kubectl exec aws-cli -- aws sts get-caller-identity --debug
    ```
23. Pod에 지정된 환경변수 확인

    ```
    kubectl exec aws-cli -- printenv
    ```
24. Pod에 생성된 AWS 임시토큰 파일 내용 확인

    ```
    kubectl exec aws-cli -- bash -c 'cat $AWS_WEB_IDENTITY_TOKEN_FILE'
    ```
25. 위에서 확인한 토큰 내용 확인

    ```
    jq -R 'split(".") | .[0],.[1] | @base64d | fromjson' <<<\
    $(kubectl exec aws-cli -- bash -c 'cat $AWS_WEB_IDENTITY_TOKEN_FILE')
    ```
26. ServiceAccount와 연동된 IAM 역할에 부여된 신뢰관계 정책 확인

    ```
    aws iam get-role --role-name $IAM_ROLE_NAME
    ```
27. Pod에서 AWS CLI를 통해서 S3 버킷 목록 확인

    ```
    kubectl exec aws-cli -- aws s3 ls
    ```
28. 리소스 삭제

    ```
    {
        eksctl delete iamserviceaccount --cluster $CLUSTER_NAME --name aws-cli
        kubectl delete pod aws-cli
    }
    ```