Iniziare a utilizzare la console Google Cloud (GKE)

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

Al momento del deployment, Autorizzazione binaria utilizza gli attestatori per verificare le firme digitali nelle attestations. Le attestazioni sono state create dai significanti nell'ambito del processo di compilazione.

In questo tutorial, il cluster GKE, le attestazioni e gli attestatori si trovano tutti in un singolo progetto. Una configurazione a progetto singolo è utile soprattutto per eseguire test o sperimentare con il servizio. Per un esempio più reale, consulta Configurazione di più progetti.

I passaggi seguenti descrivono le attività che esegui dalla console Google Cloud, nonché alcune attività che esegui utilizzando i comandi gcloud. Per eseguire questi passaggi utilizzando gcloud, consulta Iniziare a utilizzare Google Cloud CLI.

Obiettivi

In questo tutorial imparerai a:

Crea un cluster (GKE) con Autorizzazione binaria abilitata
Crea un attestatore utilizzato dall'esecutore di Autorizzazione binaria per verificare 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:

Artifact Registry
Autorizzazione binaria
GKE
Container Registry
(Facoltativo) Cloud Key Management Service

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud possono essere idonei a una prova senza costi aggiuntivi.

Prima di iniziare

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.

Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

Vai al selettore progetti

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

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

Abilita le API

Installa Google Cloud CLI.

Per initialize gcloud CLI, esegui questo comando:

gcloud init

Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

Vai al selettore progetti

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

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

Abilita le API

Installa Google Cloud CLI.

Per initialize gcloud CLI, esegui questo comando:

gcloud init

Installa kubectl.

Imposta il progetto predefinito

Per semplificare i comandi che seguono, memorizza l'ID progetto Google Cloud in una 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 abilitata. Qui devi creare un cluster denominato test-cluster nella zona GKE us-central1-a.

Per creare il cluster, segui questi passaggi:

Visita il menu GKE nella console Google Cloud.

Vai a GKE
Fai clic su Crea cluster.
Inserisci test-cluster nel campo Nome.
Seleziona A livello di zona nelle opzioni Tipo di località.
Seleziona us-central1-a dall'elenco a discesa Zona.
Fai clic su Disponibilità, networking, sicurezza e funzionalità aggiuntive.
Nella sezione Sicurezza, seleziona Abilita Autorizzazione binaria.
Seleziona Solo applicazione forzata.
Fai clic su Crea.

Configura `kubectl`

Devi inoltre aggiornare il file kubeconfig locale per l'installazione di kubectl. Fornisce le credenziali e le informazioni sugli endpoint necessarie 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 che regolano 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, segui questi passaggi:

Vai alla pagina Autorizzazione binaria nella console Google Cloud.

Vai ad Autorizzazione binaria
Fai clic su Modifica criterio.
In Regola predefinita del progetto, viene visualizzata l'opzione Consenti tutte le immagini.
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 ed è in genere gestito da persone responsabili della sicurezza della catena di fornitura del software.

Per creare un attestatore devi:

Crea l'attestatore stesso in Autorizzazione binaria
Genera automaticamente una nota di attestatore associato in Artifact Analysis per archiviare i metadati di attestazione attendibili utilizzati nel processo di autorizzazione

Per questo tutorial, è disponibile un attestatore denominato test-attestor. In uno scenario reale, è possibile avere un numero qualsiasi 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 firmanti. Ciò garantisce che possa essere eseguito il deployment solo delle immagini container autorizzate. La coppia di chiavi è costituita da una chiave privata e una chiave pubblica. Il signer utilizza la chiave privata per firmare il digest dell'immagine container, producendo una firma che viene quindi archiviata in una attestazione. La chiave pubblica è archiviata nell'attestatore. Al momento del deployment, l'applicazione forzata di Autorizzazione binaria utilizza la chiave pubblica dell'attestatore per verificare la firma nell'attestazione prima di consentire il deployment del container.

In questo tutorial, utilizzerai il formato Infrastruttura a chiave pubblica (X.509) (PKIX) per le chiavi di crittografia. Questo tutorial utilizza l'algoritmo di firma digitale Elliptic Curve (ECDSA) consigliato per generare una coppia di chiavi PKIX. Puoi anche utilizzare chiavi RSA o PGP per la firma. Per saperne di più sugli algoritmi di firma, consulta Scopi e algoritmi chiave.

Le chiavi generate e archiviate da Cloud Key Management Service (Cloud KMS) sono conformi a PKIX. Per ulteriori informazioni sull'utilizzo delle chiavi PKIX e di Cloud KMS, consulta Creazione di attestatori mediante l'interfaccia a riga di comando.

