Questa pagina è stata tradotta dall'API Cloud Translation.

Crea attestatori mediante la console Google Cloud

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

Prima di iniziare

Prima di creare attestatori, procedi come segue:

Autorizzazione binaria deve essere abilitata. Per ulteriori informazioni, consulta la sezione Attivare Autorizzazione binaria.
Il criterio deve essere configurato in modo da consentire solo le immagini verificate dagli attestatori. Per ulteriori informazioni, consulta Configurare un criterio utilizzando la console.

Panoramica

Un attestatore è una risorsa Google Cloud che Autorizzazione binaria utilizza per verificare un'attesta. Per scoprire di più su Autorizzazione binaria, consulta la panoramica su Autorizzazione binaria.

Per creare un attestatore devi:

Configura una coppia di chiavi PKIX da utilizzare 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 chiave pubblica che hai creato

In una configurazione a progetto singolo, puoi creare il tuo attestatore nello stesso progetto in cui configuri il criterio di Autorizzazione binaria. In una configurazione multiprogetto, molto probabilmente hai un progetto deployer in cui è configurato il tuo criterio e un progetto attestatore separato in cui sono archiviati gli attestatori.

Configurare le chiavi di crittografia

Autorizzazione binaria consente di utilizzare le chiavi PKIX per verificare in modo sicuro l'identità degli attestatori. Questo garantisce che solo le parti verificate possano autorizzare un'immagine container.

In questa guida, viene usato l'algoritmo di firma digitale della curva ellittica (ECDSA) consigliato per generare una coppia di chiavi PKIX. Per la firma puoi anche utilizzare chiavi RSA o PGP. Per scoprire di più sulla firma di algoritmi, consulta la pagina Scopo e algoritmi principali.

Crea una coppia di chiavi PKIX

Autorizzazione binaria consente di utilizzare coppie di chiavi PKIX asimmetriche per verificare l'identità di un attestatore. La coppia di chiavi è composta da una chiave privata, che l'attestatore utilizza per firmare digitalmente le attestazioni, e da una chiave pubblica, che si aggiunge all'attestatore come archiviato dal servizio Autorizzazione binaria.

Una coppia di chiavi PKIX è composta da una chiave privata, che il firmatore utilizza per firmare le attestazioni digitali, e da una chiave pubblica, che aggiungi all'attestatore. Al momento del deployment, Autorizzazione binaria utilizza questa chiave pubblica per verificare l'attestazione firmata dalla chiave privata.

Le coppie di chiavi asimmetriche generate e archiviate in Cloud KMS sono conformi al formato PKIX. Per creare una chiave Cloud KMS da utilizzare con Autorizzazione binaria, consulta Creazione di chiavi asimmetriche. Assicurati di scegliere Firma asimmetrica come scopo della chiave quando crei la chiave.

PKIX (Cloud KMS)

Per creare la coppia di chiavi in Cloud KMS, procedi nel seguente modo:

Configura le variabili di ambiente necessarie per creare la coppia di chiavi.

KMS_KEY_PROJECT_ID=${PROJECT_ID}
KMS_KEYRING_NAME=my-binauthz-keyring
KMS_KEY_NAME=my-binauthz-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

Crea il keyring.

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

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}

PKIX (chiave locale)

Per generare una nuova coppia di chiavi PKIX asimmetrica locale e archiviarla in un file, procedi nel seguente modo:

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 poterlo aggiungere all'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 stesso e associare una nota Container Analysis e una chiave pubblica.

Autorizzazione binaria utilizza Container Analysis per archiviare i metadati attendibili utilizzati nel processo di autorizzazione. Devi creare una nota Container Analysis per ogni attestatore creato. Ogni attezione è archiviata come ricorrenza di questa nota.

Per creare l'attestatore:

Vai alla pagina Autorizzazione binaria del progetto dell'attestatore.

