Esegui le tue autorità di certificazione e chiavi in GKE

Nota:questo documento utilizza una funzionalità di disponibilità generale denominata GKE control plane authority, disponibile solo per i clienti Google Cloud idonei. Per richiedere l'accesso a questa funzionalità, contatta il tuo Google Cloud team dedicato all'account

.

Questa pagina mostra come configurare il control plane del cluster Google Kubernetes Engine (GKE) con le autorità di certificazione (CA) e le chiavi che gestisci. Queste indicazioni sono destinate agli amministratori della sicurezza che hanno requisiti specifici di conformità o policy organizzativa per il controllo dell'emissione e della firma delle credenziali.

Questa pagina descrive una parte di un insieme di funzionalità facoltative del control plane in GKE che ti consente di eseguire attività come la verifica della postura di sicurezza del control plane o la configurazione della crittografia e della firma delle credenziali nel control plane utilizzando chiavi che gestisci. Per maggiori dettagli, consulta l'articolo Informazioni sull'autorità del piano di controllo GKE.

Per impostazione predefinita, Google Cloud applica varie misure di sicurezza al piano di controllo gestito. Questa pagina descrive le funzionalità facoltative che offrono maggiore visibilità o controllo sul control plane GKE.

Dovresti già avere familiarità con i seguenti concetti:

• Richieste di firma del certificato (CSR)
• Autorità di certificazione (CA)
• etcd
• Architettura del cluster GKE

Componenti delle credenziali del control plane

I cluster GKE utilizzano CA e chiavi specifiche per emettere credenziali nel cluster, come certificati X.509 o token ServiceAccount. Puoi creare chiavi in Cloud Key Management Service (Cloud KMS) e CA in Certificate Authority Service (CA Service) e configurare i cluster in modo che utilizzino queste risorse anziché le CA e le chiavi gestite da Google Cloud.

Per saperne di più sui componenti specifici che crei, consulta CA e chiavi autogestite.

Utilizzo con altre funzionalità di GKE control plane authority

GKE control plane authority fornisce le seguenti funzionalità relative alle chiavi autogestite:

• Esegui le tue autorità di certificazione (CA) e le tue chiavi (questa pagina)
• Criptare i componenti del control plane

Nota :puoi abilitare queste funzionalità solo quando crei un nuovo cluster GKE. Non puoi aggiornare i cluster esistenti per utilizzare queste funzionalità. Per utilizzare entrambe queste funzionalità nello stesso cluster, esegui tutte le procedure di configurazione delle chiavi e della CA in entrambe le guide, quindi esegui il comando di creazione del cluster che attiva entrambi i set di funzionalità come descritto nella sezione Crea un cluster.

Prepara l'ambiente

In questa sezione, identifichi i Google Cloud progetti che utilizzerai in questo tutorial e crei un keyring in Cloud KMS per contenere le tue chiavi.

Identificare i progetti

Ti consigliamo di utilizzare progetti Google Cloud separati nel seguente modo:

• Progetto chiave: contiene tutte le chiavi e le CA.
• Progetto cluster: contiene i cluster GKE.

Puoi anche utilizzare lo stesso progetto per chiavi, CA e cluster GKE, ma ti consigliamo di utilizzare progetti separati in modo che i team che gestiscono le operazioni crittografiche nella tua organizzazione siano separati dai team che gestiscono le operazioni sui cluster.

Creazione di chiavi automatizzate

Crea una chiave automatizzata nel progetto delle chiavi per contenere tutte le chiavi di un cluster specifico. Devi creare il portachiavi nella stessa località del cluster GKE.

Nota :non puoi eliminare un portachiavi dopo la creazione. I keyring non comportano costi aggiuntivi. Tuttavia, avere troppi keyring in un progetto potrebbe rendere più noiosa la gestione delle risorse in Cloud KMS.

Esegui questo comando:

