Esegui le tue autorità di certificazione e le tue chiavi in GKE

Autopilota Standard

---

Nota: questo documento utilizza una funzionalità di disponibilità generale denominata GKE control plane authority che può essere utilizzata solo su richiesta. Per utilizzare questa funzionalità, contatta il team dedicato all'account Google Cloud.

Questa pagina mostra come configurare il cluster Google Kubernetes Engine (GKE) con le autorità di certificazione (CA) e le chiavi che gestisci. Questo sono rivolte agli amministratori della sicurezza che hanno conformità organizzativa o requisiti dei criteri per il controllo delle credenziali l'emissione e la firma.

In questa pagina viene descritta una parte di un insieme di funzionalità facoltative del piano di controllo in GKE, che consente di eseguire attività come la verifica della security posture del piano di controllo o configurando la crittografia e la firma delle credenziali nel piano di controllo utilizzando le chiavi che gestisci tu. Per maggiori dettagli, consulta Informazioni sull'autorità del piano di controllo.

Per impostazione predefinita, Google Cloud applica varie misure di sicurezza al piano di controllo gestito. In questa pagina vengono descritte le funzionalità facoltative che offrono maggiore visibilità o controllo sulle il piano di controllo.

Dovresti già conoscere i seguenti concetti:

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

Componenti delle credenziali del piano di controllo

I cluster GKE utilizzano CA e chiavi specifiche per emettere credenziali nel cluster, ad esempio 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 per utilizzare queste risorse anziché in CA e chiavi gestite da Google Cloud.

Per scoprire di più sui componenti specifici che crei, consulta Chiavi e CA autogestite.

Utilizzo con altre funzionalità di autorità del piano di controllo GKE

L'autorità del piano di controllo GKE fornisce le seguenti funzionalità relative alle chiavi gestite autonomamente:

• Gestisci le tue autorità di certificazione (CA) e le tue chiavi (questa pagina)
• Crittografia dei componenti del piano di controllo

Nota: puoi abilitare queste funzionalità solo quando crei un nuovo GKE in un cluster Kubernetes. 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 delle CA descritte in entrambe le guide, quindi esegui il comando di creazione del cluster che attiva entrambi gli insiemi di funzionalità come descritto nella sezione Creare un cluster.

Obiettivi

• Crea chiavi in Cloud KMS
• Crea CA in CA Service
• Concedi i ruoli IAM (Identity and Access Management) all'agente di servizio GKE
• Crea un cluster GKE che utilizza le tue CA e le tue chiavi
• Verifica che il cluster utilizzi le tue CA e le tue chiavi

Costi

In questo documento utilizzi i seguenti componenti fatturabili di Google Cloud:

• GKE
• Cloud KMS
• CA Service
• Cloud Logging

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.

Una volta completate le attività descritte in questo documento, puoi evitare la fatturazione continua eliminando le risorse che hai creato. Per ulteriori informazioni, consulta la pagina Pulizia.

Prima di iniziare

1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.
2. Install the Google Cloud CLI.

3. To initialize the gcloud CLI, run the following command:

   gcloud init

   Note: If you installed the gcloud CLI previously, make sure you have the latest version by running gcloud components update.

4. Make sure that billing is enabled for your Google Cloud project.

5. Enable the Kubernetes Engine, Certificate Authority Service, and Cloud Key Management Service APIs:

   gcloud services enable container.googleapis.com privateca.googleapis.com cloudkms.googleapis.com

6. Install the Google Cloud CLI.

7. To initialize the gcloud CLI, run the following command:

   gcloud init

   Note: If you installed the gcloud CLI previously, make sure you have the latest version by running gcloud components update.

8. Make sure that billing is enabled for your Google Cloud project.

9. Enable the Kubernetes Engine, Certificate Authority Service, and Cloud Key Management Service APIs:

   gcloud services enable container.googleapis.com privateca.googleapis.com cloudkms.googleapis.com

