Produk yang dijelaskan dalam dokumentasi ini, Cluster Anthos di AWS (generasi sebelumnya), kini berada dalam mode pemeliharaan. Semua penginstalan baru harus menggunakan produk generasi saat ini, cluster Anthos di AWS.

Halaman ini diterjemahkan oleh Cloud Translation API.

Menggunakan workload identity dengan AWS

Topik ini menjelaskan cara mengaktifkan workload identity untuk workload GKE di AWS Anda guna mengontrol aksesnya ke resource AWS.

Untuk mengetahui informasi tentang cara menggunakan identitas beban kerja dengan akun Google Cloud Identity and Access Management (IAM) untuk mengontrol akses ke resource GCP, lihat Menggunakan identitas beban kerja dengan Google Cloud.

Ringkasan

Workload identity menggunakan izin IAM AWS untuk mengontrol akses ke resource cloud. Dengan identitas workload, Anda dapat menetapkan peran IAM yang berbeda ke setiap workload. Kontrol izin yang mendetail ini memungkinkan Anda mengikuti prinsip hak istimewa terendah. Tanpa workload identity, Anda harus menetapkan peran IAM AWS ke node GKE di AWS, sehingga semua workload di node tersebut memiliki izin yang sama dengan node itu sendiri.

Untuk mengaktifkan workload identity bagi cluster Anda, selesaikan langkah-langkah berikut, yang dikelompokkan berdasarkan peran administratif yang melakukannya.

Administrator cluster

Buat bucket Cloud Storage untuk menyimpan data penemuan OIDC.
Buat peran Identity and Access Management untuk membaca dari bucket tersebut.
Buat cluster pengguna dengan workload identity diaktifkan.
Buat webhook di cluster Anda yang menerapkan kredensial workload identity ke Pod saat pembuatan. Jika tidak ingin menggunakan webhook, Anda dapat menyetel variabel lingkungan secara manual di pod.
Konfigurasi penyedia OIDC AWS.
Buat peran dan kebijakan AWS IAM.

Administrator atau developer cluster

Buat akun layanan Kubernetes, dan ikat kebijakan AWS ke akun layanan tersebut.

Developer

Terapkan kredensial ke Pods Anda.

Prasyarat

Untuk menyelesaikan langkah-langkah dalam dokumen ini, Anda harus melakukan penyiapan berikut:

Layanan pengelolaan GKE di AWS.
Cluster pengguna yang menjalankan versi Kubernetes yang lebih tinggi dari 1.17.9.

Catatan: Jika Anda membuat cluster Kubernetes 1.17 atau 1.18, Anda harus Mengupgrade webhook sebelum mengupgrade ke Kubernetes 1.19.
Izin dan alat berikut.

Izin

Untuk membuat cluster dengan workload identity diaktifkan, Anda memerlukan izin berikut:

Google Cloud

Buat bucket Cloud Storage yang dapat dibaca publik dengan akses level bucket yang seragam diaktifkan.
Beri izin baca/tulis management-sa@PROJECT_NAME.iam.gserviceaccount.com ke bucket.

AWS

Membuat penyedia OIDC AWS
Membuat peran IAM AWS

Alat

Di komputer lokal, sebaiknya instal alat jq.

Membuat bucket penemuan OIDC

Bagian ini ditujukan bagi administrator cluster.

Cluster pengguna Anda perlu menyimpan data penemuan OIDC di bucket Cloud Storage yang dapat diakses secara publik. Bucket mencakup konfigurasi penemuan OIDC dan kunci publik. AWS menggunakan konten untuk mengautentikasi permintaan dari cluster pengguna Anda.

Bucket Anda harus memiliki atribut berikut:

Dapat dibaca oleh publik.
Mengaktifkan akses level bucket yang seragam.

Jika Anda tidak memiliki bucket dengan atribut ini, buat bucket menggunakan perintah gcloud storage berikut:

BUCKET=BUCKET_NAME
gcloud storage buckets create gs://${BUCKET} --uniform-bucket-level-access
gcloud storage buckets add-iam-policy-binding gs://${BUCKET} \
    --member=allUsers --role=roles/storage.objectViewer

Ganti BUCKET_NAME dengan nama bucket baru Anda.

Memberikan izin akun layanan pengelolaan

Akun layanan Identity and Access Management untuk layanan pengelolaan GKE di AWS memerlukan izin untuk membaca dan menulis objek ke dalam bucket ini.

Beri akun layanan pengelolaan Anda izin menggunakan perintah berikut.

MANAGEMENT_SA=management-sa@PROJECT_NAME.iam.gserviceaccount.com
gcloud storage buckets add-iam-policy-binding gs://${BUCKET} \
    --member=serviceAccount:${MANAGEMENT_SA} \
    --role=roles/storage.admin

Ganti PROJECT_NAME dengan Google Cloud project Anda.

Buat peran IAM baru dengan izin untuk mengelola bucket ini. Untuk membuat peran, simpan definisi peran ke file terlebih dahulu, lalu buat peran dan ikat peran ke akun layanan pengelolaan Anda.

Untuk menyelesaikan langkah-langkah ini, jalankan perintah berikut:

cat << EOF >  anthos-oidc-role.yaml
title: anthosAwsOidcStorageAdmin
description: permissions to manage the OIDC buckets
stage: GA
includedPermissions:
- storage.buckets.get
EOF

gcloud iam roles create anthosAwsOidcStorageAdmin --project=PROJECT_NAME \
  --file=anthos-oidc-role.yaml

gcloud projects add-iam-policy-binding \
  PROJECT_NAME \
  --member=serviceAccount:${MANAGEMENT_SA} \
  --role=projects/PROJECT_NAME/roles/anthosAwsOidcStorageAdmin

Ganti PROJECT_NAME dengan Google Cloud project Anda.

Google Cloud CLI mengonfirmasi bahwa binding kebijakan telah dibuat.

Membuat cluster pengguna

Bagian ini ditujukan bagi administrator cluster.

Membuat cluster pengguna dengan workload identity diaktifkan

Buat cluster pengguna yang berisi detail tentang bucket penemuan OIDC Anda. Anda menetapkan informasi ini di kolom spec.controlPlane.workloadIdentity.oidcDiscoveryGCSBucket AWSCluster.

Dalam contoh ini, Anda membuat cluster secara manual dari CRD AWSCluster dan AWSNodePool.

