Inizia a utilizzare la console Google Cloud (GKE)

Impostare il progetto predefinito

Per facilitare 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 progetto.

Se il progetto predefinito non è selezionato, impostalo ora:

gcloud config set project ${PROJECT_ID}

Creare un cluster con Autorizzazione binaria abilitata

Crea il cluster

Ora puoi creare un cluster GKE con Autorizzazione binaria attivata. Qui crei un cluster denominato test-cluster nella us-central1-a zona GKE.

Per creare il cluster:

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 A livello di zona nelle opzioni Tipo di località.

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 l'installazione di kubectl. Vengono fornite 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 governano il deployment delle immagini container. Puoi avere un criterio per progetto. Per impostazione predefinita, il criterio è configurato per 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, viene visualizzata l'opzione Consenti tutte le immagini.

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

Crea un attestatore

Un attestatore è l'autorità di verifica utilizzata dall'agente di applicazione di Autorizzazione binaria 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 dalle persone responsabili della sicurezza della catena di fornitura del software.

Per creare un attestatore, devi:

• Creare l'attestatore stesso in Autorizzazione binaria
• Genera automaticamente una nota associata all'attestatore in Analisi degli elementi per archiviare i metadati di attestazione attendibili utilizzati nella procedura di autorizzazione

Per questo tutorial, hai un attestatore denominato test-attestor. In uno scenario reale, puoi avere un numero qualsiasi di attestatori, ognuno dei quali rappresenta una parte che partecipa alla procedura di autorizzazione dell'immagine.

Genera una coppia di chiavi

L'Autorizzazione binaria utilizza le chiavi crittografiche per verificare in modo sicuro l'identità dei firmatari. In questo modo, viene garantito che venga eseguito il deployment solo delle immagini container autorizzate. La coppia di chiavi è composta 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 poi archiviata in un'attestazione. La chiave pubblica è memorizzata nell'attestatore. Al momento del deployment, l'applicazione 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 PKIX (Public-Key Infrastructure, X.509) per le chiavi di crittografia. Questo tutorial utilizza l'algoritmo di firma digitale con curva ellittica (ECDSA) consigliato per generare una coppia di chiavi PKIX. Puoi anche utilizzare chiavi RSA o PGP per la firma. Per ulteriori informazioni sugli algoritmi di firma, consulta la sezione Finalità e algoritmi delle chiavi.

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

Per generare una coppia di chiavi PKIX:

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 stesso 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 all'Autorizzazione binaria

2. Nella scheda Attestatori, fai clic su Crea.

   

3. Compila i campi come segue:

   1. Inserisci test-attestor nel campo Nome di chi attesta.

   2. Verifica che l'opzione Crea automaticamente una nota di Artifact Analysis elementi 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 che hai creato nel passaggio precedente. Copia i contenuti del file nella casella di testo Materiale della chiave pubblica.

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

   6. Fai clic su Fine.

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

5. Memorizza l'ID chiave pubblica.

   Per visualizzare l'ID chiave pubblica del tuo attestatore dopo averlo aggiunto, utilizza gcloud container binauthz attestors describe ${ATTESTOR_NAME}. Per creare una variabile di ambiente per archiviare l'ID chiave pubblica, esegui il seguente 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 Criteri, fai clic su Modifica criteri.

3. Seleziona Consenti solo le immagini approvate dai seguenti attestatori.

4. Fai clic su Aggiungi attestatori.

5. Fai clic su Aggiungi in base a nome progetto e attestatore.

6. Inserisci PROJECT_ID nel campo Nome progetto.

7. Inserisci test-attestor nel campo Nome di chi attesta.

8. Fai clic su Aggiungi 1 attestatore.

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

Per ulteriori informazioni, consulta la pagina Configurare un criterio utilizzando la console.

Testa il criterio

Puoi testare il criterio configurato sopra tentando di eseguire il deployment di un'immagine container di esempio nel cluster. Il criterio bloccherà il deployment perché non è stata eseguita la verifica obbligatoria.

Per questo tutorial, puoi utilizzare immagini di esempio da Container Registry e Artifact Registry. L'immagine di Container Registry si trova nel percorsogcr.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 include un'applicazione di esempio "Hello, World!".

Per provare a eseguire il deployment dell'immagine, esegui il seguente 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 l'immagine non è stata dimessa:

No resources found.

Puoi trovare ulteriori dettagli sul deployment:

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

Viene 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 passare al passaggio successivo:

kubectl delete deployment hello-server

Creare un'attestazione

Un'attestazione è un documento digitale creato da un firmatario che conferma che GKE è autorizzato a eseguire il deployment dell'immagine del container associata. Il processo di creazione di un'attestazione è a volte chiamato "firma di un'immagine".

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

Per creare un'attestazione:

1. Imposta le variabili che memorizzano il percorso del registry 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}
   

2. Genera il payload dell'attestazione:

   Container Registry

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

   Il file JSON del 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 del 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"
   }
   }
   

3. 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 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 chiave pubblica che hai trovato in Genera una coppia di chiavi PKIX sopra.

   Il flag validate verifica che l'attestazione possa essere verificata dall'attestatore configurato nelle norme.

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 la sezione Creare attestazioni.

Riprovare il criterio

Di nuovo, 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. In questo caso, Autorizzazione binaria consente il deployment dell'immagine perché è stata eseguita l'attestazione richiesta.

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

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

Per verificare che l'immagine sia stata dispiata, esegui il seguente comando:

kubectl get pods

Il comando stampa un messaggio simile al seguente, che indica che il deployment è andato a buon fine:

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