Mengonfigurasi penyiapan multi-project

---

Tutorial ini menjelaskan cara menggunakan Otorisasi Biner dalam konfigurasi multi-project. Untuk konfigurasi project tunggal yang lebih sederhana, lihat Mulai menggunakan Google Cloud CLI (GKE).

Untuk menetapkan pemisahan tugas, Anda dapat menyiapkan Otorisasi Biner dalam konfigurasi beberapa project. Tujuan setiap project akan dibahas nanti dalam tutorial ini.

Tujuan

Dalam tutorial ini, Anda akan melakukan tugas berikut:

1. Siapkan project lain untuk deployment (GKE), attestor, dan pengelolaan pengesahan, untuk mendukung pemisahan tugas.

2. Konfigurasikan aturan default kebijakan Otorisasi Biner Anda untuk mewajibkan pengesahan.

3. Buat pasangan kunci untuk menandatangani, dan kemudian memverifikasi pengesahan.

4. Buat attestor yang digunakan oleh pemberlakuan Otorisasi Biner untuk memverifikasi pengesahan.

5. Menandatangani image contoh, yang membuat pengesahan.

6. Uji kebijakan dengan men-deploy image contoh.

Anda harus mengonfigurasi kontrol akses yang sesuai untuk setiap project melalui Identity and Access Management (IAM).

Untuk keamanan tambahan, Anda dapat menggunakan Kontrol Layanan VPC untuk membantu melindungi resource yang Anda buat dalam tutorial ini. Untuk mengetahui informasi selengkapnya, lihat Mengamankan dengan Kontrol Layanan VPC.

Biaya

Dalam dokumen ini, Anda menggunakan komponen Google Cloud yang dapat ditagih berikut:

• Artifact Registry atau Container Registry
• Otorisasi Biner
• GKE
• Container Registry
• Opsional: Cloud Key Management Service

Untuk membuat perkiraan biaya berdasarkan proyeksi penggunaan Anda, gunakan kalkulator harga. Pengguna baru Google Cloud mungkin memenuhi syarat untuk mendapatkan uji coba gratis.

Sebelum memulai

Catatan: Untuk konfigurasi ini, Anda harus menyiapkan tiga project.

1. Login ke akun Google Cloud Anda. Jika Anda baru menggunakan Google Cloud, buat akun untuk mengevaluasi performa produk kami dalam skenario dunia nyata. Pelanggan baru juga mendapatkan kredit gratis senilai $300 untuk menjalankan, menguji, dan men-deploy workload.

2. Di konsol Google Cloud, pada halaman pemilih project, pilih atau buat project Google Cloud.

   Catatan: Jika tidak berencana untuk menyimpan resource yang Anda buat dalam prosedur ini, buatlah project, bukan memilih project yang ada. Setelah menyelesaikan langkah ini, Anda dapat menghapus project, yang menghapus semua resource yang terkait dengan project ini.

   Buka pemilih project

3. Pastikan penagihan telah diaktifkan untuk project Google Cloud Anda.

4. Menginstal Google Cloud CLI.

5. Untuk initialize gcloud CLI, jalankan perintah berikut:

   gcloud init

6. Di konsol Google Cloud, pada halaman pemilih project, pilih atau buat project Google Cloud.

   Catatan: Jika tidak berencana untuk menyimpan resource yang Anda buat dalam prosedur ini, buatlah project, bukan memilih project yang ada. Setelah menyelesaikan langkah ini, Anda dapat menghapus project, yang menghapus semua resource yang terkait dengan project ini.

   Buka pemilih project

7. Pastikan penagihan telah diaktifkan untuk project Google Cloud Anda.

8. Menginstal Google Cloud CLI.

9. Untuk initialize gcloud CLI, jalankan perintah berikut:

   gcloud init

10. Instal kubectl untuk berinteraksi dengan GKE.

Menyiapkan project deployer

Project deployer mengelola cluster Google Kubernetes Engine (GKE), tempat Anda men-deploy image, dan kebijakan Otorisasi Biner yang diberlakukan oleh Otorisasi Biner pada waktu deployment. Anda dapat memiliki lebih dari satu project deployer, bergantung pada ukuran, kompleksitas, dan persyaratan lainnya dari lingkungan Anda.