gcloud kms keyrings create KEY_RING_NAME \
    --location=LOCATION \
    --project=KEY_PROJECT_ID

Sostituisci quanto segue:

• KEY_RING_NAME: un nome per il tuo portachiavi.
• KEY_PROJECT_ID: l'ID progetto del tuo progetto chiave.
• LOCATION: la Google Cloud regione in cui vuoi creare le chiavi automatizzate. Deve essere la stessa regione in cui si trova il cluster GKE.

Crea chiavi

Per ciascuna delle autorità delle credenziali, come le chiavi degli account di servizio e le CA, crea una chiave utilizzando Cloud KMS. Questa sezione mostra come creare le chiavi che GKE utilizza per firmare e verificare le credenziali nel cluster. Puoi specificare le tue proprietà per queste chiavi in base alle esigenze della tua organizzazione. Per i dettagli, consulta la pagina Crea una chiave e il riferimento API projects.locations.keyRings.cryptoKeys.

Attenzione :non attivare la rotazione automatica delle chiavi con Cloud KMS. La rotazione delle chiavi di crittografia richiede passaggi aggiuntivi per garantire che le risorse del control plane vengano ricriptate con le nuove versioni delle chiavi prima che le versioni delle chiavi originali vengano eliminate.

Quando crei queste risorse in Cloud KMS, considera quanto segue:

• Se hai una chiave automatizzata esistente nel tuo progetto chiave, puoi utilizzarla per archiviare tutte le chiavi che crei per l'utilizzo con il tuo cluster.
• Il portachiavi deve trovarsi nella stessa posizione del cluster Google Cloud per ridurre al minimo la latenza.
• Le chiavi devono specificare asymmetric-signing come scopo della chiave.
• Utilizza i seguenti algoritmi in base al tipo di chiave:
  • Chiavi di firma ServiceAccount: un algoritmo PKCS1 di firma RSA sicuro, come rsa-sign-pkcs1-4096-sha256 o rsa-sign-pkcs1-3072-sha256.
  • Chiavi dell'autorità di certificazione: un algoritmo avanzato come ec-sign-p256-sha256.
• Le chiavi hardware Cloud HSM sono supportate, ma il livello di protezione software è sufficiente per la maggior parte dei casi d'uso. Per informazioni dettagliate sulle chiavi hardware, consulta Cloud HSM.
• Non modificare la durata predefinita per l'eliminazione delle chiavi.
• GKE non impedisce l'eliminazione delle chiavi Cloud KMS, incluse le chiavi del servizio CA, in uso dal cluster. Prima di eliminare chiavi o CA, assicurati che le risorse non siano utilizzate.

Per creare le chiavi, esegui i seguenti comandi:

1. Crea la chiave di firma di Kubernetes ServiceAccount, che specifichi anche come chiave di verifica delaccount di serviziot durante la creazione del cluster:

   gcloud kms keys create sa-signing-key \
       --keyring=KEY_RING_NAME \
       --location=LOCATION \
       --purpose="asymmetric-signing" \
       --protection-level=hsm \
       --default-algorithm=rsa-sign-pkcs1-4096-sha256 \
       --project=KEY_PROJECT_ID
   

   Sostituisci KEY_PROJECT_ID con l'ID progetto del tuo progetto di chiavi dedicato.

2. Crea la chiave CA radice del cluster:

   gcloud kms keys create cluster-ca-key \
       --keyring=KEY_RING_NAME \
       --location=LOCATION \
       --purpose="asymmetric-signing" \
       --protection-level=hsm \
       --default-algorithm=ec-sign-p256-sha256 \
       --project=KEY_PROJECT_ID
   

3. Crea la chiave della CA radice peer etcd:

   gcloud kms keys create etcd-peer-ca-key \
       --keyring=KEY_RING_NAME \
       --location=LOCATION \
       --purpose="asymmetric-signing" \
       --protection-level=hsm \
       --default-algorithm=ec-sign-p256-sha256 \
       --project=KEY_PROJECT_ID
   

