Questa pagina mostra come utilizzare la convalida continua (CV) di Autorizzazione binaria semplice controllo dell'attestazione di firma. Il controllo verifica le attestazioni delle immagini container associate ai pod in esecuzione in un cluster Google Kubernetes Engine (GKE) in cui è abilitata la verifica della conformità.
Costi
Questa guida utilizza i seguenti servizi Google Cloud :
- Autorizzazione binaria, ma CV è disponibile senza costi durante la fase di anteprima
- GKE
- Cloud Key Management Service
Per generare una stima dei costi in base all'utilizzo previsto, utilizza il calcolatore prezzi.
Prima di iniziare
- 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.
-
Install the Google Cloud CLI.
-
Se utilizzi un provider di identità (IdP) esterno, devi prima accedere a gcloud CLI con la tua identità federata.
-
Per inizializzare gcloud CLI, esegui questo comando:
gcloud init
-
Create or select a Google Cloud project.
-
Create a Google Cloud project:
gcloud projects create PROJECT_ID
Replace
PROJECT_ID
with a name for the Google Cloud project you are creating. -
Select the Google Cloud project that you created:
gcloud config set project PROJECT_ID
Replace
PROJECT_ID
with your Google Cloud project name.
-
-
Verify that billing is enabled for your Google Cloud project.
-
Enable the Binary Authorization, Cloud Key Management Service, Google Kubernetes Engine APIs:
gcloud services enable binaryauthorization.googleapis.com
cloudkms.googleapis.com container.googleapis.com -
Install the Google Cloud CLI.
-
Se utilizzi un provider di identità (IdP) esterno, devi prima accedere a gcloud CLI con la tua identità federata.
-
Per inizializzare gcloud CLI, esegui questo comando:
gcloud init
-
Create or select a Google Cloud project.
-
Create a Google Cloud project:
gcloud projects create PROJECT_ID
Replace
PROJECT_ID
with a name for the Google Cloud project you are creating. -
Select the Google Cloud project that you created:
gcloud config set project PROJECT_ID
Replace
PROJECT_ID
with your Google Cloud project name.
-
-
Verify that billing is enabled for your Google Cloud project.
-
Enable the Binary Authorization, Cloud Key Management Service, Google Kubernetes Engine APIs:
gcloud services enable binaryauthorization.googleapis.com
cloudkms.googleapis.com container.googleapis.com - Assicurati che gcloud CLI sia aggiornato all'ultima versione.
- Installa lo strumento a riga di comando
kubectl
. - Se i criteri di Autorizzazione binaria e i cluster GKE si trovano in progetti diversi, assicurati che Autorizzazione binaria sia abilitata in entrambi i progetti.
-
Se il progetto del cluster è diverso dal progetto dei criteri:
Valutatore criterio di autorizzazione binaria (
roles/binaryauthorization.policyEvaluator
) nell'agente di servizio di autorizzazione binaria del progetto del cluster, per accedere al progetto dei criteri -
Se il progetto di attestazione è diverso dal progetto di criteri:
Visualizzatore occorrenze Container Analysis (
roles/containeranalysis.occurrences.viewer
) sull'agente di servizio di autorizzazione binaria del progetto di criteri, per consentirgli di accedere al progetto di attestazione Concedi l'autorizzazione all'agente di servizio di Autorizzazione binaria del progetto del cluster per accedere alla policy nel progetto della policy.
Recupera l'agente di servizio di Autorizzazione binaria del progetto del cluster:
PROJECT_NUMBER=$(gcloud projects list --filter="projectId:CLUSTER_PROJECT_ID" \ --format="value(PROJECT_NUMBER)") CLUSTER_SERVICE_ACCOUNT="service-$PROJECT_NUMBER@gcp-sa-binaryauthorization.iam.gserviceaccount.com"
Sostituisci
CLUSTER_PROJECT_ID
con l'ID progetto del cluster.Consenti a CV di valutare la policy sul cluster:
gcloud projects add-iam-policy-binding POLICY_PROJECT_ID \ --member="serviceAccount:$CLUSTER_SERVICE_ACCOUNT" \ --role='roles/binaryauthorization.policyEvaluator'
Sostituisci
POLICY_PROJECT_ID
con l'ID del progetto che contiene la tua policy.
Consenti all'agente di servizio di autorizzazione binaria del progetto di policy di accedere alle attestazioni nel progetto di attestazione:
Ottieni l'agente di servizio di Autorizzazione binaria del progetto della policy:
PROJECT_NUMBER=$(gcloud projects list \ --filter="projectId:POLICY_PROJECT_ID" \ --format="value(PROJECT_NUMBER)") SERVICE_ACCOUNT="service-$PROJECT_NUMBER@gcp-sa-binaryauthorization.iam.gserviceaccount.com"
Sostituisci
POLICY_PROJECT_ID
con l'ID del progetto che contiene la tua policy.Concedi il ruolo:
gcloud projects add-iam-policy-binding ATTESTATION_PROJECT_ID \ --member="serviceAccount:$SERVICE_ACCOUNT" \ --role='roles/containeranalysis.occurrences.viewer'
Sostituisci
ATTESTATION_PROJECT_ID
con l'ID del progetto che contiene le tue attestazioni.
Configura le variabili di ambiente necessarie per creare la coppia di chiavi. Per farlo, ti consigliamo di compilare i segnaposto nel seguente comando e poi eseguirlo.
KMS_KEY_PROJECT_ID=KMS_KEY_PROJECT_ID KMS_KEYRING_NAME=KMS_KEYRING_NAME KMS_KEY_NAME=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 KEY_FILE=KEY_FILE
Sostituisci quanto segue:
KMS_KEY_PROJECT_ID
: il tuo ID progettoKMS_KEYRING_NAME
: un nome per la raccolta di chiavi Cloud KMSKMS_KEY_NAME
: un nome per la chiave Cloud KMSKEY_FILE
: un percorso locale per salvare la chiave Cloud KMS
Crea il keyring:
gcloud kms keyrings create ${KMS_KEYRING_NAME} \ --location=${KMS_KEY_LOCATION} \ --project=${KMS_KEY_PROJECT_ID}
Crea la chiave:
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}
Esporta il materiale della chiave pubblica in un file:
gcloud kms keys versions get-public-key ${KMS_KEY_VERSION} \ --key=${KMS_KEY_NAME} \ --keyring=${KMS_KEYRING_NAME} \ --location=${KMS_KEY_LOCATION} \ --output-file=${KEY_FILE} \ --project=${KMS_KEY_PROJECT_ID}
Crea la chiave privata:
PRIVATE_KEY_FILE="/tmp/ec_private.pem" openssl ecparam -genkey -name prime256v1 -noout -out ${PRIVATE_KEY_FILE}
Recupera la chiave pubblica dalla chiave privata:
PUBLIC_KEY_FILE="/tmp/ec_public.pem" openssl ec -in ${PRIVATE_KEY_FILE} -pubout -out ${PUBLIC_KEY_FILE}
Crea il file YAML della policy della piattaforma di controllo dell'attestazione di firma semplice:
PKIX Cloud KMS
cat > /tmp/my-policy.yaml << EOF gkePolicy: checkSets: - checks: - simpleSigningAttestationCheck: containerAnalysisAttestationProjects: - projects/ATTESTATION_PROJECT_ID attestationAuthenticators: pkixPublicKeySet: pkixPublicKeys: publicKeyPem: | $(awk '{printf " %s\n", $0}' ${KEY_FILE}) signatureAlgorithm: ECDSA_P256_SHA256 keyId: |- //cloudkms.googleapis.com/v1/projects/${KMS_KEY_PROJECT_ID}/locations/${KMS_KEY_LOCATION}/keyRings/${KMS_KEYRING_NAME}/cryptoKeys/${KMS_KEY_NAME}/cryptoKeyVersions/${KMS_KEY_VERSION} EOF
Sostituisci
ATTESTATION_PROJECT_ID
con l'ID del progetto che archivia le attestazioni create utilizzando questa chiave Cloud KMS.Chiave locale
cat > /tmp/my-policy.yaml <<EOF gkePolicy: checkSets: - checks: - simpleSigningAttestationCheck: containerAnalysisAttestationProjects: - projects/ATTESTATION_PROJECT_ID attestationAuthenticators: pkixPublicKeySet: pkixPublicKeys: publicKeyPem: | $(awk '{printf " %s\n", $0}' /tmp/ec_public.pem) signatureAlgorithm: ECDSA_P256_SHA256 keyId: | PUBLIC_KEY_ID EOF
Sostituisci quanto segue:
ATTESTATION_PROJECT_ID
: l'ID del progetto che archivia le attestazioni create utilizzando la chiave localePUBLIC_KEY_ID
: un ID che identifica in modo univoco la chiave locale
Crea la policy della piattaforma:
Prima di utilizzare i dati dei comandi riportati di seguito, effettua le seguenti sostituzioni:
- POLICY_ID: un ID policy della piattaforma
a tua scelta. Se la norma si trova in un altro progetto, puoi utilizzare il nome completo della risorsa:
projects/POLICY_PROJECT_ID/platforms/gke/policies/POLICY_ID
. - POLICY_PATH: un percorso del file delle norme.
- POLICY_PROJECT_ID: l'ID progetto della policy.
Esegui questo comando:
Linux, macOS o Cloud Shell
gcloud beta container binauthz policy create POLICY_ID \ --platform=gke \ --policy-file=POLICY_PATH \ --project=POLICY_PROJECT_ID
Windows (PowerShell)
gcloud beta container binauthz policy create POLICY_ID ` --platform=gke ` --policy-file=POLICY_PATH ` --project=POLICY_PROJECT_ID
Windows (cmd.exe)
gcloud beta container binauthz policy create POLICY_ID ^ --platform=gke ^ --policy-file=POLICY_PATH ^ --project=POLICY_PROJECT_ID
- POLICY_ID: un ID policy della piattaforma
a tua scelta. Se la norma si trova in un altro progetto, puoi utilizzare il nome completo della risorsa:
Memorizza il valore dell'ID per utilizzarlo in un secondo momento:
PUBLIC_KEY_ID="PUBLIC_KEY_ID"
Sostituisci
PUBLIC_KEY_ID
con l'ID specificato nel campokeyId
del file di policy della piattaforma all'inizio di questa guida.La chiave privata viene utilizzata quando vengono create le attestazioni, come descritto più avanti in questa guida.
CLUSTER_NAME
: un nome del cluster.LOCATION
: la località, ad esempious-central1
oasia-south1
.POLICY_PROJECT_ID
: l'ID del progetto in cui è archiviata la policy.POLICY_ID
: l'ID della policy.CLUSTER_PROJECT_ID
: l'ID progetto del cluster.CLUSTER_NAME
: un nome del cluster.LOCATION
: la località, ad esempious-central1
oasia-south1
.POLICY_PROJECT_ID
: l'ID del progetto in cui è archiviata la policy.POLICY_ID
: l'ID della policy.CLUSTER_PROJECT_ID
: l'ID progetto del cluster.CLUSTER_NAME
: il nome del clusterLOCATION
: la località, ad esempious-central1
oasia-south1
POLICY_PROJECT_ID
: l'ID del progetto in cui è archiviata la policyPOLICY_ID
: l'ID policyCLUSTER_PROJECT_ID
: l'ID progetto del clusterCLUSTER_NAME
: un nome del clusterLOCATION
: la località, ad esempious-central1
oasia-south1
POLICY_PROJECT_ID
: l'ID del progetto in cui è archiviata la policyPOLICY_ID
: l'ID policyCLUSTER_PROJECT_ID
: l'ID progetto del clusterCrea le variabili della nota:
NOTE_PROJECT_ID=NOTE_PROJECT_ID NOTE_ID="test-note" NOTE_URI="projects/${NOTE_PROJECT_ID}/notes/${NOTE_ID}" DESCRIPTION="CV test note"
Sostituisci
NOTE_PROJECT_ID
: l'ID del progetto che contiene la nota.Crea il file dei contenuti della nota:
cat > /tmp/note_payload.json << EOM { "name": "${NOTE_URI}", "attestation": { "hint": { "human_readable_name": "${DESCRIPTION}" } } } EOM
Crea la nota:
curl -X POST \ -H "Content-Type: application/json" \ -H "Authorization: Bearer $(gcloud auth print-access-token)" \ -H "x-goog-user-project: ${NOTE_PROJECT_ID}" \ --data-binary @/tmp/note_payload.json "https://containeranalysis.googleapis.com/v1/projects/${NOTE_PROJECT_ID}/notes/?noteId=${NOTE_ID}"
Sostituisci
NOTE_PROJECT_ID
: l'ID del progetto che contiene la nota(Facoltativo) Per verificare di aver creato la nota:
curl \ -H "Authorization: Bearer $(gcloud auth print-access-token)" \ -H "x-goog-user-project: NOTE_PROJECT_ID" \ "https://containeranalysis.googleapis.com/v1/projects/NOTE_PROJECT_ID/notes/"
Sostituisci
NOTE_PROJECT_ID
con l'ID del progetto che contiene la nota.Firma l'immagine e crea l'attestazione utilizzando la codifica pre-autenticazione (PAE) (consigliata):
gcloud beta container binauthz attestations sign-and-create \ --artifact-url=${IMAGE_TO_ATTEST} \ --keyversion=${KMS_KEY_VERSION} \ --keyversion-key=${KMS_KEY_NAME} \ --keyversion-keyring=${KMS_KEYRING_NAME} \ --keyversion-location=${KMS_KEY_LOCATION} \ --note=${NOTE_URI} \ --pae-encode-payload \ --dsse-type=DSSE_TYPE
Sostituisci
DSSE_TYPE
con il tipo DSSE per la codifica PAE. Il flag è impostato suapplication/vnd.dev.cosign.simplesigning.v1+json
per impostazione predefinita.Crea un file payload della firma:
cat > /tmp/generated_payload.json << EOM { "critical": { "identity": { "docker-reference": "${IMAGE_PATH}" }, "image": { "docker-manifest-digest": "${IMAGE_DIGEST}" }, "type": "Google Cloud BinAuthz container signature" } } EOM
Firma il payload:
gcloud kms asymmetric-sign \ --version=${KMS_KEY_VERSION} \ --key=${KMS_KEY_NAME} \ --keyring=${KMS_KEYRING_NAME} \ --location=${KMS_KEY_LOCATION} \ --digest-algorithm=sha256 \ --input-file=/tmp/generated_payload.json \ --signature-file=/tmp/ec_signature \ --project=${KMS_KEY_PROJECT_ID}
Crea i contenuti dell'attestazione:
cat > /tmp/attestation.json << EOM { "resourceUri": "${IMAGE_TO_ATTEST}", "note_name": "${NOTE_URI}", "attestation": { "serialized_payload": "$(base64 --wrap=0 /tmp/generated_payload.json)", "signatures": [{ "public_key_id": "${PUBLIC_KEY_ID}", "signature": "$(base64 --wrap=0 /tmp/ec_signature)" }] } } EOM
Crea l'attestazione:
curl -X POST "https://containeranalysis.googleapis.com/v1/projects/${NOTE_PROJECT_ID}/occurrences/" \ -H "Content-Type: application/json" \ -H "X-Goog-User-Project: ${NOTE_PROJECT_ID}" \ -H "Authorization: Bearer $(gcloud auth print-access-token)" \ --data-binary @/tmp/attestation.json
Sostituisci
NOTE_PROJECT_ID
con l'ID del progetto che contiene la nota.Crea un file payload della firma:
cat > /tmp/generated_payload.json << EOM { "critical": { "identity": { "docker-reference": "${IMAGE_PATH}" }, "image": { "docker-manifest-digest": "${IMAGE_DIGEST}" }, "type": "Google Cloud BinAuthz container signature" } } EOM
Crea il file del payload della firma:
openssl dgst -sha256 -sign ${PRIVATE_KEY_FILE} /tmp/generated_payload.json > /tmp/ec_signature
Crea l'attestazione:
gcloud container binauthz attestations create \ --project=ATTESTATION_PROJECT_ID \ --artifact-url=${IMAGE_TO_ATTEST} \ --note=${NOTE_URI} \ --signature-file=/tmp/ec_signature \ --public-key-id=PUBLIC_KEY_ID
Crea un file payload della firma:
cat > /tmp/generated_payload.json << EOM { "critical": { "identity": { "docker-reference": "${IMAGE_PATH}" }, "image": { "docker-manifest-digest": "${IMAGE_DIGEST}" }, "type": "Google Cloud BinAuthz container signature" } } EOM
Crea il file del payload della firma:
openssl dgst -sha256 -sign ${PRIVATE_KEY_FILE} /tmp/generated_payload.json > /tmp/ec_signature
Crea i contenuti dell'attestazione:
cat > /tmp/attestation.json << EOM { "resourceUri": "${IMAGE_TO_ATTEST}", "note_name": "${NOTE_URI}", "attestation": { "serialized_payload": "$(base64 --wrap=0 /tmp/generated_payload.json)", "signatures": [{ "public_key_id": "${PUBLIC_KEY_ID}", "signature": "$(base64 --wrap=0 /tmp/ec_signature)" }] } } EOM
Crea l'attestazione:
curl -X POST "https://containeranalysis.googleapis.com/v1/projects/${NOTE_PROJECT_ID}/occurrences/" \ -H "Content-Type: application/json" \ -H "X-Goog-User-Project: ${NOTE_PROJECT_ID}" \ -H "Authorization: Bearer $(gcloud auth print-access-token)" \ --data-binary @/tmp/attestation.json
Configura
kubectl
:gcloud container clusters get-credentials CLUSTER_NAME \ --location=LOCATION \ --project=CLUSTER_PROJECT_ID
Sostituisci quanto segue:
CLUSTER_NAME
: il nome del tuo clusterLOCATION
: la posizione del clusterCLUSTER_PROJECT_ID
: l'ID progetto del cluster
Esegui il deployment di un servizio e controlla il deployment in base al criterio di Autorizzazione binaria:
kubectl run hello-app-with-attestation --image=$IMAGE_PATH@$IMAGE_DIGEST
Il pod è stato sottoposto a deployment. Poiché l'immagine ha un'attestazione, CV non produce voci di log correlate a questo pod.
ImageFreshnessCheck
SigstoreSignatureCheck
SimpleSigningAttestationCheck
SlsaCheck
TrustedDirectoryCheck
VulnerabilityCheck
CLUSTER_NAME
: il nome del clusterLOCATION
: la posizione del clusterCLUSTER_PROJECT_ID
: l'ID progetto del clusterCLUSTER_NAME
: il nome del clusterLOCATION
: la posizione del clusterCLUSTER_PROJECT_ID
: l'ID progetto del clusterPOLICY_ID
: l'ID della policyPOLICY_PROJECT_ID
: l'ID progetto della policy- Utilizzare il controllo dell'aggiornamento delle immagini
- Utilizzare il semplice controllo dell'attestazione della firma
- Utilizzare il controllo della firma Sigstore
- Utilizzare il controllo SLSA
- Utilizzare il controllo della directory attendibile
- Utilizzare il controllo delle vulnerabilità
- Visualizza i log delle conversioni
Ruoli obbligatori
Questa sezione mostra come impostare i ruoli per questo controllo.
Panoramica
Se esegui tutti i prodotti menzionati in questa guida nello stesso progetto, non devi impostare alcuna autorizzazione. Autorizzazione binaria configura correttamente i ruoli quando lo attivi. Se esegui i prodotti in progetti diversi, devi impostare i ruoli come descritto in questa sezione.
Per assicurarti che l'agente di servizio Binary Authorization in ogni progetto disponga delle autorizzazioni necessarie per valutare il controllo dell'attestazione di firma semplice CV, chiedi all'amministratore di concedere all'agente di servizio Binary Authorization in ogni progetto i seguenti ruoli IAM:
Per ulteriori informazioni sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.
L'amministratore potrebbe anche essere in grado di concedere all'agente di servizio Binary Authorization in ogni progetto le autorizzazioni richieste tramite ruoli personalizzati o altri ruoli predefiniti.
Concedi ruoli utilizzando gcloud CLI
Per assicurarti che il service agent di autorizzazione binaria in ogni progetto disponga delle autorizzazioni necessarie per valutare il controllo di attestazione della firma semplice CV, concedi al service agent di autorizzazione binaria in ogni progetto i seguenti ruoli IAM:
Creare una coppia di chiavi
In questa sezione, crei una coppia di chiavi asimmetriche Elliptic Curve Digital Signature Algorithm (ECDSA).
Utilizzi la chiave privata per firmare l'immagine, creando l'attestazione. Includi la chiave pubblica in una norma della piattaforma. Quando CV controlla l'attestazione, utilizza la chiave pubblica per verificarla.
Puoi utilizzare Cloud Key Management Service o chiavi locali, ma ti consigliamo di utilizzare le chiavi Cloud KMS per la produzione.
PKIX Cloud KMS
Per creare la coppia di chiavi in Cloud KMS:
Chiave locale
Per creare la coppia di chiavi localmente:
Crea una policy della piattaforma
Per creare una policy della piattaforma CV con un semplice controllo di attestazione della firma:
Abilita CV
Puoi creare un nuovo cluster o aggiornarne uno esistente per utilizzare il monitoraggio CV con criteri della piattaforma basati su controlli.
Crea un cluster che utilizza il monitoraggio CV
In questa sezione, creerai un cluster che utilizza solo il monitoraggio CV con criteri della piattaforma basati su controlli.
Prima di utilizzare i dati dei comandi riportati di seguito, effettua le seguenti sostituzioni:
Esegui questo comando:
Linux, macOS o Cloud Shell
gcloud beta container clusters create CLUSTER_NAME \ --location=LOCATION \ --binauthz-evaluation-mode=POLICY_BINDINGS \ --binauthz-policy-bindings=name=projects/POLICY_PROJECT_ID/platforms/gke/policies/POLICY_ID \ --project=CLUSTER_PROJECT_ID
Windows (PowerShell)
gcloud beta container clusters create CLUSTER_NAME ` --location=LOCATION ` --binauthz-evaluation-mode=POLICY_BINDINGS ` --binauthz-policy-bindings=name=projects/POLICY_PROJECT_ID/platforms/gke/policies/POLICY_ID ` --project=CLUSTER_PROJECT_ID
Windows (cmd.exe)
gcloud beta container clusters create CLUSTER_NAME ^ --location=LOCATION ^ --binauthz-evaluation-mode=POLICY_BINDINGS ^ --binauthz-policy-bindings=name=projects/POLICY_PROJECT_ID/platforms/gke/policies/POLICY_ID ^ --project=CLUSTER_PROJECT_ID
Crea un cluster che utilizza l'applicazione e il monitoraggio CV
In questa sezione, creerai un cluster che utilizza sia l'applicazione dei criteri project-singleton sia il monitoraggio delle vulnerabilità comuni con criteri della piattaforma basati su controlli:
Prima di utilizzare i dati dei comandi riportati di seguito, effettua le seguenti sostituzioni:
Esegui questo comando:
Linux, macOS o Cloud Shell
gcloud beta container clusters create CLUSTER_NAME \ --location=LOCATION \ --binauthz-evaluation-mode=POLICY_BINDINGS_AND_PROJECT_SINGLETON_POLICY_ENFORCE \ --binauthz-policy-bindings=name=projects/POLICY_PROJECT_ID/platforms/gke/policies/POLICY_ID \ --project=CLUSTER_PROJECT_ID
Windows (PowerShell)
gcloud beta container clusters create CLUSTER_NAME ` --location=LOCATION ` --binauthz-evaluation-mode=POLICY_BINDINGS_AND_PROJECT_SINGLETON_POLICY_ENFORCE ` --binauthz-policy-bindings=name=projects/POLICY_PROJECT_ID/platforms/gke/policies/POLICY_ID ` --project=CLUSTER_PROJECT_ID
Windows (cmd.exe)
gcloud beta container clusters create CLUSTER_NAME ^ --location=LOCATION ^ --binauthz-evaluation-mode=POLICY_BINDINGS_AND_PROJECT_SINGLETON_POLICY_ENFORCE ^ --binauthz-policy-bindings=name=projects/POLICY_PROJECT_ID/platforms/gke/policies/POLICY_ID ^ --project=CLUSTER_PROJECT_ID
Aggiorna un cluster per utilizzare il monitoraggio CV
In questa sezione, aggiornerai un cluster in modo che utilizzi il monitoraggio CV solo con i criteri della piattaforma basati su controlli. Se il cluster ha già l'applicazione dei criteri project-singleton abilitata, l'esecuzione di questo comando la disabilita. Ti consigliamo invece di aggiornare il cluster con l'applicazione e il monitoraggio delle vulnerabilità e delle esposizioni comuni abilitati.
Prima di utilizzare i dati dei comandi riportati di seguito, effettua le seguenti sostituzioni:
Esegui questo comando:
Linux, macOS o Cloud Shell
gcloud beta container clusters update CLUSTER_NAME \ --location=LOCATION \ --binauthz-evaluation-mode=POLICY_BINDINGS \ --binauthz-policy-bindings=name=projects/POLICY_PROJECT_ID/platforms/gke/policies/POLICY_ID \ --project=CLUSTER_PROJECT_ID
Windows (PowerShell)
gcloud beta container clusters update CLUSTER_NAME ` --location=LOCATION ` --binauthz-evaluation-mode=POLICY_BINDINGS ` --binauthz-policy-bindings=name=projects/POLICY_PROJECT_ID/platforms/gke/policies/POLICY_ID ` --project=CLUSTER_PROJECT_ID
Windows (cmd.exe)
gcloud beta container clusters update CLUSTER_NAME ^ --location=LOCATION ^ --binauthz-evaluation-mode=POLICY_BINDINGS ^ --binauthz-policy-bindings=name=projects/POLICY_PROJECT_ID/platforms/gke/policies/POLICY_ID ^ --project=CLUSTER_PROJECT_ID
Aggiorna un cluster per utilizzare l'applicazione e il monitoraggio CV
In questa sezione, aggiornerai un cluster in modo che utilizzi sia l'applicazione dei criteri singleton del progetto sia il monitoraggio delle vulnerabilità comuni con i criteri della piattaforma basati su controlli.
Prima di utilizzare i dati dei comandi riportati di seguito, effettua le seguenti sostituzioni:
Esegui questo comando:
Linux, macOS o Cloud Shell
gcloud beta container clusters update CLUSTER_NAME \ --location=LOCATION \ --binauthz-evaluation-mode=POLICY_BINDINGS_AND_PROJECT_SINGLETON_POLICY_ENFORCE \ --binauthz-policy-bindings=name=projects/POLICY_PROJECT_ID/platforms/gke/policies/POLICY_ID \ --project=CLUSTER_PROJECT_ID
Windows (PowerShell)
gcloud beta container clusters update CLUSTER_NAME ` --location=LOCATION ` --binauthz-evaluation-mode=POLICY_BINDINGS_AND_PROJECT_SINGLETON_POLICY_ENFORCE ` --binauthz-policy-bindings=name=projects/POLICY_PROJECT_ID/platforms/gke/policies/POLICY_ID ` --project=CLUSTER_PROJECT_ID
Windows (cmd.exe)
gcloud beta container clusters update CLUSTER_NAME ^ --location=LOCATION ^ --binauthz-evaluation-mode=POLICY_BINDINGS_AND_PROJECT_SINGLETON_POLICY_ENFORCE ^ --binauthz-policy-bindings=name=projects/POLICY_PROJECT_ID/platforms/gke/policies/POLICY_ID ^ --project=CLUSTER_PROJECT_ID
Creare la nota Artifact Analysis
In questa sezione, crea una nota di analisi degli artefatti di esempio per collegare le attestazioni. Per creare la nota:
Test CV
In questa sezione, testerai CV eseguendo il deployment dell'immagine per cui hai creato un'attestazione. In questo caso, il controllo dell'attestazione della firma semplice del CV verifica l'attestazione e non produce alcuna voce di log.
Quindi tenti di eseguire il deployment di un'altra immagine senza attestazione. In questo caso, il controllo CV non riesce a trovare l'attestazione e registra la violazione in Cloud Logging.
Per creare le variabili che utilizzi per testare la conversione, esegui i seguenti comandi:
IMAGE_PATH="us-docker.pkg.dev/google-samples/containers/gke/hello-app"
IMAGE_DIGEST="sha256:37e5287945774f27b418ce567cd77f4bbc9ef44a1bcd1a2312369f31f9cce567"
IMAGE_TO_ATTEST="${IMAGE_PATH}@${IMAGE_DIGEST}"
Creare un'attestazione
Per superare il controllo della semplice attestazione della firma, l'immagine deve avere un'attestazione valida.
Puoi creare un'attestazione utilizzando gcloud CLI o l'API REST.
PKIX Cloud KMS
gcloud
Per creare un'attestazione utilizzando gcloud CLI:
API REST
Per creare un'attestazione utilizzando l'API REST:
Chiave locale
gcloud
API REST
Esegui il deployment dell'immagine con un'attestazione
Per eseguire il deployment di un'immagine per cui è stata creata un'attestazione:
Esegui il deployment di un'immagine senza attestazione
In questa sezione, esegui il deployment di un'immagine senza attestazione associata.
Poiché le norme richiedono attestazioni e questa immagine non ne ha una, CV registra regolarmente la violazione mentre il container è in esecuzione.
Per eseguire il deployment dell'immagine, esegui questo comando:
kubectl run hello-app-without-attestation \
--image=$IMAGE_PATH@$IMAGE_DIGEST
Il pod è stato sottoposto a deployment. Poiché l'immagine non ha un'attestazione, CV produce voci di log� mentre il pod è in esecuzione.
Visualizzare i log per le voci CV
Puoi cercare le voci di Cloud Logging per trovare errori di configurazione di CV e violazioni della convalida delle norme della piattaforma CV.
CV registra errori e violazioni in Cloud Logging entro 24 ore. Di solito puoi visualizzare le voci entro poche ore.
Visualizzare i log degli errori di configurazione di CV
Per visualizzare i log degli errori di configurazione di CV, esegui questo comando:
gcloud logging read \
--order="desc" \
--freshness=7d \
--project=CLUSTER_PROJECT_ID \
'logName:"binaryauthorization.googleapis.com%2Fcontinuous_validation" "configErrorEvent"'
L'output seguente mostra un errore di configurazione in cui non viene trovata una policy della piattaforma CV:
{
"insertId": "141d4f10-72ea-4a43-b3ec-a03da623de42",
"jsonPayload": {
"@type": "type.googleapis.com/google.cloud.binaryauthorization.v1beta1.ContinuousValidationEvent",
"configErrorEvent": {
"description": "Cannot monitor cluster 'us-central1-c.my-cluster': Resource projects/123456789/platforms/gke/policies/my-policy does not exist."
}
},
"resource": {
"type": "k8s_cluster",
"labels": {
"cluster_name": "my-cluster",
"location": "us-central1-c",
"project_id": "my-project"
}
},
"timestamp": "2024-05-28T15:31:03.999566Z",
"severity": "WARNING",
"logName": "projects/my-project/logs/binaryauthorization.googleapis.com%2Fcontinuous_validation",
"receiveTimestamp": "2024-05-28T16:30:56.304108670Z"
}
Visualizzare le violazioni della convalida delle norme della piattaforma CV
Se nessuna immagine viola le norme della piattaforma che hai attivato, nei log non vengono visualizzate voci.
Per visualizzare le voci di log CV degli ultimi sette giorni, esegui questo comando:
gcloud logging read \
--order="desc" \
--freshness=7d \
--project=CLUSTER_PROJECT_ID \
'logName:"binaryauthorization.googleapis.com%2Fcontinuous_validation" "policyName"'
Sostituisci CLUSTER_PROJECT_ID
con l'ID progetto del cluster.
Tipi di controllo
I log di CV controllano le informazioni sulle violazioni per checkResults
. Nella voce, il valore checkType
indica il controllo. I valori per ogni controllo sono
i seguenti:
Log di esempio
La seguente voce di log CV descrive un'immagine non conforme che viola un controllo della directory attendibile:
{
"insertId": "637c2de7-0000-2b64-b671-24058876bb74",
"jsonPayload": {
"podEvent": {
"endTime": "2022-11-22T01:14:30.430151Z",
"policyName": "projects/123456789/platforms/gke/policies/my-policy",
"images": [
{
"result": "DENY",
"checkResults": [
{
"explanation": "TrustedDirectoryCheck at index 0 with display name \"My trusted directory check\" has verdict NOT_CONFORMANT. Image is not in a trusted directory",
"checkSetName": "My check set",
"checkSetIndex": "0",
"checkName": "My trusted directory check",
"verdict": "NON_CONFORMANT",
"checkType": "TrustedDirectoryCheck",
"checkIndex": "0"
}
],
"image": "gcr.io/my-project/hello-app:latest"
}
],
"verdict": "VIOLATES_POLICY",
"podNamespace": "default",
"deployTime": "2022-11-22T01:06:53Z",
"pod": "hello-app"
},
"@type": "type.googleapis.com/google.cloud.binaryauthorization.v1beta1.ContinuousValidationEvent"
},
"resource": {
"type": "k8s_cluster",
"labels": {
"project_id": "my-project",
"location": "us-central1-a",
"cluster_name": "my-test-cluster"
}
},
"timestamp": "2022-11-22T01:44:28.729881832Z",
"severity": "WARNING",
"logName": "projects/my-project/logs/binaryauthorization.googleapis.com%2Fcontinuous_validation",
"receiveTimestamp": "2022-11-22T03:35:47.171905337Z"
}
Esegui la pulizia
Questa sezione descrive come eseguire la pulizia del monitoraggio delle conversioni che hai configurato in precedenza in questa guida.
Puoi disattivare il monitoraggio delle vulnerabilità comuni o sia Autorizzazione binaria che le vulnerabilità comuni nel tuo cluster.
Disabilitare Autorizzazione binaria in un cluster
Per disattivare l'applicazione sia di CV che di Autorizzazione binaria nel tuo cluster, esegui questo comando:
gcloud beta container clusters update CLUSTER_NAME \
--binauthz-evaluation-mode=DISABLED \
--location=LOCATION \
--project=CLUSTER_PROJECT_ID
Sostituisci quanto segue:
Disabilita il monitoraggio delle policy basato sui controlli in un cluster
Per disattivare CV con criteri basati su controlli nel cluster e riattivare l'applicazione utilizzando il criterio di applicazione di Autorizzazione binaria, esegui il seguente comando:
gcloud beta container clusters update CLUSTER_NAME \
--binauthz-evaluation-mode=PROJECT_SINGLETON_POLICY_ENFORCE \
--location=LOCATION \
--project="CLUSTER_PROJECT_ID"
Sostituisci quanto segue:
Tieni presente che --binauthz-evaluation-mode=PROJECT_SINGLETON_POLICY_ENFORCE
è
equivalente al flag precedente --enable-binauthz
.
Elimina la policy
Per eliminare la policy, esegui questo comando. Non è necessario eliminare la policy della piattaforma basata su controlli per disattivare il controllo delle policy basato su controlli.
gcloud beta container binauthz policy delete POLICY_ID \
--platform=gke \
--project="POLICY_PROJECT_ID"
Sostituisci quanto segue: