Creare attestatori utilizzando gcloud CLI

Questa pagina spiega come creare un attestatore in Autorizzazione binaria utilizzando Google Cloud CLI. In alternativa, puoi eseguire questi passaggi utilizzando la consoleGoogle Cloud o l'API REST. Questa attività fa parte della configurazione di Autorizzazione binaria.

In qualità di utente di Cloud Build, puoi utilizzare l'attestatore built-by-cloud-build per eseguire il deployment solo delle immagini create da Cloud Build.

Un attestatore è una risorsaGoogle Cloud utilizzata da Autorizzazione binaria per verificare un'attestazione. Per scoprire di più sulle attestazioni, consulta la panoramica di Autorizzazione binaria.

Per creare un attestatore, segui questi passaggi:

• Crea una nota in Artifact Analysis per archiviare i metadati attendibili utilizzati nel processo di attestazione.
• Configura una coppia di chiavi PKIX (Public-Key Infrastructure (X.509)) che può essere utilizzata per verificare l'identità dell'attestatore. (Le coppie di chiavi asimmetriche generate da Cloud Key Management Service (Cloud KMS) sono in formato compatibile con PKIX).
• Crea l'attestatore in Autorizzazione binaria e associa la nota e la chiave pubblica che hai creato.

In una configurazione con un singolo progetto, crei l'attestatore nello stesso progetto Google Cloudin cui configuri la policy di Autorizzazione binaria. Per un tutorial end-to-end su un singolo progetto che include questi passaggi, consulta Inizia a utilizzare Google Cloud CLI o Inizia a utilizzare la console Google Cloud .

In una configurazione multiprogetto, ti consigliamo di avere progetti separati: un progetto di deployment, in cui è configurata la policy; un progetto attestatore, in cui sono archiviati gli attestatori; e un progetto di attestazione per le attestazioni. Per un tutorial end-to-end su più progetti che include questi passaggi, consulta Configurazione di più progetti.

Prima di iniziare

Prima di creare gli attestatori, segui questi passaggi:

1. Attiva Autorizzazione binaria.

2. Configura Autorizzazione binaria per la tua piattaforma.

Configurare l'ambiente del progetto

In questa sezione, configuri le variabili di ambiente.

Configura le variabili di ambiente per archiviare i nomi e i numeri dei progetti. Se i progetti attestatore e deployer sono lo stesso progetto, utilizza lo stesso ID progetto per entrambe le variabili.

DEPLOYER_PROJECT_ID=DEPLOYER_PROJECT_ID=
DEPLOYER_PROJECT_NUMBER="$(
    gcloud projects describe "${DEPLOYER_PROJECT_ID}" \
      --format="value(projectNumber)"
)"

ATTESTOR_PROJECT_ID=ATTESTOR_PROJECT_ID
ATTESTOR_PROJECT_NUMBER="$(
    gcloud projects describe "${ATTESTOR_PROJECT_ID}" \
    --format="value(projectNumber)"
)"

Devi anche ottenere i nomi dei account di servizio per i progetti:

DEPLOYER_SERVICE_ACCOUNT="service-${DEPLOYER_PROJECT_NUMBER}@gcp-sa-binaryauthorization."
ATTESTOR_SERVICE_ACCOUNT="service-${ATTESTOR_PROJECT_NUMBER}@gcp-sa-binaryauthorization."

Crea una nota Artifact Analysis

Autorizzazione binaria utilizza Artifact Analysis per archiviare i metadati attendibili utilizzati nel processo di autorizzazione. Per ogni attestatore che crei, devi creare una nota Artifact Analysis. Ogni attestazione viene archiviata come occorrenza di questa nota.

Per creare la nota, segui questi passaggi:

1. Configura le variabili di ambiente per archiviare l'ID della nota e una descrizione leggibile:

   NOTE_ID=NOTE_ID
   NOTE_URI="projects/${ATTESTOR_PROJECT_ID}/notes/${NOTE_ID}"
   DESCRIPTION=DESCRIPTION
   

   Sostituisci quanto segue:

   • NOTE_ID: il nome interno della nota in caratteri alfanumerici senza spazi, ad esempio test-attestor-note
   • NOTE_URI: il percorso completo della risorsa della nota
   • DESCRIPTION: un nome visualizzato leggibile per la nota, ad esempio Test Attestor Note

2. Crea un file JSON che descriva la nota:

   cat > /tmp/note_payload.json << EOF
   {
     "name": "${NOTE_URI}",
     "attestation": {
       "hint": {
         "human_readable_name": "${DESCRIPTION}"
       }
     }
   }
   EOF
   