Catatan: Untuk menggunakan attestor yang sama dengan beberapa project deployer, ulangi langkah-langkah di bawah, dengan mengganti DEPLOYER_PROJECT_ID dengan ID setiap project deployer.

Untuk menyiapkan project deployer:

1. Buat project dan aktifkan penagihan di Konsol Google Cloud jika Anda belum melakukannya.

2. Catatan Identity and Access Management: Project deployer berisi cluster GKE Anda. Konfigurasi Identity and Access Management untuk project ini harus mencerminkan hal tersebut.

3. Setel variabel lingkungan untuk menyimpan project Google Cloud dan nomornya:

   DEPLOYER_PROJECT_ID=DEPLOYER_PROJECT_ID
   

   Ganti DEPLOYER_PROJECT_ID dengan ID project Google Cloud.

   DEPLOYER_PROJECT_NUMBER=$(gcloud projects describe "${DEPLOYER_PROJECT_ID}" \
       --format="value(projectNumber)")
   

4. Mengaktifkan API:

   Container Registry

   gcloud --project=${DEPLOYER_PROJECT_ID} \
     services enable\
     container.googleapis.com\
     containerregistry.googleapis.com\
     binaryauthorization.googleapis.com
   

   Artifact Registry

   gcloud --project=${DEPLOYER_PROJECT_ID} \
     services enable\
     container.googleapis.com\
     artifactregistry.googleapis.com\
     binaryauthorization.googleapis.com
   

5. Dapatkan nama akun layanan project deployer:

   DEPLOYER_SERVICE_ACCOUNT="service-${DEPLOYER_PROJECT_NUMBER}@gcp-sa-binaryauthorization.iam.gserviceaccount.com"
   

   Gunakan nama akun layanan di langkah berikutnya saat mengonfigurasi izin pada catatan Artifact Analysis yang terkait dengan attestor Anda.

Menyiapkan project attestor

Project attestor menyimpan attestor yang dapat memverifikasi bahwa image siap untuk deployment. Sering kali, Anda memiliki satu project attestor yang bertindak sebagai penyimpanan terpusat untuk informasi tentang pihak tepercaya dalam proses otorisasi. Dengan begitu, Anda dapat mengelola kunci keamanan secara terpusat yang diperlukan untuk memverifikasi identitas attestor dan membatasi akses hanya kepada pihak yang mengelolanya.

Untuk menyiapkan project attestor:

1. Buat project dan aktifkan penagihan di Konsol Google Cloud jika Anda belum melakukannya.

2. Catatan Identity and Access Management: Karena project ini berisi attestor Anda, hanya staf keamanan yang boleh memiliki akses tulis.

3. Tetapkan variabel lingkungan untuk menyimpan project ID dan nomor:

   ATTESTOR_PROJECT_ID=ATTESTOR_PROJECT_ID
   

   Ganti ATTESTOR_PROJECT_ID dengan project ID attestor.

   ATTESTOR_PROJECT_NUMBER=$(gcloud projects describe "${ATTESTOR_PROJECT_ID}" \
       --format="value(projectNumber)")
   

4. Aktifkan Artifact Analysis dan Binary Authorization API:

   gcloud services --project=${ATTESTOR_PROJECT_ID} \
       enable containeranalysis.googleapis.com \
       binaryauthorization.googleapis.com
   

5. Dapatkan nama akun layanan project attestor:

   ATTESTOR_SERVICE_ACCOUNT="service-${ATTESTOR_PROJECT_NUMBER}@gcp-sa-binaryauthorization.iam.gserviceaccount.com"
   

   Gunakan nama akun layanan di langkah berikutnya saat mengonfigurasi izin pada catatan Artifact Analysis yang terkait dengan attestor Anda.

Menyiapkan project pengesahan

Project pengesahan adalah project yang menyimpan attestations yang dibuat attestor saat memverifikasi image. Project pengesahan terpisah memungkinkan Anda mengatur dan memeriksa pernyataan tentang kesiapan software dengan lebih mudah.

1. Buat project dan aktifkan penagihan di Konsol Google Cloud jika Anda belum melakukannya.

