Halaman ini diterjemahkan oleh Cloud Translation API.

Mulai menggunakan Google Cloud CLI (GKE)

Tutorial ini menunjukkan cara mengonfigurasi dan menguji kebijakan Otorisasi Biner yang memerlukan atestasi. Jenis kebijakan ini mengamankan rantai pasokan software berbasis container Anda dengan memverifikasi bahwa image container memiliki pengesahan yang ditandatangani sebelum mengizinkan deployment image.

Pada waktu deployment, Otorisasi Biner menggunakan attestor untuk memverifikasi tanda tangan digital dalam pengesahan. Pengesahan dibuat oleh penanda tangan, biasanya sebagai bagian dari pipeline integrasi berkelanjutan (CI).

Dalam tutorial ini, cluster GKE, pengesahan, dan penegasnya semuanya berada dalam satu project. Konfigurasi satu project sebagian besar berguna untuk menguji atau bereksperimen dengan layanan. Untuk contoh di dunia nyata yang lebih nyata, lihat konfigurasi multi-project.

Langkah-langkah di bawah menjelaskan tugas yang Anda lakukan di command line. Untuk mengikuti langkah-langkah ini menggunakan konsol Google Cloud, lihat Memulai penggunaan konsol Google Cloud.

Tujuan

Dalam tutorial ini, Anda akan mempelajari cara:

Membuat cluster Google Kubernetes Engine (GKE) dengan Otorisasi Biner diaktifkan
Membuat pengesah yang digunakan penegak Otorisasi Biner untuk memverifikasi tanda tangan pada pengesahan
Mengonfigurasi kebijakan yang memerlukan pengesahan
Membuat pasangan kunci kriptografis untuk menandatangani pengesahan dan memverifikasinya nanti
Menandatangani ringkasan image container, membuat tanda tangan
Membuat pengesahan menggunakan tanda tangan
Menguji kebijakan dengan men-deploy image container ke GKE

Biaya

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

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

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Install the Google Cloud CLI.

To initialize the gcloud CLI, run the following command:

gcloud init

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Install the Google Cloud CLI.

To initialize the gcloud CLI, run the following command:

gcloud init

Instal kubectl untuk berinteraksi dengan GKE.

Aktifkan Otorisasi Biner

Menetapkan project default

Langkah pertama adalah menetapkan project Google Cloud default yang digunakan oleh perintah gcloud:

PROJECT_ID=PROJECT_ID
gcloud config set project ${PROJECT_ID}

dengan PROJECT_ID adalah nama project Anda.

Mengaktifkan API yang diperlukan

Aktifkan API untuk:

Container Registry

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

Artifact Registry

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

Membuat cluster dengan Otorisasi Biner diaktifkan

Membuat cluster

Buat cluster GKE dengan Otorisasi Biner yang diaktifkan. Ini adalah cluster tempat Anda ingin image container yang di-deploy berjalan. Saat membuat cluster, Anda meneruskan flag --binauthz-evaluation-mode=PROJECT_SINGLETON_POLICY_ENFORCE ke perintah gcloud container clusters create.

Untuk membuat cluster, ikuti langkah-langkah berikut:

gcloud container clusters create \
    --binauthz-evaluation-mode=PROJECT_SINGLETON_POLICY_ENFORCE \
    --zone us-central1-a \
    test-cluster

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

Konfigurasi `kubectl`

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

Untuk mengupdate file kubeconfig lokal:

gcloud container clusters get-credentials \
    --zone us-central1-a \
    test-cluster

Melihat kebijakan default

Kebijakan di Otorisasi Biner adalah sekumpulan aturan yang mengatur deployment image container. Anda dapat memiliki satu kebijakan per project. Secara default, kebijakan dikonfigurasi untuk mengizinkan semua image container di-deploy.

Otorisasi Biner memungkinkan Anda mengekspor dan mengimpor file kebijakan dalam format YAML. Format ini mencerminkan struktur kebijakan saat disimpan oleh layanan. Saat mengonfigurasi kebijakan menggunakan perintah gcloud, Anda mengedit file ini.

Untuk melihat kebijakan default, ekspor file YAML kebijakan:

gcloud container binauthz policy export

Secara default, file memiliki konten berikut:

defaultAdmissionRule:
  enforcementMode: ENFORCED_BLOCK_AND_AUDIT_LOG
  evaluationMode: ALWAYS_ALLOW