3. Crea la nota inviando una richiesta HTTP all'API REST Artifact Analysis:

   curl -X POST \
       -H "Content-Type: application/json" \
       -H "Authorization: Bearer $(gcloud auth print-access-token)"  \
       -H "x-goog-user-project: ${ATTESTOR_PROJECT_ID}" \
       --data-binary @/tmp/note_payload.json  \
       "https://containeranalysis.googleapis.com/v1/projects/${ATTESTOR_PROJECT_ID}/notes/?noteId=${NOTE_ID}"
   

   Attenzione: Autorizzazione binaria non supporta l'archiviazione regionale o gli endpoint regionali di Artifact Analysis. Ti consigliamo di utilizzare l'endpoint API globale di Artifact Analysis (https://containeranalysis.googleapis.com/).

   Per verificare che la nota sia stata creata correttamente, esegui questo comando:

   curl \
       -H "Authorization: Bearer $(gcloud auth print-access-token)"  \
       -H "x-goog-user-project: ${ATTESTOR_PROJECT_ID}" \
       "https://containeranalysis.googleapis.com/v1/projects/${ATTESTOR_PROJECT_ID}/notes/"
   

Imposta le autorizzazioni IAM sulla nota

Devi concedere un ruolo Identity and Access Management (IAM) al account di servizio del progetto attestatore sulla risorsa della nota Artifact Analysis. Per farlo, aggiungi il account di servizio del progetto dell'attestatore al ruolo containeranalysis.notes.occurrences.viewer nella policy IAM della nota.

Per aggiungere il ruolo:

1. Genera un file JSON contenente le informazioni necessarie per impostare il ruolo IAM sulla nota:

   cat > /tmp/iam_request.json << EOM
   {
     "resource": "${NOTE_URI}",
     "policy": {
       "bindings": [
         {
           "role": "roles/containeranalysis.notes.occurrences.viewer",
           "members": [
             "serviceAccount:${ATTESTOR_SERVICE_ACCOUNT}"
           ]
         }
       ]
     }
   }
   EOM
   

2. Aggiungi il account di servizio e i ruoli di accesso richiesti alla policy IAM per la nota che hai creato:

   curl -X POST  \
       -H "Content-Type: application/json" \
       -H "Authorization: Bearer $(gcloud auth print-access-token)" \
       -H "x-goog-user-project: ${ATTESTOR_PROJECT_ID}" \
       --data-binary @/tmp/iam_request.json \
       "https://containeranalysis.googleapis.com/v1/projects/${ATTESTOR_PROJECT_ID}/notes/${NOTE_ID}:setIamPolicy"
   

   Nota: quando aggiungi un ruolo alla policy utilizzando il metodo precedente, questo sostituisce eventuali ruoli esistenti nella nota. Se vuoi conservare i ruoli esistenti, assicurati di includerli nel file di dati JSON precedente.

Se ricevi un errore service account not found quando concedi il ruolo IAM, potresti dover creare manualmente l'agente di servizio.

Utilizzo di più progetti

Se memorizzi l'attestatore in un progetto e lo esegui il deployment in un progetto separato, devi concedere il ruolo roles/binaryauthorization.attestorsVerifier al account di servizio associato al progetto del deployer sull'attestatore.

Configura le chiavi di crittografia

Autorizzazione binaria consente di utilizzare chiavi PKIX o chiavi di crittografia post-quantistica (PQC) per verificare le attestazioni. Devi configurare un solo tipo di chiave utilizzando uno dei seguenti metodi:

• Crea chiavi di crittografia post-quantistica (PQC): crea chiavi PQC gestite da Cloud Key Management Service per contribuire ad affrontare le minacce dei futuri computer quantistici.
• Genera una coppia di chiavi: crea coppie di chiavi PKIX standard utilizzando Cloud KMS o strumenti locali.

Crea chiavi di crittografia post-quantistica (PQC)

Per fornire sicurezza a lungo termine e affrontare le minacce dei futuri computer quantistici, Autorizzazione binaria supporta le chiavi che utilizzano algoritmi di crittografia post-quantistica (PQC). Questi algoritmi sono standardizzati per resistere agli attacchi sia dei computer classici che di quelli quantistici.

• Algoritmi supportati: Autorizzazione binaria supporta gli algoritmi di firma PQC, come ML-DSA-65 (Dilithium3), per la creazione e la verifica delle attestazioni.
• Gestione delle chiavi: ti consigliamo di gestire le chiavi PQC utilizzando Cloud Key Management Service. Cloud KMS fornisce archiviazione e gestione sicure per queste chiavi di crittografia.

Genera una coppia di chiavi PQC

Per creare la coppia di chiavi in Cloud KMS, segui questi passaggi:

1. Per configurare le variabili di ambiente necessarie per creare la coppia di chiavi, esegui questi comandi:

       KMS_KEY_PROJECT_ID=KMS_KEY_PROJECT_ID
       KMS_KEY_LOCATION=KMS_KEY_LOCATION
       KMS_KEYRING_NAME=KMS_KEYRING_NAME
       KMS_KEY_NAME=KMS_KEY_NAME
       KMS_KEY_VERSION=KMS_KEY_VERSION
       KMS_KEY_PURPOSE=asymmetric-signing
       KMS_KEY_ALGORITHM=KMS_KEY_ALGORITHM
       KMS_PROTECTION_LEVEL=KMS_PROTECTION_LEVEL
     

2. Sostituisci quanto segue:

   • KMS_KEY_PROJECT_ID: l'ID del progetto in cui sono archiviate le chiavi
   • KMS_KEY_LOCATION: la posizione della chiave
   • KMS_KEYRING_NAME: il nome delle chiavi automatizzate
   • KMS_KEY_NAME: il nome della chiave
   • KMS_KEY_VERSION: la versione della chiave
   • KMS_KEY_ALGORITHM: l'algoritmo; ml-dsa-65
   • KMS_PROTECTION_LEVEL: il livello di protezione, ad esempio software

3. Per creare le chiavi automatizzate, esegui questo comando:

     gcloud kms keyrings create ${KMS_KEYRING_NAME} \
         --location ${KMS_KEY_LOCATION}
   

4. Per creare la chiave, esegui questo comando:

     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}
   