2. Catatan Identity and Access Management: Semua peran yang terlibat dalam otorisasi biner harus memiliki akses baca ke Catatan dan Kejadian Analisis Artefak di project ini, tetapi hanya pengelola pengesahan yang perlu memiliki akses tulis.

3. Tetapkan variabel lingkungan untuk menyimpan nama project:

   ATTESTATION_PROJECT_ID=ATTESTATION_PROJECT_ID
   

   Ganti ATTESTATION_PROJECT_ID dengan project ID pengesahan.

4. Aktifkan Artifact Analysis dan Binary Authorization API:

   gcloud services --project=${ATTESTATION_PROJECT_ID} \
       enable containeranalysis.googleapis.com \
       binaryauthorization.googleapis.com
   

Membuat cluster

Sekarang, Anda dapat membuat cluster GKE di project deployer. Ini adalah cluster tempat Anda ingin menjalankan image container yang telah di-deploy. Saat membuat cluster, Anda meneruskan flag --binauthz-evaluation-mode=PROJECT_SINGLETON_POLICY_ENFORCE ke perintah gcloud container clusters create.

Untuk membuat cluster:

gcloud --project=${DEPLOYER_PROJECT_ID} \
    container clusters create \
    --binauthz-evaluation-mode=PROJECT_SINGLETON_POLICY_ENFORCE \
    --zone us-central1-a \
    test-cluster

Di sini, Anda membuat cluster bernama test-cluster di zona GKE us-central1-a.

Anda juga harus mengupdate file kubeconfig lokal untuk penginstalan kubectl. Langkah ini memberikan kredensial dan informasi endpoint yang diperlukan untuk mengakses cluster di GKE.

Untuk mengupdate file kubeconfig lokal:

gcloud --project=${DEPLOYER_PROJECT_ID} \
    container clusters get-credentials \
    --zone us-central1-a \
    test-cluster

Membuat attestor

attestor adalah pihak yang bertanggung jawab untuk mengesahkan bahwa proses yang diperlukan telah selesai sebelum image container dapat di-deploy. Pihak ini dapat berupa pengguna manusia atau, lebih sering, proses mesin seperti sistem build dan pengujian, atau pipeline continuous integration (CI) dan deployment (CD). Anda membuat attestor di project attestor.

Membuat attestor mengharuskan Anda untuk:

• Buat catatan di Artifact Analysis untuk menyimpan metadata tepercaya yang digunakan dalam proses otorisasi
• Membuat attestor itu sendiri di project attestor dan mengaitkan catatan yang Anda buat
• Menambahkan binding peran IAM untuk akun layanan project deploy ke attestor
• Menetapkan izin pada catatan Artifact Analysis

Untuk tutorial ini, Anda memiliki satu attestor bernama test-attestor dan catatan Analisis Container bernama test-attestor-note. Dalam skenario nyata, Anda dapat memiliki berapa pun attestor, yang masing-masing mewakili pihak yang berpartisipasi dalam proses otorisasi gambar.

Membuat catatan Artifact Analysis

1. Tetapkan variabel yang menyimpan nama attestor dan catatan Artifact Analysis:

   ATTESTOR_NAME=test-attestor
   NOTE_ID=test-attestor-note
   

   Ganti:

   • test-attestor: nama attestor pilihan Anda.
   • test-attestor-note: nama catatan attestor pilihan Anda.

2. Buat file JSON di /tmp/note_payload.json yang mendeskripsikan catatan Container Analysis:

   cat > /tmp/note_payload.json << EOM
   {
     "name": "projects/${ATTESTOR_PROJECT_ID}/notes/${NOTE_ID}",
     "attestation": {
       "hint": {
         "human_readable_name": "Attestor Note"
       }
     }
   }
   EOM
   

3. Buat catatan dengan mengirim permintaan HTTP ke Artifact Analysis REST API:

   curl -X POST \
       -H "Content-Type: application/json" \
       -H "Authorization: Bearer $(gcloud auth print-access-token)"  \
       --data-binary @/tmp/note_payload.json  \
       "https://containeranalysis.googleapis.com/v1/projects/${ATTESTOR_PROJECT_ID}/notes/?noteId=${NOTE_ID}"
   