Beralih ke direktori dengan konfigurasi GKE di AWS. Anda membuat direktori ini saat Menginstal layanan pengelolaan.
```
cd anthos-aws
```
Dari direktori anthos-aws, gunakan anthos-gke untuk mengganti konteks ke layanan pengelolaan Anda.
```
cd anthos-aws
anthos-gke aws management get-credentials
```
Catatan: anthos-gke menggunakan kredensial yang Anda tentukan saat menjalankan aws configure.
Buka editor teks dan salin definisi AWSCluster berikut ke dalam file bernama custom-cluster.yaml.
```
apiVersion: multicloud.cluster.gke.io/v1
kind: AWSCluster
metadata:
  name: CLUSTER_NAME
spec:
  region: AWS_REGION
  networking:
    vpcID: VPC_ID
    podAddressCIDRBlocks: POD_ADDRESS_CIDR_BLOCKS
    serviceAddressCIDRBlocks: SERVICE_ADDRESS_CIDR_BLOCKS
    ServiceLoadBalancerSubnetIDs: SERVICE_LOAD_BALANCER_SUBNETS
  controlPlane:
    version:  CLUSTER_VERSION # Latest version is 1.25.5-gke.2100
    instanceType: AWS_INSTANCE_TYPE
    keyName: SSH_KEY_NAME
    subnetIDs:
    - CONTROL_PLANE_SUBNET_IDS
    securityGroupIDs:
    - CONTROL_PLANE_SECURITY_GROUPS
    iamInstanceProfile: CONTROL_PLANE_IAM_ROLE
    rootVolume:
      sizeGiB: ROOT_VOLUME_SIZE
      volumeType: ROOT_VOLUME_TYPE # Optional
      iops: ROOT_VOLUME_IOPS # Optional
      kmsKeyARN: ROOT_VOLUME_KEY # Optional
    etcd:
      mainVolume:
        sizeGiB: ETCD_VOLUME_SIZE
        volumeType: ETCD_VOLUME_TYPE # Optional
        iops: ETCD_VOLUME_IOPS # Optional
        kmsKeyARN: ETCD_VOLUME_KEY # Optional
    databaseEncryption:
      kmsKeyARN: ARN_OF_KMS_KEY
    hub: # Optional
      membershipName: ANTHOS_CONNECT_NAME
    cloudOperations: # Optional
      projectID: YOUR_PROJECT
      location: GCP_REGION
      enableLogging: ENABLE_LOGGING
      enableMonitoring: ENABLE_MONITORING
    workloadIdentity: # Optional
      oidcDiscoveryGCSBucket: WORKLOAD_IDENTITY_BUCKET
```
Ganti kode berikut:
- CLUSTER_NAME: nama cluster Anda.
- AWS_REGION: region AWS tempat cluster Anda berjalan.
  
  Catatan: Anda harus membuat cluster pengguna di region yang sama dengan layanan pengelolaan Anda.