Per generare una coppia di chiavi PKIX:

Crea la chiave privata:

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

Estrae 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 attestatore

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

Per creare l'attestatore:

Torna alla pagina Autorizzazione binaria nella console Google Cloud.

Torna ad Autorizzazione binaria
Nella scheda Attestatori, fai clic su Crea.
Compila i campi come segue:
1. Inserisci test-attestor nel campo Nome attestatore.
2. Verifica che l'opzione Crea automaticamente una nota di Artifact Analysis sia selezionata.
3. Fai clic su Aggiungi una chiave pubblica PKIX.
4. Apri /tmp/ec_public.pem in un editor di testo. Si tratta del file della chiave pubblica creato nel passaggio precedente. Copia i contenuti del file nella casella di testo Materiale chiave pubblica.
5. Fai clic su Elliptic Curve P-256 - SHA256 Digest nel menu a discesa Algoritmo di firma.
6. Fai clic su Fine.
Fai clic su Crea per creare l'attestatore.
Memorizza l'ID della chiave pubblica.

Utilizza gcloud container binauthz attestors describe ${ATTESTOR_NAME} per visualizzare l'ID della chiave pubblica dell'attestatore dopo averlo aggiunto all'attestatore. Per creare una variabile di ambiente in cui 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:

Torna alla pagina Autorizzazione binaria nella console Google Cloud.
Nella scheda Norme, fai clic su Modifica norma.
Seleziona Consenti solo le immagini che sono state approvate dai seguenti attestatori.
Fai clic su Aggiungi attestatori.
Fai clic su Aggiungi per nome progetto e attestatore.
Inserisci PROJECT_ID nel campo Nome progetto.
Inserisci test-attestor nel campo Nome attestatore.
Fai clic su Aggiungi 1 attestatore.
Fai clic su Save Policy (Salva criterio).

Per ulteriori informazioni, consulta Configurazione di un criterio mediante la console.

Testa il criterio

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

Per questo tutorial, puoi utilizzare immagini di esempio di Container Registry e Artifact Registry. L'immagine di Container Registry si trova nel percorso gcr.io/google-samples/hello-app:1.0. L'immagine da 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'applicazione di esempio "Hello, World!".

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 stampa il seguente messaggio, che indica che il deployment dell'immagine non è stato eseguito:

No resources found.

Puoi trovare 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 è autorizzato a eseguire il deployment dell'immagine container associata. Il processo di creazione di un'attestazione a volte è chiamato "firma di un'immagine".

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

Per creare un'attestazione:

Imposta le variabili che archiviano il percorso del Registro di sistema e il digest dell'immagine, nonché il nome dell'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}

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 payload ha 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 payload ha 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"
}
}

Firma il payload con la tua chiave privata PKIX e genera un file di firma:
```
openssl dgst -sha256 -sign ${PRIVATE_KEY_FILE} /tmp/generated_payload.json > /tmp/ec_signature
```
Il file della firma è una versione firmata digitalmente del file JSON del payload che hai creato in precedenza.

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 di chiave pubblica indicato nella sezione Generare una coppia di chiavi PKIX qui sopra.

Il flag validate verifica che l'attestazione possa essere verificata dall'attestatore configurato nel criterio.

Verifica che l'attestazione sia stata creata:

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

Per saperne di più sulla creazione delle attestazioni, consulta Creazione delle attestazioni.

Ripeti il test delle norme

Verifica nuovamente 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à sia il percorso dell'immagine sia il digest per cercare le attestazioni. Qui, Autorizzazione binaria consente il deployment dell'immagine perché è 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 stampa un messaggio simile al seguente, che indica che il 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

Scopri di più su Autorizzazione binaria
Scopri i concetti chiave utilizzati in Autorizzazione binaria
Utilizza l'attestatore built-by-cloud-build per eseguire il deployment solo delle immagini create da Cloud Build (anteprima).
Scopri come utilizzare i digest di immagini nei manifest di Kubernetes
Abilitare la modalità di prova per disabilitare l'applicazione forzata

Iniziare a utilizzare la console Google Cloud (GKE)

Obiettivi

Costi

Prima di iniziare

Imposta il progetto predefinito

Crea un cluster con Autorizzazione binaria abilitata

Crea il cluster

Configura kubectl

Visualizza il criterio predefinito

Crea un attestatore

Genera una coppia di chiavi

Crea attestatore

Configura il criterio

Testa il criterio

Crea un'attestazione

Container Registry

Artifact Registry

Container Registry

Artifact Registry

Ripeti il test delle norme

Esegui la pulizia

Passaggi successivi

Configura `kubectl`