Mengakses cluster Google Kubernetes Engine pribadi dari kumpulan pribadi Cloud Build menggunakan Identity Service untuk GKE

Membuat cluster GKE pribadi

1. Di Cloud Shell, buat cluster GKE yang tidak memiliki akses klien ke endpoint publik bidang kontrol, dan yang telah menginstal Identity Service untuk GKE:

   gcloud container clusters create CLUSTER  \
     --enable-identity-service \
     --enable-ip-alias \
     --enable-master-authorized-networks \
     --enable-private-endpoint \
     --enable-private-nodes \
     --master-ipv4-cidr CONTROL_PLANE_CIDR \
     --network NETWORK\
     --release-channel regular \
     --scopes cloud-platform \
     --subnetwork SUBNET \
     --tags NODE_TAGS \
     --workload-pool PROJECT_ID.svc.id.goog \
     --zone ZONE
   

   Ganti kode berikut:

   • CLUSTER: nama cluster. Untuk tutorial ini, gunakan private-cluster.
   • CONTROL_PLANE_CIDR: rentang alamat IP bidang kontrol. Harus memiliki awalan /28. Untuk tutorial ini, Anda dapat menggunakan 172.16.0.32/28.
   • NETWORK: jaringan VPC yang terhubung ke bidang kontrol. Untuk tutorial ini, gunakan default.
   • SUBNET: subnet yang terhubung ke bidang kontrol cluster GKE. Subnet harus menjadi bagian dari jaringan VPC yang ditentukan oleh NETWORK. Untuk tutorial ini, gunakan default.
   • NODE_TAGS: daftar tag jaringan yang dipisahkan koma untuk diterapkan ke node. Untuk tutorial ini, gunakan private-cluster-node.
   • PROJECT_ID: ID project Google Cloud Anda.
   • ZONE: zona untuk cluster GKE. Untuk tutorial ini, gunakan us-central1-f.

   Perhatikan hal-hal berikut tentang perintah ini:

   • Flag --enable-identity-service mengaktifkan Identity Service untuk GKE di cluster. Di lingkungan Anda sendiri, Anda dapat mengaktifkan Identity Service untuk GKE di cluster yang sudah ada.

   • Flag --enable-private-endpoint mengonfigurasi bidang kontrol agar dapat diakses hanya dengan menggunakan alamat IP internal.

   • Flag --enable-private-nodes mengonfigurasi node cluster agar hanya memiliki alamat IP internal.

   • Flag --enable-master-authorized-networks dan --enable-private-nodes mengizinkan akses ke server API hanya dari jaringan pribadi yang ditentukan oleh flag --network.

   • Flag --workload-pool opsional mengaktifkan Workload Identity Federation for GKE. Hal ini tidak diperlukan untuk tutorial ini.

2. Tambahkan aturan firewall yang memungkinkan bidang kontrol cluster GKE terhubung ke webhook penerimaan validasi untuk resource ClientConfig:

   gcloud compute firewall-rules create allow-control-plane-clientconfig-webhook \
     --allow tcp:15000 \
     --network NETWORK\
     --source-ranges CONTROL_PLANE_CIDR\
     --target-tags NODE_TAGS
   

   ClientConfig adalah jenis resource kustom (CRD) Kubernetes yang digunakan Identity Service untuk GKE guna mengonfigurasi cara berinteraksi dengan penyedia identitas.

Mendaftarkan Identity Service untuk GKE sebagai aplikasi klien OAuth 2.0

Di bagian ini, Anda akan mendaftarkan Layanan Identitas untuk GKE sebagai aplikasi klien menggunakan sistem autentikasi OAuth 2.0 Google.

1. Buka halaman Credentials di Google Cloud console.

   Buka halaman Credentials

2. Klik Buat Kredensial.