4. Pastikan bahwa catatan telah dibuat:

   curl \
   -H "Authorization: Bearer $(gcloud auth print-access-token)" \
   "https://containeranalysis.googleapis.com/v1/projects/${ATTESTOR_PROJECT_ID}/notes/${NOTE_ID}"
   

Membuat attestor

Sekarang, Anda dapat membuat attestor:

1. Buat attestor di Otorisasi Biner:

   gcloud --project=${ATTESTOR_PROJECT_ID} \
       container binauthz attestors create ${ATTESTOR_NAME} \
       --attestation-authority-note=${NOTE_ID} \
       --attestation-authority-note-project=${ATTESTOR_PROJECT_ID}
   

2. Pastikan bahwa attestor sudah dibuat:

   gcloud --project=${ATTESTOR_PROJECT_ID} \
       container binauthz attestors list
   

Attestor yang Anda buat belum dapat digunakan tanpa pasangan kunci PKIX terkait, yang Anda buat di bawah.

Menambahkan binding peran IAM untuk project deployer

Anda harus menambahkan binding peran IAM untuk project deploy ke attestor. Hal ini digunakan oleh Otorisasi Biner saat mengevaluasi kebijakan untuk menentukan apakah project memiliki izin untuk mengakses pengesahan terkait.

Untuk menambahkan binding peran IAM:

gcloud --project ${ATTESTOR_PROJECT_ID} \
    container binauthz attestors add-iam-policy-binding \
    "projects/${ATTESTOR_PROJECT_ID}/attestors/${ATTESTOR_NAME}" \
    --member="serviceAccount:${DEPLOYER_SERVICE_ACCOUNT}" \
    --role=roles/binaryauthorization.attestorsVerifier

Menetapkan izin pada catatan Artifact Analysis

Anda juga harus menetapkan izin pada catatan Artifact Analysis yang Anda buat sehingga dapat diakses oleh project deployer dan project attestor. Untuk melakukannya, perbarui kebijakan IAM untuk catatan guna menetapkan akses Viewer ke akun layanan project.

1. Buat file JSON yang berisi informasi yang diperlukan untuk menetapkan kebijakan IAM di catatan Anda.

   cat > /tmp/iam_request.json << EOM
   {
     'resource': 'projects/${ATTESTOR_PROJECT_ID}/notes/${NOTE_ID}',
     'policy': {
       'bindings': [
         {
           'role': 'roles/containeranalysis.notes.occurrences.viewer',
           'members': [
             'serviceAccount:${ATTESTOR_SERVICE_ACCOUNT}',
             'serviceAccount:${DEPLOYER_SERVICE_ACCOUNT}'
           ]
         }
       ]
     }
   }
   EOM
   

2. Tambahkan akun layanan dan peran akses yang diminta ke kebijakan IAM untuk catatan yang Anda buat:

   curl -X POST  \
       -H "Content-Type: application/json" \
       -H "Authorization: Bearer $(gcloud auth print-access-token)" \
       --data-binary @/tmp/iam_request.json \
       "https://containeranalysis.googleapis.com/v1/projects/${ATTESTOR_PROJECT_ID}/notes/${NOTE_ID}:setIamPolicy"
   

Siapkan kunci PKIX

Otorisasi Biner menggunakan kunci kriptografis untuk memverifikasi identitas attestor dengan aman. Hal ini memastikan bahwa hanya pihak terverifikasi yang dapat berpartisipasi dalam otorisasi image container. Pasangan kunci terdiri dari kunci pribadi, yang digunakan attestor untuk menandatangani pengesahan secara digital, dan kunci publik, yang Anda tambahkan ke attestor seperti yang disimpan oleh layanan Otorisasi Biner.

Dalam tutorial ini, Anda menggunakan Elliptic Curve Digital Signing Algorithm (ECDSA) yang direkomendasikan untuk membuat pasangan kunci. Anda juga dapat menggunakan kunci RSA atau PGP untuk penandatanganan. Lihat Tujuan dan algoritma utama untuk informasi selengkapnya tentang algoritma penandatanganan.