4. Crea la chiave CA radice dell'API etcd:

   gcloud kms keys create etcd-api-ca-key \
       --keyring=KEY_RING_NAME \
       --location=LOCATION \
       --purpose="asymmetric-signing" \
       --protection-level=hsm \
       --default-algorithm=ec-sign-p256-sha256 \
       --project=KEY_PROJECT_ID
   

5. Crea la chiave CA radice di aggregazione:

   gcloud kms keys create aggregation-ca-key \
       --keyring=KEY_RING_NAME \
       --location=LOCATION \
       --purpose="asymmetric-signing" \
       --protection-level=hsm \
       --default-algorithm=ec-sign-p256-sha256 \
       --project=KEY_PROJECT_ID
   

Crea le CA

Dopo aver creato le chiavi per ciascuna delle funzioni del control plane, utilizza ogni chiave per creare i pool di CA e le CA radice corrispondenti utilizzando il servizio CA:

1. Crea il pool di CA del cluster:

   gcloud privateca pools create cluster-ca-pool \
       --location=LOCATION \
       --tier=enterprise \
       --project=KEY_PROJECT_ID \
       --no-publish-crl --no-publish-ca-cert
   

   I flag --no-publish-crl e --no-publish-ca-cert sono facoltativi. Se questi flag vengono omessi, i certificati vengono pubblicati in un bucket Cloud Storage. Per maggiori dettagli, vedi Attivare la pubblicazione di certificati CA e CRL per le CA in un pool di CA.

2. Crea la CA radice del cluster:

   gcloud privateca roots create cluster-root-ca \
       --pool=cluster-ca-pool \
       --location=LOCATION \
       --kms-key-version=projects/KEY_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING_NAME/cryptoKeys/cluster-ca-key/cryptoKeyVersions/1 \
       --subject="CN=cluster-ca, O=ORGANIZATION" \
       --project=KEY_PROJECT_ID \
       --auto-enable
   

   Sostituisci ORGANIZATION con il nome della tua organizzazione.

3. Crea il pool di CA peer etcd:

   gcloud privateca pools create etcd-peer-ca-pool \
       --location=LOCATION \
       --tier=enterprise \
       --project=KEY_PROJECT_ID \
       --no-publish-crl --no-publish-ca-cert
   

4. Crea la CA radice peer etcd:

   gcloud privateca roots create etcd-peer-root-ca \
       --pool=etcd-peer-ca-pool \
       --location=LOCATION \
       --kms-key-version=projects/KEY_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING_NAME/cryptoKeys/etcd-peer-ca-key/cryptoKeyVersions/1 \
       --subject="CN=etcd-peer-ca, O=ORGANIZATION" \
       --project=KEY_PROJECT_ID \
       --auto-enable
   

5. Crea il pool di CA dell'API etcd:

   gcloud privateca pools create etcd-api-ca-pool \
       --location=LOCATION \
       --tier=enterprise \
       --project=KEY_PROJECT_ID \
       --no-publish-crl --no-publish-ca-cert
   

6. Crea la CA radice dell'API etcd:

   gcloud privateca roots create etcd-api-root-ca \
       --pool=etcd-api-ca-pool \
       --location=LOCATION \
       --kms-key-version=projects/KEY_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING_NAME/cryptoKeys/etcd-api-ca-key/cryptoKeyVersions/1 \
       --subject="CN=etcd-api-ca, O=ORGANIZATION" \
       --project=KEY_PROJECT_ID \
       --auto-enable
   

7. Crea il pool di CA di aggregazione:

   gcloud privateca pools create aggregation-ca-pool \
       --location=LOCATION \
       --tier=enterprise \
       --project=KEY_PROJECT_ID \
       --no-publish-crl --no-publish-ca-cert
   