3. Pilih OAuth Client ID.

   Jika layar izin belum dikonfigurasi untuk project Google Cloud, klik Configure consent screen. Ikuti dokumentasi tentang mengonfigurasi layar izin. Untuk tutorial ini, tetapkan nilai berikut:

   • Jenis Pengguna dapat berupa Internal atau Eksternal. Untuk tutorial ini, Anda dapat memilih Internal.
   • Nilai untuk Nama aplikasi, Email dukungan pengguna, dan Informasi kontak developer wajib diisi dan dapat berupa nilai apa pun.
   • Anda tidak perlu menambahkan cakupan apa pun untuk tutorial ini.

   Setelah selesai mengonfigurasi layar izin, klik Kembali ke dasbor, lalu mulai lagi dari langkah 1 prosedur saat ini.

4. Pada daftar Application type, pilih Web application.

5. Di kolom Name, masukkan nama untuk ID klien. Untuk tutorial ini, gunakan Identity Service for GKE.

6. Klik Buat.

   Dialog akan muncul. Salin nilai Client ID Anda; Anda akan memerlukannya nanti dalam prosedur ini.

7. Klik OK untuk menutup kotak dialog.

8. Di Cloud Shell, buat direktori di bawah direktori beranda Anda yang bernama cloud-build-private-pools-gke-tutorial, lalu buka direktori tersebut:

   mkdir -p ~/cloud-build-private-pools-gke-tutorial cd ~/cloud-build-private-pools-gke-tutorial

9. Di direktori baru, buat file YAML bernama client-config-patch.yaml yang memiliki nilai yang Anda perlukan nanti untuk menambal resource Identity Service for GKE ClientConfig:

   cat << EOF > client-config-patch.yaml
   spec:
     authentication:
     - name: google-oidc
       oidc:
         clientID: CLIENT_ID
         cloudConsoleRedirectURI: https://console.cloud.google.com/kubernetes/oidc
         extraParams: prompt=consent,access_type=offline
         issuerURI: https://accounts.google.com
         kubectlRedirectURI: http://localhost:10000/callback
         scopes: email
         userClaim: email
         userPrefix: '-'
   EOF
   

   Ganti CLIENT_ID dengan client ID OAuth dari langkah sebelumnya.

   Perhatikan hal-hal berikut tentang patch:

   • Token ID yang dikeluarkan oleh sistem autentikasi OAuth 2.0 Google berisi ID numerik unik dalam klaim sub (subjek). Penggunaan ID buram ini dalam binding peran akan mempersulit identifikasi subjek binding peran. Oleh karena itu, patch ini mengonfigurasi Identity Service untuk GKE agar menggunakan klaim email dari token ID untuk mengidentifikasi pengguna, bukan menggunakan klaim sub default.

   • Cakupan email ditambahkan sehingga token ID yang dikeluarkan menyertakan klaim email.

   • Kolom cloudConsoleRedirectURI, extraParams, kubectlRedirectURI, dan cakupan digunakan saat developer melakukan autentikasi ke cluster menggunakan Identity Service untuk GKE. Kredensial ini tidak digunakan saat akun layanan Google melakukan autentikasi ke cluster. Kolom kubectlRedirectURI wajib diisi.

   • Kolom userPrefix adalah awalan untuk pengguna yang melakukan autentikasi menggunakan penyedia identitas yang dikonfigurasi. Nilai '-' berarti tidak ada awalan.

   • Kolom spec.authentication adalah array. Anda dapat menggunakan beberapa penyedia identitas OpenID Connect dengan Identity Service untuk GKE. Misalnya, Anda dapat menggunakan Google sebagai penyedia identitas untuk mengautentikasi akun layanan Google, dan penyedia identitas lain untuk mengautentikasi developer.

   Untuk mengetahui informasi selengkapnya tentang kolom dalam konfigurasi ini, lihat Menggunakan penyedia identitas eksternal untuk melakukan autentikasi ke GKE.

Buat akun layanan Google untuk mengonfigurasi Identity Service untuk GKE

1. Di Cloud Shell, buat akun layanan Google:

   gcloud iam service-accounts create ISG_GSA \
     --display-name "Configure Identity Service for GKE"
   

   Ganti ISG_GSA dengan nama yang ingin Anda gunakan untuk akun layanan Google. Untuk tutorial ini, gunakan identity-service-for-gke.

   Anda menetapkan akun layanan Google ini ke instance VM Compute Engine untuk mengonfigurasi Identity Service untuk GKE dan kontrol akses berbasis peran Kubernetes di cluster.

