Questa pagina spiega come creare un attestatore personalizzato in Autorizzazione binaria utilizzando l'API REST.
In alternativa, puoi anche eseguire questi passaggi utilizzando la Google Cloud CLI oppure Console Google Cloud. Questo fa 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.
Panoramica
Un attestatore è una risorsa di Google Cloud che Autorizzazione binaria utilizza per verificare un'attestazione. Per scoprire di più sulle attestazioni, consulta la panoramica di Autorizzazione binaria.
Per creare un attestatore, devi:
- 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. Puoi anche usare PGP coppie di chiavi al posto delle chiavi PKIX.
- Crea l'attestatore in Autorizzazione binaria e associa la nota e chiave pubblica che hai creato.
In una configurazione per un singolo progetto, devi creare l'attestatore in nello stesso progetto Google Cloud in cui configuri Autorizzazione binaria. . In un più progetti, molto probabilmente avrai progetto deployer in cui è configurato il criterio e un server progetto attestatore in cui sono archiviati gli attestatori.
Prima di iniziare
Imposta il progetto predefinito
Imposta il progetto Google Cloud predefinito se non lo hai già fatto:
PROJECT_ID=PROJECT_ID gcloud config set project ${PROJECT_ID}
Configura l'ambiente
Configura le variabili di ambiente per archiviare i nomi e i numeri dei progetti:
DEPLOYER_PROJECT_ID=${PROJECT_ID} DEPLOYER_PROJECT_NUMBER="$( gcloud projects describe "${DEPLOYER_PROJECT_ID}" \ --format="value(projectNumber)" )" ATTESTOR_PROJECT_ID=${PROJECT_ID} ATTESTOR_PROJECT_NUMBER="$( gcloud projects describe "${ATTESTOR_PROJECT_ID}" \ --format="value(projectNumber)" )"
Se il progetto attestatore e deploymenter sono nello stesso progetto, usa lo stesso progetto ID per entrambe le variabili.
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 come occorrenza di questo nota.
Per creare una nota Artifact Analysis:
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
caratteri senza spazi (ad esempio,
test-attestor-note
) - NOTE_URI è il percorso completo della risorsa nota
- DESCRIPTION è un nome visualizzato leggibile per la nota
(ad es.
Test Attestor Note
)
- NOTE_ID è il nome interno della nota in caratteri alfanumerici
caratteri senza spazi (ad esempio,
In un editor di testo, crea un file JSON in
/tmp/note_payload.json
che descrive la nota di Artifact Analysis:cat > /tmp/note_payload.json << EOM { "name": "${NOTE_URI}", "attestation": { "hint": { "human_readable_name": "${DESCRIPTION}" } } } EOM
Crea la nota inviando una richiesta HTTP al REST di Artifact Analysis API:
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 le autorizzazioni nella nota
Nella nota in Artifact Analysis, devi anche impostare le autorizzazioni.
creato in modo che sia accessibile all'account di servizio del progetto attestatore. Tu
aggiorna il criterio IAM per la nota in modo da assegnare
containeranalysis.notes.occurrences.viewer
all'account.
Per impostare le autorizzazioni:
Genera un file JSON contenente le informazioni necessarie per impostare IAM norme sulla 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
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"
Configurazione delle chiavi di crittografia
Autorizzazione binaria ti consente di usare le chiavi PKIX per verificare in modo sicuro l'identità del firmatario che ha creato un attestazione. In questo modo viene garantito che solo le parti interessate possono autorizzare un'immagine container. In alternativa a PKIX, puoi anche per utilizzare chiavi PGP.
Creare una coppia di chiavi PKIX
Autorizzazione binaria consente di usare criteri asimmetrici coppie di chiavi PKIX per verificare un l'attestazione. La coppia di chiavi è composta da una chiave privata, il firmatario utilizza la firma digitale delle attestazioni e un che aggiungi all'attestatore. In seguito, l'applicazione forzata di Autorizzazione binaria la chiave pubblica nell'attestatore per verificare che l'attestazione sia stata creata firmatario.
In questa guida, i suggerimenti Algoritmo di firma digitale con curva ellittica (ECDSA) per generare una coppia di chiavi PKIX. Puoi anche usare chiavi RSA o PGP per firma. Per saperne di più, consulta Scopi e algoritmi principali informazioni sugli algoritmi di firma.
Le coppie di chiavi asimmetriche generate e archiviate in Cloud KMS è conforme al formato PKIX. Per creare chiave Cloud KMS da utilizzare con Autorizzazione binaria, consulta Creazione di chiavi asimmetriche. Accertati che scegli Segno asimmetrico come scopo della chiave quando crei la chiave.
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}
PKIX (chiave locale)
Per generare una nuova coppia di chiavi PKIX asimmetrica locale e memorizzarla in un file:
Genera la chiave:
PRIVATE_KEY_FILE="/tmp/ec_private.pem" openssl ecparam -genkey -name prime256v1 -noout -out ${PRIVATE_KEY_FILE}
Poiché questo file contiene una chiave pubblica e una privata, devi estrarre la chiave pubblica in un file separato in modo da poterla aggiungere al attestatore:
PUBLIC_KEY_FILE="/tmp/ec_public.pem" openssl ec -in ${PRIVATE_KEY_FILE} -pubout -out ${PUBLIC_KEY_FILE}
Crea l'attestatore
Il passaggio successivo consiste nel creare l'attestatore in Autorizzazione binaria con nella nota Artifact Analysis associata. Devi inoltre aggiungere chiave pubblica di crittografia.
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 es.
build-secure
oprod-qa
).Crea l'attestatore e allega il token di sicurezza pubblico:
PKIX (Cloud KMS)
Configura variabili di ambiente aggiuntive per archiviare le informazioni la coppia di chiavi Cloud KMS per la chiamata ad Autorizzazione binaria API.
KMS_CRYPTO_KEY_URI="projects/${KMS_KEY_PROJECT_ID}/locations/${KMS_KEY_LOCATION}/keyRings/${KMS_KEYRING_NAME}/cryptoKeys/${KMS_KEY_NAME}" KMS_CRYPTO_KEY_VERSION_URI="${KMS_CRYPTO_KEY_URI}/cryptoKeyVersions/${KMS_KEY_VERSION}" KMS_KEY_ID="//cloudkms.googleapis.com/v1/${KMS_CRYPTO_KEY_VERSION_URI}"
Scarica il file della chiave pubblica da Cloud KMS e salvarlo in un file denominato
/tmp/kms_public_key.pem
sul tuo sistema locale.Genera un file JSON contenente le informazioni necessarie per creare l'attestatore:
cat > /tmp/attestor.json << EOM { "userOwnedDrydockNote": { "noteReference": "${NOTE_URI}", "publicKeys": { "id": "${KMS_KEY_ID}", "pkixPublicKey": { "signatureAlgorithm": "${KMS_KEY_ALGORITHM}", "publicKeyPem": $( \ python < /tmp/kms_public_key.pem \ -c 'import json, sys; print(json.dumps(sys.stdin.read()))' \ ) } } } } EOM
Crea l'attestatore:
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/attestor.json \ "https://binaryauthorization.googleapis.com/v1/projects/${ATTESTOR_PROJECT_ID}/attestors?attestorId=${ATTESTOR_NAME}"
PKIX (chiave locale)
Genera un file JSON contenente le informazioni necessarie per creare l'attestatore:
cat > /tmp/attestor.json << EOM { "userOwnedGrafeasNote": { "noteReference": "${NOTE_URI}", "publicKeys": { "pkixPublicKey": { "signatureAlgorithm": "ecdsa_p256_sha256", "publicKeyPem": $( \ python < ${PUBLIC_KEY_FILE} \ -c 'import json, sys; print(json.dumps(sys.stdin.read()))' \ ) } } } } EOM
Crea l'attestatore:
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/attestor.json \ "https://binaryauthorization.googleapis.com/v1/projects/${ATTESTOR_PROJECT_ID}/attestors?attestorId=${ATTESTOR_NAME}"
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 all'attestatore a cui viene fatto riferimento.
Genera un file JSON contenente le informazioni necessarie per impostare IAM norme in merito all'attestatore:
cat > /tmp/iam_request.json << EOM { 'resource': 'projects/${ATTESTOR_PROJECT_ID}/attestors/${ATTESTOR_NAME}', 'policy': { 'bindings': [ { 'role': 'roles/binaryauthorization.attestorsVerifier', 'members': [ 'serviceAccount:${DEPLOYER_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://binaryauthorization.googleapis.com/v1beta1/projects/${ATTESTOR_PROJECT_ID}/attestors/${ATTESTOR_NAME}:setIamPolicy"
Verificare che l'attestatore sia stato creato
Per verificare che l'attestatore sia stato creato, esegui questo comando:
curl \ -H "Authorization: Bearer $(gcloud auth print-access-token)" \ -H "x-goog-user-project: ${ATTESTOR_PROJECT_ID}" \ "https://binaryauthorization.googleapis.com/v1/projects/${ATTESTOR_PROJECT_ID}/attestors/"
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.