globalPolicyEvaluationMode: ENABLE
name: projects/PROJECT_ID/policy

Aturan default ditentukan di node defaultAdmissionRule. evaluationMode menentukan bahwa kebijakan mengizinkan semua upaya deployment image. Dalam tutorial ini, Anda akan memperbarui aturan default untuk mewajibkan pengesahan.

globalPolicyEvaluationMode mengecualikan image sistem yang dikelola Google dari penerapan Otorisasi Biner.

Untuk menambahkan gambar yang dikecualikan ke daftar yang diizinkan, tambahkan hal berikut ke file kebijakan:

admissionWhitelistPatterns:
  - namePattern: EXEMPT_IMAGE_PATH

Ganti EXEMPT_IMAGE_PATH dengan jalur ke gambar yang akan dikecualikan. Untuk mengecualikan gambar tambahan, tambahkan entri - namePattern tambahan. Pelajari admissionWhitelistPatterns lebih lanjut.

Untuk informasi selengkapnya tentang struktur kebijakan, lihat Referensi YAML kebijakan.

Membuat attestor

Pengesah adalah otoritas verifikasi yang digunakan oleh penegak Otorisasi Biner pada waktu deployment untuk memutuskan apakah akan mengizinkan GKE men-deploy image container yang ditandatangani yang sesuai. Pengesah berisi kunci publik dan biasanya dikelola oleh personel di organisasi Anda yang bertanggung jawab atas keamanan rantai pasok software.

Untuk membuat attestor, Anda harus:

Buat catatan di Artifact Analysis untuk menyimpan metadata tepercaya yang digunakan dalam proses otorisasi
Buat pengautentikasi itu sendiri di Otorisasi Biner dan kaitkan catatan yang Anda buat

Untuk tutorial ini, Anda memiliki satu pengautentikasi bernama test-attestor dan catatan Analisis Penampung bernama test-attestor-note. Dalam skenario dunia nyata, Anda dapat memiliki sejumlah pengautentikasi, yang masing-masing mewakili pihak yang berpartisipasi dalam proses otorisasi untuk image container.

Membuat catatan Artifact Analysis

Tetapkan variabel yang menyimpan nama pengautentikasi dan catatan Analisis Artefak Anda:
```
ATTESTOR_NAME=test-attestor
NOTE_ID=test-attestor-note
```
Ganti:
- test-attestor: nama pemberi pengesahan pilihan Anda.
- attestor-note: nama catatan penguji pilihan Anda.

Buat file JSON di /tmp/note_payload.json yang menjelaskan catatan Analisis Penampung:

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

Buat catatan dengan mengirim permintaan HTTP ke REST API Analisis Artefak:

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/${PROJECT_ID}/notes/?noteId=${NOTE_ID}"

Pastikan bahwa catatan telah dibuat:

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

Membuat attestor

Sekarang, Anda dapat membuat pengautentikasi:

Buat attestor di Otorisasi Biner:

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

Pastikan bahwa pengautentikasi telah dibuat:
```
gcloud container binauthz attestors list
```

Pengesah yang Anda buat belum dapat digunakan tanpa pasangan kunci yang terkait, yang akan Anda buat nanti dalam panduan ini.

Untuk konfigurasi multi-project, Anda harus menetapkan izin pada catatan Analisis Penampung seperti yang dijelaskan dalam Penyiapan Multi-Project. Hal ini tidak diperlukan dalam skenario satu project, karena project memiliki roles/containeranalysis.notes.occurrences.viewer yang diperlukan secara default.

Membuat pasangan kunci

Otorisasi Biner menggunakan kunci kriptografis untuk memverifikasi identitas penanda tangan dengan aman. Hal ini memastikan hanya image container resmi yang dapat di-deploy. Pasangan kunci terdiri dari kunci pribadi dan kunci publik. Penanda tangan menggunakan kunci pribadi untuk menandatangani ringkasan image penampung, sehingga menghasilkan tanda tangan yang kemudian disimpan dalam pernyataan. Kunci publik disimpan di attestor. Pada waktu deployment, penegak Binary Authorization menggunakan kunci publik pengautentikasi untuk memverifikasi tanda tangan dalam pengakuan sebelum mengizinkan container di-deploy.

