Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Creare attestatori utilizzando l'API REST

Questa pagina spiega come creare un attestatore personalizzato in Autorizzazione binaria utilizzando l'API REST.

In alternativa, puoi eseguire questi passaggi utilizzando il Google Cloud CLI o la Google Cloud console. Questa attività fa parte della configurazione di Autorizzazione binaria.

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

Panoramica

Un attestatore è una Google Cloud risorsa che Autorizzazione binaria utilizza per verificare un'attestazione. Per saperne di più sulle attestazioni, consulta la panoramica di Autorizzazione binaria.

Per creare un attestatore, devi:

Crea una nota in Artifact Analysis per archiviare i metadati attendibili utilizzati nel processo di attestazione.
Configura una coppia di chiavi dell'infrastruttura a chiave pubblica (X.509) (PKIX) 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.) Puoi anche utilizzare coppie di chiavi PGP anziché chiavi PKIX.
Crea l'attestatore stesso in Autorizzazione binaria e associa la nota e la chiave pubblica che hai creato.

In una configurazione a progetto singolo, crei l'attestatore nello stesso progetto in cui configuri il criterio di Autorizzazione binaria . Google Cloud In una configurazione multi-progetto, molto probabilmente hai un progetto di deployment in cui è configurato il criterio e un progetto attestatore separato in cui sono archiviati gli attestatori.

Prima di iniziare

Imposta il progetto predefinito

Imposta il progetto predefinito Google Cloud se non l'hai già fatto:

PROJECT_ID=PROJECT_ID
gcloud config set project ${PROJECT_ID}

Configura l'ambiente

Imposta 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 il progetto di deployment sono lo stesso progetto, utilizza lo stesso ID progetto per entrambe le variabili.

Devi anche recuperare i nomi dei 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 di 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 di Artifact Analysis note. Ogni attestazione viene archiviata come occorrenza di questa nota.

Per creare una nota di Artifact Analysis:

Imposta 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 nota
- DESCRIPTION è un nome visualizzato leggibile per la nota (ad esempio, Test Attestor Note)

In un editor di testo, crea un file JSON in /tmp/note_payload.json che descriva 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 all'API REST di 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 le autorizzazioni per la nota

Devi anche impostare le autorizzazioni per la nota di Artifact Analysis che hai creato in modo che sia accessibile all'account di servizio del progetto attestatore. Per farlo, aggiorna il criterio IAM per la nota in modo da assegnare il ruolo containeranalysis.notes.occurrences.viewer all'account.

Per impostare le autorizzazioni:

Genera un file JSON che contenga le informazioni necessarie per impostare il criterio IAM per la 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 il 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"
```
Quando aggiungi un ruolo al criterio utilizzando il metodo sopra descritto, questo sostituisce tutti i ruoli esistenti nella nota. Se vuoi conservare i ruoli esistenti, assicurati di includerli nei dati JSON quando imposti il criterio.

Configura le chiavi di crittografia

Autorizzazione binaria ti consente di utilizzare le chiavi PKIX per verificare in modo sicuro l'identità del firmatario che ha creato un' attestazione. In questo modo, solo le parti verificate possono autorizzare un'immagine container. In alternativa a PKIX, puoi anche utilizzare le chiavi PGP.

Crea una coppia di chiavi PKIX

Autorizzazione binaria ti consente di utilizzare coppie di chiavi PKIX asimmetriche per verificare un' attestazione. La coppia di chiavi è costituita da una chiave privata, che il firmatario utilizza per firmare digitalmente le attestazioni, e da una chiave pubblica, che aggiungi all'attestatore. In un secondo momento, l'applicazione di Autorizzazione binaria utilizza la chiave pubblica nell'attestatore per verificare che l'attestazione sia stata creata dal firmatario.

In questa guida, per generare una coppia di chiavi PKIX viene utilizzato l'algoritmo di firma digitale con curva ellittica (ECDSA) consigliato . Puoi anche utilizzare chiavi RSA o PGP per la firma. Per ulteriori informazioni sugli algoritmi di firma, consulta Finalità e algoritmi delle chiavi.

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:

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 località 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; è consigliato ec-sign-p256-sha256
- KMS_PROTECTION_LEVEL: il livello di protezione, ad 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 asimmetriche locali e archiviarla 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 sia una chiave pubblica sia una privata, devi estrarre la chiave pubblica in un file separato in modo da poterla 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 in Autorizzazione binaria con la nota di Artifact Analysis associata. Devi anche aggiungere la 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 esempio, build-secure o prod-qa).

Crea l'attestatore e collega il token di sicurezza pubblico:

PKIX (Cloud KMS)

Configura altre variabili di ambiente per archiviare le informazioni sulla coppia di chiavi Cloud KMS per la chiamata all'API Autorizzazione binaria.

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 salvalo in un file denominato /tmp/kms_public_key.pem sul tuo sistema locale.

Genera un file JSON che contenga 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 che contenga 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 un'associazione di ruoli IAM per il progetto di deployment all'attestatore. Questo viene utilizzato 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 che contenga le informazioni necessarie per impostare il criterio IAM per l'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 il 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://binaryauthorization.googleapis.com/v1beta1/projects/${ATTESTOR_PROJECT_ID}/attestors/${ATTESTOR_NAME}:setIamPolicy"

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

Creare attestatori utilizzando l'API REST Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Panoramica

Prima di iniziare

Imposta il progetto predefinito

Configura l'ambiente

Crea una nota di Artifact Analysis

Imposta le autorizzazioni per la nota

Configura le chiavi di crittografia

Crea una coppia di chiavi PKIX

PKIX (Cloud KMS)

PKIX (chiave locale)

Crea l'attestatore

PKIX (Cloud KMS)

PKIX (chiave locale)

Verifica che l'attestatore sia stato creato

Passaggi successivi

Creare attestatori utilizzando l'API REST