2. Berikan peran Admin Kubernetes Engine di project ke akun layanan Google:

   gcloud projects add-iam-policy-binding PROJECT_ID \
     --member serviceAccount:ISG_GSA@PROJECT_ID.iam.gserviceaccount.com \
     --role roles/container.admin
   

   Peran ini memberikan izin yang diperlukan untuk melakukan tugas berikut dalam tutorial ini:

   • Mengonfigurasi setelan Identity Service untuk GKE di cluster dalam project.
   • Buat binding peran dan binding peran cluster di cluster.

Mengonfigurasi Identity Service untuk GKE

Untuk mengonfigurasi Identity Service untuk GKE, Anda harus memiliki akses ke bidang kontrol cluster. Dalam tutorial ini, Anda akan membuat instance VM Compute Engine untuk mengakses bidang kontrol.

Anda memerlukan akses SSH ke instance VM. Untuk mengaktifkan akses SSH yang diautentikasi dan diberi otorisasi dari luar jaringan VPC ke instance VM, Anda menggunakan penerusan TCP dengan Identity-Aware Proxy (IAP). Fitur ini memungkinkan akses SSH tanpa mengharuskan instance VM memiliki alamat IP publik.

1. Di Cloud Shell, buat aturan firewall yang mengizinkan akses SSH menggunakan penerusan TCP IAP ke instance VM mana pun yang memiliki tag jaringan ssh-iap:

   gcloud compute firewall-rules create allow-ssh-ingress-from-iap \
     --allow tcp:22 \
     --description "Allow SSH tunneling using Identity-Aware Proxy" \
     --network NETWORK \
     --source-ranges 35.235.240.0/20 \
     --target-tags ssh-iap
   

   Rentang sumber berisi alamat IP yang digunakan IAP untuk penerusan TCP.

2. Buat instance VM Compute Engine di jaringan VPC yang sama dengan cluster GKE:

   gcloud compute instances create VM \
     --metadata enable-oslogin=TRUE \
     --network NETWORK \
     --no-address \
     --scopes cloud-platform,userinfo-email \
     --service-account ISG_GSA@PROJECT_ID.iam.gserviceaccount.com \
     --subnet SUBNET  \
     --tags ssh-iap \
     --zone ZONE
   

   Ganti VM dengan nama yang ingin Anda gunakan untuk instance VM. Untuk tutorial ini, gunakan identity-service-for-gke-configuration.

   Perhatikan hal-hal berikut tentang perintah di atas:

   • Flag --service-account melampirkan akun layanan Google ke instance VM.

   • Cakupan cloud-platform diperlukan untuk mengakses Service Account Credentials API.

   • Cakupan userinfo-email berguna saat membuat instance VM untuk mengelola kontrol akses berbasis peran Kubernetes. Opsi ini bersifat opsional untuk tutorial ini.

   • Flag --no-address berarti instance VM dibuat tanpa alamat IP eksternal.

   • Nilai metadata instance enable-oslogin opsional mengaktifkan Login OS di instance VM. Login OS memungkinkan pengelolaan akses SSH ke instance VM menggunakan IAM.

3. Salin file patch ClientConfig ke instance VM:

   gcloud compute scp client-config-patch.yaml VM:~ --tunnel-through-iap --zone ZONE
   

   Flag --tunnel-through-iap menginstruksikan gcloud untuk membuat tunnel koneksi melalui IAP.

4. Hubungkan ke instance VM menggunakan SSH:

   gcloud compute ssh VM --tunnel-through-iap --zone ZONE
   

   Anda akan menjalankan perintah lainnya di bagian ini dari sesi SSH.

5. Instal alat command line kubectl dan biner gke-gcloud-auth-plugin di instance VM:

   sudo apt-get install -y kubectl google-cloud-sdk-gke-gcloud-auth-plugin
   

6. Ambil kredensial untuk cluster GKE:

   export USE_GKE_GCLOUD_AUTH_PLUGIN=True
   gcloud container clusters get-credentials CLUSTER --zone ZONE
   

7. Patch resource ClientConfig default:

   kubectl patch clientconfig default \
       --namespace kube-public \
       --patch-file client-config-patch.yaml \
       --type merge
   