Vai ad Autorizzazione binaria
Nella scheda Attestatori, fai clic su Crea.
Fai clic su Crea nuovo attestatore.
In Nome attestatore, inserisci un nome per l'attestatore (ad esempio build-secure o prod-qa).
Per aggiungere la chiave pubblica all'attestatore, procedi nel seguente modo:
PKIX (chiave locale)
1. Fai clic su Aggiungi una chiave PKIX.
2. Fai clic su Importa da file.
3. Individua e seleziona il file della chiave PKIX salvato in precedenza. Nota:puoi anche incollare una chiave pubblica in formato PEM.
4. Seleziona l'algoritmo di firma. La chiave di esempio in questa guida viene generata con l'algoritmo Elliptic Curve P256 - SHA Digest.
PKIX (Cloud KMS)
1. Fai clic su Aggiungi una chiave PKIX.
2. Fai clic su Importa da Cloud KMS.
3. Inserisci l'ID risorsa per la versione della chiave nella finestra visualizzata. Il formato dell'ID risorsa è:
```
projects/KMS_KEY_PROJECT_ID/locations/KMS_KEY_LOCATION/keyRings/KMS_KEYRING_NAME/cryptoKeys/KMS_KEY_NAME/cryptoKeyVersions/KMS_KEY_VERSION
```
  dove:
  - KMS_KEY_PROJECT_ID è l'ID del progetto in cui sono archiviate le chiavi
  - KMS_KEY_LOCATION è la posizione della chiave (global è l'impostazione predefinita)
  - KMS_KEYRING_NAME è il nome del keyring
  - KMS_KEY_NAME è il nome della chiave
  - KMS_KEY_VERSION è la versione della chiave
  Se hai creato una coppia di chiavi Cloud KMS utilizzando le variabili di ambiente di esempio in questa pagina, puoi visualizzare l'ID risorsa con il seguente comando:
```
echo projects/${KMS_KEY_PROJECT_ID}/locations/${KMS_KEY_LOCATION}/keyRings/${KMS_KEYRING_NAME}/cryptoKeys/${KMS_KEY_NAME}/cryptoKeyVersions/${KMS_KEY_VERSION}
```
  Per aggiungere la chiave, devi avere il ruolo "cloudkms.publicKeyViewer" sulla risorsa chiave.
4. Fai clic su Invia.
Se vuoi utilizzare una nota esistente che hai creato in precedenza, espandi la sezione Impostazioni avanzate.
1. Deseleziona Genera automaticamente un'analisi dei container nota.
2. Inserisci il nome completo nel campo ID nota Container Analysis. Il nome è nel formato projects/PROJECT_ID/notes/NOTE_ID.
Fai clic su Crea.

Verifica che l'attestatore sia stato creato

Per verificare che l'attestatore sia stato creato:

Torna alla pagina Autorizzazione binaria in Google Cloud Console.
Apri la scheda Attestatori.

Configurazione con più progetti

Se utilizzi una configurazione multiprogetto, in cui hai progetti deployer e attestatore separati, è necessario impostare autorizzazioni aggiuntive sulla risorsa attestatore affinché il progetto deployer utilizzi le attestazioni create durante il deployment.

Aggiungi un'associazione del ruolo IAM per il progetto deployer

Devi aggiungere un'associazione del ruolo IAM per l'account di servizio del progetto deployer all'attestatore. Questo viene utilizzato da Autorizzazione binaria quando valuta un criterio per determinare se l'account ha le autorizzazioni per accedere all'attestatore.

Devi aggiungere l'associazione dei ruoli IAM dalla riga di comando perché questo passaggio non è supportato nella console Google Cloud.

Per aggiungere l'associazione dei ruoli IAM:

Configura le variabili di ambiente per archiviare i tuoi nomi e numeri di progetto.

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

Configura le variabili di ambiente per archiviare i nomi degli account di servizio per i progetti:

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

Aggiungi l'associazione del ruolo IAM:

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

Aggiungi un'associazione dei ruoli IAM per l'utente che configura l'Autorizzazione binaria

Devi aggiungere un'associazione di ruolo IAM per l'utente che aggiunge un attestatore al criterio di autorizzazione binaria nel progetto deployer, poiché l'utente deve avere l'autorizzazione per visualizzare l'attestatore da aggiungere. Se vuoi, questa autorizzazione può essere revocata in sicurezza dopo l'aggiunta dell'attestatore.

Devi inoltre aggiungere l'associazione dei ruoli IAM dalla riga di comando, poiché questo passaggio non è supportato nella console Google Cloud.

Per aggiungere l'associazione dei ruoli IAM:

gcloud --project ATTESTOR_PROJECT_ID \
    beta container binauthz attestors add-iam-policy-binding \
    "projects/ATTESTOR_PROJECT_ID/attestors/ATTESTOR" \
    --member=ADMIN_EMAIL_ACCOUNT \
    --role=roles/binaryauthorization.attestorsViewer

Per rimuovere l'associazione del ruolo IAM dopo l'aggiunta dell'attestatore:

gcloud --project ATTESTOR_PROJECT_ID \
    beta container binauthz attestors remove-iam-policy-binding \
    "projects/ATTESTOR_PROJECT_ID/attestors/ATTESTOR" \
    --member=ADMIN_EMAIL_ACCOUNT \
    --role=roles/binaryauthorization.attestorsViewer

Passaggi successivi

Crea un'attestazione