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 CV è abilitata.
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
- Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.
- Installa Google Cloud CLI.
-
Per initialize 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.
-
-
Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.
-
Abilita le API Binary Authorization, Cloud Key Management Service, Google Kubernetes Engine.
gcloud services enable binaryauthorization.googleapis.com
cloudkms.googleapis.com container.googleapis.com - Installa Google Cloud CLI.
-
Per initialize 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.
-
-
Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.
-
Abilita le API Binary Authorization, Cloud Key Management Service, Google Kubernetes Engine.
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.
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 i ruoli correttamente quando viene abilitata. Se esegui i prodotti in progetti diversi, devi impostare i ruoli come descritto in questa sezione.
Per assicurarti che l'agente di servizio di Autorizzazione binaria in ogni progetto disponga delle autorizzazioni necessarie per valutare il semplice controllo dell'attestazione di firma di CV, chiedi all'amministratore di concedere all'agente di servizio di Autorizzazione binaria in ogni progetto i seguenti ruoli IAM:
-
Se il progetto del cluster è diverso dal progetto dei criteri:
Valutazione dei criteri di autorizzazione binaria (
roles/binaryauthorization.policyEvaluator
) nell'agente di servizio del progetto di cluster Autorizzazione binaria, per consentire l'accesso al progetto dei criteri -
Se il progetto di attestazione è diverso dal progetto dei criteri:
Visualizzatore occorrenze Container Analysis (
roles/containeranalysis.occurrences.viewer
) nell'agente di servizio del progetto di criteri Autorizzazione binaria, affinché possa accedere al progetto di attestazione
Per saperne di più sulla concessione dei ruoli, consulta Gestire l'accesso.
L'amministratore potrebbe anche essere in grado di concedere all'agente di servizio di Autorizzazione binaria in ogni progetto le autorizzazioni richieste mediante ruoli personalizzati o altri ruoli predefiniti.
Concedi ruoli utilizzando gcloud CLI
Per assicurarti che l'agente di servizio di Autorizzazione binaria in ogni progetto disponga delle autorizzazioni necessarie per valutare il controllo dell'attestazione della firma semplice di CV, concedi all'agente di servizio di Autorizzazione binaria in ogni progetto i seguenti ruoli IAM:
Concedi l'autorizzazione all'agente di servizio di Autorizzazione binaria del progetto cluster per accedere al criterio nel progetto di criteri.
Ottieni l'agente di servizio di Autorizzazione binaria del progetto 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 il criterio 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 il criterio.
Consenti all'agente di servizio di Autorizzazione binaria del progetto di criteri di accedere alle attestazioni nel progetto di attestazione:
Recupera l'agente di servizio di Autorizzazione binaria del progetto di criteri:
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 il criterio.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.
Crea una coppia di chiavi
In questa sezione, creerai una coppia di chiavi asimmetriche Elliptic Curve Digital Signature Algorithm (ECDSA).
Utilizzi la chiave privata per firmare l'immagine, che crea l'attestazione. Includi la chiave pubblica in un criterio della piattaforma. Quando CV controlla l'attestazione, utilizza la chiave pubblica per verificare l'attestazione.
Puoi utilizzare Cloud Key Management Service o le chiavi locali, ma ti consigliamo di utilizzare le chiavi Cloud KMS per la produzione.
Cloud KMS PKIX
Per creare la coppia di chiavi in Cloud KMS, segui questi passaggi:
Configura le variabili di ambiente necessarie per creare la coppia di chiavi. Per farlo, ti consigliamo di compilare i segnaposto nel comando seguente e di eseguire il comando.
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 il keyring di Cloud KMSKMS_KEY_NAME
: un nome per la tua chiave Cloud KMSKEY_FILE
: un percorso locale in cui 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}
Chiave locale
Per creare la coppia di chiavi localmente:
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 un criterio relativo alla piattaforma
Per creare un criterio della piattaforma CV con un semplice controllo dell'attestazione della firma, segui questi passaggi:
Crea il semplice file YAML dei criteri della piattaforma per il controllo dell'attestazione della firma:
Cloud KMS PKIX
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: | 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 in cui sono archiviate 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 in cui sono archiviate le attestazioni create utilizzando la chiave localePUBLIC_KEY_ID
: un ID che identifica in modo unico la tua chiave locale
Crea il criterio della piattaforma:
Prima di utilizzare qualsiasi dato di comando riportato di seguito, effettua le seguenti sostituzioni:
- POLICY_ID: un ID criterio della piattaforma
a tua scelta. Se il criterio 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 al file del criterio.
- POLICY_PROJECT_ID: l'ID progetto del criterio.
Esegui questo seguente 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 criterio della piattaforma
a tua scelta. Se il criterio si trova in un altro progetto, puoi utilizzare il nome completo della risorsa:
Memorizza il valore ID per utilizzarlo in un secondo momento:
PUBLIC_KEY_ID="PUBLIC_KEY_ID"
Sostituisci
PUBLIC_KEY_ID
con l'ID specificato nel campokeyId
nel file dei criteri della piattaforma in precedenza in questa guida.La chiave privata viene utilizzata quando vengono create le attestazioni, come descritto più avanti in questa guida.
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 sui controlli.
Prima di utilizzare qualsiasi dato di comando riportato di seguito, effettua le seguenti sostituzioni:
CLUSTER_NAME
: il nome di un cluster.LOCATION
: la località, ad esempious-central1
oasia-south1
.POLICY_PROJECT_ID
: l'ID del progetto in cui è archiviato il criterio.POLICY_ID
: l'ID del criterio.CLUSTER_PROJECT_ID
: l'ID progetto del cluster.
Esegui questo seguente 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 forzata e il monitoraggio delle conversioni
In questa sezione creerai un cluster che utilizza sia l'applicazione dei criteri project-singleton sia il monitoraggio delle conversioni avanzate con criteri della piattaforma basati sui controlli:
Prima di utilizzare qualsiasi dato di comando riportato di seguito, effettua le seguenti sostituzioni:
CLUSTER_NAME
: il nome di un cluster.LOCATION
: la località, ad esempious-central1
oasia-south1
.POLICY_PROJECT_ID
: l'ID del progetto in cui è archiviato il criterio.POLICY_ID
: l'ID del criterio.CLUSTER_PROJECT_ID
: l'ID progetto del cluster.
Esegui questo seguente 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 aggiorni un cluster in modo che utilizzi il monitoraggio CV solo con criteri della piattaforma basati su controlli. Se nel cluster è già abilitata l'applicazione dei criteri per singoli progetti, questo comando la disabilita. Valuta invece la possibilità di aggiornare il cluster con l'applicazione forzata e il monitoraggio delle conversioni avanzate abilitati.
Prima di utilizzare qualsiasi dato di comando riportato di seguito, effettua le seguenti sostituzioni:
CLUSTER_NAME
: il nome del clusterLOCATION
: la località, ad esempious-central1
oasia-south1
POLICY_PROJECT_ID
: l'ID del progetto in cui è archiviato il criterioPOLICY_ID
: l'ID del criterioCLUSTER_PROJECT_ID
: l'ID progetto del cluster
Esegui questo seguente 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 forzata e il monitoraggio delle conversioni
In questa sezione aggiorni un cluster in modo che utilizzi sia l'applicazione forzata dei criteri dei singoli progetti sia il monitoraggio delle conversioni avanzate con criteri della piattaforma basati sui controlli.
Prima di utilizzare qualsiasi dato di comando riportato di seguito, effettua le seguenti sostituzioni:
CLUSTER_NAME
: il nome di un clusterLOCATION
: la località, ad esempious-central1
oasia-south1
POLICY_PROJECT_ID
: l'ID del progetto in cui è archiviato il criterioPOLICY_ID
: l'ID del criterioCLUSTER_PROJECT_ID
: l'ID progetto del cluster
Esegui questo seguente 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
Crea la nota Artifact Analysis
In questa sezione, creerai una nota di Artifact Analysis di esempio per collegare le attestazioni. Per creare la nota:
Crea le variabili delle note:
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.
Verifica CV
In questa sezione testerai il CV eseguendo il deployment dell'immagine per cui hai creato un'attestazione. In questo caso, il controllo di attestazione della firma di CV semplice verifica l'attestazione e non producevoce di logg.
Successivamente, tenti di eseguire il deployment di un'immagine diversa che non ha 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 CV, esegui questi comandi:
IMAGE_PATH="us-docker.pkg.dev/google-samples/containers/gke/hello-app"
IMAGE_DIGEST="sha256:37e5287945774f27b418ce567cd77f4bbc9ef44a1bcd1a2312369f31f9cce567"
IMAGE_TO_ATTEST="${IMAGE_PATH}@${IMAGE_DIGEST}"
Crea un'attestazione
Per soddisfare il semplice controllo dell'attestazione della firma, l'immagine richiede un'attestazione valida.
Puoi creare un'attestazione utilizzando gcloud CLI o l'API REST.
Cloud KMS PKIX
gcloud
Per creare un'attestazione utilizzando gcloud CLI:
Firma l'immagine e crea l'attestazione utilizzando la codifica di pre-autenticazione (PAE) (opzione 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. Per impostazione predefinita, il flag èapplication/vnd.dev.cosign.simplesigning.v1+json
.
API REST
Per creare un'attestazione utilizzando l'API REST, segui questi passaggi:
Crea un file di payload per la 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.
Chiave locale
gcloud
Crea un file di payload per la 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 per la 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
API REST
Crea un file di payload per la 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 per la 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
Esegui il deployment dell'immagine che ha un'attestazione
Per eseguire il deployment di un'immagine per la quale è stata creata un'attestazione:
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 località del clusterCLUSTER_PROJECT_ID
: l'ID progetto del cluster
Esegui il deployment di un servizio e confrontalo con il criterio di Autorizzazione binaria:
kubectl run hello-app-with-attestation --image=$IMAGE_PATH@$IMAGE_DIGEST
È stato eseguito il deployment del pod. Poiché l'immagine ha un'attestazione, CV non produce voci di log correlate a questo pod.
Esegui il deployment di un'immagine senza un'attestazione
In questa sezione eseguirai il deployment di un'immagine a cui non è associata un'attestazione.
Poiché il criterio richiede 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=gcr.io/google-samples/hello-app@sha256:845f77fab71033404f4cfceaa1ddb27b70c3551ceb22a5e7f4498cdda6c9daea
È stato eseguito il deployment del pod. Poiché l'immagine non ha un'attestazione, CV produce voci di log mentre il pod è in esecuzione.
Visualizza i log per le voci CV
Puoi cercare nelle voci di Cloud Logging per trovare gli errori di configurazione CV e le violazioni della convalida dei criteri della piattaforma CV.
CV registra errori e violazioni in Cloud Logging entro 24 ore. In genere, puoi visualizzare le voci entro poche ore.
Visualizza i log degli errori di configurazione CV
Per visualizzare i log degli errori di configurazione 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 è stato trovato un criterio 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"
}
Visualizza le violazioni dei criteri della piattaforma CV
Se nessuna immagine viola i criteri della piattaforma che hai abilitato, non viene visualizzata alcuna voce nei log.
Per visualizzare le voci di log CV relative agli 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 controlli
I log CV controllano le informazioni sulle violazioni per checkResults
. Nella voce, il valore checkType
indica la verifica. I valori di ogni controllo sono i seguenti:
ImageFreshnessCheck
SigstoreSignatureCheck
SimpleSigningAttestationCheck
SlsaCheck
TrustedDirectoryCheck
VulnerabilityCheck
Log di esempio
L'esempio di voce di CV Logging di seguito 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 ripulire il monitoraggio CV che hai configurato in precedenza in questa guida.
Puoi disabilitare il monitoraggio degli errori di conversione o sia Autorizzazione binaria sia CV nel tuo cluster.
Disabilita Autorizzazione binaria in un cluster
Per disabilitare l'applicazione forzata di CV e 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:
CLUSTER_NAME
: il nome del clusterLOCATION
: la località del clusterCLUSTER_PROJECT_ID
: l'ID progetto del cluster
Disabilita il monitoraggio dei criteri basato su controlli in un cluster
Per disabilitare la CV con criteri basati su controllo nel cluster e riabilitare l'applicazione mediante il criterio di applicazione di Autorizzazione binaria, esegui questo comando:
gcloud beta container clusters update CLUSTER_NAME \
--binauthz-evaluation-mode=PROJECT_SINGLETON_POLICY_ENFORCE \
--location=LOCATION \
--project="CLUSTER_PROJECT_ID"
Sostituisci quanto segue:
CLUSTER_NAME
: il nome del clusterLOCATION
: la località del clusterCLUSTER_PROJECT_ID
: l'ID progetto del cluster
Tieni presente che --binauthz-evaluation-mode=PROJECT_SINGLETON_POLICY_ENFORCE
è
equivalente al flag precedente --enable-binauthz
.
Elimina il criterio
Per eliminare il criterio, esegui questo comando. Non è necessario eliminare il criterio della piattaforma basato sui controlli per disabilitare questo tipo di controllo.
gcloud beta container binauthz policy delete POLICY_ID \
--platform=gke \
--project="POLICY_PROJECT_ID"
Sostituisci quanto segue:
POLICY_ID
: l'ID del criterioPOLICY_PROJECT_ID
: l'ID progetto del criterio
Passaggi successivi
- Utilizzare il controllo di aggiornamento delle immagini
- Utilizzare il semplice controllo dell'attestazione della firma
- Utilizzare il controllo della firma di Sigstore
- Utilizzare il controllo SLSA
- Utilizzare il controllo della directory attendibile
- Utilizza il controllo delle vulnerabilità
- Visualizza log CV