Kunci asimetris yang dihasilkan dan disimpan oleh Cloud Key Management Service (Cloud KMS) telah mematuhi PKIX. Baca bagian Membuat attestor menggunakan CLI untuk mengetahui informasi lebih lanjut tentang cara menggunakan kunci PKIX dan Cloud KMS.

Membuat pasangan kunci

Pasangan kunci PKIX terdiri dari kunci pribadi, yang digunakan penanda tangan untuk menandatangani pengesahan secara digital, dan kunci publik, yang Anda tambahkan ke attestor. Pada waktu deployment, Otorisasi Biner menggunakan kunci publik ini untuk memverifikasi pengesahan yang ditandatangani oleh kunci pribadi.

1. Buat kunci pribadi:

   Untuk menghasilkan pasangan kunci PKIX asimetris lokal baru dan menyimpannya dalam file:

   PKIX (Cloud KMS)

   Langkah ini menunjukkan cara melakukan pengesahan menggunakan kunci yang dihasilkan dan disimpan di Cloud Key Management Service.

   1. Siapkan variabel lingkungan untuk menyimpan informasi tentang pasangan kunci seperti yang dikelola oleh Cloud KMS:

      Jika sudah memiliki pasangan kunci, Anda dapat menetapkan variabel lingkungan ini dan melewati langkah berikutnya.

      KMS_KEY_PROJECT_ID=KMS_KEY_PROJECT_ID
      KMS_KEY_LOCATION=KMS_KEY_LOCATION
      KMS_KEYRING_NAME=KMS_KEYRING_NAME
      KMS_KEY_NAME=KMS_KEY_NAME
      KMS_KEY_VERSION=KMS_KEY_VERSION
      

      Ganti kode berikut:

      • KMS_KEY_PROJECT_ID: ID project tempat kunci disimpan
      • KMS_KEY_LOCATION: lokasi kunci
      • KMS_KEYRING_NAME: nama key ring
      • KMS_KEY_NAME: nama kunci
      • KMS_KEY_VERSION: versi kunci

   2. [Opsional] Menyiapkan kunci KMS:

      Catatan: Anda dapat melewati langkah-langkah ini jika sudah memiliki kunci KMS.

      1. Membuat kunci KMS yang kunci publiknya dapat disimpan di attestor. Langkah ini juga akan menyiapkan variabel lingkungan yang Anda gunakan di bawah.

         Untuk membuat kunci dan menyiapkan variabel lingkungan:

         KMS_KEY_PROJECT_ID=${PROJECT_ID}
         KMS_KEYRING_NAME=my-binauthz-keyring
         KMS_KEY_NAME=my-binauthz-kms-key-name
         KMS_KEY_LOCATION=global
         KMS_KEY_PURPOSE=asymmetric-signing
         KMS_KEY_ALGORITHM=ec-sign-p256-sha256
         KMS_PROTECTION_LEVEL=software
         KMS_KEY_VERSION=1
         

      2. Buat key ring KMS:

         gcloud kms keyrings create ${KMS_KEYRING_NAME} \
           --location ${KMS_KEY_LOCATION} \
           --project ${KMS_KEY_PROJECT_ID}
         

      3. Buat kunci:

         gcloud kms keys create ${KMS_KEY_NAME} \
           --location ${KMS_KEY_LOCATION} \
           --keyring ${KMS_KEYRING_NAME}  \
           --purpose ${KMS_KEY_PURPOSE} \
           --default-algorithm ${KMS_KEY_ALGORITHM} \
           --protection-level ${KMS_PROTECTION_LEVEL} \
           --project ${KMS_KEY_PROJECT_ID}
         

         Untuk informasi lebih lanjut tentang cara membuat kunci KMS, lihat Membuat kunci asimetris.

   3. Tambahkan kunci publik ke attestor:

      gcloud --project="${ATTESTOR_PROJECT_ID}" \
          container binauthz attestors public-keys add \
          --attestor="${ATTESTOR_NAME}" \
          --keyversion-project="${KMS_KEY_PROJECT_ID}" \
          --keyversion-location="${KMS_KEY_LOCATION}" \
          --keyversion-keyring="${KMS_KEYRING_NAME}" \
          --keyversion-key="${KMS_KEY_NAME}" \
          --keyversion="${KMS_KEY_VERSION}"
      

   PKIX (kunci lokal)

   Peringatan: Kami sangat tidak menyarankan penggunaan pasangan kunci yang dibuat secara lokal di lingkungan produksi karena dapat menimbulkan risiko keamanan. Sebaiknya gunakan Cloud Key Management Service. Contoh ini diberikan hanya untuk ilustrasi.

   1. Untuk membuat kunci pribadi, jalankan perintah berikut:

      PRIVATE_KEY_FILE="/tmp/ec_private.pem"
      openssl ecparam -genkey -name prime256v1 -noout -out ${PRIVATE_KEY_FILE}
      

      PRIVATE_KEY_FILE adalah nama file yang berisi kunci pribadi yang disimpan di attestor.

   2. Ekstrak kunci publik dari kunci pribadi, lalu simpan dalam file:

      PUBLIC_KEY_FILE="/tmp/ec_public.pem"
      openssl ec -in ${PRIVATE_KEY_FILE} -pubout -out ${PUBLIC_KEY_FILE}
      

      PUBLIC_KEY_FILE adalah nama file yang berisi kunci publik yang disimpan di attestor.

   3. Untuk menambahkan kunci publik yang Anda ekspor ke attestor, jalankan kode berikut.

      gcloud --project="${ATTESTOR_PROJECT_ID}" \
        container binauthz attestors public-keys add \
        --attestor="${ATTESTOR_NAME}" \
        --pkix-public-key-file=${PUBLIC_KEY_FILE} \
        --pkix-public-key-algorithm=ecdsa-p256-sha256
      

      Otorisasi Biner menggunakan kunci publik pada attestor untuk memverifikasi pengesahan.

Mengonfigurasi kebijakan

Sekarang, Anda dapat mengonfigurasi kebijakan di project deployer. Pada langkah ini, Anda akan mengekspor file YAML kebijakan ke sistem lokal dan mengubah aturan default sehingga memerlukan pengesahan oleh attestor yang Anda tetapkan di atas.

Untuk mengonfigurasi kebijakan:

1. Buat file kebijakan baru yang mengizinkan image sistem yang dikelola Google, tetapkan evaluationMode ke REQUIRE_ATTESTATION, dan tambahkan node bernama requireAttestationsBy yang merujuk attestor yang Anda buat:

   cat > /tmp/policy.yaml << EOM
       globalPolicyEvaluationMode: ENABLE
       defaultAdmissionRule:
         evaluationMode: REQUIRE_ATTESTATION
         enforcementMode: ENFORCED_BLOCK_AND_AUDIT_LOG
         requireAttestationsBy:
           - projects/${ATTESTOR_PROJECT_ID}/attestors/${ATTESTOR_NAME}
       name: projects/${DEPLOYER_PROJECT_ID}/policy
   EOM
   

2. Impor file YAML kebijakan ke Otorisasi Biner:

   gcloud --project=${DEPLOYER_PROJECT_ID} \
       container binauthz policy import /tmp/policy.yaml
   

Untuk informasi selengkapnya tentang cara mengonfigurasi kebijakan, lihat Mengonfigurasi Kebijakan Menggunakan CLI.

Menguji kebijakan

Dalam tutorial ini, Anda akan membuat pengesahan, misalnya, image "Halo Dunia!" publik dari Container Registry dan Artifact Registry. Awalnya, pelaksana ini memblokir image agar tidak di-deploy karena pengesahan yang diperlukan tidak ada.

Untuk mencoba men-deploy image:

Container Registry

kubectl run hello-server --image gcr.io/google-samples/hello-app:1.0 --port 8080

Artifact Registry

kubectl run hello-server --image us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0 --port 8080

Sekarang, verifikasi bahwa deployment diblokir oleh Otorisasi Biner:

kubectl get pods

Perintah tersebut mencetak pesan berikut, yang menunjukkan bahwa image tidak di-deploy:

No resources found.

Anda bisa mendapatkan detail deployment lebih lanjut:

kubectl get event --template \
'{{range.items}}{{"\033[0;36m"}}{{.reason}}:{{"\033[0m"}}\{{.message}}{{"\n"}}{{end}}'