- VPC_ID: ID VPC tempat cluster Anda berjalan.
- POD_ADDRESS_CIDR_BLOCKS: rentang alamat IPv4 yang digunakan oleh pod cluster. Saat ini, hanya satu rentang yang didukung. Rentang tidak boleh tumpang-tindih dengan subnet yang dapat dijangkau dari jaringan Anda. Anda dapat menggunakan rentang yang sama di beberapa objek AWSCluster yang berbeda. Contoh, 10.2.0.0/16.
- SERVICE_ADDRESS_CIDR_BLOCKS: rentang alamat IPv4 yang digunakan oleh layanan cluster. Saat ini, hanya satu rentang yang didukung. Rentang tidak boleh tumpang tindih dengan subnet yang dapat dijangkau dari jaringan Anda. Rentang yang sama dapat digunakan dengan aman di beberapa objek AWSCluster yang berbeda. Contoh, 10.1.0.0/16.
- SERVICE_LOAD_BALANCER_SUBNETS: ID subnet tempat GKE di AWS dapat membuat load balancer publik atau pribadi.
- CLUSTER_VERSION: a versi Kubernetes yang didukung oleh GKE di AWS. Versi terbaru adalah 1.25.5-gke.2100.
- AWS_INSTANCE_TYPE: jenis instance EC2 yang didukung.
- SSH_KEY_NAME: pasangan kunci AWS EC2.
- CONTROL_PLANE_SUBNET_IDS: ID subnet di AZ tempat instance bidang kontrol Anda berjalan.
- CONTROL_PLANE_SECURITY_GROUPS: securityGroupID yang dibuat selama penginstalan layanan pengelolaan. Anda dapat menyesuaikannya dengan menambahkan securityGroupIDs yang diperlukan untuk terhubung ke bidang kontrol.
- CONTROL_PLANE_IAM_PROFILE: nama profil instance AWS EC2 yang ditetapkan ke replika bidang kontrol.
- ROOT_VOLUME_SIZE: ukuran, dalam gibibyte (GiB), volume root bidang kontrol Anda.
- ROOT_VOLUME_TYPE dengan jenis volume EBS. Misalnya, gp3.
- ROOT_VOLUME_IOPS dengan jumlah operasi I/O yang disediakan per detik (IOPS) untuk volume. Hanya valid jika volumeType adalah GP3. Untuk mengetahui informasi selengkapnya, lihat Volume SSD Tujuan Umum (gp3).
- ROOT_VOLUME_KEY dengan Amazon Resource Name dari kunci AWS KMS yang mengenkripsi volume root instance bidang kontrol Anda.
- ETCD_VOLUME_SIZE: ukuran volume yang digunakan oleh etcd.
- ETCD_VOLUME_TYPE dengan jenis volume EBS. Misalnya, gp3.
- ETCD_VOLUME_IOPS dengan jumlah operasi I/O yang disediakan per detik (IOPS) untuk volume. Hanya valid jika volumeType adalah gp3. Untuk mengetahui informasi selengkapnya, lihat Volume SSD Tujuan Umum (gp3).
- ETCD_VOLUME_KEY dengan Amazon Resource Name dari kunci AWS KMS yang mengenkripsi volume data etcd bidang kontrol Anda.
- ARN_OF_KMS_KEY: kunci AWS KMS yang digunakan untuk mengenkripsi Secret cluster.
- ANTHOS_CONNECT_NAME: nama keanggotaan Connect yang digunakan untuk mendaftarkan cluster Anda. Nama keanggotaan harus unik. Misalnya, projects/YOUR_PROJECT/locations/global/memberships/CLUSTER_NAME, dengan YOUR_PROJECT adalah project Google Cloud Anda dan CLUSTER_NAME adalah nama unik di project Anda. Kolom ini bersifat opsional.
- YOUR_PROJECT: project ID Anda.
- GCP_REGION: region Google Cloud tempat Anda ingin menyimpan log. Pilih region yang dekat dengan region AWS. Untuk mengetahui informasi selengkapnya, lihat Lokasi Global - Region & Zona — misalnya, us-central1.
- ENABLE_LOGGING: true atau false, apakah Cloud Logging diaktifkan di node bidang kontrol.
- ENABLE_MONITORING: true atau false, apakah Cloud Monitoring diaktifkan di node bidang kontrol.
- WORKLOAD_IDENTITY_BUCKET: nama bucket Cloud Storage yang berisi informasi penemuan identitas beban kerja Anda. Kolom ini bersifat opsional.
Buat satu atau beberapa AWSNodePool untuk cluster Anda. Buka editor teks dan salin definisi AWSCluster berikut ke dalam file bernama custom-nodepools.yaml.
```
apiVersion: multicloud.cluster.gke.io/v1
kind: AWSNodePool
metadata:
  name: NODE_POOL_NAME
spec:
  clusterName: AWSCLUSTER_NAME
  version:  CLUSTER_VERSION # latest version is 1.25.5-gke.2100
  region: AWS_REGION
  subnetID: AWS_SUBNET_ID
  minNodeCount: MINIMUM_NODE_COUNT
  maxNodeCount: MAXIMUM_NODE_COUNT
  maxPodsPerNode: MAXIMUM_PODS_PER_NODE_COUNT
  instanceType: AWS_NODE_TYPE
  keyName: KMS_KEY_PAIR_NAME
  iamInstanceProfile: NODE_IAM_PROFILE
  proxySecretName: PROXY_SECRET_NAME
  rootVolume:
    sizeGiB: ROOT_VOLUME_SIZE
    volumeType: VOLUME_TYPE # Optional
    iops: IOPS # Optional
    kmsKeyARN: NODE_VOLUME_KEY # Optional 
```
Ganti kode berikut:
- NODE_POOL_NAME: nama unik untuk AWSNodePool Anda.
- AWSCLUSTER_NAME: nama AWSCluster Anda. Contoh, staging-cluster.
- CLUSTER_VERSION: versi Kubernetes GKE di AWS yang didukung.
- AWS_REGION: region AWS yang sama dengan AWSCluster Anda.
- AWS_SUBNET_ID: subnet AWS di region yang sama dengan AWSCluster Anda.
- MINIMUM_NODE_COUNT: jumlah minimum node dalam node pool. Lihat Menskalakan cluster pengguna untuk mengetahui informasi selengkapnya.
- MAXIMUM_NODE_COUNT: jumlah node maksimum dalam node pool.
- MAXIMUM_PODS_PER_NODE_COUNT: jumlah maksimum pod yang dapat dialokasikan GKE on AWS ke node.
- AWS_NODE_TYPE: jenis instance AWS EC2.
- KMS_KEY_PAIR_NAME: pasangan kunci AWS KMS yang ditetapkan ke setiap worker node pool.
- NODE_IAM_PROFILE: nama profil instance AWS EC2 yang ditetapkan ke node di pool.
- ROOT_VOLUME_SIZE: ukuran, dalam gibibyte (GiB), volume root bidang kontrol Anda.
- VOLUME_TYPE: jenis volume EBS AWS node. Misalnya, gp3.
- IOPS: jumlah operasi I/O yang disediakan per detik (IOPS) untuk volume. Hanya valid jika volumeType adalah gp3.
- NODE_VOLUME_KEY: ARN kunci AWS KMS yang digunakan untuk mengenkripsi volume. Untuk mengetahui informasi selengkapnya, lihat Menggunakan CMK yang dikelola pelanggan untuk mengenkripsi volume.

Terapkan manifes ke layanan pengelolaan Anda.

env HTTPS_PROXY=http://localhost:8118 \
  kubectl apply -f custom-cluster.yaml
env HTTPS_PROXY=http://localhost:8118 \
  kubectl apply -f custom-nodepools.yaml

Membuat kubeconfig

Saat cluster pengguna Anda dimulai, Anda dapat membuat konteks kubeconfig untuk cluster pengguna baru. Anda menggunakan konteks untuk mengautentikasi ke cluster pengguna atau pengelolaan.

Gunakan anthos-gke aws clusters get-credentials untuk membuat kubeconfig untuk cluster pengguna Anda di ~/.kube/config.
```
env HTTPS_PROXY=http://localhost:8118 \
  anthos-gke aws clusters get-credentials CLUSTER_NAME
```
Ganti CLUSTER_NAME dengan nama cluster Anda. Contoh, cluster-0.
Gunakan kubectl untuk melakukan autentikasi ke cluster pengguna baru Anda.
```
env HTTPS_PROXY=http://localhost:8118 \
  kubectl cluster-info
```
Jika cluster Anda sudah siap, output akan menyertakan URL untuk komponen Kubernetes dalam cluster Anda.

Melihat status cluster Anda

Layanan pengelolaan menyediakan resource AWS saat Anda menerapkan AWSCluster atau AWSNodePool.

Dari direktori anthos-aws, gunakan anthos-gke untuk mengganti konteks ke layanan pengelolaan Anda.
```
cd anthos-aws
anthos-gke aws management get-credentials
```
Catatan: anthos-gke menggunakan kredensial yang Anda tentukan saat menjalankan aws configure.

Untuk mencantumkan cluster, gunakan kubectl get AWSClusters.

env HTTPS_PROXY=http://localhost:8118 \
  kubectl get AWSClusters

Output mencakup nama, status, usia, versi, dan endpoint setiap cluster.

Misalnya, output berikut hanya menyertakan satu AWSCluster bernama cluster-0:

NAME        STATE          AGE     VERSION         ENDPOINT
cluster-0   Provisioning   2m41s   1.25.5-gke.2100   gke-xyz.elb.us-east-1.amazonaws.com

Melihat peristiwa cluster Anda

Untuk melihat Peristiwa Kubernetes terbaru dari cluster pengguna Anda, gunakan kubectl get events.

