Utilizza il semplice controllo dell'attestazione della firma

Questa pagina mostra come utilizzare la convalida continua (CV) di Autorizzazione binaria controllo semplice 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

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 senza costi per l'esecuzione, il test e il deployment dei workload.

Installa Google Cloud CLI.

Nota: se hai già installato gcloud CLI, assicurati di avere l'ultima versione eseguendo gcloud components update.

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

Crea o seleziona un Google Cloud progetto.

Ruoli richiesti per selezionare o creare un progetto

Seleziona un progetto: la selezione di un progetto non richiede un ruolo IAM specifico. Puoi selezionare qualsiasi progetto per il quale ti è stato concesso un ruolo.
Crea un progetto: per creare un progetto, devi disporre del ruolo Autore progetto (roles/resourcemanager.projectCreator), che contiene l'autorizzazione resourcemanager.projects.create. Scopri come concedere i ruoli.

Creare 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 progetto Google Cloud .

Verifica che la fatturazione sia abilitata per il tuo progetto Google Cloud .

Abilita le API Autorizzazione binaria, Cloud Key Management Service e Google Kubernetes Engine:

Ruoli richiesti per abilitare le API

Per abilitare le API, devi disporre del ruolo IAM Amministratore utilizzo dei servizi (roles/serviceusage.serviceUsageAdmin), che include l'autorizzazione serviceusage.services.enable. Scopri come concedere i ruoli.

gcloud services enable binaryauthorization.googleapis.com cloudkms.googleapis.com container.googleapis.com

Installa Google Cloud CLI.

Nota: se hai già installato gcloud CLI, assicurati di avere l'ultima versione eseguendo gcloud components update.

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

Crea o seleziona un Google Cloud progetto.

Ruoli richiesti per selezionare o creare un progetto

Seleziona un progetto: la selezione di un progetto non richiede un ruolo IAM specifico. Puoi selezionare qualsiasi progetto per il quale ti è stato concesso un ruolo.
Crea un progetto: per creare un progetto, devi disporre del ruolo Autore progetto (roles/resourcemanager.projectCreator), che contiene l'autorizzazione resourcemanager.projects.create. Scopri come concedere i ruoli.

Creare 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 progetto Google Cloud .

Verifica che la fatturazione sia abilitata per il tuo progetto Google Cloud .

Abilita le API Autorizzazione binaria, Cloud Key Management Service e Google Kubernetes Engine:

Ruoli richiesti per abilitare le API

gcloud services enable binaryauthorization.googleapis.com cloudkms.googleapis.com container.googleapis.com

Assicurati che gcloud CLI sia aggiornata 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 correttamente i ruoli quando lo abiliti. 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 i seguenti ruoli IAM all'agente di servizio Binary Authorization in ogni progetto:

Se il progetto del cluster è diverso dal progetto della policy: Valutatore della policy di autorizzazione binaria (roles/binaryauthorization.policyEvaluator) nell'agente di servizio di autorizzazione binaria del progetto del cluster, per accedere al progetto della policy
Se il progetto di attestazione è diverso dal progetto di policy: Visualizzatore occorrenze Container Analysis (roles/containeranalysis.occurrences.viewer) sul service agent di autorizzazione binaria del progetto di policy, per consentirgli di accedere al progetto di attestazione

Per saperne di più 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 l'agente di servizio di autorizzazione binaria in ogni progetto disponga delle autorizzazioni necessarie per valutare il controllo di attestazione della firma semplice CV, concedi all'agente di servizio di autorizzazione binaria in ogni progetto i seguenti ruoli IAM:

Concedi l'autorizzazione al service agent di Autorizzazione binaria del progetto del cluster per accedere alla policy nel progetto policy.

Recupera il service agent 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 il service agent 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.

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:

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 progetto
- KMS_KEYRING_NAME: un nome per le chiavi automatizzate Cloud KMS
- KMS_KEY_NAME: un nome per la chiave Cloud KMS
- KEY_FILE: un percorso locale per salvare la chiave Cloud KMS

Crea le chiavi automatizzate:

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 una policy della piattaforma

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

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 locale
PUBLIC_KEY_ID: un ID che identifica in modo univoco la tua 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 della policy.
- POLICY_PROJECT_ID: l'ID progetto della policy.
Esegui questo comando:
Linux, macOS o Cloud Shell