8. Ekstrak kolom certificateAuthorityData dari resource ClientConfig default yang di-patch dan simpan dalam file bernama certificateAuthorityData.pem:

   kubectl get clientconfig default \
        --namespace kube-public \
        --output jsonpath='{.spec.certificateAuthorityData}' \
        | base64 --decode > certificateAuthorityData.pem
   

9. Ekstrak kolom server dari resource ClientConfig default yang di-patch dan simpan di file bernama server.txt:

   kubectl get clientconfig default \
        --namespace kube-public \
        --output jsonpath='{.spec.server}' > server.txt
   

10. Keluar dari sesi SSH:

    exit
    

(Opsional) Verifikasi konfigurasi cluster

Sebelum melanjutkan, Anda dapat memverifikasi bahwa Identity Service untuk GKE telah disiapkan dengan benar di cluster. Anda memverifikasi penyiapan dengan menggunakan akun layanan Google yang terlampir ke instance VM untuk melakukan autentikasi ke cluster menggunakan Identity Service untuk GKE.

1. Di Cloud Shell, berikan peran Service Account OpenID Connect Identity Token Creator di akun layanan Google ke akun layanan itu sendiri:

   gcloud iam service-accounts add-iam-policy-binding \
     ISG_GSA@PROJECT_ID.iam.gserviceaccount.com \
     --member serviceAccount:ISG_GSA@PROJECT_ID.iam.gserviceaccount.com \
     --role roles/iam.serviceAccountOpenIdTokenCreator
   

   Peran ini memberikan izin iam.serviceAccounts.getOpenIdToken yang diperlukan untuk meminta token ID bagi akun layanan dari Service Account Credentials API.

2. Hubungkan ke instance VM menggunakan SSH:

   gcloud compute ssh VM --tunnel-through-iap --zone ZONE
   

   Anda akan menjalankan perintah lainnya di bagian ini dari sesi SSH.

3. Minta token akses OAuth 2.0 dari server metadata untuk akun layanan Google yang terlampir ke instance VM, menggunakan ID klien OAuth sebagai klaim aud (audiens) yang diminta:

   ACCESS_TOKEN=$(curl --silent --header "Metadata-Flavor: Google" \
   http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/token \
          | python3 -c 'import json, sys; print(json.load(sys.stdin).get("access_token"))')
   

   Isi respons dari server metadata adalah dokumen JSON. Perintah ini menggunakan skrip Python inline untuk mengekstrak kolom access_token dari isi respons.

4. Minta token ID dari Service Account Credentials API untuk akun layanan Google yang terpasang ke instance VM:

   ID_TOKEN=$(curl --silent --request POST \
       --data '{"audience": "CLIENT_ID", "includeEmail": true}' \
       --header "Authorization: Bearer $ACCESS_TOKEN" \
       --header "Content-Type: application/json; charset=utf-8" \
   "https://iamcredentials.googleapis.com/v1/projects/-/serviceAccounts/ISG_GSA@PROJECT_ID.iam.gserviceaccount.com:generateIdToken" \
          | python3 -c 'import json, sys; print(json.load(sys.stdin).get("token"))')
   

   Perhatikan hal-hal berikut tentang perintah di atas:

   • Kolom audience dalam JSON isi permintaan menentukan klaim aud (audiens) yang diminta dari token ID.
   • Token akses dari langkah sebelumnya digunakan untuk mengautentikasi API.

5. Melihat klaim dalam token ID:

   echo $ID_TOKEN \
       | cut -d. -f2 \
       | base64 --decode --ignore-garbage 2> /dev/null \
       | python3 -m json.tool
   

   Pastikan bahwa klaim email berisi alamat email akun layanan Google.

6. Gunakan token ID untuk melakukan autentikasi ke bidang kontrol menggunakan Identity Service untuk GKE:

   kubectl get namespaces \
       --certificate-authority certificateAuthorityData.pem \
       --server $(cat server.txt) \
       --token $ID_TOKEN
   

   Outputnya akan terlihat seperti berikut:

     Error from server (Forbidden): namespaces is forbidden: User "ISG_GSA@PROJECT_ID.iam.gserviceaccount.com" cannot list resource "namespaces" in API group "" at the cluster scope
   

   Error ini wajar terjadi. Meskipun akun layanan Google diberi izin IAM di cluster GKE dalam project, izin IAM tidak berlaku saat Anda melakukan autentikasi menggunakan Identity Service untuk GKE. Sebagai gantinya, Anda mengonfigurasi akses menggunakan kontrol akses berbasis peran (RBAC) Kubernetes.