Dari direktori anthos-aws, gunakan anthos-gke untuk mengganti konteks ke layanan pengelolaan Anda.
```
cd anthos-aws
anthos-gke aws management get-credentials
```
Catatan: anthos-gke menggunakan kredensial yang Anda tentukan saat menjalankan aws configure.

Jalankan kubectl get events.

env HTTPS_PROXY=http://localhost:8118 \
  kubectl get events

Output mencakup informasi, peringatan, dan error terkait dari layanan pengelolaan Anda.

Membuat webhook identitas beban kerja

Bagian ini ditujukan bagi administrator cluster.

Untuk memberikan kredensial identitas beban kerja ke beban kerja Anda tanpa konfigurasi tambahan, Anda dapat secara opsional membuat webhook di cluster pengguna. Webhook ini mencegat permintaan pembuatan Pod, lalu menyediakan informasi AWS IAM berikut sebagai variabel lingkungan untuk Pod:

AWS_ROLE_ARN: Amazon Resource Name (ARN) peran IAM
aws-iam-token: token yang ditukar dengan kredensial AWS IAM
AWS_WEB_IDENTITY_TOKEN_FILE: jalur tempat token disimpan

Dengan variabel ini, workload Anda dapat memanggil alat command line AWS atau SDK dapat mengakses resource yang diberikan ke peran AWS.

Membuat webhook bersifat opsional. Jika memutuskan untuk tidak membuat webhook, Anda harus menyetel variabel lingkungan yang tercantum sebelumnya di Pod. Untuk informasi tentang cara tidak menggunakan webhook, lihat Menerapkan kredensial tanpa webhook.

Membuat file YAML untuk webhook

Untuk men-deploy webhook, lakukan langkah-langkah berikut:

Dari direktori anthos-aws, gunakan anthos-gke untuk mengganti konteks ke layanan pengelolaan Anda.
```
cd anthos-aws
anthos-gke aws management get-credentials
```
Catatan: anthos-gke menggunakan kredensial yang Anda tentukan saat menjalankan aws configure.
Dapatkan nama cluster pengguna dengan kubectl:
```
env HTTPS_PROXY=http://localhost:8118 \
  kubectl get awscluster
```
kubectl mencantumkan semua cluster pengguna Anda. Pilih cluster pengguna yang Anda buat dengan Workload Identity diaktifkan.
Tetapkan nama cluster dalam variabel lingkungan.
```
CLUSTER_NAME=CLUSTER_NAME
```
Ganti CLUSTER_NAME dengan nama cluster Anda. Contoh, cluster-0.

Tetapkan variabel lingkungan untuk image dan namespace Pod Workload Identity.

IDENTITY_IMAGE=amazon/amazon-eks-pod-identity-webhook:ed8c41f

WEBHOOK_NAMESPACE=workload-identity-webhook

Buat manifes YAML webhook dalam file bernama aws-webhook.yaml dengan melakukan langkah-langkah berikut:

env HTTPS_PROXY=http://localhost:8118 \
  anthos-gke aws clusters get-credentials ${CLUSTER_NAME}

CLUSTER_CA=$(env HTTPS_PROXY=http://localhost:8118 \
  kubectl config view --raw -o json  | jq -r '.clusters[] | select(.name == "'$(kubectl config current-context)'") | .cluster."certificate-authority-data"')

cat << EOF > aws-webhook.yaml
apiVersion: v1
kind: Namespace
metadata:
  name: ${WEBHOOK_NAMESPACE}
---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: pod-identity-webhook
  namespace: ${WEBHOOK_NAMESPACE}
---
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: pod-identity-webhook
  namespace: ${WEBHOOK_NAMESPACE}
rules:
  - apiGroups: ['']
    resources: ['secrets']
    verbs: ['create']
  - apiGroups: ['']
    resources: ['secrets']
    verbs: ['get', 'update', 'patch']
    resourceNames:
      - pod-identity-webhook
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: pod-identity-webhook
  namespace: ${WEBHOOK_NAMESPACE}
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: Role
  name: pod-identity-webhook
subjects:
  - kind: ServiceAccount
    name: pod-identity-webhook
    namespace: ${WEBHOOK_NAMESPACE}
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: pod-identity-webhook
rules:
  - apiGroups: ['']
    resources: ['serviceaccounts']
    verbs: ['get', 'watch',  'list']
  - apiGroups:  ['certificates.k8s.io']
    resources: ['certificatesigningrequests']
    verbs:  ['create', 'get', 'list', 'watch']
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: pod-identity-webhook
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: pod-identity-webhook
subjects:
  - kind: ServiceAccount
    name: pod-identity-webhook
    namespace: ${WEBHOOK_NAMESPACE}
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: pod-identity-webhook
  namespace: ${WEBHOOK_NAMESPACE}
spec:
  replicas: 1
  selector:
    matchLabels:
      app: pod-identity-webhook
  template:
    metadata:
      labels:
        app: pod-identity-webhook
    spec:
      serviceAccountName: pod-identity-webhook
      containers:
        - name: pod-identity-webhook
          image: ${IDENTITY_IMAGE}
          imagePullPolicy: Always
          command:
            - /webhook
            - --in-cluster
            - --namespace=${WEBHOOK_NAMESPACE}
            - --service-name=pod-identity-webhook
            - --tls-secret=pod-identity-webhook
            - --annotation-prefix=eks.amazonaws.com
            - --token-audience=sts.amazonaws.com
            - --logtostderr
          volumeMounts:
            - name: webhook-certs
              mountPath: /var/run/app/certs
              readOnly: false
      volumes:
        - name: webhook-certs
          emptyDir: {}
---
apiVersion: v1
kind: Service
metadata:
  name: pod-identity-webhook
  namespace: ${WEBHOOK_NAMESPACE}
  annotations:
    prometheus.io/port: '443'
    prometheus.io/scheme: https
    prometheus.io/scrape: 'true'
spec:
  ports:
    - port: 443
      targetPort: 443
  selector:
    app: pod-identity-webhook
---
apiVersion: admissionregistration.k8s.io/v1
kind: MutatingWebhookConfiguration
metadata:
  name: pod-identity-webhook
  namespace: ${WEBHOOK_NAMESPACE}
webhooks:
  - name: pod-identity-webhook.amazonaws.com
    failurePolicy: Ignore
    sideEffects: 'None'
    admissionReviewVersions: ['v1beta1']
    clientConfig:
      service:
        name: pod-identity-webhook
        namespace: ${WEBHOOK_NAMESPACE}
        path: /mutate
      caBundle: ${CLUSTER_CA}
    rules:
      - operations: ['CREATE']
        apiGroups: ['']
        apiVersions: ['v1']
        resources: ['pods']