Genera una coppia di chiavi

In questa guida, utilizzerai l'algoritmo Elliptic Curve Digital Signature Algorithm (ECDSA) consigliato per generare una coppia di chiavi PKIX. Puoi anche utilizzare coppie di chiavi RSA o PGP. Per saperne di più sugli algoritmi di firma, consulta Scopi e algoritmi delle chiavi.

Una coppia di chiavi PKIX comprende una chiave privata che i firmatari utilizzano per firmare le attestazioni e una chiave pubblica che aggiungi all'attestatore. Al momento del deployment, Autorizzazione binaria utilizza questa chiave pubblica per verificare l'attestazione.

PKIX (Cloud KMS)

Per creare la coppia di chiavi in Cloud KMS, segui questi passaggi:

1. Per configurare le variabili di ambiente necessarie per creare la coppia di chiavi, esegui questi comandi:

   KMS_KEY_PROJECT_ID=KMS_KEY_PROJECT_ID
   KMS_KEY_LOCATION=KMS_KEY_LOCATION
   KMS_KEYRING_NAME=KMS_KEYRING_NAME
   KMS_KEY_NAME=KMS_KEY_NAME
   KMS_KEY_VERSION=KMS_KEY_VERSION
   KMS_KEY_PURPOSE=asymmetric-signing
   KMS_KEY_ALGORITHM=KMS_KEY_ALGORITHM
   KMS_PROTECTION_LEVEL=KMS_PROTECTION_LEVEL
   

   Sostituisci quanto segue:

   • KMS_KEY_PROJECT_ID: l'ID del progetto in cui sono archiviate le chiavi
   • KMS_KEY_LOCATION: la posizione della chiave
   • KMS_KEYRING_NAME: il nome delle chiavi automatizzate
   • KMS_KEY_NAME: il nome della chiave
   • KMS_KEY_VERSION: la versione della chiave
   • KMS_KEY_ALGORITHM: l'algoritmo; ec-sign-p256-sha256 è consigliato
   • KMS_PROTECTION_LEVEL: il livello di protezione, ad esempio software

2. Per creare le chiavi automatizzate, esegui questo comando:

   gcloud kms keyrings create ${KMS_KEYRING_NAME} \
       --location ${KMS_KEY_LOCATION}
   

3. Per creare la chiave, esegui questo comando:

   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}
   

   Sostituisci quanto segue:

   • KMS_KEY_NAME: il nome della chiave
   • KMS_KEY_LOCATION: la posizione della chiave
   • KMS_KEYRING_NAME: il nome delle chiavi automatizzate
   • KMS_KEY_PURPOSE: lo scopo della chiave, impostato su ASYMMETRIC_SIGN
   • KMS_KEY_ALGORITHM: l'algoritmo, ec-sign-p256-sha256 è consigliato
   • KMS_PROTECTION_LEVEL: il livello di protezione, ad esempio software

PKIX (chiave locale)

Avviso: sconsigliamo vivamente di utilizzare coppie di chiavi generate localmente negli ambienti di produzione, in quanto presentano un rischio per la sicurezza. Ti consigliamo di utilizzare Cloud Key Management Service. Questo esempio è fornito esclusivamente a scopo illustrativo.

Per generare una nuova coppia di chiavi PKIX asimmetriche locali e archiviarla in un file, segui questi passaggi:

