Questa pagina spiega come creare un attestatore in Autorizzazione binaria utilizzando con Google Cloud CLI. In alternativa, puoi eseguire questi passaggi utilizzando la Console Google Cloud oppure l'API REST. Questa attività è parte della configurazione di Autorizzazione binaria.
Utenti di Cloud Build: puoi utilizzare invece 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 per archiviare i metadati attendibili utilizzati nel processo di attestazione.
- Imposta una coppia di chiavi PKIX che possa essere utilizzata per verificare l'identità del o l'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 per un singolo progetto, crei l'attestatore nello stesso progetto Google Cloud nel progetto in cui configuri il criterio di Autorizzazione binaria. Per un tutorial end-to-end per un singolo progetto che includa questi passaggi, consulta Inizia a utilizzare Google Cloud CLI oppure Inizia a utilizzare la console Google Cloud.
In una configurazione con più progetti, ti consigliamo di creare progetti separati: deployer project, nel quale è configurato il criterio; un progetto attestatore, dove sono archiviati gli attestatori; e un progetto di attestazione per le attestazioni. Per un tutorial end-to-end per più progetti che include questi passaggi, vedi per la configurazione multiprogetto.
Prima di iniziare
Prima di creare gli attestatori, segui questi passaggi:
Configurare l'ambiente del progetto
In questa sezione, configurerai le variabili di ambiente.
Configura le variabili di ambiente per archiviare i nomi e i numeri dei progetti. Se le tue i progetti attestatore e deployer sono lo stesso, usa lo stesso dell'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
Usi di Autorizzazione binaria Artifact Analysis per per archiviare i metadati attendibili utilizzati nel processo di autorizzazione. Per ogni attestatore devi creare un'analisi Artifact Analysis nota. Ciascuna attestazione viene archiviata un'occorrenza di questa nota.
Per creare la nota:
Imposta le variabili di ambiente per memorizzare 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 esempiotest-attestor-note
NOTE_URI
: il percorso completo della nota risorsaDESCRIPTION
: un nome visualizzato leggibile per la Nota, ad esempioTest Attestor Note
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
Crea la nota inviando una richiesta HTTP al 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 di Identity and Access Management (IAM) a
l'account di servizio del progetto attestatore in Artifact Analysis
nota. Per farlo, aggiungi l'account di servizio del progetto attestatore al
Ruolo containeranalysis.notes.occurrences.viewer
nella nota
criterio IAM.
Per aggiungere il ruolo:
Genera un file JSON contenente le informazioni necessarie per impostare IAM ruolo nella nota:
cat > /tmp/iam_request.json << EOM { "resource": "${NOTE_URI}", "policy": { "bindings": [ { "role": "roles/containeranalysis.notes.occurrences.viewer", "members": [ "serviceAccount:${ATTESTOR_SERVICE_ACCOUNT}" ] } ] } } EOM
Aggiungi l'account di servizio e i ruoli di accesso richiesti al criterio IAM per 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"
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.
Configurazione delle chiavi di crittografia
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. Consulta la sezione Scopi e algoritmi principali per ulteriori informazioni su di firma digitale.
Una coppia di chiavi PKIX comprende una chiave privata che i firmatari per firmare le attestazioni e una chiave pubblica che aggiungi all'attestatore. Alle ore per il 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:
Per impostare le variabili di ambiente necessarie per creare la coppia di chiavi, esegui il 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 chiaveKMS_KEYRING_NAME
: il nome del keyringKMS_KEY_NAME
: il nome della chiaveKMS_KEY_VERSION
: la versione della chiaveKMS_KEY_ALGORITHM
: l'algoritmo; Orario consigliato:ec-sign-p256-sha256
KMS_PROTECTION_LEVEL
: il livello di protezione per esempio,software
Per creare il keyring, esegui questo comando:
gcloud kms keyrings create ${KMS_KEYRING_NAME} \ --location ${KMS_KEY_LOCATION}
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 chiaveKMS_KEY_LOCATION
: posizione della chiaveKMS_KEYRING_NAME
: il nome del keyringKMS_KEY_PURPOSE
: lo scopo della chiave, impostato suASYMMETRIC_SIGN
KMS_KEY_ALGORITHM
: l'algoritmo, Orario consigliato:ec-sign-p256-sha256
KMS_PROTECTION_LEVEL
: il livello di protezione per esempio,software
PKIX (chiave locale)
Per generare una nuova coppia di chiavi PKIX asimmetrica locale e memorizzarla in un file, procedi nel seguente modo:
Genera la chiave privata:
PRIVATE_KEY_FILE è il nome del file contenente 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}
Estrai la chiave pubblica dalla chiave privata e archiviala in un file:
PUBLIC_KEY_FILE è il nome del file che contiene il pubblico chiave 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:
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
oprod-qa
).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}"
Aggiungi all'attestatore un'associazione del ruolo IAM per il progetto deployer. 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
Per aggiungere la chiave pubblica all'attestatore:
PKIX (Cloud KMS)
Per aggiungere la chiave pubblica da una coppia di chiavi Cloud KMS a 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 campoid
del comando come output. L'ID restituito può essere salvato inPUBLIC_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 della chiave pubblica, puoi copiarlo dall'output della classe
binauthz attestors public-keys add
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 le attestazioni per l'attestatore.
- Aggiorna il criterio di Autorizzazione binaria per richiedere le attestazioni mediante la console Google Cloud Google Cloud CLI l'API REST.