EOF

Konten aws-webhook.yaml siap diterapkan ke cluster Anda.

Terapkan webhook ke cluster pengguna Anda

Untuk menerapkan webhook ke cluster pengguna, lakukan langkah-langkah berikut.

Terapkan file aws-webhook.yaml ke cluster pengguna Anda.

env HTTPS_PROXY=http://localhost:8118 \
  kubectl apply -f aws-webhook.yaml

Saat Anda menerapkan manifes, Pod webhook akan membuat permintaan penandatanganan sertifikat (CSR) Kubernetes. Setujui semua permintaan dari system:serviceaccount:${WEBHOOK_NAMESPACE}:pod-identity-webhook dengan kubectl certificate approve.

env HTTPS_PROXY=http://localhost:8118 \
  kubectl certificate approve $(env HTTPS_PROXY=http://localhost:8118 \ &&\
  kubectl get csr -o \
    jsonpath="{.items[?(@.spec.username==\"system:serviceaccount:${WEBHOOK_NAMESPACE}:pod-identity-webhook\")].metadata.name}")

Pastikan tidak ada CSR yang belum disetujui.

Gunakan kubectl get csr untuk memeriksa bahwa semua CSR dari pemohon system:serviceaccount:${WEBHOOK_NAMESPACE}:pod-identity-webhook disetujui:

env HTTPS_PROXY=http://localhost:8118 \
  kubectl get csr

Respons:

NAME        AGE   REQUESTOR                                            CONDITION
csr-mxrt8   10s   system:serviceaccount:default:pod-identity-webhook   Approved,Issued

Mengonfigurasi penyedia OIDC AWS

Bagian ini ditujukan bagi administrator cluster.

Untuk membuat penyedia OIDC di AWS, AWS memerlukan thumbprint sertifikat server atau Certificate Authority (CA) perantara. Kredensial penemuan OIDC Anda disimpan di storage.googleapis.com, dengan sertifikat yang ditandatangani oleh CA perantara bernama GTS CA 1C3. Ringkasan SHA-1 CA perantara GTS CA 1C3 adalah 08745487E891C19E3078C1F2A07E452950EF36F6.

Untuk mendaftarkan bucket penemuan OIDC Anda sebagai penyedia OIDC dengan AWS, lakukan langkah-langkah berikut:

Dari direktori anthos-aws, gunakan anthos-gke untuk mengganti konteks ke layanan pengelolaan Anda.
```
cd anthos-aws
anthos-gke aws management get-credentials
```
Catatan: anthos-gke menggunakan kredensial yang Anda tentukan saat menjalankan aws configure.

Simpan URL penerbit OIDC, jalur host penerbit, dan sidik jari Cloud Storage dalam variabel lingkungan.

ISSUER_URL=$(env HTTPS_PROXY=http://localhost:8118 \
  kubectl get awscluster ${CLUSTER_NAME} -o jsonpath='{.status.workloadIdentityInfo.issuerURL}')
ISSUER_HOSTPATH=${ISSUER_URL#"https://"}
CA_THUMBPRINT=08745487E891C19E3078C1F2A07E452950EF36F6

Gunakan alat command line aws untuk membuat penyedia OIDC di AWS.

aws iam create-open-id-connect-provider \
  --url ${ISSUER_URL} \
  --thumbprint-list ${CA_THUMBPRINT} \
  --client-id-list sts.amazonaws.com

Memperbarui thumbprint

Jika Google mengganti CA untuk storage.googleapis.com, jalankan perintah berikut:

Salin thumbprint sertifikat yang diperbarui, 08745487E891C19E3078C1F2A07E452950EF36F6.
Ikuti petunjuk untuk perintah aws iam update-open-id-connect-provider-thumbprint. Gunakan storage.googleapis.com sebagai nama host target dan 08745487E891C19E3078C1F2A07E452950EF36F6 sebagai sidik jari.

Membuat peran dan kebijakan AWS IAM

Bagian ini ditujukan bagi administrator cluster.

Buat peran IAM AWS untuk diikat ke akun layanan Kubernetes. Peran IAM memiliki izin untuk sts:AssumeRoleWithWebIdentity.

Untuk membuat peran, lakukan langkah-langkah berikut:

Temukan atau buat kebijakan IAM AWS yang memberikan izin yang diperlukan untuk beban kerja Anda.

Anda memerlukan Amazon Resource Name (ARN) kebijakan kebijakan IAM AWS. Contoh, arn:aws:iam::aws:policy/AmazonS3ReadOnlyAccess.
Tetapkan variabel lingkungan dengan informasi autentikasi Anda.
```
KSA_NAME=KUBERNETES_SERVICE_ACCOUNT
WORKLOAD_NAMESPACE=WORKLOAD_IDENTITY_NAMESPACE

AWS_ROLE_NAME=AWS_ROLE_NAME
AWS_POLICY=EXISTING_AWS_POLICY
```
Ganti kode berikut:
- KUBERNETES_SERVICE_ACCOUNT: nama akun layanan Kubernetes baru
- WORKLOAD_IDENTITY_NAMESPACE: nama namespace tempat workload berjalan
- AWS_ROLE_NAME: nama untuk peran AWS baru bagi beban kerja Anda
- EXISTING_AWS_POLICY: Amazon Resource Name (ARN) dari kebijakan AWS IAM yang ada Misalnya, arn:aws:iam::aws:policy/AmazonS3ReadOnlyAccess.
Dari direktori anthos-aws, gunakan anthos-gke untuk mengganti konteks ke layanan pengelolaan Anda.
```
cd anthos-aws
anthos-gke aws management get-credentials
```
Catatan: anthos-gke menggunakan kredensial yang Anda tentukan saat menjalankan aws configure.

Buat kebijakan AWS IAM yang memungkinkan cluster pengguna Anda mengambil kredensial keamanan sementara dengan AWS Security Token Service:

CLUSTER_ID=$(env HTTPS_PROXY=http://localhost:8118 \
  kubectl get awscluster ${CLUSTER_NAME} -o jsonpath='{.status.clusterID}')

# Get the ID Provider ARN
PROVIDER_ARN=$(aws iam list-open-id-connect-providers  \
| jq '.OpenIDConnectProviderList' \
| jq ".[] | select(.Arn |  contains(\"${CLUSTER_ID}\"))"   \
| jq  '.Arn' | tr -d '"')

# Create AWS role and policy
cat > irp-trust-policy.json << EOF
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Federated": "${PROVIDER_ARN}"
      },
      "Action": "sts:AssumeRoleWithWebIdentity",
      "Condition": {
        "StringEquals": {
          "${ISSUER_HOSTPATH}:sub": "system:serviceaccount:${WORKLOAD_NAMESPACE}:${KSA_NAME}"
        }
      }
    }
  ]
}
EOF

