Inizia a utilizzare la console Google Cloud (GKE)

Questo tutorial mostra come configurare e testare un criterio di Autorizzazione binaria che richiede attestazioni. Questo tipo di criterio protegge la tua catena di fornitura del software basata su container definendo chi può eseguire il deployment immagini su Google Kubernetes Engine (GKE) e a quali immagini container Il deployment di GKE è consentito.

Durante la fase di deployment, Autorizzazione binaria utilizza gli attacchi per Verificare le firme digitali negli attestazioni. La le attestazioni sono state create dai firmati nell'ambito del un processo di compilazione.

In questo tutorial vengono illustrati il cluster GKE, le attestazioni gli attestatori si trovano tutti in un unico progetto. La configurazione per un singolo progetto utile soprattutto per eseguire test o sperimentare con il servizio. Per un altri esempi reali, vedi configurazione multiprogetto.

I passaggi riportati di seguito descrivono le attività eseguite dalla console Google Cloud, nonché ad alcune attività che esegui utilizzando i comandi gcloud. Per eseguire questi passaggi utilizzando gcloud, consulta la guida introduttiva all'utilizzo di Google Cloud CLI.

Obiettivi

In questo tutorial imparerai a:

  • Crea un cluster (GKE) con Autorizzazione binaria attivata
  • Crea un attestatore utilizzato dall'applicazione forzata dell'Autorizzazione binaria per la verifica la firma su un'attestazione
  • Configura un criterio che richiede un'attestazione
  • Crea una coppia di chiavi di crittografia per firmare le attestazioni e verificarle in un secondo momento
  • Firma un digest dell'immagine container, creando una firma
  • Crea un'attestazione utilizzando la firma
  • Testa il criterio eseguendo il deployment di un'immagine container in GKE

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi basata sull'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud potrebbero essere idonei per una prova gratuita.

Prima di iniziare

  1. Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  3. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

  4. Abilita le API Container Registry, Artifact Analysis and Binary Authorization.

    Abilita le API

  5. Installa Google Cloud CLI.

  6. Per initialize gcloud CLI, esegui questo comando: 

    gcloud init
    7.

  7. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  8. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

  9. Abilita le API Container Registry, Artifact Analysis and Binary Authorization.

    Abilita le API

  10. Installa Google Cloud CLI.

  11. Per initialize gcloud CLI, esegui questo comando: 

    gcloud init
    12.
  12. Installa kubectl.

Imposta il progetto predefinito

Per facilitare i comandi che seguono, archivia l'ID progetto Google Cloud in un di variabile di ambiente come segue:

PROJECT_ID=PROJECT_ID

dove PROJECT_ID è il nome del tuo progetto.

Se il progetto predefinito non è selezionato, impostalo ora:

gcloud config set project ${PROJECT_ID}

Crea un cluster con Autorizzazione binaria abilitata

Crea il cluster

Ora puoi creare un cluster GKE con Autorizzazione binaria in un bucket con il controllo delle versioni attivo. Qui crei un cluster denominato test-cluster nel Zona GKE us-central1-a.

Per creare il cluster, segui questi passaggi:

  1. Vai al menu GKE nella console Google Cloud.

    Vai a GKE

  2. Fai clic su Crea cluster.

  3. Inserisci test-cluster nel campo Nome.

  4. Seleziona Zonal nelle opzioni Zonal.

  5. Seleziona us-central1-a dall'elenco a discesa Zona.

  6. Fai clic su Disponibilità, networking, sicurezza e funzionalità aggiuntive.

  7. Nella sezione Sicurezza, seleziona Attiva Autorizzazione binaria.

  8. Seleziona Solo applicazione forzata.

  9. Fai clic su Crea.

Configura kubectl

Devi anche aggiornare il file kubeconfig locale per il tuo kubectl dell'installazione. In questo modo avrai a disposizione le credenziali e le informazioni sugli endpoint per accedere al cluster in GKE.

Per aggiornare il file kubeconfig locale:

gcloud container clusters get-credentials \
    --zone us-central1-a \
    test-cluster