10. Assicurati che il tuo ambiente sia idoneo all'utilizzo Funzionalità di autorità del piano di controllo GKE. Per attivare queste funzionalità, contatta il team di vendita di Google Cloud.
11. Per monitorare in modo affidabile l'emissione e l'utilizzo delle credenziali, assicurati che: Gli audit log di accesso ai dati sono abilitati:
    • Cloud KMS: DATA_READ
    • Servizio CA: ADMIN_READ e ADMIN_WRITE

    Per abilitare questi tipi di log, consulta Abilitare gli audit log di accesso ai dati.

Ruoli e autorizzazioni richiesti

Per ottenere le autorizzazioni necessarie per eseguire le tue CA e chiavi, chiedi all'amministratore di concederti seguenti ruoli IAM:

• Crea chiavi Cloud KMS: Amministratore Cloud KMS (roles/cloudkms.admin) sul tuo progetto chiave
• Crea pool di CA e CA radice: CA Service Admin (roles/privateca.admin) sul tuo progetto chiave
• Crea i cluster GKE: Amministratore cluster Kubernetes Engine (roles/container.clusterAdmin) sul progetto del cluster

Per saperne di più sulla concessione dei ruoli, consulta Gestire l'accesso a progetti, cartelle e organizzazioni.

Potresti anche riuscire a ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

Requisiti

Devi utilizzare GKE 1.31.1-gke.1846000 o versioni successive.

Limitazioni

Si applicano le seguenti limitazioni:

• Puoi utilizzare solo le chiavi di Cloud KMS. Non puoi utilizzare un altro KMS o un altro provider di crittografia.
• Le chiavi Cloud External Key Manager (Cloud EKM) non sono supportate.
• Puoi utilizzare solo le CA di CA Service.

prepara l'ambiente

In questa sezione identificherai i progetti Google Cloud che utilizzerai nella questo tutorial e creerai un keyring in Cloud KMS per chiave.

Identificare i progetti

Ti consigliamo di utilizzare progetti Google Cloud separati, come segue:

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

Facoltativamente, puoi utilizzare lo stesso progetto per le chiavi, le CA e i 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 dei cluster.

Creazione di un keyring

Crea un keyring nel progetto chiave per contenere tutte le chiavi per un'istanza specifica in un cluster Kubernetes. Devi creare il portachiavi nella stessa posizione del cluster GKE.

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

Esegui questo comando:

gcloud kms keyrings create KEY_RING_NAME \
    --location=us-central1 \
    --project=KEY_PROJECT_ID

Sostituisci quanto segue:

• KEY_RING_NAME: un nome per il keyring.
• KEY_PROJECT_ID: l'ID del progetto principale.

Crea chiavi

Per ogni autorità di credenziali, come le chiavi dell'account di servizio e le CA, devi creare una chiave utilizzando Cloud KMS. Questa sezione mostra come creare le chiavi utilizzate da GKE per firmare e verificare le credenziali nel cluster. Puoi specificare le tue proprietà per queste chiavi a seconda le esigenze dell'organizzazione. Per maggiori dettagli, consulta la sezione Creare una chiave e il projects.locations.keyRings.cryptoKeys: Riferimento API.

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 piano di controllo siano sottoposte a nuova crittografia con le nuove versioni delle chiavi prima che le versioni delle chiavi originali vengano distrutte.

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

• Se nel progetto chiave è già presente un keyring, puoi utilizzarlo per archiviare tutte le chiavi che crei e utilizzarle con il cluster.
• Il keyring deve trovarsi nella stessa località Google Cloud del cluster 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 efficace, come rsa-sign-pkcs1-4096-sha256 o rsa-sign-pkcs1-3072-sha256.
  • Chiavi dell'autorità di certificazione: un algoritmo sicuro come ec-sign-p256-sha256.