Untuk membuat peran IAM AWS dengan kebijakan ini dan melampirkan kebijakan yang ada ke peran tersebut, jalankan perintah berikut:

aws iam create-role \
  --role-name ${AWS_ROLE_NAME} \
  --assume-role-policy-document file://irp-trust-policy.json
aws iam update-assume-role-policy \
  --role-name ${AWS_ROLE_NAME} \
  --policy-document file://irp-trust-policy.json
aws iam attach-role-policy \
  --role-name ${AWS_ROLE_NAME} \
  --policy-arn ${AWS_POLICY}

Alat command line aws mengonfirmasi bahwa kebijakan dilampirkan ke peran Anda.

Membuat akun layanan Kubernetes untuk workload

Bagian ini ditujukan untuk developer atau administrator cluster.

Untuk membuat akun layanan Kubernetes yang terikat ke peran IAM AWS yang ditentukan sebelumnya, lakukan langkah-langkah berikut:

Dari direktori anthos-aws, gunakan anthos-gke untuk beralih konteks ke cluster pengguna Anda.
```
cd anthos-aws
env HTTPS_PROXY=http://localhost:8118 \
  anthos-gke aws clusters get-credentials CLUSTER_NAME
```
Ganti CLUSTER_NAME dengan nama cluster pengguna Anda.

Buat akun layanan Kubernetes dengan menjalankan perintah berikut:

S3_ROLE_ARN=$(aws iam get-role \
  --role-name AWS_ROLE_NAME \
  --query Role.Arn --output text)

cat << EOF  > k8s-service-account.yaml
apiVersion: v1
kind: ServiceAccount
metadata:
  name: ${KSA_NAME}
  namespace: WORKLOAD_IDENTITY_NAMESPACE
EOF

env HTTPS_PROXY=http://localhost:8118 \
kubectl apply -f k8s-service-account.yaml

env HTTPS_PROXY=http://localhost:8118 \
kubectl annotate sa --namespace ${WORKLOAD_NAMESPACE} ${KSA_NAME} eks.amazonaws.com/role-arn=${S3_ROLE_ARN}

Ganti kode berikut:

AWS_ROLE_NAME: nama peran IAM AWS yang akan diterapkan ke beban kerja Anda
WORKLOAD_IDENTITY_NAMESPACE: nama namespace tempat workload berjalan

Menerapkan kredensial ke Pod Anda

Bagian ini ditujukan untuk developer.

Bagian ini mengasumsikan bahwa Anda telah men-deploy webhook identitas workload. Jika Anda belum men-deploy webhook, lanjutkan ke Menerapkan kredensial tanpa webhook.

Menerapkan kredensial dengan webhook

Bagian ini menjelaskan cara mengonfigurasi Pod Anda untuk membaca kredensial yang disediakan oleh webhook.

Menambahkan akun layanan ke Pod

Untuk menggunakan workload identity dengan workload, tambahkan akun layanan Kubernetes ke kolom berikut:

Untuk Deployment: spec.template.spec.serviceAccountName
Untuk Pod: spec.serviceAccount

Manifes Pod berikut meluncurkan image CentOS dasar dan berisi kolom spec.serviceAccount.

apiVersion: v1
kind: Pod
metadata:
  name: sample-centos-pod
  namespace: WORKLOAD_IDENTITY_NAMESPACE
spec:
  containers:
  - command:
    - /bin/bash
    - -ec
    - while :; do echo '.'; sleep 500 ; done
    image: amazon/aws-cli
    name: centos
  serviceAccount: KUBERNETES_SERVICE_ACCOUNT

Ganti kode berikut:

WORKLOAD_IDENTITY_NAMESPACE: nama namespace tempat workload berjalan
KUBERNETES_SERVICE_ACCOUNT: nama akun layanan Kubernetes yang Anda buat sebelumnya

Periksa apakah Pod telah menyetel variabel lingkungan

Untuk memeriksa apakah Pod telah menetapkan variabel lingkungan, jalankan perintah berikut untuk mendapatkan informasi Pod:

kubectl get pod --namespace WORKLOAD_IDENTITY_NAMESPACE POD_NAME -o yaml

Ganti kode berikut:

WORKLOAD_IDENTITY_NAMESPACE: nama namespace tempat workload berjalan
POD_NAME: nama Pod yang akan diperiksa

Output berisi nilai variabel lingkungan di spec.containers.command.env dan titik pemasangan untuk token AWS IAM. Manifes Pod contoh berikut.

apiVersion: v1
kind: Pod
metadata:
  ...
spec:
  containers:
  - command:
    - /bin/bash
    - -ec
    - while :; do echo '.'; sleep 500 ; done
    env:
    - name: AWS_ROLE_ARN
      value: arn:aws:iam::1234567890:role/my-example-workload-role-1
    - name: AWS_WEB_IDENTITY_TOKEN_FILE
      value: /var/run/secrets/eks.amazonaws.com/serviceaccount/token
    image: amazon/aws-cli
    imagePullPolicy: IfNotPresent
    name: centos
    resources: {}
    terminationMessagePath: /dev/termination-log
    terminationMessagePolicy: File
    volumeMounts:
    - mountPath: /var/run/secrets/kubernetes.io/serviceaccount
      name: my-k8s-serviceaccount-token-d4nz4
      readOnly: true
    - mountPath: /var/run/secrets/eks.amazonaws.com/serviceaccount
      name: aws-iam-token
      readOnly: true
  serviceAccount: my-k8s-serviceaccount
  serviceAccountName: my-k8s-serviceaccount
  volumes:
  - name: aws-iam-token
    projected:
      defaultMode: 420
      sources:
      - serviceAccountToken:
          audience: sts.amazonaws.com
          expirationSeconds: 86400
          path: token
  - name: my-k8s-serviceaccount-token-d4nz4
    secret:
      defaultMode: 420
      secretName: my-k8s-serviceaccount-token-d4nz4
   ...