Nota:Assicurati di aver inizializzato Google Cloud CLI con l'autenticazione e un progetto eseguendo gcloud init; o 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 l'autenticazione e un progetto eseguendo gcloud init; o 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 l'autenticazione e un progetto eseguendo gcloud init; o 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 utilizzarlo in un secondo momento:
```
PUBLIC_KEY_ID="PUBLIC_KEY_ID"
```
Sostituisci PUBLIC_KEY_ID con l'ID specificato nel campo keyId del file della policy 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 le norme della piattaforma basate su controlli.

Crea un cluster che utilizza il monitoraggio CV

In questa sezione crei 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:

CLUSTER_NAME: un nome del cluster.
LOCATION: la località, ad esempio us-central1 o asia-south1.
POLICY_PROJECT_ID: l'ID del progetto in cui è archiviata la policy.
POLICY_ID: l'ID policy.
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 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:

CLUSTER_NAME: un nome del cluster.
LOCATION: la località, ad esempio us-central1 o asia-south1.
POLICY_PROJECT_ID: l'ID del progetto in cui è archiviata la policy.
POLICY_ID: l'ID policy.
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, 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:

CLUSTER_NAME: il nome del cluster
LOCATION: la posizione, ad esempio us-central1 o asia-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

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, aggiorni 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:

CLUSTER_NAME: un nome del cluster
LOCATION: la posizione, ad esempio us-central1 o asia-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

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 dell'artefatto di esempio per collegare le attestazioni. Per creare la nota:

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

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

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 su application/vnd.dev.cosign.simplesigning.v1+json per impostazione predefinita.

API REST

Per creare un'attestazione utilizzando l'API REST:

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.

Chiave locale

gcloud

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

API REST

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

Esegui il deployment dell'immagine con un'attestazione

Per eseguire il deployment di un'immagine per cui è 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 posizione del cluster
- CLUSTER_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
```
È 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 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

È stato eseguito il deployment del pod. 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 dei criteri 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:

ImageFreshnessCheck
SigstoreSignatureCheck
SimpleSigningAttestationCheck
SlsaCheck
TrustedDirectoryCheck
VulnerabilityCheck

Log di esempio

La seguente voce di logging 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 del CV che hai configurato in precedenza in questa guida.

Puoi disattivare il monitoraggio di CV o sia Autorizzazione binaria che CV nel tuo cluster.

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

CLUSTER_NAME: il nome del cluster
LOCATION: la posizione del cluster
CLUSTER_PROJECT_ID: l'ID progetto del cluster

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:

CLUSTER_NAME: il nome del cluster
LOCATION: la posizione 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 la policy

Per eliminare la policy, esegui questo comando. Non è necessario eliminare la policy della piattaforma basata su controlli per disabilitare il controllo delle policy basato su controlli.

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

Sostituisci quanto segue:

POLICY_ID: l'ID della policy
POLICY_PROJECT_ID: l'ID progetto della policy

Utilizza il semplice controllo dell'attestazione della firma Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Costi

Prima di iniziare

Ruoli obbligatori

Panoramica

Concedi ruoli utilizzando gcloud CLI

Creare una coppia di chiavi

PKIX Cloud KMS

Chiave locale

Crea una policy della piattaforma

PKIX Cloud KMS

Chiave locale

Linux, macOS o Cloud Shell

Windows (PowerShell)

Windows (cmd.exe)

Abilita CV

Crea un cluster che utilizza il monitoraggio CV

Linux, macOS o Cloud Shell

Windows (PowerShell)

Windows (cmd.exe)

Crea un cluster che utilizza l'applicazione 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 e il monitoraggio CV

Linux, macOS o Cloud Shell

Windows (PowerShell)

Windows (cmd.exe)

Creare la nota Artifact Analysis

Test CV

Creare un'attestazione

PKIX Cloud KMS

gcloud

API REST

Chiave locale

gcloud

API REST

Esegui il deployment dell'immagine con un'attestazione

Esegui il deployment di un'immagine senza attestazione

Visualizzare i log per le voci CV

Visualizzare i log degli errori di configurazione di CV

Visualizzare le violazioni della convalida delle norme della piattaforma CV

Tipi di controllo

Log di esempio

Esegui la pulizia

Disabilita Autorizzazione binaria in un cluster

Disabilita il monitoraggio delle policy basato sui controlli in un cluster

Elimina la policy

Passaggi successivi

Utilizza il semplice controllo dell'attestazione della firma