Mulai menggunakan Google Cloud CLI (GKE)

Tutorial ini menunjukkan cara mengonfigurasi dan menguji kebijakan Otorisasi Biner yang memerlukan pengesahan. 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 continuous integration (CI).

Dalam tutorial ini, cluster GKE, pengesahan, dan pengesah semuanya berada dalam satu project. Konfigurasi satu project sebagian besar berguna untuk menguji atau bereksperimen dengan layanan. Untuk contoh 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 Google Cloud console, lihat Mulai menggunakan Google Cloud console.

Tujuan

Dalam tutorial ini, Anda akan mempelajari cara:

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

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

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

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

    Go to project selector

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

  4. Install the Google Cloud CLI.

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

  6. To initialize the gcloud CLI, run the following command: 

    gcloud init

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

    Go to project selector

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

  9. Install the Google Cloud CLI.

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

  11. To initialize the gcloud CLI, run the following command: 

    gcloud init
  12. 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:

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 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 Anda. Tindakan ini akan memberikan informasi endpoint dan kredensial yang diperlukan untuk mengakses cluster di GKE.

Untuk memperbarui 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 sebagaimana 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 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 mengetahui informasi selengkapnya tentang struktur kebijakan, lihat Referensi YAML kebijakan.

Membuat pengesah

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

Untuk membuat pengesah, Anda harus:

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

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 image container.

Buat catatan Analisis Artefak

  1. 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.
    • attestor-note: nama catatan pengesah pilihan Anda.

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

    cat > /tmp/note_payload.json << EOM
{
  "name": "projects/${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/${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/${PROJECT_ID}/notes/${NOTE_ID}"

Buat pengesah

Sekarang, Anda dapat membuat pengesah:

  1. Buat attestor di Otorisasi Biner:

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

  2. Pastikan bahwa pengesah telah dibuat:

    gcloud container binauthz attestors list

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

Membuat pasangan kunci

Otorisasi Biner menggunakan kunci kriptografi untuk memverifikasi identitas penanda tangan secara aman. Hal ini memastikan bahwa hanya image container yang diizinkan yang dapat di-deploy. Pasangan kunci terdiri dari kunci pribadi dan kunci publik. Penanda tangan menggunakan kunci pribadi untuk menandatangani ringkasan gambar penampung, sehingga menghasilkan tanda tangan yang kemudian disimpan dalam pengesahan. Kunci publik disimpan di attestor. Pada waktu deployment, penegak Binary Authorization menggunakan kunci publik pengesah untuk memverifikasi tanda tangan dalam pengesahan sebelum mengizinkan container di-deploy.

Dalam tutorial ini, Anda menggunakan format Public-Key Infrastructure (X.509) (PKIX) untuk kunci kriptografi. 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 mengetahui informasi selengkapnya tentang algoritma penandatanganan, lihat Tujuan dan algoritma kunci.

Kunci yang dibuat dan disimpan oleh Cloud Key Management Service (Cloud KMS) sesuai dengan PKIX. Lihat Membuat pengesah 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:

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

  2. Untuk membuat keyring, jalankan perintah berikut:

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

  3. 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}

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

  5. Dapatkan ID kunci publik dari pengesah 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:

  1. Buat kunci pribadi:

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

  2. Ekstrak kunci publik dari kunci pribadi:

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

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

  4. 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 mengekspor file YAML kebijakan ke sistem lokal dan mengubah aturan default sehingga memerlukan pengesahan oleh pengesah yang Anda tentukan di atas.

Untuk mengonfigurasi kebijakan, ikuti langkah-langkah berikut:

  1. 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/${PROJECT_ID}/attestors/${ATTESTOR_NAME}
    name: projects/${PROJECT_ID}/policy
EOM

  2. 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 Anda konfigurasi di atas dengan mencoba men-deploy image container contoh ke cluster. Kebijakan akan memblokir deployment karena pengesahan yang diperlukan belum dilakukan.

Untuk tutorial ini, Anda dapat menggunakan contoh image dari Artifact Registry. Image dari Artifact Registry berada di jalur us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0. Jalur ini berisi image publik yang dibuat oleh Google yang berisi aplikasi contoh "Hello, World!".

Pertama, coba deploy image:

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 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 seseorang atau, lebih sering, proses otomatis yang berjalan saat image container dibuat. Tanda tangan dibuat menggunakan kunci pribadi dari pasangan kunci. Pada waktu deployment, pengelola Otorisasi Biner menggunakan kunci publik pengesah 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:

  1. 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}

  2. Untuk membuat pengesahan, lakukan hal berikut:

    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:

    1. Buat payload pengesahan:

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

      File JSON payload memiliki isi berikut:

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

    2. Untuk menandatangani payload dengan kunci pribadi PKIX Anda 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 bertanda tangan dari file JSON payload yang Anda buat sebelumnya dalam panduan ini.

    3. 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 Buat pasangan kunci PKIX di atas.

      Flag validate memeriksa bahwa pengesahan dapat diverifikasi oleh pengesah yang Anda konfigurasi dalam kebijakan Anda.

  3. Verifikasi bahwa pengesahan telah dibuat:

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

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

Menguji ulang kebijakan

Sekali lagi, 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 akan menggunakan ringkasan untuk mencari pengesahan. Di sini, Otorisasi Biner mengizinkan image di-deploy karena pengesahan yang diperlukan telah dilakukan.

Untuk men-deploy gambar, 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 berikutnya