Halaman ini diterjemahkan oleh Cloud Translation API.

Mengonfigurasi penyiapan multi-project

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

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

Tujuan

Dalam tutorial ini, Anda akan melakukan tugas-tugas berikut:

Siapkan project yang berbeda untuk deployment (GKE), pengesah, dan pengelolaan pengesahan, untuk mendukung pemisahan tugas.
Konfigurasi aturan default dari kebijakan Otorisasi Biner Anda untuk mewajibkan pengesahan.
Buat pasangan kunci Infrastruktur Kunci Publik (X.509) (PKIX) untuk menandatangani, dan kemudian memverifikasi, pengesahan.
Buat pengesah yang digunakan pengelola Otorisasi Biner untuk memverifikasi pengesahan.
Tandatangani contoh gambar, buat pengesahan.
Uji kebijakan dengan men-deploy gambar 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 akan menggunakan komponen Google Cloudyang dapat ditagih berikut:

Untuk membuat perkiraan biaya berdasarkan proyeksi penggunaan Anda, gunakan kalkulator harga.

Pengguna Google Cloud baru 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

Verify that billing is enabled for your Google Cloud project.

Install the Google Cloud CLI.

Jika Anda menggunakan penyedia identitas (IdP) eksternal, Anda harus login ke gcloud CLI dengan identitas gabungan Anda terlebih dahulu.

Untuk melakukan inisialisasi gcloud CLI, jalankan perintah berikut:

gcloud init

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

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Install the Google Cloud CLI.

Jika Anda menggunakan penyedia identitas (IdP) eksternal, Anda harus login ke gcloud CLI dengan identitas gabungan Anda terlebih dahulu.

Untuk melakukan inisialisasi gcloud CLI, jalankan perintah berikut:

gcloud init

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 diterapkan Otorisasi Biner pada waktu deployment. Anda dapat memiliki lebih dari satu project deployer, bergantung pada ukuran, kompleksitas, dan persyaratan lingkungan Anda lainnya.

Untuk menyiapkan project deployer:

Buat project dan aktifkan penagihan di konsol Google Cloud jika Anda belum melakukannya.
Catatan Identity and Access Management: Project deployer berisi cluster GKE Anda. Konfigurasi Identity and Access Management untuk project ini harus mencerminkan hal tersebut.

Tetapkan variabel lingkungan untuk menyimpan project dan nomor Google Cloud :

DEPLOYER_PROJECT_ID=DEPLOYER_PROJECT_ID

Ganti DEPLOYER_PROJECT_ID dengan ID Google Cloud project.

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

Aktifkan API:

Artifact Registry

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

Dapatkan nama akun layanan project deployer:
```
DEPLOYER_SERVICE_ACCOUNT="service-${DEPLOYER_PROJECT_NUMBER}@gcp-sa-binaryauthorization.iam.gserviceaccount.com"
```
Anda akan menggunakan nama akun layanan di langkah selanjutnya saat mengonfigurasi izin pada catatan Analisis Artefak yang terkait dengan pengesah Anda.

Menyiapkan project pengesah

Project pengesah menyimpan pengesah yang dapat memverifikasi bahwa image siap untuk di-deploy. Sering kali, Anda memiliki satu project pengesah yang berfungsi sebagai penyimpanan terpusat untuk informasi tentang pihak tepercaya dalam proses otorisasi. Hal ini memungkinkan Anda mengelola kunci keamanan secara terpusat yang diperlukan untuk memverifikasi identitas pengesah dan membatasi akses hanya kepada pihak yang mengelola kunci tersebut.

Untuk menyiapkan project pengesah:

Buat project dan aktifkan penagihan di konsol Google Cloud jika Anda belum melakukannya.
Catatan Identity and Access Management: Karena project ini berisi pengesah Anda, hanya personel keamanan yang boleh memiliki akses tulis.

Tetapkan variabel lingkungan untuk menyimpan ID dan nomor project:

ATTESTOR_PROJECT_ID=ATTESTOR_PROJECT_ID

Ganti ATTESTOR_PROJECT_ID dengan project ID pengesah.

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

