Utilizzare il controllo semplice dell'attestazione di firma

Questa pagina mostra come utilizzare il controllo semplice dell'attestazione di firma di Autorizzazione binaria. Il controllo verifica le attestazioni delle immagini container associate ai pod in esecuzione in un cluster Google Kubernetes Engine (GKE) in cui è abilitato CV.

Costi

Questa guida utilizza i seguenti servizi Google Cloud:

Autorizzazione binaria, ma il 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

Nota: se hai già installato gcloud CLI in precedenza, assicurati di disporre della versione più recente eseguendo

gcloud components
      update

Crea o seleziona un progetto Google Cloud.

Crea un progetto Google Cloud:
```
gcloud projects create PROJECT_ID
```
Sostituisci PROJECT_ID con un nome per il progetto Google Cloud che stai creando.
Seleziona il progetto Google Cloud che hai creato:
```
gcloud config set project PROJECT_ID
```
Sostituisci PROJECT_ID con il nome del tuo progetto Google Cloud.

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

Nota: se hai già installato gcloud CLI in precedenza, assicurati di disporre della versione più recente eseguendo

gcloud components
      update

Crea o seleziona un progetto Google Cloud.

Crea un progetto Google Cloud:
```
gcloud projects create PROJECT_ID
```
Sostituisci PROJECT_ID con un nome per il progetto Google Cloud che stai creando.
Seleziona il progetto Google Cloud che hai creato:
```
gcloud config set project PROJECT_ID
```
Sostituisci PROJECT_ID con il nome del tuo progetto Google Cloud.

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 nello stesso progetto tutti i prodotti menzionati in questa guida, 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 controllo dell'attestazione di firma semplice della 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 da quello del criterio: Valutatore criteri di Autorizzazione binaria (roles/binaryauthorization.policyEvaluator) nell'agente di servizio di Autorizzazione binaria del progetto del cluster, affinché possa accedere al progetto del criterio
Se il progetto di attestazione è diverso da quello dei criteri: Visualizzatore occorrenze di Container Analysis (roles/containeranalysis.occurrences.viewer) nell'agente di servizio di Autorizzazione binaria del progetto dei criteri per consentire l'accesso 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 tramite i 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 di attestazione della firma del CV semplice, concedi all'agente di servizio di Autorizzazione binaria in ogni progetto i seguenti ruoli IAM:

Concedi all'agente di servizio di Autorizzazione binaria del progetto del cluster l'autorizzazione ad accedere al criterio nel progetto del criterio.
1. Recupera 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.
2. Consenti al CV di valutare il criterio nel 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 del criterio di accedere alle attestazioni nel progetto di attestazione:
1. Recupera l'agente di servizio di Autorizzazione binaria del progetto del criterio:
```
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.
2. 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 asimmetrica Elliptic Curve Digital Signature Algorithm (ECDSA).

Dovrai utilizzare la chiave privata per firmare l'immagine, che crea l'attestazione. Includi la chiave pubblica in un criterio della piattaforma. Quando il CV controlla l'attestazione, utilizza la chiave pubblica per verificare l'attestazione.

Puoi utilizzare Cloud Key Management Service o 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 inserire 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
```
Sostituisci quanto segue:
- KMS_KEY_PROJECT_ID: il tuo ID progetto
- KMS_KEYRING_NAME: un nome per il keyring Cloud KMS
- KMS_KEY_NAME: un nome per 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 1 \
    --key=${KMS_KEY_NAME} \
    --keyring=${KMS_KEYRING_NAME} \
    --location=${KMS_KEY_LOCATION} \
    --output-file=/tmp/ec_public.pem \
    --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 della piattaforma

Per creare un criterio della piattaforma CV con un semplice controllo di attestazione della firma:

Crea il semplice file YAML del criterio della piattaforma per il controllo dell'attestazione di 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}' /tmp/ec_public.pem)
              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 quanto segue:

ATTESTATION_PROJECT_ID: l'ID del progetto che archivia le attestazioni
KMS_KEY_PROJECT_ID: l'ID progetto della tua chiave 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
PUBLIC_KEY_ID: un ID che identifica in modo univoco la chiave locale

Crea il criterio della piattaforma:

Prima di utilizzare uno qualsiasi dei dati di comando riportati 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 dei criteri.
- POLICY_PROJECT_ID: l'ID progetto del criterio.
Esegui questo comando:
Linux, macOS o Cloud Shell

Nota: assicurati di aver inizializzato Google Cloud CLI con autenticazione e un progetto eseguendo gcloud init; oppure gcloud auth login e gcloud config set project.
```
gcloud beta container binauthz policy create POLICY_ID \
    --platform=gke \
    --policy-file=POLICY_PATH \
    --project=POLICY_PROJECT_ID
```
Windows (PowerShell)