7. Buat binding peran cluster yang memberikan peran cluster view ke akun layanan Google saat akun layanan melakukan autentikasi ke cluster menggunakan penyedia OpenID Connect Google:

   kubectl create clusterrolebinding ISG_GSA-cluster-view \
       --clusterrole view \
       --user ISG_GSA@PROJECT_ID.iam.gserviceaccount.com
   

   Jika Anda menetapkan nilai userPrefix selain - di ClientConfig di lingkungan Anda sendiri, tambahkan awalan ke nilai flag --user dalam perintah ini.

8. Akses cluster GKE menggunakan Identity Service untuk GKE:

   kubectl get namespaces \
       --certificate-authority certificateAuthorityData.pem \
       --server $(cat server.txt) \
       --token $ID_TOKEN
   

   Outputnya akan terlihat seperti berikut:

   NAME                      STATUS   AGE
   anthos-identity-service   Active   1h
   default                   Active   1h
   kube-node-lease           Active   1h
   kube-public               Active   1h
   kube-system               Active   1h
   

9. Keluar dari sesi SSH:

   exit
   

Membuat konteks untuk alat kubectl

Perintah kubectl dapat menggunakan file kubeconfig untuk mengonfigurasi akses ke cluster. File kubeconfig berisi satu atau beberapa konteks. Setiap konteks memiliki nama, dan secara opsional mencakup informasi konektivitas cluster, kredensial yang digunakan untuk mengautentikasi ke cluster, dan namespace default.

Di bagian ini, Anda akan membuat file kubeconfig yang memiliki konteks. Konteks mencakup detail konektivitas proxy Identity Service untuk GKE bagi cluster Anda. Anda tidak menambahkan kredensial pengguna ke file kubeconfig.

1. Di Cloud Shell, salin file yang berisi data otoritas sertifikat dan URL server dari instance VM ke direktori saat ini:

   gcloud compute scp VM:~/certificateAuthorityData.pem VM:~/server.txt . \
       --tunnel-through-iap --zone ZONE
   

2. Buat konteks dan konfigurasi cluster yang akan Anda gunakan nanti untuk terhubung ke cluster GKE dari Cloud Build:

   kubectl config set-context private-cluster \
       --cluster private-cluster \
       --kubeconfig kubeconfig
   

   Flag --kubeconfig membuat konfigurasi konteks dan cluster dalam file baru bernama kubeconfig di direktori saat ini.

   Perintah ini menggunakan nama cluster GKE sebagai nama konfigurasi cluster untuk konteks. Di lingkungan Anda sendiri, Anda dapat menggunakan nama konfigurasi cluster yang berbeda dalam konteks.

3. Tetapkan kolom certificateAuthorityData pada konfigurasi cluster:

   kubectl config set-cluster private-cluster \
       --certificate-authority certificateAuthorityData.pem \
       --embed-certs \
       --kubeconfig kubeconfig
   

4. Tetapkan kolom server pada konfigurasi cluster:

   kubectl config set-cluster private-cluster \
       --kubeconfig kubeconfig \
       --server $(cat server.txt)
   

Buat akun layanan Google untuk Cloud Build

1. Di Cloud Shell, buat akun layanan Google untuk menjalankan build di kumpulan pribadi Cloud Build:

   gcloud iam service-accounts create CB_GSA \
     --description "Runs builds on Cloud Build private pools" \
     --display-name "Cloud Build private pool"
   

   Ganti CB_GSA dengan nama yang ingin Anda gunakan untuk akun layanan Google. Untuk tutorial ini, gunakan cloud-build-private-pool.