Aktifkan Artifact Analysis API dan Binary Authorization API:

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

Dapatkan nama akun layanan project pengesah:
```
ATTESTOR_SERVICE_ACCOUNT="service-${ATTESTOR_PROJECT_NUMBER}@gcp-sa-binaryauthorization.iam.gserviceaccount.com"
```
Anda akan menggunakan nama akun layanan di langkah selanjutnya saat mengonfigurasi izin pada catatan Analisis Artefak yang terkait dengan pengesah Anda.

Menyiapkan project pengesahan

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

Buat project dan aktifkan penagihan di konsol Google Cloud jika Anda belum melakukannya.
Catatan Identity and Access Management: Semua peran yang terlibat dalam otorisasi biner harus memiliki akses baca ke Catatan dan Kemunculan Analisis Artefak dalam project ini, tetapi hanya pengelola pengesahan yang memerlukan akses tulis.
Tetapkan variabel lingkungan untuk menyimpan nama project:
```
ATTESTATION_PROJECT_ID=ATTESTATION_PROJECT_ID
```
Ganti ATTESTATION_PROJECT_ID dengan project ID pengesahan.

Aktifkan Artifact Analysis API 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 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 akan membuat cluster bernama test-cluster di zona GKE us-central1-a.

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

Untuk memperbarui file kubeconfig lokal:

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

Membuat pengesah

Pengesah 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. Anda membuat pengesah di project pengesah Anda.

Untuk membuat pengesah, Anda harus:

Buat catatan di Artifact Analysis untuk menyimpan metadata tepercaya yang digunakan dalam proses otorisasi
Buat attestor itu sendiri di project attestor dan kaitkan catatan yang Anda buat
Tambahkan binding peran IAM untuk akun layanan project deployer ke pengesah
Menetapkan izin pada catatan Analisis Artefak

Untuk tutorial ini, Anda memiliki satu pengesah bernama test-attestor dan catatan Container Analysis bernama test-attestor-note. Dalam skenario dunia nyata, Anda dapat memiliki sejumlah pengesah, yang masing-masing mewakili pihak yang berpartisipasi dalam proses otorisasi untuk gambar.

Buat catatan Analisis Artefak

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

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

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

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}"

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}"

Buat pengesah

Sekarang, Anda dapat membuat pengesah:

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}

Pastikan bahwa pengesah telah dibuat:

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

Pengesah 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 deployer ke pengesah. Hal ini digunakan oleh Binary Authorization 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 Analisis Artefak

Anda juga harus menetapkan izin pada catatan Analisis Artefak yang Anda buat agar dapat diakses oleh project deployer dan project pengesahan. Anda melakukannya dengan memperbarui kebijakan IAM untuk catatan guna menetapkan akses Pelihat ke akun layanan project.