• Le chiavi hardware Cloud HSM sono supportate, ma il software di protezione è sufficiente per la maggior parte dei casi d'uso. Per maggiori dettagli sull'hardware vedi Cloud HSM.
• Non modificare il durata predefinita per l'eliminazione delle chiavi.
• GKE non ti impedisce di eliminare le chiavi Cloud KMS, incluse le chiavi CA Service utilizzate 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 devi specificare anche come chiave di verifica dell'account di servizio durante la creazione del cluster:

   gcloud kms keys create sa-signing-key \
       --keyring=KEY_RING_NAME \
       --location=us-central1\
       --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 un progetto chiave dedicato.

2. Crea la chiave dell'autorità di certificazione principale del cluster:

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

3. Crea la chiave della CA radice del peer etcd:

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

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

   gcloud kms keys create etcd-api-ca-key \
       --keyring=KEY_RING_NAME \
       --location=us-central1\
       --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=us-central1\
       --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 piano di controllo, 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=us-central1 \
       --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 ambiente Cloud Storage di sincronizzare la directory di una VM con un bucket. Per informazioni dettagliate, consulta Attivare la pubblicazione del certificato CA e della 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=us-central1 \
       --kms-key-version=projects/KEY_PROJECT_ID/locations/us-central1/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=us-central1 \
       --tier=enterprise \
       --project=KEY_PROJECT_ID \
       --no-publish-crl --no-publish-ca-cert
   

4. Crea la CA radice del peer etcd:

   gcloud privateca roots create etcd-peer-root-ca \
       --pool=etcd-peer-ca-pool \
       --location=us-central1 \
       --kms-key-version=projects/KEY_PROJECT_ID/locations/us-central1/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=us-central1 \
       --tier=enterprise \
       --project=KEY_PROJECT_ID \
       --no-publish-crl --no-publish-ca-cert
   

6. Crea la CA principale dell'API etcd:

   gcloud privateca roots create etcd-api-root-ca \
       --pool=etcd-api-ca-pool \
       --location=us-central1 \
       --kms-key-version=projects/KEY_PROJECT_ID/locations/us-central1/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=us-central1 \
       --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=us-central1 \
       --kms-key-version=projects/KEY_PROJECT_ID/locations/us-central1/keyRings/KEY_RING_NAME/cryptoKeys/aggregation-ca-key/cryptoKeyVersions/1 \
       --subject="CN=aggregation-ca, O=ORGANIZATION" \
       --project=KEY_PROJECT_ID \
       --auto-enable
   

Concedi i ruoli IAM all'agente di servizio GKE

L'agente di servizio GKE richiede l'accesso alle risorse che hai creato in Cloud KMS e nel servizio CA. 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, segui questi passaggi:

1. Trova il numero del progetto del cluster:

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

   Sostituisci CLUSTER_PROJECT_ID con l'ID progetto di del progetto di cluster.

2. Concedi il ruolo Kubernetes Engine KMS Crypto Key User alla chiave di firma dell'account di servizio che hai creato in Creare chiavi:

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

   Sostituisci CLUSTER_PROJECT_NUMBER con il numero del progetto del cluster.

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

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

Configura CA e chiavi in un nuovo cluster

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

Dopo aver creato chiavi, pool di CA, CA radice e concesso i ruoli IAM a l'agente di servizio GKE, crea un nuovo cluster che utilizzi questi Google Cloud.

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

• Percorso di una versione della chiave in Cloud KMS per la chiave di firma dell'account servizio che hai creato in Creare chiavi. Devi specificare questo percorso per il flag service-account-signing-keys e per il flag service-account-verification-keys.
• Percorso di ciascun pool di CA che hai creato in Creare le CA.

Nota: prima di eseguire questi passaggi, decidi se vuoi anche criptare i dischi di avvio e i dischi etcd del piano di controllo con le chiavi che gestisci. Se esegui tutti i passaggi chiave di configurazione Crittografia dei dischi di avvio etcd e del piano di controllo e specificare i flag facoltativi descritti nel comando di creazione del cluster

.

Per configurare un nuovo cluster per l'utilizzo delle tue chiavi e delle tue CA, segui questi passaggi:

1. Trova il percorso della versione più recente della chiave di firma del service account abilitata:

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

   Sostituisci KEY_PROJECT_ID con l'ID del progetto principale.

   L'output è simile al seguente:

   projects/KEY_PROJECT_ID/locations/us-central1/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/us-central1/caPools/cluster-ca-pool
   projects/KEY_PROJECT_ID/locations/us-central1/caPools/etcd-peer-ca-pool
   projects/KEY_PROJECT_ID/locations/us-central1/caPools/etcd-api-ca-pool
   projects/KEY_PROJECT_ID/locations/us-central1/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 creerai un cluster con diverse opzioni specificate a seconda delle funzionalità di autorità del piano di controllo GKE configurare. Puoi configurare queste funzionalità solo su un cluster durante il cluster per la creazione di contenuti.

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

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

  Sostituisci quanto segue:

  • CLUSTER_PROJECT_ID: l'ID del progetto del cluster.
  • VERSION: la versione GKE della in un cluster Kubernetes. Deve essere 1.31.1-gke.1846000 o successiva.

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

  1. Esegui tutti i passaggi di configurazione principali Crittografia dei dischi di avvio etcd e del piano di controllo.
  2. Trova i percorsi di ciascuna chiave utilizzando le istruzioni riportate in Utilizza chiavi di crittografia in un cluster.

  3. Crea un cluster:

     gcloud container clusters create-auto example-cluster \
         --location=us-central1 \
         --project=CLUSTER_PROJECT_ID \
         --cluster-version=VERSION \
         --service-account-signing-keys=projects/KEY_PROJECT_ID/locations/us-central1/keyRings/KEY_RING_NAME/cryptoKeys/sa-signing-key/cryptoKeyVersions/1 \
         --service-account-verification-keys=projects/KEY_PROJECT_ID/locations/us-central1/keyRings/KEY_RING_NAME/cryptoKeys/sa-signing-key/cryptoKeyVersions/1 \
         --cluster-ca=projects/KEY_PROJECT_ID/locations/us-central1/caPools/cluster-ca-pool \
         --etcd-peer-ca=projects/KEY_PROJECT_ID/locations/us-central1/caPools/etcd-peer-ca-pool \
         --etcd-api-ca=projects/KEY_PROJECT_ID/locations/us-central1/caPools/etcd-api-ca-pool \
         --aggregation-ca=projects/KEY_PROJECT_ID/locations/us-central1/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 del progetto del cluster.
     • VERSION: la versione GKE della in un cluster Kubernetes. Deve essere 1.31.1-gke.1846000 o successiva.
     • PATH_TO_DISK_KEY: il percorso della chiave di crittografia del disco.
     • PATH_TO_ETCD_BACKUP_KEY: il percorso della chiave di crittografia del 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 per la creazione del cluster. Puoi eseguire questa verifica utilizzando Cloud Logging oppure con Google Cloud CLI.

Usa Logging per verificare chiavi e CA

Per verificare le chiavi e le CA utilizzando Logging, segui questi passaggi:

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

   Vai a Esplora log

2. Specifica la query seguente:

   resource.type="gke_cluster"
   resource.labels.cluster_name="CLUSTER_NAME"
   resource.labels.location="CLUSTER_LOCATION"
   protoPayload.serviceName="container.googleapis.com"
   protoPayload.methodName="google.container.v1.ClusterManager.CreateCluster"
   protoPayload.request.cluster.userManagedKeysConfig:*
   

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

3. Fai clic su Esegui query.

4. Nei risultati, espandi il log di creazione del cluster. Verifica che i percorsi verso e CA sono le stesse che hai creato per il cluster.

Utilizza gcloud CLI per verificare le chiavi e le CA

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

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

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

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

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 i progetti

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:

• L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per le attività descritte in questo documento, quando lo elimini elimini anche tutto il lavoro svolto nel progetto.
• Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un appspot.com URL, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, il riuso dei progetti può aiutarti a non superare i limiti di quota.

Delete a Google Cloud project:

gcloud projects delete PROJECT_ID

Elimina singole risorse

1. Elimina il cluster:

   gcloud container clusters delete example-cluster \
       --location=us-central1 \
       --project=CLUSTER_PROJECT_ID
   