Dalam tutorial ini, Anda menggunakan format Public-Key Infrastructure (X.509) (PKIX) untuk kunci kriptografis. Tutorial ini menggunakan Elliptic Curve Digital Signature Algorithm (ECDSA) yang direkomendasikan untuk menghasilkan pasangan kunci PKIX. Anda juga dapat menggunakan kunci RSA atau PGP untuk menandatangani gambar.

Untuk informasi selengkapnya tentang algoritma penandatanganan, lihat Tujuan dan algoritma kunci.

Kunci yang dibuat dan disimpan oleh Cloud Key Management Service (Cloud KMS) mematuhi PKIX. Lihat Membuat pengautentikasi menggunakan gcloud CLI untuk mengetahui informasi selengkapnya tentang penggunaan kunci PKIX dan Cloud KMS.

PKIX (Cloud KMS)

Untuk membuat pasangan kunci di Cloud KMS, lakukan hal berikut:

Siapkan variabel lingkungan yang diperlukan untuk membuat pasangan kunci.

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

Untuk membuat ring kunci, jalankan perintah berikut:

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

Untuk membuat kunci, jalankan perintah berikut:

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}

Untuk menambahkan kunci publik ke attestor, jalankan perintah berikut:

gcloud --project="${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}"

Dapatkan ID kunci publik dari attestor sebagai berikut:

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

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 ${PROJECT_ID})
```

PKIX (kunci lokal)

Untuk membuat pasangan kunci PKIX, ikuti langkah-langkah berikut:

Buat kunci pribadi:

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

Ekstrak kunci publik dari kunci pribadi:

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

Tambahkan kunci publik ke attestor.

Sekarang, tambahkan kunci publik yang Anda ekspor ke attestor agar dapat digunakan oleh Otorisasi Biner untuk verifikasi identitas:
```
gcloud --project="${PROJECT_ID}" \
    beta container binauthz attestors public-keys add \
    --attestor="${ATTESTOR_NAME}" \
    --pkix-public-key-file=${PUBLIC_KEY_FILE} \
    --pkix-public-key-algorithm=ecdsa-p256-sha256
```
Catatan: Perintah ini menghasilkan PUBLIC_KEY_ID yang Anda gunakan saat membuat pengesahan. Kolom ini berada di kolom id output dan terlihat sepertini:///sha-256;ybf_gINTzsBKLCaRIeQnExNhKFkGONXXXlr63QeZY-Q.
Simpan ID kunci publik.

Untuk menyimpan ID kunci publik, Anda dapat menyalinnya dari output public-keys add di atas. Untuk melihat ID kunci publik attestor setelah menambahkannya ke attestor, gunakan gcloud container binauthz attestors describe ${ATTESTOR_NAME}:
```
PUBLIC_KEY_ID=$(gcloud container binauthz attestors describe ${ATTESTOR_NAME} \
  --format='value(userOwnedGrafeasNote.publicKeys[0].id)')