Buat file JSON yang berisi informasi yang diperlukan untuk menetapkan kebijakan IAM pada 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

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"
```
Perhatian: Otorisasi Biner tidak mendukung penyimpanan regional atau endpoint regional Analisis Artefak. Sebaiknya gunakan endpoint API global Analisis Artefak (https://containeranalysis.googleapis.com/).

Menyiapkan kunci PKIX

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

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

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

Membuat pasangan kunci

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

Buat kunci pribadi:

Untuk membuat pasangan kunci asimetris PKIX lokal baru dan menyimpannya dalam file:
PKIX (Cloud KMS)
Langkah ini menunjukkan cara melakukan pengesahan menggunakan kunci yang dibuat dan disimpan di Cloud Key Management Service.
1. Siapkan variabel lingkungan untuk menyimpan informasi tentang pasangan kunci 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] Siapkan kunci KMS:
  
  Catatan: Anda dapat melewati langkah-langkah ini jika sudah memiliki kunci KMS.
  1. Buat kunci KMS yang kunci publiknya dapat disimpan dalam pengesah. Langkah ini juga 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 mengetahui informasi selengkapnya 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: Sebaiknya jangan gunakan pasangan kunci yang dibuat secara lokal di lingkungan produksi karena menimbulkan risiko keamanan. Sebaiknya gunakan Cloud Key Management Service. Contoh ini hanya disediakan untuk tujuan 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 pengesah.
2. Ekstrak kunci publik dari kunci pribadi dan simpan ke 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 pengesah.
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 di pengesah untuk memverifikasi pengesahan.

Mengonfigurasi kebijakan

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

Untuk mengonfigurasi kebijakan:

Buat file kebijakan baru yang mengizinkan image sistem yang dikelola Google, menetapkan evaluationMode ke REQUIRE_ATTESTATION, dan menambahkan node bernama requireAttestationsBy yang mereferensikan pengesah 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

Impor file YAML kebijakan ke Otorisasi Biner:

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

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

Menguji kebijakan

Dalam tutorial ini, Anda akan membuat pengesahan untuk contohnya, image "Hello World!" publik dari Artifact Registry. Awalnya, penegak memblokir gambar agar tidak di-deploy karena pengesahan yang diperlukan tidak ada.

Untuk mencoba men-deploy image:

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 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 pengesah.

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

kubectl delete deployment hello-server

Membuat pengesahan

Pengesahan adalah pernyataan dari pengesah bahwa proses yang diperlukan dalam pipeline Anda telah selesai dan image penampung yang dimaksud telah diizinkan untuk di-deploy. Pengesahan itu sendiri adalah catatan yang ditandatangani secara digital yang berisi jalur lengkap ke versi image seperti yang disimpan di registry image container Anda, serta identitas pengesah.

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

Untuk membuat pengesahan:

Tetapkan variabel yang menyimpan jalur registry dan ringkasan image:

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}

Membuat pengesahan

PKIX Cloud KMS

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

Buat payload pengesahan:

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

File JSON payload memiliki isi berikut:

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"
}
}

Tandatangani payload.

Jika menggunakan file PKIX lokal, tanda tangani payload dengan kunci pribadi PKIX lokal Anda dan hasilkan file tanda tangan:
```
openssl dgst -sha256 -sign ${PRIVATE_KEY_FILE} /tmp/generated_payload.json > /tmp/ec_signature
```
File output adalah versi bertanda tangan dari file JSON payload yang Anda buat di atas.
Dapatkan ID kunci publik dari pengesah.

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})
```

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 bahwa pengesahan dapat diverifikasi oleh pengesah yang Anda konfigurasi dalam kebijakan Anda.

Verifikasi bahwa pengesahan telah dibuat:

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

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

Menguji ulang kebijakan

Uji kebijakan dengan men-deploy image container sampel ke cluster. Kali ini, Anda harus men-deploy image menggunakan ringkasan, bukan tag seperti 1.0 atau latest, karena Otorisasi Biner menggunakan ringkasan untuk mencari pengesahan. Di sini, Otorisasi Biner mengizinkan image di-deploy karena image memiliki pengesahan terkait.

Untuk men-deploy image:

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, 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 memverifikasi bahwa penyiapan Anda 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.

Hapus cluster yang Anda buat di GKE:

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

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

Mengonfigurasi penyiapan multi-project Tetap teratur dengan koleksi Simpan dan kategorikan konten berdasarkan preferensi Anda.

Tujuan

Biaya

Sebelum memulai

Menyiapkan project deployer

Artifact Registry

Menyiapkan project pengesah

Menyiapkan project pengesahan

Membuat cluster

Membuat pengesah

Buat catatan Analisis Artefak

Buat pengesah

Menambahkan binding peran IAM untuk project deployer

Menetapkan izin pada catatan Analisis Artefak

Menyiapkan kunci PKIX

Membuat pasangan kunci

PKIX (Cloud KMS)

PKIX (kunci lokal)

Mengonfigurasi kebijakan

Menguji kebijakan

Artifact Registry

Membuat pengesahan

Artifact Registry

PKIX Cloud KMS

PKIX (kunci lokal)

Artifact Registry

Menguji ulang kebijakan

Pembersihan

Langkah berikutnya

Mengonfigurasi penyiapan multi-project