2. Disabilita le CA radice:

   gcloud privateca roots disable cluster-root-ca \
       --location=us-central1 \
       --pool=projects/KEY_PROJECT_ID/locations/us-central1/caPools/cluster-ca-pool \
       --project=KEY_PROJECT_ID
   
   gcloud privateca roots disable etcd-peer-root-ca \
       --location=us-central1 \
       --pool=projects/KEY_PROJECT_ID/locations/us-central1/caPools/etcd-peer-ca-pool \
       --project=KEY_PROJECT_ID
   
   gcloud privateca roots disable etcd-api-root-ca \
       --location=us-central1 \
       --pool=projects/KEY_PROJECT_ID/locations/us-central1/caPools/etcd-api-ca-pool \
       --project=KEY_PROJECT_ID
   
   gcloud privateca roots disable aggregation-root-ca \
       --location=us-central1 \
       --pool=projects/KEY_PROJECT_ID/locations/us-central1/caPools/aggregation-ca-pool \
       --project=KEY_PROJECT_ID
   

3. Elimina le CA radice:

   gcloud privateca roots delete cluster-root-ca \
       --location=us-central1 \
       --pool=projects/KEY_PROJECT_ID/locations/us-central1/caPools/cluster-ca-pool \
       --project=KEY_PROJECT_ID
   
   gcloud privateca roots delete etcd-peer-root-ca \
       --location=us-central1 \
       --pool=projects/KEY_PROJECT_ID/locations/us-central1/caPools/etcd-peer-ca-pool \
       --project=KEY_PROJECT_ID
   
   gcloud privateca roots delete etcd-api-root-ca \
       --location=us-central1 \
       --pool=projects/KEY_PROJECT_ID/locations/us-central1/caPools/etcd-api-ca-pool \
       --project=KEY_PROJECT_ID
   
   gcloud privateca roots delete aggregation-root-ca \
       --location=us-central1 \
       --pool=projects/KEY_PROJECT_ID/locations/us-central1/caPools/aggregation-ca-pool \
       --project=KEY_PROJECT_ID
   

4. Elimina i pool di CA:

   gcloud privateca pools delete cluster-ca-pool --location=us-central1 \
       --project=KEY_PROJECT_ID
   
   gcloud privateca pools delete etcd-peer-ca-pool --location=us-central1 \
       --project=KEY_PROJECT_ID
   
   gcloud privateca pools delete etcd-api-ca-pool --location=us-central1 \
       --project=KEY_PROJECT_ID
   
   gcloud privateca pools delete aggregation-ca-pool --location=us-central1 \
       --project=KEY_PROJECT_ID
   

5. Elimina le chiavi:

   gcloud kms keys versions destroy 1 \
       --location=us-central1 \
       --keyring=KEY_RING_NAME \
       --key=sa-signing-key \
       --project=KEY_PROJECT_ID
   
   gcloud kms keys versions destroy 1 \
       --location=us-central1 \
       --keyring=KEY_RING_NAME \
       --key=cluster-ca-key \
       --project=KEY_PROJECT_ID
   
   gcloud kms keys versions destroy 1 \
       --location=us-central1 \
       --keyring=KEY_RING_NAME \
       --key=etcd-peer-ca-key \
       --project=KEY_PROJECT_ID
   
   gcloud kms keys versions destroy 1 \
       --location=us-central1 \
       --keyring=KEY_RING_NAME \
       --key=etcd-api-ca-key \
       --project=KEY_PROJECT_ID
   
   gcloud kms keys versions destroy 1 \
       --location=us-central1 \
       --keyring=KEY_RING_NAME \
       --key=aggregation-ca-key \
       --project=KEY_PROJECT_ID
   

Non puoi eliminare i keyring da Cloud KMS. Tuttavia, i portachiavi non comportano costi aggiuntivi.

Passaggi successivi

• Esplora architetture di riferimento, diagrammi e best practice su Google Cloud. Dai un'occhiata al nostro Centro architetture cloud.