```

Mengonfigurasi kebijakan

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

Untuk mengonfigurasi kebijakan, ikuti langkah-langkah berikut:

Buat file kebijakan baru yang mengizinkan image sistem yang dikelola Google, menetapkan evaluationMode ke REQUIRE_ATTESTATION, dan menambahkan node bernama requireAttestationsBy yang mereferensikan pengautentikasi yang Anda buat:

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

Impor file YAML kebijakan ke Otorisasi Biner:

gcloud container binauthz policy import /tmp/policy.yaml

Untuk mengetahui informasi selengkapnya tentang cara mengonfigurasi kebijakan, lihat Mengonfigurasi kebijakan menggunakan gcloud CLI.

Menguji kebijakan

Anda dapat menguji kebijakan yang dikonfigurasi di atas dengan mencoba men-deploy contoh image container ke cluster. Kebijakan akan memblokir deployment karena atestasi yang diperlukan belum dibuat.

Untuk tutorial ini, Anda dapat menggunakan contoh image dari Container Registry dan Artifact Registry. Image dari Container Registry terletak di jalur gcr.io/google-samples/hello-app:1.0. Image dari Artifact Registry terletak di jalur us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0. Kedua jalur tersebut berisi gambar publik yang dibuat oleh Google yang berisi aplikasi contoh "Halo, Dunia!".

Pertama, coba deploy image:

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

Sekarang, verifikasi bahwa deployment diblokir oleh Otorisasi Biner:

kubectl get pods

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

No resources found.

Anda bisa mendapatkan detail lebih lanjut tentang deployment:

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

Anda akan melihat respons yang menyerupai 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 pengautentikasi.

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

kubectl delete deployment hello-server

Membuat pengesahan

Pengesahan adalah dokumen digital yang dibuat oleh penanda tangan yang menyatakan bahwa GKE diizinkan untuk men-deploy image container terkait. Proses pembuatan pengesahan terkadang disebut "menandatangani image". Penanda tangan dapat berupa orang atau, lebih sering, proses otomatis yang berjalan saat image container dibuat. Tanda tangan dibuat menggunakan kunci pribadi dari pasangan kunci. Pada waktu deployment, penegak Otorisasi Biner menggunakan kunci publik penanda tangan untuk memverifikasi tanda tangan dalam pengesahan.

Dalam tutorial ini, pengesahan Anda hanya menyatakan bahwa Anda mengizinkan image untuk di-deploy.

Untuk membuat pengesahan, ikuti langkah-langkah berikut:

Tetapkan variabel yang menyimpan jalur registry dan ringkasan image:

Container Registry

IMAGE_PATH="gcr.io/google-samples/hello-app"
IMAGE_DIGEST="sha256:c62ead5b8c15c231f9e786250b07909daf6c266d0fcddd93fea882eb722c3be4"
IMAGE_TO_ATTEST=${IMAGE_PATH}@${IMAGE_DIGEST}

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}

Untuk membuat pengesahan, lakukan hal berikut:

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 hal berikut:

Buat payload pengesahan:

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

File JSON payload memiliki konten berikut:

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

Untuk menandatangani payload dengan kunci pribadi PKIX dan membuat file tanda tangan, jalankan perintah berikut:
```
openssl dgst -sha256 -sign ${PRIVATE_KEY_FILE} /tmp/generated_payload.json > /tmp/ec_signature
```
File tanda tangan adalah versi file JSON payload yang ditandatangani yang Anda buat sebelumnya dalam panduan ini.

Buat dan validasi pengesahan:

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

Ganti PUBLIC_KEY_ID dengan ID kunci publik yang Anda temukan di Membuat pasangan kunci PKIX di atas.

Flag validate memeriksa apakah pengesahan dapat diverifikasi oleh penegasnya yang Anda konfigurasi dalam kebijakan.

Pastikan bahwa pengesahan telah dibuat:

gcloud container binauthz attestations list \
    --attestor=$ATTESTOR_NAME --attestor-project=$PROJECT_ID

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

Menguji ulang kebijakan

Sekali lagi, uji kebijakan dengan men-deploy contoh image container ke cluster. Kali ini, Anda harus men-deploy image menggunakan ringkasan, bukan tag seperti 1.0 atau latest, karena Otorisasi Biner akan menggunakan ringkasan untuk mencari atestasi. Di sini, Otorisasi Biner memungkinkan image di-deploy karena pengesahan yang diperlukan telah dibuat.

Untuk men-deploy image, ikuti langkah-langkah berikut:

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

Untuk memverifikasi bahwa image telah di-deploy:

kubectl get pods

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

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

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.

Hapus cluster yang Anda buat di GKE:

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

Langkah selanjutnya

Pelajari Otorisasi Biner lebih lanjut
Pelajari konsep utama yang digunakan dalam Otorisasi Biner
Gunakan pengautentikasi built-by-cloud-build untuk hanya men-deploy image yang dibuat oleh Cloud Build (Pratinjau).
Mengaktifkan mode uji coba untuk menonaktifkan penerapan
Menggunakan breakglass untuk mengabaikan penerapan

Mulai menggunakan Google Cloud CLI (GKE)

Tujuan

Biaya

Sebelum memulai

Aktifkan Otorisasi Biner

Menetapkan project default

Mengaktifkan API yang diperlukan

Container Registry

Artifact Registry

Membuat cluster dengan Otorisasi Biner diaktifkan

Membuat cluster

Konfigurasi kubectl

Melihat kebijakan default

Membuat attestor

Membuat catatan Artifact Analysis

Membuat attestor

Membuat pasangan kunci

PKIX (Cloud KMS)

PKIX (kunci lokal)

Mengonfigurasi kebijakan

Menguji kebijakan

Membuat pengesahan

Container Registry

Artifact Registry

Cloud KMS PKIX

PKIX (kunci lokal)

Menguji ulang kebijakan

Pembersihan

Langkah selanjutnya

Konfigurasi `kubectl`