8. Crea la CA radice di aggregazione:

   gcloud privateca roots create aggregation-root-ca \
       --pool=aggregation-ca-pool \
       --location=LOCATION \
       --kms-key-version=projects/KEY_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING_NAME/cryptoKeys/aggregation-ca-key/cryptoKeyVersions/1 \
       --subject="CN=aggregation-ca, O=ORGANIZATION" \
       --project=KEY_PROJECT_ID \
       --auto-enable
   

Concedi ruoli IAM al service agent GKE

Il service agent GKE richiede l'accesso alle risorse che hai creato in Cloud KMS e in CA Service. L'agente di servizio utilizza queste risorse per firmare, verificare ed emettere credenziali nel cluster. Puoi utilizzare i seguenti ruoli IAM predefiniti:

• Kubernetes Engine KMS Crypto Key User (roles/container.cloudKmsKeyUser)
• CA Service Certificate Manager (roles/privateca.certificateManager)

Per concedere questi ruoli all'agente di servizio GKE:

1. Trova il numero di progetto del progetto cluster:

   gcloud projects describe CLUSTER_PROJECT_ID \
       --format='value(projectNumber)'
   

   Sostituisci CLUSTER_PROJECT_ID con l'ID progetto del progetto cluster.

2. Concedi il ruolo Utente chiave di crittografia KMS di Kubernetes Engine alla chiave di firma del account di servizio che hai creato in Crea chiavi:

   gcloud kms keys add-iam-policy-binding sa-signing-key \
     --location=LOCATION \
     --keyring=KEY_RING_NAME \
     --member="serviceAccount:[e-mail]" \
     --role=roles/container.cloudKmsKeyUser \
     --project=KEY_PROJECT_ID
   

   Sostituisci CLUSTER_PROJECT_NUMBER con il numero di progetto del progetto cluster.

3. Concedi il ruolo Gestore certificati del servizio CA ai pool di CA che hai creato in Crea le CA:

   gcloud privateca pools add-iam-policy-binding cluster-ca-pool \
       --location=LOCATION \
       --member="serviceAccount:[e-mail]" \
       --role=roles/privateca.certificateManager \
       --project=KEY_PROJECT_ID
   
   gcloud privateca pools add-iam-policy-binding etcd-peer-ca-pool \
       --location=LOCATION \
       --member="serviceAccount:[e-mail]" \
       --role=roles/privateca.certificateManager \
       --project=KEY_PROJECT_ID
   
   gcloud privateca pools add-iam-policy-binding etcd-api-ca-pool \
       --location=LOCATION \
       --member="serviceAccount:[e-mail]" \
       --role=roles/privateca.certificateManager \
       --project=KEY_PROJECT_ID
   
   gcloud privateca pools add-iam-policy-binding aggregation-ca-pool \
       --location=LOCATION \
       --member="serviceAccount:[e-mail]" \
       --role=roles/privateca.certificateManager \
       --project=KEY_PROJECT_ID
   

Concedere ruoli aggiuntivi quando non si utilizza gcloud CLI

Questa sezione descrive i passaggi di configurazione aggiuntivi che devi eseguire se prevedi di configurare le CA e le chiavi utilizzando un client come Terraform o la console Google Cloud anziché l'interfaccia alla gcloud CLI. Se utilizzi gcloud CLI, salta questa sezione e vai alla sezione Configurare CA e chiavi su un nuovo cluster.

Quando utilizzi gcloud CLI per configurare le CA e le chiavi, come descritto in questa pagina, gcloud CLI crea e configura automaticamente un service agent per CA Service e concede ruoli IAM al service agent. Tuttavia, se utilizzi un client come Terraform o la console Google Cloud per configurare l'ambiente Google Cloud, devi eseguire manualmente questi passaggi di configurazione come segue per il progetto chiave:

