Crea attestatori mediante gcloud CLI

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

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

Per creare un attestatore:

  • Crea una nota in Artifact Analysis per archiviare i metadati attendibili utilizzati nel processo di attestazione.
  • Configura una coppia di chiavi PKIX che possa 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.
  • Crea l'attestatore stesso in Autorizzazione binaria e associa la nota e la chiave pubblica che hai creato.

In una configurazione di un singolo progetto, puoi creare 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 a più progetti, consigliamo di creare progetti separati: un progetto deployment, in cui è configurato il criterio, un progetto attestatore in cui sono archiviati gli attestatori e un progetto di attestazione per le attestazioni. Per un tutorial end-to-end multiprogetto che includa questi passaggi, consulta Configurazione di più progetti.

Prima di iniziare

Prima di creare gli attestatori:

  1. Autorizzazione binaria deve essere abilitata. Per informazioni su come farlo, consulta Attivazione di Autorizzazione binaria.

  2. Il criterio deve essere configurato in modo da consentire solo le immagini verificate dagli attestatori. Per informazioni su come farlo, consulta Configurare un criterio utilizzando gcloud CLI.

Configura l'ambiente del progetto

In questa sezione imposterai le variabili di ambiente.

Configura le variabili di ambiente per archiviare i nomi e i numeri dei progetti. Se i progetti dell'attestatore e dell'autore del deployment 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 ottenere 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"

Creazione di una nota Artifact Analysis

Autorizzazione binaria utilizza Artifact Analysis per archiviare i metadati attendibili utilizzati nel processo di autorizzazione. Per ogni attestatore creato, devi creare una nota di Artifact Analysis. Ogni attestazione viene archiviata come occorrenza di questa nota.

Per creare la nota:

  1. Imposta le variabili di ambiente per archiviare l'ID 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: nome interno della nota in caratteri alfanumerici senza spazi, ad esempio test-attestor-note
    • NOTE_URI: il percorso completo della risorsa delle note
    • 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 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 IAM sulla nota

Devi concedere un ruolo Identity and Access Management (IAM) all'account di servizio del progetto di attestatore nella risorsa nota di Artifact Analysis. Per farlo, aggiungi l'account di servizio del progetto di attestatore al ruolo containeranalysis.notes.occurrences.viewer nel criterio IAM della nota.

Per aggiungere il ruolo:

  1. Genera un file JSON contenente le informazioni necessarie per impostare il ruolo IAM 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
    
  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"
    

Utilizzo in più progetti

Se archivi l'attestatore in un progetto e ne esegui il deployment in un progetto separato, devi concedere il ruolo roles/binaryauthorization.attestorsVerifier all'account di servizio associato al progetto del deployer sull'attestatore.

Configura le chiavi di crittografia

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

Genera una coppia di chiavi

In questa guida, viene utilizzato l'algoritmo di firma digitale Elliptic Curve (ECDSA) per generare una coppia di chiavi PKIX. Puoi anche utilizzare coppie di chiavi RSA o PGP. Consulta Scopi e algoritmi chiave per ulteriori informazioni sugli algoritmi di firma.

Una coppia di chiavi PKIX comprende una chiave privata che i firmatori utilizzano per firmare le attestazioni e una chiave pubblica che aggiungi all'attestatore. Al momento del 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:

  1. Per configurare le variabili di ambiente necessarie alla creazione della 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 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, ad esempio software

PKIX (chiave locale)

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 firmare il payload di attestazione.

    PRIVATE_KEY_FILE="/tmp/ec_private.pem"
    openssl ecparam -genkey -name prime256v1 -noout -out ${PRIVATE_KEY_FILE}
    
  2. Estrae la chiave pubblica dalla chiave privata e la archivia in un file:

    PUBLIC_KEY_FILE è il nome del file contenente la chiave pubblica archiviata nell'attestatore.

    PUBLIC_KEY_FILE="/tmp/ec_public.pem"
    openssl ec -in ${PRIVATE_KEY_FILE} -pubout -out ${PUBLIC_KEY_FILE}
    

Crea attestatore

Per creare l'attestatore, segui questi passaggi:

  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 di 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 deployer all'attestatore. Viene 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 all'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 localmente, esegui questo 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 una qualsiasi stringa), ne viene automaticamente fornito uno nel formato RFC 6920: ni:///sha-256;..., dove ... è un hash codificato della 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 della chiave pubblica, puoi copiarlo dall'output del comando binauthz attestors public-keys add in alto.

In alternativa, puoi visualizzare l'ID 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 il seguente comando:

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

Verifica 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