2. Berikan peran Akun Layanan Cloud Build di project ke akun layanan Google:

   gcloud projects add-iam-policy-binding PROJECT_ID \
       --member serviceAccount:CB_GSA@PROJECT_ID.iam.gserviceaccount.com \
       --role roles/cloudbuild.builds.builder
   

   Peran ini memberikan izin default akun layanan Cloud Build yang dikelola Google.

3. Berikan Service Account OpenID Connect Identity Token Creator di akun layanan Google ke akun layanan itu sendiri:

   gcloud iam service-accounts add-iam-policy-binding \
       CB_GSA@PROJECT_ID.iam.gserviceaccount.com \
       --member serviceAccount:CB_GSA@PROJECT_ID.iam.gserviceaccount.com \
       --role roles/iam.serviceAccountOpenIdTokenCreator
   

   Peran ini memberikan izin iam.serviceAccounts.getOpenIdToken yang diperlukan untuk meminta token ID bagi akun layanan dari Service Account Credentials API.

4. Hubungkan ke instance VM menggunakan SSH:

   gcloud compute ssh VM --tunnel-through-iap --zone ZONE
   

   Anda akan menjalankan perintah lainnya di bagian ini dari sesi SSH.

5. Dalam sesi SSH, buat binding peran cluster Kubernetes yang memberikan peran cluster cluster-admin ke akun layanan Google saat akun layanan melakukan autentikasi ke cluster menggunakan penyedia OpenID Connect Google:

   kubectl create clusterrolebinding CB_GSA-cluster-admin \
       --clusterrole cluster-admin \
       --user CB_GSA@PROJECT_ID.iam.gserviceaccount.com
   

   Peran cluster cluster-admin memberikan izin luas di seluruh cluster. Di lingkungan Anda sendiri, Anda dapat menggunakan peran cluster yang hanya memberikan izin yang diperlukan untuk tugas yang dilakukan Cloud Build. Anda juga dapat menggunakan binding peran untuk memberikan izin hanya ke namespace tertentu.

   Jika Anda menetapkan userPrefix di ClientConfig di lingkungan Anda sendiri, Anda harus menambahkan awalan tersebut ke nilai flag --user dalam perintah ini.

6. Keluar dari sesi SSH:

   exit
   

Membuat kumpulan pribadi Cloud Build

1. Di Cloud Shell, alokasikan rentang alamat IP di jaringan VPC Anda untuk koneksi dengan kumpulan pribadi:

   gcloud compute addresses create RESERVED_RANGE_NAME \
   --addresses RESERVED_RANGE_START_IP\
       --description "Cloud Build private pool reserved range" \
       --global \
       --network NETWORK \
       --prefix-length RESERVED_RANGE_PREFIX_LENGTH \
       --purpose VPC_PEERING
   

   Ganti kode berikut:

   • RESERVED_RANGE_NAME: nama rentang alamat IP yang dialokasikan yang menghosting pool pribadi Cloud Build. Untuk tutorial ini, gunakan cloud-build-private-pool.
   • RESERVED_RANGE_START_IP: alamat IP pertama dari rentang alamat IP yang dialokasikan. Untuk tutorial ini, gunakan 192.168.12.0.
   • RESERVED_RANGE_PREFIX_LENGTH: panjang awalan (subnet mask) rentang alamat IP yang dialokasikan. Panjang awalan harus /23 atau lebih rendah, misalnya /22 atau /21. Angka yang lebih rendah berarti rentang alamat yang lebih besar. Untuk tutorial ini, gunakan 23, dan jangan masukkan / (garis miring) di depannya.

2. Buat aturan firewall untuk mengizinkan traffic masuk dari rentang alamat IP yang dicadangkan ke resource lain di jaringan VPC Anda:

   gcloud compute firewall-rules create allow-private-pools-ingress \
       --allow all \
       --network NETWORK \
       --source-ranges RESERVED_RANGE_START_IP/RESERVED_RANGE_PREFIX_LENGTH
   