1. Attiva la creazione dell'agente di servizio del servizio CA Service.

   Anteprima — triggering service agent creation

   Questa funzionalità è soggetta ai "Termini delle Offerte pre-GA" nella sezione Termini di servizio generali dei Termini specifici dei servizi. Le funzionalità pre-GA sono disponibili "così come sono" e potrebbero avere un supporto limitato. Per saperne di più, consulta le descrizioni della fase di lancio.

   gcloud beta services identity create --service=privateca.googleapis.com \
       --project=KEY_PROJECT_ID
   

2. Trova il numero di progetto del tuo progetto chiave:

   gcloud projects describe KEY_PROJECT_ID \
       --format='value(projectNumber)'
   

3. Concedi il ruolo Visualizzatore (roles/viewer) e il ruolo Firmatario/Verificatore CryptoKey Cloud KMS (roles/cloudkms.signerVerifier) per tutte le chiavi CA radice che hai creato nella sezione Crea chiavi:

   for key in cluster-ca-key etcd-peer-ca-key etcd-api-ca-key aggregation-ca-key
   do
   gcloud kms keys add-iam-policy-binding $key \
       --keyring=KEY_RING_NAME \
       --location=LOCATION \
       --role=roles/viewer \
       --member="serviceAccount:[e-mail]" \
       --project=KEY_PROJECT_ID
   
   gcloud kms keys add-iam-policy-binding $key \
       --keyring=KEY_RING_NAME \
       --location=LOCATION \
       --role=roles/cloudkms.signerVerifier \
       --member="serviceAccount:[e-mail]" \
       --project=KEY_PROJECT_ID
   done
   

   Sostituisci KEY_PROJECT_NUMBER con il numero del progetto chiave dall'output del passaggio precedente.

   Questo comando è un ciclo for che scorre le chiavi della CA radice, concedendo a ogni ruolo su quella chiave l'agente di servizio del servizio CA. Se hai utilizzato nomi diversi per le chiavi CA radice, esegui questi comandi manualmente per ogni chiave.

Configura CA e chiavi su un nuovo cluster

Avviso: l'eliminazione di chiavi o CA in uso dal cluster potrebbe comportare cluster irrecuperabili. Prima di eliminare chiavi o CA, assicurati che il cluster non utilizzi più le risorse.

Dopo aver creato chiavi, pool di CA, CA radice e concesso ruoli IAM all'agente di servizio GKE, crea un nuovo cluster che utilizzi queste risorse.

I flag specificati nel comando di creazione del cluster richiedono i seguenti percorsi delle risorse come valori:

• Il percorso di una versione della chiave in Cloud KMS per la chiave di firma dell'account di servizio che hai creato in Crea chiavi. Specifichi questo percorso per il flag service-account-signing-keys e per il flag service-account-verification-keys.
• Il percorso di ciascuno dei pool di CA creati in Crea le CA.

Nota: prima di eseguire questi passaggi, decidi se vuoi anche criptare i dischi di avvio del piano di controllo e i dischi etcd con chiavi che gestisci. In questo caso, esegui tutti i passaggi di configurazione chiave in Cripta i dischi di avvio di etcd e del control plane e specifica i flag facoltativi descritti nel comando di creazione del cluster in questa sezione.

Per configurare un nuovo cluster in modo che utilizzi le tue chiavi e CA, segui questi passaggi:

1. Trova il percorso dell'ultima versione della chiave di firma del account di servizio abilitata:

   gcloud kms keys versions list \
       --key=sa-signing-key \
       --keyring=KEY_RING_NAME \
       --location=LOCATION \
       --project=KEY_PROJECT_ID \
       --filter="STATE=ENABLED" --sort-by=~ --format="value(name)" | sed 1q
   

   Sostituisci KEY_PROJECT_ID con l'ID progetto del progetto di chiavi.

   L'output è simile al seguente:

   projects/KEY_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING_NAME/cryptoKeys/sa-signing-key/cryptoKeyVersions/1
   