status:
  ...

Menerapkan kredensial tanpa webhook

Jika Anda tidak men-deploy webhook workload identity, Anda harus melakukan hal berikut:

Periksa apakah variabel lingkungan berikut telah ditetapkan:
- AWS_ROLE_ARN: Amazon Resource Name (ARN) peran IAM
- AWS_WEB_IDENTITY_TOKEN_FILE: jalur tempat token disimpan
Buat titik pemasangan untuk token IAM (aws-iam-token) dan akun layanan yang terkait dengan peran IAM AWS

Membuat Pod dengan kredensial untuk workload identity

Untuk membuat Pod yang menyertakan kredensial yang diperlukan untuk workload identity, lakukan langkah-langkah berikut:

Salin manifes Pod berikut ke dalam file bernama sample-pod-no-webhook.yaml. Konfigurasi meluncurkan image CentOS dasar dengan kredensial yang diperlukan.

apiVersion: v1
kind: Pod
metadata:
  name: sample-centos-pod-no-webhook
  namespace: WORKLOAD_IDENTITY_NAMESPACE
spec:
  containers:
  - command:
    - /bin/bash
    - -ec
    - while :; do echo '.'; sleep 500 ; done
    image: centos:7
    name: centos
    env:
    - name: AWS_ROLE_ARN
      value: IAM_ROLE_ARN
    - name: AWS_WEB_IDENTITY_TOKEN_FILE
      value: /var/run/secrets/eks.amazonaws.com/serviceaccount/token
    volumeMounts:
    - mountPath: /var/run/secrets/eks.amazonaws.com/serviceaccount
      name: aws-iam-token
      readOnly: true
  volumes:
  - name: aws-iam-token
    projected:
      defaultMode: 420
      sources:
      - serviceAccountToken:
          audience: sts.amazonaws.com
          expirationSeconds: 86400
          path: token
  serviceAccount: KUBERNETES_SERVICE_ACCOUNT

Ganti kode berikut:

WORKLOAD_IDENTITY_NAMESPACE: nama namespace tempat workload berjalan.
IAM_ROLE_ARN: ARN peran IAM yang diberikan ke Pod. Contoh, arn:aws:iam::aws:policy/AmazonS3ReadOnlyAccess.
KUBERNETES_SERVICE_ACCOUNT: nama akun layanan Kubernetes yang Anda buat sebelumnya.

Terapkan manifes Pod ke cluster Anda menggunakan kubectl:

env HTTPS_PROXY=http://localhost:8118 \
  kubectl apply -f sample-pod-no-webhook.yaml

Memeriksa apakah Pod dapat mengakses resource AWS

Prosedur berikut menjelaskan cara memeriksa apakah Pod telah menerima kredensial yang diperlukan agar identitas workload berfungsi.

Untuk menyelesaikan langkah-langkahnya, Anda harus memiliki hal berikut:

akses shell bashke container; sebagian besar image produksi tidak memiliki shell yang tersedia. Contoh berikut menunjukkan cara menggunakan Pod yang ditentukan di bagian sebelumnya untuk mengakses AWS S3.
Pod Anda harus memiliki akses keluar ke internet untuk mendownload antarmuka command line AWS.

Untuk memeriksa apakah Pod dapat mengakses bucket S3, lakukan langkah-langkah berikut:

Gunakan kubectl exec untuk meluncurkan shell bash interaktif di Pod sample-centos-pod-no-webhook:

env HTTPS_PROXY=http://localhost:8118 \
  kubectl exec -it --namespace ${WORKLOAD_NAMESPACE} sample-centos-pod-no-webhook -- bash

Terminal Anda akan membuka shell bash di Pod.

Periksa izin dan kredensial AWS IAM menggunakan alat aws:

aws sts assume-role-with-web-identity \
 --role-arn ${AWS_ROLE_ARN} \
 --role-session-name mh9test \
 --web-identity-token file:///var/run/secrets/eks.amazonaws.com/serviceaccount/token \
 --duration-seconds 1000

Alat aws mencetak informasi kredensial yang mirip dengan berikut ini:

{
    "AssumedRoleUser": {
        "AssumedRoleId": "AROAR2ZZZLEXVSDCDJ37N:mh9test",
        "Arn": "arn:aws:sts::126285863215:assumed-role/my-example-workload-role-1/mh9test"
    },
    "Audience": "sts.amazonaws.com",
    "Provider": "arn:aws:iam::126285863215:oidc-provider/storage.googleapis.com/gke-issuer-cec6c353",
    "SubjectFromWebIdentityToken": "system:serviceaccount:default:my-s3-reader-ksa",
    "Credentials": {
        "SecretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
        "SessionToken": "MY_TOKEN",
        "Expiration": "2020-08-14T22:46:36Z",
        "AccessKeyId": "AKIAIOSFODNN7EXAMPLE"
    }
}

Jika Anda melihat pesan berikut, periksa apakah bucket dapat diakses secara publik: An error occurred (InvalidIdentityToken) when calling the AssumeRoleWithWebIdentity operation: Couldn't retrieve verification key from your identity provider, please reference AssumeRoleWithWebIdentity documentation for requirements

Mengupgrade webhook

Jika Anda membuat cluster Kubernetes 1.18 atau yang lebih rendah dengan workload identity diaktifkan dan versi webhook workload identity release-0.2.2-gke.0, Anda harus mengupgrade webhook sebelum mengupgrade ke Kubernetes 1.19.

Untuk mengupgrade webhook, lakukan langkah-langkah berikut:

Konfirmasi webhook telah diinstal dengan menjalankan perintah berikut:
```
env HTTPS_PROXY=http://localhost:8118 \
  kubectl get MutatingWebhookConfiguration
```
Jika cluster Anda telah men-deploy webhook, output-nya akan mencakup hal berikut:
```
NAME                   WEBHOOKS   AGE
pod-identity-webhook   1          11m
```
Jika webhook tidak di-deploy di cluster Anda, Anda dapat melewati langkah-langkah berikut.

Jika Anda menyimpan file aws-webhook.yaml, Anda dapat menghapus manifes. Jika file ini tidak tersedia, Anda dapat menghapus komponen webhook secara manual. Pilih dari file atau komponen di bawah.

