Google menggunakan teknologi AI untuk menerjemahkan konten ke dalam bahasa pilihan Anda. Terjemahan AI mungkin mengandung kesalahan.

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

Siapkan project yang berbeda untuk deployment (GKE), attestor, dan pengelolaan pengesahan, untuk mendukung pemisahan tugas.
Konfigurasi aturan default kebijakan Otorisasi Biner Anda untuk mewajibkan pengesahan.
Buat pasangan kunci Infrastruktur Kunci Publik (X.509) (PKIX) untuk menandatangani, dan kemudian memverifikasi, pengesahan.
Buat attestor yang digunakan penguat Otorisasi Biner untuk memverifikasi pengesahan.
Tandatangani contoh gambar, buat pengesahan.
Uji kebijakan dengan men-deploy contoh gambar.

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

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.

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

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Install the Google Cloud CLI.

If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.

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.

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Install the Google Cloud CLI.

If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.

To initialize the gcloud CLI, run the following command:

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 oleh 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 project Google Cloud .

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

Mengaktifkan 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 berikutnya saat mengonfigurasi izin pada catatan Artifact Analysis yang terkait dengan attestor Anda.

Menyiapkan project pengesah

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

Untuk menyiapkan project attestor:

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 project ID dan nomor project:

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

Aktifkan Artifact Analysis dan Binary Authorization API:

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

Dapatkan nama akun layanan project attestor:
```
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 Artifact Analysis yang terkait dengan attestor 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 Artifact Analysis dalam project ini, tetapi hanya pengelola pengesahan yang perlu memiliki 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 kredensial dan informasi endpoint 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 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. Anda membuat attestor di project attestor Anda.

Untuk membuat attestor, Anda harus:

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

Untuk tutorial ini, Anda memiliki satu attestor 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.

Membuat catatan Artifact Analysis

Tetapkan variabel yang menyimpan nama attestor dan catatan Artifact Analysis 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 attestor

Sekarang, Anda dapat membuat attestor:

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 attestor telah 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 deployer ke attestor. 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 agar dapat diakses oleh project deployer dan project attestor. Anda dapat melakukannya dengan memperbarui kebijakan IAM untuk catatan guna menetapkan akses Viewer 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 Artifact Analysis (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 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 akan 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.

Buat 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 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 PKIX asimetris 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 sebagaimana 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.
  
  Buat kunci KMS yang kunci publiknya dapat disimpan di attestor. 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
  
  Buat key ring KMS:
  
  gcloud kms keyrings create ${KMS_KEYRING_NAME} \ --location ${KMS_KEY_LOCATION} \ --project ${KMS_KEY_PROJECT_ID}
  
  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: Kami sangat menyarankan untuk tidak menggunakan key pair yang dibuat secara lokal di lingkungan produksi karena dapat menimbulkan risiko keamanan. Sebaiknya gunakan Cloud Key Management Service. Contoh ini diberikan hanya 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 attestor.
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 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 di 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 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 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

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 contoh, image "Hello World!" publik dari Artifact Registry. Awalnya, enforcer memblokir image 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 mirip dengan berikut ini:

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

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

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

Menandatangani payload.

Jika menggunakan file PKIX lokal, tandatangani payload dengan kunci pribadi PKIX lokal Anda dan keluarkan 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 attestor.

Anda dapat melihat ID kunci publik Anda 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 apakah pengesahan dapat diverifikasi oleh attestor yang Anda konfigurasi dalam kebijakan.

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

Tes 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 attestor

Membuat catatan Artifact Analysis

Buat attestor

Menambahkan binding peran IAM untuk project deployer

Menetapkan izin pada catatan Artifact Analysis

Menyiapkan kunci PKIX

Buat 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

Tes ulang kebijakan

Pembersihan

Langkah berikutnya

Mengonfigurasi penyiapan multi-project