Visualizza il criterio predefinito

Un criterio in Autorizzazione binaria è un insieme di regole il deployment delle immagini container. Puoi avere un solo criterio per progetto. Per impostazione predefinita, il criterio è configurato in modo da consentire il deployment di tutte le immagini container.

Per visualizzare il criterio predefinito:

  1. Vai alla pagina Autorizzazione binaria nella console Google Cloud.

    Vai ad Autorizzazione binaria

  2. Fai clic su Modifica criterio.

  3. In Regola predefinita del progetto, l'opzione Consenti tutte le immagini è visualizzati.

  4. Fai clic su Save Policy (Salva criterio).

Crea un attestatore

Un attestatore è l'autorità di verifica che L'applicazione forzata di Autorizzazione binaria utilizza al momento del deployment per decidere se consentire a GKE di eseguire il deployment dell'immagine container firmata corrispondente. L'attestatore contiene la chiave pubblica e in genere è gestito da persone responsabile della sicurezza della catena di fornitura del software.

Per creare un attestatore devi:

  • Crea l'attestatore in Autorizzazione binaria
  • Genera automaticamente una nota attestante associata in Artifact Analysis da archiviare metadati di attestazione attendibile utilizzati nel processo di autorizzazione

Per questo tutorial, hai un attestatore denominato test-attestor. In un contesto reale uno scenario, può esistere un qualsiasi numero di attestatori, ognuno dei quali rappresenta una parte che partecipa al processo di autorizzazione dell'immagine.

Genera una coppia di chiavi

Autorizzazione binaria utilizza chiavi crittografiche per verificare in modo sicuro l'identità dei sottoscrittori. Ciò garantisce di cui è possibile eseguire il deployment solo per le immagini container autorizzate. La coppia di chiavi è composto da una chiave privata e una chiave pubblica. Il firmatario utilizza la chiave privata per firmare il digest dell'immagine container, producendo una firma che viene quindi archiviato in un'attestazione. Il pubblico viene archiviata nell'attestatore. Al momento del deployment, l'applicazione forzata di Autorizzazione binaria usa la chiave pubblica dell'attestatore per verificare nell'attestazione prima di consentire il deployment del container.

In questo tutorial utilizzi Infrastruttura a chiave pubblica (X.509) (PKIX) per le chiavi di crittografia. Questo tutorial utilizza lo strumento 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 chiavi generate e archiviate Cloud Key Management Service (Cloud KMS) è conforme a PKIX. Per ulteriori informazioni, consulta Creazione di attestatori utilizzando l'interfaccia a riga di comando informazioni sull'uso delle chiavi PKIX e di Cloud KMS.

Per generare una coppia di chiavi PKIX, segui questi passaggi:

  1. Crea la chiave privata:

    PRIVATE_KEY_FILE="/tmp/ec_private.pem"
openssl ecparam -genkey -name prime256v1 -noout -out ${PRIVATE_KEY_FILE}

  2. Estrai la chiave pubblica dalla chiave privata:

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

Crea l'attestatore

Ora puoi creare l'attestatore in Autorizzazione binaria e associare la chiave pubblica che hai creato.

Per creare l'attestatore:

  1. Torna alla pagina Autorizzazione binaria nella console Google Cloud.

    Torna ad Autorizzazione binaria

  2. Nella scheda Attestatori, fai clic su Crea.

    Screenshot della scheda dei criteri che mostra la regola predefinita

  3. Compila i campi come segue:

    1. Inserisci test-attestor nel campo Nome attestatore.

    2. Verifica che l'opzione Crea automaticamente una nota Artifact Analysis sia selezionata.

    3. Fai clic su Add a PKIX Public Key (Aggiungi una chiave pubblica PKIX).

    4. Apri /tmp/ec_public.pem in un editor di testo. Questa è la chiave pubblica creato nel passaggio precedente. Copia i contenuti del tag nella casella di testo Materiale chiave pubblica.

    5. Fai clic su Elliptic Curve P-256 - SHA256 Digest nella Menu a discesa Algoritmo di firma.

    6. Fai clic su Fine.

  4. Fai clic su Crea per creare l'attestatore.

  5. Archivia l'ID della chiave pubblica.

    Per visualizzare l'ID della chiave pubblica dell'attestatore dopo averlo aggiunto, utilizza gcloud container binauthz attestors describe ${ATTESTOR_NAME}. Per creare un di variabile di ambiente per archiviare l'ID della chiave pubblica, esegui questo comando: :

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

