Questa pagina è stata tradotta dall'API Cloud Translation.

Utilizza il semplice controllo dell'attestazione della firma

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

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 basata sull'utilizzo previsto, utilizza 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

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

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

gcloud components
      update

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 pubblichi tutti i prodotti menzionati in questa guida nello stesso non devi impostare alcuna autorizzazione. Autorizzazione binaria configura i ruoli correttamente quando lo abiliti. Se pubblichi i prodotti in in progetti diversi, devi impostare i ruoli come descritto in questa sezione.

per garantire che l'agente di servizio di Autorizzazione binaria in ogni progetto disponga delle autorizzazioni necessarie le autorizzazioni per valutare il controllo dell'attestazione della firma semplice di CV, chiedi all'amministratore di concedere all'agente di servizio di Autorizzazione binaria in ciascun progetto seguenti ruoli IAM:

Se il progetto del cluster è diverso dal progetto dei criteri: Valutatore criteri di autorizzazione binaria (roles/binaryauthorization.policyEvaluator) sull'agente di servizio di Autorizzazione binaria del progetto cluster, affinché possa accedere al progetto dei criteri
Se il progetto di attestazione è diverso dal progetto dei criteri: Visualizzatore occorrenze Container Analysis (roles/containeranalysis.occurrences.viewer) sull'agente di servizio di Autorizzazione binaria del progetto di criteri, 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 fornire all'agente di servizio di Autorizzazione binaria in ciascun progetto le autorizzazioni richieste tramite la ruoli o altri ruoli predefiniti ruoli.

Concedi ruoli utilizzando gcloud CLI

Per assicurarti che l'agente di servizio di Autorizzazione binaria in ogni progetto disponga autorizzazioni necessarie per valutare la firma semplice del CV verifica dell'attestazione, concedi l'agente di servizio di Autorizzazione binaria in ciascun progetto i seguenti ruoli IAM:

Concedi l'autorizzazione per il servizio di Autorizzazione binaria del progetto del cluster Agente per accedere al criterio nel progetto del criterio.
1. 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 nel cluster.
2. 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 contenente il criterio.

Consenti all'agente di servizio di Autorizzazione binaria del progetto di criteri di accedere al 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 contenente 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 che contiene le tue attestazioni.

Crea una coppia di chiavi

In questa sezione, creerai un algoritmo di firma digitale ellittica (ECDSA). una coppia di chiavi asimmetrica.

Utilizzi la chiave privata per firmare l'immagine, che crea l'attestazione. Tu includono la chiave pubblica in un criterio della piattaforma. Quando CV controlla la un'attestazione, utilizza la chiave pubblica per verificare l'attestazione.

Puoi utilizzare Cloud Key Management Service o chiavi locali. ma consigliamo di usare le chiavi Cloud KMS per l'ambiente di 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 seguente comando: ed esegui 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 progetto
- KMS_KEYRING_NAME: un nome per Keyring Cloud KMS
- KMS_KEY_NAME: un nome per Cloud KMS chiave
- KEY_FILE: un percorso locale in cui salvare 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