2. Trova i percorsi di ciascuno dei pool di CA che hai creato:

   gcloud privateca pools list --format="get(name)" \
       --project=KEY_PROJECT_ID
   

   L'output è simile al seguente:

   projects/KEY_PROJECT_ID/locations/LOCATION/caPools/cluster-ca-pool
   projects/KEY_PROJECT_ID/locations/LOCATION/caPools/etcd-peer-ca-pool
   projects/KEY_PROJECT_ID/locations/LOCATION/caPools/etcd-api-ca-pool
   projects/KEY_PROJECT_ID/locations/LOCATION/caPools/aggregation-ca-pool
   

   Assicurati che l'output contenga tutti i pool di CA che hai creato per GKE.

Crea un cluster

In questa sezione, crei un cluster con diverse opzioni specificate a seconda delle funzionalità dell'autorità del control plane GKE che vuoi configurare. Puoi configurare queste funzionalità su un cluster solo durante la creazione del cluster. I seguenti comandi creano cluster in modalità Standard. Per creare invece cluster in modalità Autopilot, utilizza gli stessi flag con il comando gcloud container clusters create-auto.

• Per configurare solo le CA e le chiavi che hai creato in questo tutorial, esegui il comando seguente:

  gcloud container clusters create example-cluster \
      --location=LOCATION \
      --project=CLUSTER_PROJECT_ID \
      --cluster-version=VERSION \
      --service-account-signing-keys=projects/KEY_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING_NAME/cryptoKeys/sa-signing-key/cryptoKeyVersions/1 \
      --service-account-verification-keys=projects/KEY_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING_NAME/cryptoKeys/sa-signing-key/cryptoKeyVersions/1 \
      --cluster-ca=projects/KEY_PROJECT_ID/locations/LOCATION/caPools/cluster-ca-pool \
      --etcd-peer-ca=projects/KEY_PROJECT_ID/locations/LOCATION/caPools/etcd-peer-ca-pool \
      --etcd-api-ca=projects/KEY_PROJECT_ID/locations/LOCATION/caPools/etcd-api-ca-pool \
      --aggregation-ca=projects/KEY_PROJECT_ID/locations/LOCATION/caPools/aggregation-ca-pool
  

  Sostituisci quanto segue:

  • CLUSTER_PROJECT_ID: l'ID progetto del progetto cluster.
  • VERSION: la versione GKE del cluster. Deve essere 1.31.1-gke.1846000 o versioni successive.

• Per configurare le CA e le chiavi, nonché la crittografia del disco di avvio del control plane e la crittografia etcd, segui questi passaggi:

  1. Esegui tutti i passaggi di configurazione delle chiavi in Cripta i dischi di avvio di etcd e del control plane.
  2. Trova i percorsi di ciascuna chiave seguendo le istruzioni riportate in Utilizzare le chiavi di crittografia in un cluster.

  3. Crea un cluster:

     gcloud container clusters create example-cluster \
         --location=LOCATION \
         --project=CLUSTER_PROJECT_ID \
         --cluster-version=VERSION \
         --service-account-signing-keys=projects/KEY_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING_NAME/cryptoKeys/sa-signing-key/cryptoKeyVersions/1 \
         --service-account-verification-keys=projects/KEY_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING_NAME/cryptoKeys/sa-signing-key/cryptoKeyVersions/1 \
         --cluster-ca=projects/KEY_PROJECT_ID/locations/LOCATION/caPools/cluster-ca-pool \
         --etcd-peer-ca=projects/KEY_PROJECT_ID/locations/LOCATION/caPools/etcd-peer-ca-pool \
         --etcd-api-ca=projects/KEY_PROJECT_ID/locations/LOCATION/caPools/etcd-api-ca-pool \
         --aggregation-ca=projects/KEY_PROJECT_ID/locations/LOCATION/caPools/aggregation-ca-pool \
         --control-plane-disk-encryption-key=PATH_TO_DISK_KEY \
         --gkeops-etcd-backup-encryption-key=PATH_TO_ETCD_BACKUP_KEY
     

     Sostituisci quanto segue:

     • CLUSTER_PROJECT_ID: l'ID progetto del progetto cluster.
     • VERSION: la versione GKE del cluster. Deve essere 1.31.1-gke.1846000 o versioni successive.
     • PATH_TO_DISK_KEY: il percorso della chiave di crittografia del disco.
     • PATH_TO_ETCD_BACKUP_KEY: il percorso della chiave di crittografia di backup interno di etcd.

  Puoi utilizzare questi flag anche quando crei un nuovo cluster in modalità Standard.