Nota: assicurati di aver inizializzato Google Cloud CLI con autenticazione e un progetto eseguendo gcloud init; oppure gcloud auth login e gcloud config set project.
```
gcloud beta container binauthz policy create POLICY_ID `
    --platform=gke `
    --policy-file=POLICY_PATH `
    --project=POLICY_PROJECT_ID
```
Windows (cmd.exe)

Nota: assicurati di aver inizializzato Google Cloud CLI con autenticazione e un progetto eseguendo gcloud init; oppure gcloud auth login e gcloud config set project.
```
gcloud beta container binauthz policy create POLICY_ID ^
    --platform=gke ^
    --policy-file=POLICY_PATH ^
    --project=POLICY_PROJECT_ID
```
Memorizza il valore dell'ID per un utilizzo futuro:
```
PUBLIC_KEY_ID="PUBLIC_KEY_ID"
```
Sostituisci PUBLIC_KEY_ID con l'ID che hai specificato nel campo keyId del file dei criteri della piattaforma in precedenza in questa guida.

La chiave privata viene utilizzata quando vengono create attestazioni, come descritto più avanti in questa guida.

Attiva CV

Puoi creare un nuovo cluster o aggiornarne uno esistente per utilizzare il monitoraggio CV con i criteri della piattaforma basati su controlli.

Creazione di un cluster che utilizza il monitoraggio CV

In questa sezione creerai un cluster che utilizza solo il monitoraggio del CV con criteri della piattaforma basati su controlli.

Prima di utilizzare uno qualsiasi dei dati di comando riportati di seguito, effettua le seguenti sostituzioni:

CLUSTER_NAME: nome di un cluster.
LOCATION: la località, ad esempio us-central1 o asia-south1.
POLICY_PROJECT_ID: l'ID del progetto in cui è archiviato il criterio.
POLICY_ID: l'ID criterio.
CLUSTER_PROJECT_ID: l'ID progetto del cluster.

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 forzata e il monitoraggio CV

In questa sezione creerai un cluster che utilizza sia l'applicazione dei criteri project-singleton sia il monitoraggio CV con criteri della piattaforma basati su controlli:

Prima di utilizzare uno qualsiasi dei dati di comando riportati di seguito, effettua le seguenti sostituzioni:

CLUSTER_NAME: nome di un cluster.
LOCATION: la località, ad esempio us-central1 o asia-south1.
POLICY_PROJECT_ID: l'ID del progetto in cui è archiviato il criterio.
POLICY_ID: l'ID criterio.
CLUSTER_PROJECT_ID: l'ID progetto del cluster.

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 aggiorni un cluster per utilizzare il monitoraggio del CV solo con i criteri della piattaforma basati su controlli. Se nel cluster è già abilitata l'applicazione dei criteri singleton per il progetto, l'esecuzione di questo comando la disattiva. Valuta invece la possibilità di aggiornare il cluster con l'applicazione forzata e il monitoraggio CV abilitati.

Prima di utilizzare uno qualsiasi dei dati di comando riportati di seguito, effettua le seguenti sostituzioni:

CLUSTER_NAME: nome del cluster
LOCATION: la località, ad esempio us-central1 o asia-south1
POLICY_PROJECT_ID: l'ID del progetto in cui è archiviato il criterio
POLICY_ID: l'ID criterio
CLUSTER_PROJECT_ID: l'ID progetto del cluster

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 forzata e il monitoraggio CV

In questa sezione aggiorni un cluster per utilizzare sia l'applicazione forzata dei criteri a livello di progetto sia il monitoraggio del CV con criteri della piattaforma basati su controlli.

Prima di utilizzare uno qualsiasi dei dati di comando riportati di seguito, effettua le seguenti sostituzioni:

CLUSTER_NAME: nome di un cluster
LOCATION: la località, ad esempio us-central1 o asia-south1
POLICY_PROJECT_ID: l'ID del progetto in cui è archiviato il criterio
POLICY_ID: l'ID criterio
CLUSTER_PROJECT_ID: l'ID progetto del cluster

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

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 delle note:

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.

CV di prova

In questa sezione, eseguirai il test del CV eseguendo il deployment dell'immagine per la quale hai creato un'attestazione. In questo caso, il controllo dell'attestazione di firma semplice del CV verifica l'attestazione e non produce alcuna voce di log.

Successivamente, tenti di eseguire il deployment di un'immagine diversa che non ha attestazione. In questo caso, il controllo del CV non riesce a trovare l'attestazione e registra la violazione in Cloud Logging.

Crea un'attestazione

Per soddisfare il controllo, l'immagine richiede un'attestazione valida. Per creare l'attestazione:

Crea le variabili che utilizzi per creare l'attestazione:

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 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 l'attestazione:

Firma il payload:

Cloud KMS PKIX

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}

Chiave locale

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

Sostituisci NOTE_PROJECT_ID con l'ID del progetto che contiene la nota

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 cluster
- LOCATION: la località del cluster
- CLUSTER_PROJECT_ID: l'ID progetto del cluster
Esegui il deployment di un servizio e verifica il deployment in base al criterio di Autorizzazione binaria:
```
kubectl run hello-app --image=$IMAGE_PATH@$IMAGE_DIGEST
```
È stato eseguito il deployment del pod. Poiché l'immagine ha un'attestazione, CV non produce voci di log relative a questo pod.

Esegui il deployment di un'immagine senza 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-no-attestation \
    --image=gcr.io/google-samples/hello-app@sha256:845f77fab71033404f4cfceaa1ddb27b70c3551ceb22a5e7f4498cdda6c9daea

È stato eseguito il deployment del pod. Poiché l'immagine non ha un'attestazione, il CV produce voci di log mentre il pod è in esecuzione.

Visualizzazione dei log per le voci CV

CV registra le violazioni dei criteri della piattaforma in Cloud Logging entro 24 ore. Generalmente puoi visualizzare le voci entro un paio d'ore.

Se nessuna immagine viola i criteri della piattaforma che hai abilitato, non vengono visualizzate voci 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 del CV controllano le informazioni sulla violazione in checkResults. Nella voce, il valore checkType indica il controllo. I valori di ciascun controllo sono i seguenti:

ImageFreshnessCheck
SigstoreSignatureCheck
SimpleSigningAttestationCheck
SlsaCheck
TrustedDirectoryCheck
VulnerabilityCheck

Esempio di log

La voce CV Logging di esempio riportata 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 del CV configurato in precedenza in questa guida.

Puoi disabilitare il monitoraggio CV o sia Autorizzazione binaria sia CV nel cluster.

Disabilita Autorizzazione binaria in un cluster

Per disabilitare l'applicazione sia di CV che di Autorizzazione binaria nel 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 cluster
LOCATION: la località del cluster
CLUSTER_PROJECT_ID: l'ID progetto del cluster

Disabilita il monitoraggio dei criteri basati su controlli in un cluster

Per disabilitare CV con criteri basati su controllo nel cluster e riabilitare l'applicazione forzata utilizzando il criterio di Autorizzazione binaria, esegui il comando seguente:

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 cluster
LOCATION: la località del cluster
CLUSTER_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 basata su controlli per disabilitare il controllo dei criteri basati su controlli.

gcloud beta container binauthz policy delete POLICY_ID \
    --platform=gke \
    --project="POLICY_PROJECT_ID"

Sostituisci quanto segue:

POLICY_ID: l'ID del criterio
POLICY_PROJECT_ID: l'ID progetto del criterio

Utilizzare il controllo semplice dell'attestazione di firma

Costi

Prima di iniziare

Ruoli obbligatori

Panoramica

Concedi ruoli utilizzando gcloud CLI

Crea una coppia di chiavi

Cloud KMS PKIX

Chiave locale

Crea un criterio della piattaforma

Cloud KMS PKIX

Chiave locale

Linux, macOS o Cloud Shell

Windows (PowerShell)

Windows (cmd.exe)

Attiva CV

Creazione di un cluster che utilizza il monitoraggio CV

Linux, macOS o Cloud Shell

Windows (PowerShell)

Windows (cmd.exe)

Crea un cluster che utilizza l'applicazione forzata e il monitoraggio CV

Linux, macOS o Cloud Shell

Windows (PowerShell)

Windows (cmd.exe)

Aggiorna un cluster per utilizzare il monitoraggio CV

Linux, macOS o Cloud Shell

Windows (PowerShell)

Windows (cmd.exe)

Aggiorna un cluster per utilizzare l'applicazione forzata e il monitoraggio CV

Linux, macOS o Cloud Shell

Windows (PowerShell)

Windows (cmd.exe)

Crea la nota Artifact Analysis

CV di prova

Crea un'attestazione

Cloud KMS PKIX

Chiave locale

Esegui il deployment dell'immagine che ha un'attestazione

Esegui il deployment di un'immagine senza attestazione

Visualizzazione dei log per le voci CV

Tipi di controlli

Esempio di log

Esegui la pulizia

Disabilita Autorizzazione binaria in un cluster

Disabilita il monitoraggio dei criteri basati su controlli in un cluster

Elimina il criterio

Passaggi successivi