Creare un criterio della piattaforma CV con una semplice firma dell'attestazione, effettua le seguenti operazioni:

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 in cui sono archiviate le attestazioni create utilizzando 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 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 di 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 la persone che seguo :
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 ID per utilizzarlo in un secondo momento:
```
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 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 delle conversioni con criteri della piattaforma basati su controlli.

Crea un cluster che utilizza il monitoraggio CV

In questa sezione creerai un cluster che utilizza solo CV il monitoraggio 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: il 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 del criterio.
CLUSTER_PROJECT_ID: l'ID progetto del cluster.

Esegui la persone che seguo :

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 Applicazione dei criteri project-singleton e monitoraggio delle conversioni 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: il 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 del criterio.
CLUSTER_PROJECT_ID: l'ID progetto del cluster.

Esegui la persone che seguo :

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 CV solo con criteri della piattaforma basati su controlli. Se il cluster ha già applicazione del criterio project-singleton abilitata; l'esecuzione di questo comando disabilita li annotino. Valuta invece la possibilità di aggiornare il cluster con applicazione forzata Monitoraggio CV abilitato.

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

CLUSTER_NAME: il 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 del criterio
CLUSTER_PROJECT_ID: l'ID progetto del cluster

Esegui la persone che seguo :

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 il criterio di singleton progetto applicazione delle norme e monitoraggio delle conversioni con una piattaforma basata su controlli criteri.

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

CLUSTER_NAME: il 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 del criterio
CLUSTER_PROJECT_ID: l'ID progetto del cluster

Esegui la persone che seguo :

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 un esempio di Analisi degli artefatti nota 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 la quale ha creato un'attestazione. In questo caso, la firma semplice del CV Il controllo dell'attestazione verifica l'attestazione e non produce voce di log.

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 a Cloud Logging.

Per creare le variabili da utilizzare per testare CV, esegui questo comando :

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 codice valido l'attestazione.

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 pre-autenticazione (PAE) (consigliato):

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 cluster
- LOCATION: la località del cluster
- CLUSTER_PROJECT_ID: l'ID progetto del cluster
Eseguire il deployment di un servizio e confrontarlo con Autorizzazione binaria norme:
```
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 è associato l'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 le voci di Cloud Logging per trovare gli errori di configurazione CV e violazioni dei criteri della piattaforma CV.

Errori e violazioni dei log CV di 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 un CV criterio della piattaforma non trovato:

{
  "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 le norme relative alla piattaforma che hai attivato, nessuna voce vengono visualizzate 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 , il valore checkType indica il controllo. I valori di ogni controllo sono come segue:

ImageFreshnessCheck
SigstoreSignatureCheck
SimpleSigningAttestationCheck
SlsaCheck
TrustedDirectoryCheck
VulnerabilityCheck

Log di esempio

La voce di logging CV di esempio che segue descrive un'immagine non conforme che viola un controllo delle directory attendibili:

{
  "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 CV configurate in precedenza in questa guida.

Puoi disabilitare il monitoraggio degli errori o entrambe le funzionalità di Autorizzazione binaria e CV nel tuo cluster.

Disabilita Autorizzazione binaria in un cluster

Per disattivare l'applicazione forzata di CV e di Autorizzazione binaria in 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 basato su controlli in un cluster

a disabilitare la correzione CV con criteri basati su controllo nel cluster riattiva 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 località del cluster
CLUSTER_PROJECT_ID: l'ID progetto del cluster

Tieni presente che --binauthz-evaluation-mode=PROJECT_SINGLETON_POLICY_ENFORCE è equivalente al precedente flag --enable-binauthz.

Elimina il criterio

Per eliminare il criterio, esegui questo comando. Non è necessario eliminare il criterio della piattaforma basata sui controlli per disabilitare il controllo dei criteri basati sui 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

Utilizza il semplice controllo dell'attestazione della 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 relativo alla piattaforma

Cloud KMS PKIX

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

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 delle conversioni

Linux, macOS o Cloud Shell

Windows (PowerShell)

Windows (cmd.exe)

Crea la nota Artifact Analysis

Verifica CV

Crea un'attestazione

Cloud KMS PKIX

gcloud

API REST

Chiave locale

gcloud

API REST

Esegui il deployment dell'immagine che ha un'attestazione

Esegui il deployment di un'immagine senza un'attestazione

Visualizza i log per le voci CV

Visualizza i log degli errori di configurazione CV

Visualizza le violazioni dei criteri della piattaforma CV

Tipi di controlli

Log di esempio

Esegui la pulizia

Disabilita Autorizzazione binaria in un cluster

Disabilita il monitoraggio dei criteri basato su controlli in un cluster

Elimina il criterio

Passaggi successivi