File

Jika Anda masih memiliki file aws-webhook.yaml, jalankan perintah berikut untuk menghapus webhook:

env HTTPS_PROXY=http://localhost:8118 \
  kubectl delete -f aws-webhook.yaml

Komponen

Untuk menghapus komponen webhook secara manual, jalankan perintah berikut:

env HTTPS_PROXY=http://localhost:8118 \
   kubectl delete namespace WEBHOOK_NAMESPACE
env HTTPS_PROXY=http://localhost:8118 \
   kubectl delete clusterrole pod-identity-webhook
env HTTPS_PROXY=http://localhost:8118 \
   kubectl delete clusterrolebinding pod-identity-webhook
env HTTPS_PROXY=http://localhost:8118 \
   kubectl delete mutatingwebhookconfiguration pod-identity-webhook

Ganti WEBHOOK_NAMESPACE dengan namespace tempat Anda menginstal webhook identitas beban kerja. Misalnya— workload-identity-webhook.

Periksa apakah Anda memiliki permintaan penandatanganan sertifikat (CSR) yang tersisa dengan menjalankan perintah berikut:
```
env HTTPS_PROXY=http://localhost:8118 \
  kubectl get csr |grep pod-identity-webhook
```
Jika outputnya kosong, lanjutkan ke langkah berikutnya. Jika masih ada CSR, perintah kubectl akan mencantumkan CSR yang ada. Untuk menghapus CSR, jalankan perintah berikut:
```
env HTTPS_PROXY=http://localhost:8118 \
  kubectl delete csr $(kubectl get csr -o \
  jsonpath="{.items[?(@.spec.username==\"system:serviceaccount:WEBHOOK_NAMESPACE:pod-identity-webhook\")].metadata.name}")
```
Ganti WEBHOOK_NAMESPACE dengan namespace tempat Anda menginstal webhook identitas beban kerja. Misalnya— workload-identity-webhook.
Ikuti langkah-langkah di Membuat webhook untuk men-deploy versi webhook baru.

Setelah men-deploy versi webhook baru, Anda perlu memulai ulang Pod yang menggunakan webhook. Anda dapat memulai ulang Pod dengan Mengupgrade cluster pengguna.

Pembersihan

Bagian ini menunjukkan cara menghapus resource yang Anda buat sebelumnya dalam dokumen ini.

Membersihkan akun layanan dan peran IAM terkait

Untuk menghapus akun layanan dan peran IAM terkait, lakukan langkah-langkah berikut:

Hapus akun layanan:
```
env HTTPS_PROXY=http://localhost:8118 \
  kubectl delete sa KUBERNETES_SERVICE_ACCOUNT --namespace WORKLOAD_IDENTITY_NAMESPACE
```
Ganti kode berikut:
- KUBERNETES_SERVICE_ACCOUNT: nama akun layanan Kubernetes baru
- WORKLOAD_IDENTITY_NAMESPACE: nama namespace tempat workload berjalan
Bersihkan peran IAM AWS. Pilih dari salah satu opsi berikut:
- Hapus peran IAM AWS dengan konsol AWS.
- Hapus peran dengan alat command line AWS menggunakan perintah berikut:
```
aws iam  detach-role-policy \
  --role-name=${AWS_ROLE_NAME} \
  --policy-arn=${AWS_POLICY}
aws iam delete-role --role-name=${AWS_ROLE_NAME}
```

Menghapus cluster pengguna

Untuk menghapus cluster pengguna, lakukan langkah-langkah di Menghapus GKE di AWS.

Membersihkan penyedia OIDC AWS

Setelah cluster pengguna dihapus, batalkan pendaftaran dan hapus penyedia OIDC di AWS menggunakan perintah shell bash berikut atau konsol AWS.

Dari direktori anthos-aws, gunakan anthos-gke untuk mengganti konteks ke layanan pengelolaan Anda.
```
cd anthos-aws
anthos-gke aws management get-credentials
```
Catatan: anthos-gke menggunakan kredensial yang Anda tentukan saat menjalankan aws configure.

Hapus peran dengan alat command line AWS menggunakan perintah berikut:

CLUSTER_ID=$(env HTTPS_PROXY=http://localhost:8118 \
  kubectl get awscluster ${CLUSTER_NAME} -o jsonpath='{.status.clusterID}')

PROVIDER_ARN=$(aws iam list-open-id-connect-providers  \
| jq '.OpenIDConnectProviderList' \
| jq ".[] | select(.Arn |  contains(\"${CLUSTER_ID}\"))"   \
| jq  '.Arn' | tr -d '"')

aws iam delete-open-id-connect-provider \
  --open-id-connect-provider-arn=${PROVIDER_ARN}

Anda akan menerima konfirmasi bahwa penyedia OIDC AWS telah dihapus.

Langkah berikutnya

Pelajari Peran IAM untuk Akun Layanan (IRSA) AWS, yang digunakan GKE di AWS untuk Workload Identity.
Pelajari Penggunaan workload identity dengan Google Cloud.

Menggunakan workload identity dengan AWS Tetap teratur dengan koleksi Simpan dan kategorikan konten berdasarkan preferensi Anda.

Ringkasan

Prasyarat

Izin

Alat

Membuat bucket penemuan OIDC

Memberikan izin akun layanan pengelolaan

Membuat cluster pengguna

Membuat cluster pengguna dengan workload identity diaktifkan

Membuat kubeconfig

Melihat status cluster Anda

Melihat peristiwa cluster Anda

Membuat webhook identitas beban kerja

Membuat file YAML untuk webhook

Terapkan webhook ke cluster pengguna Anda

Mengonfigurasi penyedia OIDC AWS

Memperbarui thumbprint

Membuat peran dan kebijakan AWS IAM

Membuat akun layanan Kubernetes untuk workload

Menerapkan kredensial ke Pod Anda

Menerapkan kredensial dengan webhook

Menambahkan akun layanan ke Pod

Periksa apakah Pod telah menyetel variabel lingkungan

Menerapkan kredensial tanpa webhook

Membuat Pod dengan kredensial untuk workload identity

Memeriksa apakah Pod dapat mengakses resource AWS

Mengupgrade webhook

File

Komponen

Pembersihan

Membersihkan akun layanan dan peran IAM terkait

Menghapus cluster pengguna

Membersihkan penyedia OIDC AWS

Langkah berikutnya

Menggunakan workload identity dengan AWS