3. Buat koneksi layanan pribadi untuk menghubungkan jaringan VPC Anda ke layanan Service Networking:

   gcloud services vpc-peerings connect \
       --network NETWORK \
       --ranges RESERVED_RANGE_NAME \
       --service servicenetworking.googleapis.com
   

   Kumpulan pribadi Cloud Build menjalankan pekerja menggunakan Service Networking. Koneksi layanan pribadi memungkinkan jaringan VPC Anda berkomunikasi dengan kumpulan pribadi pada rentang alamat IP internal yang dialokasikan, menggunakan koneksi Peering Jaringan VPC.

   Diperlukan waktu beberapa menit untuk membuat koneksi layanan pribadi.

   Jika Anda menggunakan VPC Bersama di lingkungan Anda sendiri, untuk mengetahui informasi tentang langkah-langkah tambahan untuk membuat koneksi layanan pribadi, lihat Menyiapkan lingkungan Anda.

4. Buat kumpulan pribadi Cloud Build di jaringan VPC milik Google yang di-peering dengan jaringan VPC Anda:

   gcloud builds worker-pools create PRIVATE_POOL_NAME \
      --no-public-egress \
      --peered-network projects/PROJECT_ID/global/networks/NETWORK \
      --region REGION
   

   Ganti kode berikut:

   • PRIVATE_POOL_NAME: nama pool pribadi. Untuk tutorial ini, gunakan private-pool.
   • REGION: region yang akan digunakan untuk pool pribadi. Untuk tutorial ini, gunakan us-central1.

   Flag --no-public-egress berarti bahwa worker di pool pribadi tidak memiliki alamat IP publik. Di lingkungan Anda sendiri, Anda dapat menghapus tanda ini jika ingin pekerja di kumpulan pribadi memiliki konektivitas internet menggunakan alamat IP publik.

   Untuk mengetahui informasi tentang opsi konfigurasi tambahan, seperti jenis mesin dan ukuran disk untuk pekerja di pool pribadi, lihat Membuat dan mengelola pool pribadi.

Memverifikasi solusi

Di bagian ini, Anda akan memverifikasi solusi dengan menjalankan build di kumpulan pribadi Cloud Build. Build mengakses cluster GKE pribadi.

1. Di Cloud Shell, buat bucket Cloud Storage untuk menyimpan log build dari Cloud Build:

   gcloud storage buckets create gs://PROJECT_ID-build-logs --location=REGION
   

2. Buat file konfigurasi build untuk Cloud Build:

   cat << "EOF" > cloudbuild.yaml
   steps:
   - id: list-services
     name: gcr.io/google.com/cloudsdktool/google-cloud-cli
     entrypoint: bash
     args:
     - -eEuo
     - pipefail
     - -c
     - |-
       kubectl config use-context $_KUBECTL_CONTEXT
   
       ACCESS_TOKEN=$$(curl --silent \
           --header "Metadata-Flavor: Google" \
           http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/token \
           | python3 -c 'import json, sys; print(json.load(sys.stdin).get("access_token"))')
   
       ID_TOKEN=$$(curl --silent --request POST \
           --data '{"audience": "CLIENT_ID", "includeEmail": true}' \
           --header "Authorization: Bearer $$ACCESS_TOKEN" \
           --header "Content-Type: application/json; charset=utf-8" \
           "https://iamcredentials.googleapis.com/v1/projects/-/serviceAccounts/$_SERVICE_ACCOUNT:generateIdToken" \
           | python3 -c 'import json, sys; print(json.load(sys.stdin).get("token"))')
   
       kubectl get services --namespace $_NAMESPACE --token $$ID_TOKEN
   
   logsBucket: gs://PROJECT_ID-build-logs
   
   options:
     env:
     - KUBECONFIG=/workspace/$_KUBECONFIG
   
   substitutions:
     _KUBECONFIG: kubeconfig
     _KUBECTL_CONTEXT: private-cluster
     _NAMESPACE: default
   
   serviceAccount: projects/$PROJECT_ID/serviceAccounts/$_SERVICE_ACCOUNT
   EOF
   

   Langkah dalam file konfigurasi build melakukan hal berikut:

   1. Beralih ke konteks kubectl yang ditentukan oleh penggantian _KUBECTL_CONTEXT. Nilai penggantian default adalah private-cluster.

   2. Mengambil token akses dari server metadata. Token akses dikeluarkan untuk akun layanan Google yang menjalankan build.

   3. Membuat token ID menggunakan Service Account Credentials API. Permintaan untuk membuat token ID diautentikasi menggunakan token akses. Klaim aud (audiens) yang diminta dari token ID adalah client ID OAuth 2.0 yang ditentukan oleh penggantian _CLIENT_ID.

   4. Mencantumkan layanan Kubernetes dalam namespace yang ditentukan oleh penggantian _NAMESPACE. Nilai penggantian default adalah default. Permintaan diautentikasi menggunakan token ID yang dibuat pada perintah sebelumnya.

   Perhatikan hal berikut tentang file konfigurasi build:

   • Karakter $ adalah awalan untuk penggantian. $$ digunakan untuk ekspansi parameter bash dan substitusi perintah.

   • Substitusi _KUBECONFIG dan _KUBECTL_CONTEXT memungkinkan file kubeconfig dan konteks yang berbeda ditentukan saat Anda menjalankan build. Substitusi ini memungkinkan Anda mengelola beberapa konfigurasi cluster dengan menggunakan satu file kubeconfig dengan beberapa konteks, atau dengan menggunakan beberapa file kubeconfig.

   • Penggantian _SERVICE_ACCOUNT tidak memiliki nilai default. Anda harus memberikan nilai untuk penggantian ini saat menjalankan build.

   • Blok options menetapkan variabel lingkungan KUBECONFIG untuk semua langkah dalam build.

   • Langkah build menggunakan image builder gcr.io/google.com/cloudsdktool/google-cloud-cli. Ini adalah image container besar, dan perlu waktu beberapa saat untuk menariknya dari registry ke pekerja kumpulan pribadi. Untuk mengurangi waktu yang diperlukan untuk menarik image builder, Anda dapat membuat image builder kustom yang hanya berisi alat yang diperlukan untuk langkah build, seperti curl, kubectl, dan Python.

   Untuk mengetahui informasi selengkapnya tentang skrip shell inline dalam file konfigurasi build, lihat Menjalankan skrip bash.