Configura il criterio

Ora puoi configurare il criterio:

  1. Torna alla pagina Autorizzazione binaria nella console Google Cloud.

  2. Nella scheda Norme, fai clic su Modifica criterio.

  3. Seleziona Consenti solo le immagini che sono state approvate dai seguenti utenti Attestatori.

  4. Fai clic su Aggiungi attestatori.

  5. Fai clic su Aggiungi per nome progetto e attestatore.

  6. Inserisci PROJECT_ID nel campo Nome progetto.

  7. Inserisci test-attestor nel campo Nome attestatore.

  8. Fai clic su Aggiungi 1 attestatore.

  9. Fai clic su Save Policy (Salva criterio).

Per ulteriori informazioni, vedi Configurazione di un criterio utilizzando la console.

Testa il criterio

Puoi testare il criterio configurato in precedenza provando a eseguire il deployment di un esempio l'immagine container al cluster. Il criterio bloccherà il deployment perché l'attestazione richiesta non è stata effettuata.

Per questo tutorial, puoi usare immagini di esempio di Container Registry Artifact Registry. L'immagine di Container Registry si trova nel percorso gcr.io/google-samples/hello-app:1.0. L'immagine di Artifact Registry si trova nel percorso us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0. Entrambi i percorsi contengono un'immagine pubblica creata da Google che contiene un messaggio "Hello, Mondo!" dell'applicazione di esempio.

Per provare a eseguire il deployment dell'immagine, esegui questo comando:

kubectl run hello-server --image gcr.io/google-samples/hello-app:1.0 --port 8080

Ora verifica che il deployment sia stato bloccato da Autorizzazione binaria:

kubectl get pods

Il comando visualizza il seguente messaggio, che indica che l'immagine non è di cui è stato eseguito il deployment:

No resources found.

Puoi ottenere ulteriori dettagli sul deployment:

kubectl get event --template \
'{{range.items}}{{"\033[0;36m"}}{{.reason}}:{{"\033[0m"}}\{{.message}}{{"\n"}}{{end}}'

Verrà visualizzata una risposta simile alla seguente:

FailedCreate: Error creating: pods POD_NAME is forbidden: admission webhook "imagepolicywebhook.image-policy.k8s.io" denied the request: Image IMAGE_NAME denied by Binary Authorization default admission rule. Image IMAGE_NAME denied by ATTESTOR_NAME: No attestations found

In questo output:

  • POD_NAME: il nome del pod.
  • IMAGE_NAME: il nome dell'immagine.
  • ATTESTOR_NAME: il nome dell'attestatore.

Assicurati di eliminare il deployment per poter andare al passaggio successivo:

kubectl delete deployment hello-server

Crea un'attestazione

Un'attestazione è un documento digitale creato da un firmatario che certifica che GKE può eseguire il deployment nell'immagine container. Il processo di creazione di un'attestazione a volte è chiamato "firmare un'immagine".

In questo tutorial creerai un'attestazione per immagini di esempio da Container Registry e Artifact Registry.

Per creare un'attestazione:

  1. Imposta le variabili in cui sono archiviati il percorso e il digest del Registro di sistema dell'immagine. nome attestatore:

    Container Registry 

    IMAGE_PATH="gcr.io/google-samples/hello-app"
IMAGE_DIGEST="sha256:c62ead5b8c15c231f9e786250b07909daf6c266d0fcddd93fea882eb722c3be4"
ATTESTOR="test-attestor"
IMAGE_TO_ATTEST=${IMAGE_PATH}@${IMAGE_DIGEST}

    Artifact Registry 

    IMAGE_PATH="us-docker.pkg.dev/google-samples/containers/gke/hello-app"