Verifica che il cluster utilizzi le chiavi e le CA specificate

Questa sezione mostra come verificare le chiavi e le CA utilizzate durante la creazione del cluster. Puoi eseguire questa verifica utilizzando Cloud Logging o Google Cloud CLI.

Utilizzare Logging per verificare chiavi e CA

Per verificare le chiavi e le CA utilizzando Logging:

1. Nella Google Cloud console, vai alla pagina Esplora log:

   Vai a Esplora log

2. Specifica la seguente query:

   resource.type="gke_cluster"
   resource.labels.cluster_name="CLUSTER_NAME"
   resource.labels.location="CLUSTER_LOCATION"
   protoPayload.serviceName="container.googleapis.com"
   protoPayload.methodName=~"google.container.v(1|1alpha1|1beta1).ClusterManager.CreateCluster"
   protoPayload.request.cluster.userManagedKeysConfig:*
   

   protoPayload.request.cluster.userManagedKeysConfig:* filtra i risultati per i log di creazione del cluster che includono chiavi e CA che gestisci.

3. Fai clic su Esegui query.

Nei risultati, espandi il log di creazione del cluster. Verifica che i percorsi delle chiavi e delle CA siano gli stessi che hai creato per quel cluster, come nel seguente esempio:

# lines omitted for clarity
userManagedKeysConfig: {
  aggregationCa: "projects/KEY_PROJECT_ID/locations/LOCATION/caPools/aggregation-ca-pool"
  clusterCa: "projects/KEY_PROJECT_ID/locations/LOCATION/caPools/cluster-ca-pool"
  etcdApiCa: "projects/KEY_PROJECT_ID/locations/LOCATION/caPools/etcd-api-ca-pool"
  etcdPeerCa: "projects/KEY_PROJECT_ID/locations/LOCATION/caPools/etcd-peer-ca-pool"
  serviceAccountSigningKeys: [
    0: "projects/KEY_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING_NAME/cryptoKeys/sa-signing-key/cryptoKeyVersions/1"
  ]
  serviceAccountVerificationKeys: [
    0: "projects/KEY_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING_NAME/cryptoKeys/sa-signing-key/cryptoKeyVersions/1"
  ]
}

Utilizza gcloud CLI per verificare chiavi e CA

Per verificare che il cluster utilizzi le CA e le chiavi che hai creato, esegui questo comando:

gcloud container clusters describe example-cluster \
    --location=LOCATION \
    --project=CLUSTER_PROJECT_ID

L'output deve includere il campo userManagedKeysConfig come nell'esempio seguente:

# lines omitted for clarity
userManagedKeysConfig:
  sa-signing-key: projects/KEY_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING_NAME/cryptoKeys/sa-signing-key/cryptoKeyVersions/1
  sa-verification-key: projects/KEY_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING_NAME/cryptoKeys/sa-signing-key/cryptoKeyVersions/1
  cluster-ca: projects/KEY_PROJECT_ID/locations/LOCATION/caPools/cluster-ca-pool
  etcd-peer-ca: projects/KEY_PROJECT_ID/locations/LOCATION/caPools/etcd-peer-ca-pool
  etcd-api-ca: projects/KEY_PROJECT_ID/locations/LOCATION/caPools/etcd-api-ca-pool
  aggregation-ca: projects/KEY_PROJECT_ID/locations/LOCATION/caPools/aggregation-ca-pool