3. Jalankan build menggunakan file konfigurasi build dan file di direktori saat ini:

   gcloud builds submit \
       --config cloudbuild.yaml \
       --region REGION \
       --substitutions _SERVICE_ACCOUNT=CB_GSA@PROJECT_ID.iam.gserviceaccount.com \
       --worker-pool projects/PROJECT_ID/locations/REGION/workerPools/PRIVATE_POOL_NAME
   

   Perintah ini mengupload semua file yang ada di direktori saat ini ke Cloud Storage untuk digunakan oleh Cloud Build. Langkah build menggunakan file kubeconfig untuk terhubung ke cluster GKE.

   Di dekat akhir output, Anda akan melihat baris yang menyerupai berikut ini:

   NAME         TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)   AGE
   kubernetes   ClusterIP   10.0.0.1     <none>        443/TCP   2h
   

   Output ini menunjukkan bahwa pekerja pool pribadi telah terhubung ke bidang kontrol cluster menggunakan proxy autentikasi Identity Service for GKE.

Pemecahan masalah

Jika Anda tidak dapat terhubung ke instance VM menggunakan SSH, tambahkan tanda --troubleshoot untuk membantu menemukan penyebab masalah konektivitas:

gcloud compute ssh VM --tunnel-through-iap --zone ZONE --troubleshoot

Jika Anda mendapatkan pesan Error from server (NotFound): clientconfigs.authentication.gke.io "default" not found saat menambal ClientConfig default di cluster GKE, pastikan Anda telah membuat aturan firewall seperti yang dijelaskan di bagian Membuat cluster GKE pribadi. Pastikan aturan firewall ada:

gcloud compute firewall-rules describe allow-control-plane-clientconfig-webhook

Jika Anda tidak dapat melakukan autentikasi ke proxy Identity Service untuk GKE, cari error di log pod dalam deployment gke-oidc-service:

gcloud compute ssh VM --tunnel-through-iap --zone ZONE --command \
    'kubectl logs deployment/gke-oidc-service \
         --namespace anthos-identity-service --all-containers'

Jika Anda mengalami masalah lain dengan tutorial ini, sebaiknya tinjau dokumen berikut:

• Pemecahan masalah GKE
• Memecahkan masalah cluster Kubernetes