1. Genera la chiave privata:

   PRIVATE_KEY_FILE è il nome del file contenente la chiave privata utilizzata per firmare il payload di attestazione.

   PRIVATE_KEY_FILE="/tmp/ec_private.pem"
   openssl ecparam -genkey -name prime256v1 -noout -out ${PRIVATE_KEY_FILE}
   

2. Estrai la chiave pubblica dalla chiave privata e memorizzala in un file:

   PUBLIC_KEY_FILE è il nome del file contenente la chiave pubblica archiviata nell'attestatore.

   PUBLIC_KEY_FILE="/tmp/ec_public.pem"
   openssl ec -in ${PRIVATE_KEY_FILE} -pubout -out ${PUBLIC_KEY_FILE}
   

Crea l'attestatore

Per creare l'attestatore, segui questi passaggi:

1. Configura una variabile di ambiente per archiviare il nome dell'attestatore come definito in Autorizzazione binaria:

   ATTESTOR_NAME=ATTESTOR_NAME
   

   Sostituisci ATTESTOR_NAME con il nome dell'attestatore che vuoi creare (ad esempio, build-secure o prod-qa).

2. Crea la risorsa attestatore in Autorizzazione binaria:

   gcloud --project="${ATTESTOR_PROJECT_ID}" \
       container binauthz attestors create "${ATTESTOR_NAME}" \
       --attestation-authority-note="${NOTE_ID}" \
       --attestation-authority-note-project="${ATTESTOR_PROJECT_ID}"
   

3. Aggiungi un'associazione di ruoli IAM per il progetto del deployer all'attestatore. Questo viene utilizzato da Autorizzazione binaria quando valuta una policy per determinare se il progetto dispone delle autorizzazioni per accedere alle attestazioni associate.

   gcloud container binauthz attestors add-iam-policy-binding \
       "projects/${ATTESTOR_PROJECT_ID}/attestors/${ATTESTOR_NAME}" \
       --member="serviceAccount:${DEPLOYER_SERVICE_ACCOUNT}" \
       --role=roles/binaryauthorization.attestorsVerifier
   

4. Per aggiungere la chiave pubblica all'attestatore, segui questi passaggi:

   PKIX (Cloud KMS)

   Per aggiungere la chiave pubblica da una coppia di chiavi Cloud KMS all'attestatore, esegui questo comando:

   gcloud --project="${ATTESTOR_PROJECT_ID}" \
       container binauthz attestors public-keys add \
       --attestor="${ATTESTOR_NAME}" \
       --keyversion-project="${KMS_KEY_PROJECT_ID}" \
       --keyversion-location="${KMS_KEY_LOCATION}" \
       --keyversion-keyring="${KMS_KEYRING_NAME}" \
       --keyversion-key="${KMS_KEY_NAME}" \
       --keyversion="${KMS_KEY_VERSION}"
   

   PKIX (chiave locale)

   Per aggiungere una chiave pubblica PKIX archiviata localmente a un attestatore, esegui il comando seguente:

   gcloud --project="${ATTESTOR_PROJECT_ID}" \
       container binauthz attestors public-keys add \
       --attestor="${ATTESTOR_NAME}" \
       --pkix-public-key-file=${PUBLIC_KEY_FILE} \
       --pkix-public-key-algorithm=ecdsa-p256-sha256
   

   Se aggiungi una chiave pubblica a un attestatore e non specifichi un ID chiave (che può essere qualsiasi stringa), ne viene assegnato automaticamente uno nel formato RFC 6920: ni:///sha-256;..., dove ... è un hash codificato della chiave pubblica. Questo valore viene restituito nel campo id dell'output comando. L'ID restituito può essere salvato in PUBLIC_KEY_ID e utilizzato per creare un'attestazione.

Salva l'ID chiave pubblica

Per creare un'attestazione, devi avere l'ID della chiave pubblica.

Per salvare l'ID chiave pubblica, puoi copiarlo dall'output del comando binauthz attestors public-keys add precedente.

In alternativa, puoi visualizzare l'ID chiave pubblica dell'attestatore in qualsiasi momento utilizzando il seguente comando:

gcloud container binauthz attestors describe ${ATTESTOR_NAME}.

Per salvare l'ID della chiave pubblica in una variabile di ambiente, inserisci questo comando:

PUBLIC_KEY_ID=$(gcloud container binauthz attestors describe ${ATTESTOR_NAME} \
--format='value(userOwnedGrafeasNote.publicKeys[0].id)')

Verifica che l'attestatore sia stato creato

Per verificare che l'attestatore sia stato creato, esegui questo comando:

gcloud container binauthz attestors list \
    --project="${ATTESTOR_PROJECT_ID}"

Passaggi successivi

• Scopri come creare attestazioni per l'attestatore.
• Aggiorna la policy di Autorizzazione binaria in modo che richieda le attestazioni utilizzando la consoleGoogle Cloud , Google Cloud CLI e l'API REST.