Crea attestatori utilizzando gcloud CLI

Questa pagina spiega come creare un attestatore in Autorizzazione binaria utilizzando l'interfaccia a riga di comando Google Cloud. In alternativa, puoi eseguire questi passaggi utilizzando la Console Google Cloud oppure l'API REST. Questa attività fa parte della configurazione di Autorizzazione binaria.

Utenti di Cloud Build: potete utilizzare l'attestatore built-by-cloud-build per eseguire il deployment solo delle immagini create da Cloud Build.

Un attestatore è un Risorsa Google Cloud utilizzata da Autorizzazione binaria per verificare un'attestazione. Per scoprire di più sulle attestazioni, vedi Panoramica di Autorizzazione binaria.

Per creare un attestatore:

• Crea una nota in Artifact Analysis per archiviare i metadati attendibili utilizzati nella procedura di attestazione.
• Configura una coppia di chiavi PKIX che può essere utilizzata per verificare l'identità dell'attestatore. (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 chiave pubblica che hai creato.

In una configurazione di un singolo progetto, crei l'attestatore nello stesso progetto Google Cloud in cui configuri il criterio di autorizzazione binaria. Per un tutorial end-to-end su un singolo progetto che include questi passaggi, consulta Iniziare a utilizzare Google Cloud CLI o Iniziare a utilizzare la console Google Cloud.

In una configurazione multi-progetto, ti consigliamo di avere progetti separati: un progetto di deployment, in cui è configurato il criterio, un progetto di attestatore, in cui sono archiviati gli attestatori, e un progetto di attestazione per le attestazioni. Per un tutorial end-to-end multi-project che include questi passaggi, consulta la configurazione multi-project.

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 memorizzare i nomi e i numeri dei progetti. Se i progetti di attestatore e di implementatore 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 recuperare i nomi degli account di servizio per i progetti:

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

Crea una nota Artifact Analysis

Autorizzazione binaria utilizza Artifact Analysis per archiviare i metadati attendibili utilizzati nella procedura di autorizzazione. Per ogni attestatore che crei, devi creare una nota di analisi degli elementi. Ciascuna attestazione viene archiviata un'occorrenza di questa nota.

Per creare la nota:

1. Imposta le variabili di ambiente per archiviare l'ID nota e un file leggibile descrizione:

   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. In un editor di testo, crea un file JSON che descriva la nota:

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

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}"
   

   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 autorizzazioni IAM nella nota

Devi concedere un ruolo Identity and Access Management (IAM) all'account di servizio del progetto di attestazione nella risorsa Nota di analisi degli elementi. Per farlo aggiungi l'account di servizio del progetto attestatore al Ruolo containeranalysis.notes.occurrences.viewer nella nota criterio IAM.

Per aggiungere il ruolo:

1. Genera un file JSON contenente le informazioni necessarie per impostare i ruoli IAM ruolo nella tua 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 l'account di servizio e i ruoli di accesso richiesti al criterio 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 al criterio utilizzando il metodo precedente, sostituisce eventuali ruoli esistenti nella nota. Se vuoi conservare i ruoli esistenti, assicurati di includerle nel file di dati JSON precedente.

Utilizzo di più progetti

Se archivi l'attestatore in un progetto ed esegui il deployment in un progetto separato, devi concedere il ruolo roles/binaryauthorization.attestorsVerifier al account di servizio associato al progetto deployer nell'attestatore.

Configurare le chiavi crittografiche

Autorizzazione binaria consente di utilizzare le chiavi PKIX per verificare le attestazioni.

Genera una coppia di chiavi

In questa guida, viene fornito l'articolo consigliato Elliptic Curve Digital Signature Algorithm (ECDSA). per generare una coppia di chiavi PKIX. Puoi anche usare coppie di chiavi RSA o PGP. Per ulteriori informazioni sugli algoritmi di firma, consulta la sezione Finalità e algoritmi delle chiavi.

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

PKIX (Cloud KMS)

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

1. Per impostare le variabili di ambiente necessarie per creare la coppia di chiavi, esegui seguenti 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: posizione della chiave
   • KMS_KEYRING_NAME: il nome del keyring
   • 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 il keyring, 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 del keyring
   • 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 per esempio, software

PKIX (chiave locale)

Avviso: sconsigliamo vivamente di utilizzare coppie di chiavi generate localmente negli ambienti di produzione perché rappresentano un rischio per la sicurezza. Ti consigliamo di utilizzare Cloud Key Management Service. Questo esempio è fornito solo a scopo illustrativo.

Per generare una nuova coppia di chiavi PKIX asimmetrica locale e memorizzarla in un file:

1. Genera la chiave privata:

   PRIVATE_KEY_FILE è il nome del file contenente la chiave privata utilizzata per la firma del payload dell'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 archiviala in un file:

   PUBLIC_KEY_FILE è il nome del file che contiene il pubblico 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:

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

   ATTESTOR_NAME=ATTESTOR_NAME
   

   dove ATTESTOR_NAME è 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 ruolo IAM per il progetto di deployment all'attestatore. Questo è utilizzata da Autorizzazione binaria quando valuta un criterio per determinare se il progetto dispone delle autorizzazioni per accedere a tutte le 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:

   PKIX (Cloud KMS)

   Per aggiungere la chiave pubblica da una coppia di chiavi Cloud KMS a 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 a un attestatore una chiave pubblica PKIX archiviata in locale, esegui seguente comando:

   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 automaticamente assegnata una nel Formato RFC 6920: ni:///sha-256;..., dove ... è un hash codificato di la chiave pubblica. Questo valore viene restituito nel campo id dell'output del comando. L'ID restituito può essere salvato in PUBLIC_KEY_ID e utilizzato per creare un'attestazione.

Salva l'ID della chiave pubblica

Per creare un'attestazione, è necessario l'ID della chiave pubblica.

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

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

gcloud container binauthz attestors describe ${ATTESTOR}.

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

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

Verificare 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 il tuo attestatore.
• Aggiorna il criterio di autorizzazione binaria in modo da richiedere le attestazioni utilizzando la console Google Cloud, Google Cloud CLI e l'API REST.