Anda akan melihat respons yang terlihat seperti berikut:

FailedCreate: Error creating: pods POD_NAME is forbidden: admission webhook "imagepolicywebhook.image-policy.k8s.io" denied the request: Image IMAGE_NAME denied by Binary Authorization default admission rule. Image IMAGE_NAME denied by attestor ATTESTOR_NAME: No attestations found

Dalam output ini:

• POD_NAME: nama Pod.
• IMAGE_NAME: nama image.
• ATTESTOR_NAME: nama attestor.

Pastikan untuk menghapus deployment agar Anda dapat melanjutkan ke langkah berikutnya:

kubectl delete deployment hello-server

Membuat pengesahan

Pengesahan adalah pernyataan dari attestor bahwa proses yang diperlukan di pipeline Anda telah selesai dan bahwa image container yang dipermasalahkan telah diotorisasi untuk deployment. Pengesahan itu sendiri adalah data yang ditandatangani secara digital yang berisi jalur lengkap ke versi image sebagai penyimpanan registry image container Anda, serta identitas attestor.

Dalam tutorial ini, pengesahan Anda hanya menyatakan bahwa Anda memberikan otorisasi pada image untuk deployment. Anda membuat pengesahan di project pengesahan.

Untuk membuat pengesahan:

1. Tetapkan variabel yang menyimpan jalur registry dan ringkasan gambar:

   Container Registry

   IMAGE_PATH="gcr.io/google-samples/hello-app"
   IMAGE_DIGEST="sha256:c62ead5b8c15c231f9e786250b07909daf6c266d0fcddd93fea882eb722c3be4"
   

   Artifact Registry

   IMAGE_PATH="us-docker.pkg.dev/google-samples/containers/gke/hello-app"
   IMAGE_DIGEST="sha256:37e5287945774f27b418ce567cd77f4bbc9ef44a1bcd1a2312369f31f9cce567"
   IMAGE_TO_ATTEST=${IMAGE_PATH}@${IMAGE_DIGEST}
   

2. Membuat pengesahan

   Cloud KMS PKIX

   Untuk membuat pengesahan menggunakan kunci Cloud KMS, jalankan perintah berikut:

   gcloud beta container binauthz attestations sign-and-create \
       --project="${PROJECT_ID}" \
       --artifact-url="${IMAGE_TO_ATTEST}" \
       --attestor="${ATTESTOR_NAME}" \
       --attestor-project="${PROJECT_ID}" \
       --keyversion-project="${KMS_KEY_PROJECT_ID}" \
       --keyversion-location="${KMS_KEY_LOCATION}" \
       --keyversion-keyring="${KMS_KEYRING_NAME}" \
       --keyversion-key="${KMS_KEY_NAME}" \
       --keyversion="${KMS_KEY_VERSION}"
   

   PKIX (kunci lokal)

   Untuk membuat pengesahan menggunakan kunci lokal, lakukan langkah berikut:

   1. Buat payload pengesahan:

      Catatan: Dalam perintah berikut, meskipun ${IMAGE_PATH} diperlukan untuk membuat payload tanda tangan untuk pengesahan, hanya ${IMAGE_DIGEST} yang digunakan pada waktu deployment. Artinya, Anda dapat men-deploy image container yang identik dari beberapa lokasi dengan pengesahan yang sama.

      gcloud --project=${ATTESTATION_PROJECT_ID} \
        container binauthz create-signature-payload \
        --artifact-url=${IMAGE_TO_ATTEST} > /tmp/generated_payload.json
      

      File JSON payload memiliki konten berikut:

      Container Registry

      {
      "critical": {
        "identity": {
          "docker-reference": "gcr.io/google-samples/hello-app"
        },
        "image": {
          "docker-manifest-digest": "sha256:c62ead5b8c15c231f9e786250b07909daf6c266d0fcddd93fea
      882eb722c3be4"
        },
        "type": "Google cloud binauthz container signature"
      }
      }
      

      Artifact Registry

      {
      "critical": {
        "identity": {
          "docker-reference": "us-docker.pkg.dev/google-samples/containers/gke/hello-app"
        },
        "image": {
          "docker-manifest-digest": "sha256:37e5287945774f27b418ce567cd77f4bbc9ef44a1bcd1a2312369f31f9cce567"
        },
        "type": "Google cloud binauthz container signature"
      }
      }
      

   2. Tanda tangani payload.

      Jika menggunakan file PKIX lokal, tanda tangani payload dengan kunci pribadi PKIX lokal dan buat file tanda tangan:

      openssl dgst -sha256 -sign ${PRIVATE_KEY_FILE} /tmp/generated_payload.json > /tmp/ec_signature
      

      File output adalah versi file JSON payload bertanda tangan yang Anda buat di atas.

   3. Dapatkan ID kunci publik dari attestor.

      Anda dapat melihat ID kunci publik kapan saja menggunakan perintah: gcloud container binauthz attestors describe ATTESTOR_NAME.

      Untuk menyimpan ID kunci publik Anda dalam variabel lingkungan, masukkan perintah ini:

      PUBLIC_KEY_ID=$(gcloud container binauthz attestors describe ${ATTESTOR_NAME} \
      --format='value(userOwnedGrafeasNote.publicKeys[0].id)' --project ${ATTESTOR_PROJECT_ID})
      

   4. Buat dan validasi pengesahan:

      gcloud container binauthz attestations create \
        --project="${ATTESTATION_PROJECT_ID}" \
        --artifact-url="${IMAGE_TO_ATTEST}" \
        --attestor="projects/${ATTESTOR_PROJECT_ID}/attestors/${ATTESTOR_NAME}" \
        --signature-file=/tmp/ec_signature \
        --public-key-id="${PUBLIC_KEY_ID}" \
        --validate
      

      Flag validate memeriksa apakah pengesahan dapat diverifikasi oleh attestor yang Anda konfigurasi di kebijakan.