IMAGE_DIGEST="sha256:37e5287945774f27b418ce567cd77f4bbc9ef44a1bcd1a2312369f31f9cce567"
ATTESTOR="test-attestor"
IMAGE_TO_ATTEST=${IMAGE_PATH}@${IMAGE_DIGEST}

  2. Genera il payload di attestazione:

    Container Registry 

    gcloud container binauthz create-signature-payload \
--artifact-url=${IMAGE_PATH}@${IMAGE_DIGEST} > /tmp/generated_payload.json

    Il file JSON del payload include i seguenti contenuti:

    {
"critical": {
  "identity": {
    "docker-reference": "gcr.io/google-samples/hello-app"
  },
  "image": {
    "docker-manifest-digest": "sha256:c62ead5b8c15c231f9e786250b07909daf6c266d0fcddd93fea
882eb722c3be4"
  },
  "type": "Google cloud binauthz container signature"
}
}

    Artifact Registry 

    gcloud container binauthz create-signature-payload \
--artifact-url=${IMAGE_PATH}@${IMAGE_DIGEST} > /tmp/generated_payload.json

    Il file JSON del payload include i seguenti contenuti:

    {
"critical": {
  "identity": {
    "docker-reference": "us-docker.pkg.dev/google-samples/containers/gke/hello-app"
  },
  "image": {
    "docker-manifest-digest": "sha256:37e5287945774f27b418ce567cd77f4bbc9ef44a1bcd1a2312369f31f9cce567"
  },
  "type": "Google cloud binauthz container signature"
}
}

  3. Firma il payload con la tua chiave privata PKIX e crea una firma file:

    openssl dgst -sha256 -sign ${PRIVATE_KEY_FILE} /tmp/generated_payload.json > /tmp/ec_signature

    Il file della firma è una versione con firma digitale del file JSON del payload che hai creato sopra.

  4. Crea e convalida l'attestazione:

    gcloud container binauthz attestations create \
    --project="${PROJECT_ID}" \
    --artifact-url="${IMAGE_TO_ATTEST}" \
    --attestor="projects/${PROJECT_ID}/attestors/${ATTESTOR_NAME}" \
    --signature-file=/tmp/ec_signature \
    --public-key-id="${PUBLIC_KEY_ID}" \
    --validate

    dove PUBLIC_KEY_ID è l'ID della chiave pubblica che hai trovato Genera una coppia di chiavi PKIX sopra.

    Il flag validate controlla che l'attestazione possa essere verificata dal configurato nel criterio.

  5. Verifica che l'attestazione sia stata creata:

    gcloud container binauthz attestations list \
    --attestor=$ATTESTOR_NAME --attestor-project=$PROJECT_ID

Per ulteriori informazioni sulla creazione di attestazioni, consulta Creazione di attestazioni.

Ripeti il test del criterio

Anche in questo caso, testa il criterio eseguendo il deployment di un'immagine container di esempio nel cluster. Questa volta, devi eseguire il deployment dell'immagine utilizzando il digest anziché un tag come 1.0 o latest, poiché Autorizzazione binaria utilizzerà il digest per cercare le attestazioni. Qui, Autorizzazione binaria consente di eseguire il deployment dell'immagine è stata effettuata l'attestazione richiesta.

Per eseguire il deployment dell'immagine, esegui questo comando:

kubectl run hello-server --image ${IMAGE_PATH}@${IMAGE_DIGEST} --port 8080

Per verificare che sia stato eseguito il deployment dell'immagine, esegui questo comando:

kubectl get pods

Il comando visualizza un messaggio simile al seguente, che indica che deployment riuscito:

NAME                            READY     STATUS    RESTARTS   AGE
hello-server-579859fb5b-h2k8s   1/1       Running   0          1m

Per eliminare il pod, esegui questo comando:

kubectl delete pod hello-server

Esegui la pulizia

Per evitare che al tuo Account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.

Elimina il cluster che hai creato in GKE:

gcloud container clusters delete \
    --zone=us-central1-a \
    test-cluster

Passaggi successivi