3. Pastikan bahwa pengesahan telah dibuat:

   gcloud --project=${ATTESTATION_PROJECT_ID} \
       container binauthz attestations list \
       --attestor=$ATTESTOR_NAME --attestor-project=$ATTESTOR_PROJECT_ID
   

Untuk informasi selengkapnya tentang cara membuat pengesahan, lihat Membuat Pengesahan.

Menguji ulang kebijakan

Uji kebijakan dengan men-deploy image container contoh ke cluster. Kali ini, Anda harus men-deploy image menggunakan digest, bukan tag seperti 1.0 atau latest, karena Binary Authorization menggunakan jalur image dan ringkasan untuk mencari pengesahan. Di sini, Otorisasi Biner memungkinkan image di-deploy karena image memiliki pengesahan terkait.

Untuk men-deploy image:

kubectl run hello-server --image ${IMAGE_TO_ATTEST} --port 8080

Untuk memastikan bahwa image telah di-deploy:

kubectl get pods

Perintah tersebut mencetak pesan yang mirip dengan yang berikut, yang menunjukkan bahwa deployment berhasil:

NAME                            READY     STATUS    RESTARTS   AGE
hello-server-579859fb5b-h2k8s   1/1       Running   0          1m

Setelah berhasil men-deploy image container dan memastikan bahwa penyiapan berfungsi, Anda dapat menghapus cluster yang dibuat di GKE:

gcloud --project=${DEPLOYER_PROJECT_ID} \
    container clusters delete \
    --zone=us-central1-a \
    test-cluster

Pembersihan

Agar tidak perlu membayar biaya pada akun Google Cloud Anda untuk resource yang digunakan dalam tutorial ini, hapus project yang berisi resource tersebut, atau simpan project dan hapus setiap resource.

1. Hapus cluster yang Anda buat di GKE:

   gcloud container clusters delete \
       --zone=us-central1-a \
       test-cluster
   

2. Anda juga dapat menghapus project Google Cloud yang dibuat untuk tutorial ini.

Langkah selanjutnya

• Pelajari Otorisasi Biner lebih lanjut
• Pelajari konsep utama yang digunakan dalam Otorisasi Biner
• Mengaktifkan mode uji coba untuk menonaktifkan penerapan
• Menggunakan akses darurat untuk mengabaikan penegakan kebijakan