Configura la creazione automatica dei pool di nodi

Standard

Puoi ridurre la quantità di gestione manuale dell'infrastruttura nei cluster Google Kubernetes Engine (GKE) Standard consentendo a GKE di creare automaticamente i node pool per i pod in attesa. Questo documento mostra come attivare la creazione automatica dei pool di nodi per cluster e workload, impostare i valori predefiniti per i nodi creati automaticamente e attivare la creazione automatica per alcuni casi d'uso comuni.

Questo documento è rivolto ad amministratori, operatori e sviluppatori di cluster che gestiscono l'infrastruttura ed eseguono il deployment dei workload nei cluster Standard. Per ulteriori informazioni sul funzionamento della creazione automatica dei pool di nodi e sui diversi metodi di attivazione (come ComputeClasses e il provisioning automatico dei nodi a livello di cluster), consulta Informazioni sulla creazione automatica dei pool di nodi pool.

Limitazioni

La creazione automatica dei node pool presenta le seguenti limitazioni:

• Tutte le limitazioni del gestore della scalabilità automatica dei cluster si applicano anche alla creazione automatica dei pool di nodi.
• I cluster con più di 200 pool di nodi totali potrebbero avere una latenza maggiore durante la scalabilità automatica. Qualsiasi configurazione che attiva la creazione di un nuovo pool di nodi, ad esempio la separazione dei workload o l'utilizzo di più ComputeClass, aumenta questo numero. Per saperne di più sui limiti dei cluster, consulta Limiti e best practice in "Pianificazione di cluster di grandi dimensioni".
• Tutti i limiti delle risorse impostati per il cluster quando attivi il provisioning automatico dei nodi si applicano anche ai node pool creati da GKE per le classi ComputeClass.
• Le seguenti impostazioni non sono supportate da ComputeClasses:
  • Upgrade surge o upgrade blu/verde.
  • Integrità dei nodi e avvio protetto.
• Per abilitare la creazione automatica pool di nodi per una ComputeClass nelle versioni di GKE precedenti alla 1.33.3-gke.1136000, devi anche abilitare il provisioning automatico dei nodi a livello di cluster. Questa limitazione non si applica a GKE 1.33.3-gke.1136000 e versioni successive.

Prima di iniziare

Prima di iniziare, assicurati di aver eseguito le seguenti attività:

• Abilita l'API Google Kubernetes Engine.
Abilita l'API Google Kubernetes Engine
• Per utilizzare Google Cloud CLI per questa attività, installala e poi inizializza gcloud CLI. Se hai già installato gcloud CLI, scarica l'ultima versione eseguendo il comando gcloud components update. Le versioni precedenti di gcloud CLI potrebbero non supportare l'esecuzione dei comandi in questo documento.
  Nota: per le installazioni esistenti di gcloud CLI, assicurati di impostare la proprietà compute/region. Se utilizzi principalmente cluster zonali, imposta invece compute/zone. Se imposti una località predefinita, puoi evitare errori in gcloud CLI come il seguente: One of [--zone, --region] must be supplied: Please specify location. Potresti dover specificare la posizione in determinati comandi se la posizione del cluster è diversa da quella predefinita che hai impostato.

Requisiti

Puoi attivare la creazione automatica dei pool di nodi per l'intero cluster in qualsiasi versione di GKE utilizzando la funzionalità di provisioning automatico dei nodi. Se vuoi utilizzare una classe ComputeClass per abilitare la creazione automatica dei pool di nodi a livello di workload e non vuoi abilitare il provisioning automatico dei nodi, il cluster deve essere alla versione GKE 1.33.3-gke.1136000 o successiva.

Per attivare la creazione automatica pool di nodi per configurazioni di nodi specifiche, devi soddisfare i requisiti di versione corrispondenti. Per ulteriori informazioni sul supporto delle versioni per varie configurazioni, consulta le note di rilascio di GKE (nuove funzionalità) o la documentazione relativa al tuo caso d'uso.

Abilita la creazione automatica a livello di workload

Puoi attivare la creazione automatica pool di nodi per workload specifici nel cluster utilizzando una classe ComputeClass. Il campo nodePoolAutoCreation in una specifica ComputeClass controlla se GKE può creare nuovi node pool per i pod che selezionano quella ComputeClass. In GKE 1.33.3-gke.1136000 e versioni successive, puoi attivare la creazione automatica pool di nodi per una ComputeClass anche se il cluster non ha il provisioning automatico dei nodi attivato. Nelle versioni precedenti alla 1.33.3-gke.1136000, devi anche attivare il provisioning automatico dei nodi a livello di cluster.

Per abilitare la creazione automatica pool di nodi per una ComputeClass, segui questi passaggi:

1. Utilizza un cluster Standard nuovo o esistente con la versione 1.33.3-gke.1136000 o successiva.

   Se vuoi, puoi creare un nuovo cluster Standard.

2. Se il tuo cluster non soddisfa i requisiti del passaggio precedente, attiva il provisioning automatico dei nodi a livello di cluster.

3. Salva il seguente esempio di ComputeClass come file YAML:

   apiVersion: cloud.google.com/v1
   kind: ComputeClass
   metadata:
     name: COMPUTE_CLASS
   spec:
     priorities:
     -  machineFamily: n4
     -  machineFamily: n2
     whenUnsatisfiable: ScaleUpAnyway
     nodePoolAutoCreation:
       enabled: true
   

   Sostituisci COMPUTE_CLASS con un nome per la nuova classe ComputeClass. Per ulteriori informazioni sui campi disponibili in ComputeClasses, consulta ComputeClass CustomResourceDefinition.

4. Applica il manifest ComputeClass al cluster:

   kubectl apply -f PATH_TO_COMPUTECLASS_MANIFEST
   

   Sostituisci PATH_TO_COMPUTECLASS_MANIFEST con il percorso del file manifest ComputeClass.

5. Salva il seguente deployment di esempio, che seleziona una classe ComputeClass, come helloweb-deploy.yaml:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: helloweb
     labels:
       app: hello
   spec:
     selector:
       matchLabels:
         app: hello
     template:
       metadata:
         labels:
           app: hello
       spec:
         nodeSelector:
           # Replace with the name of a compute class
           cloud.google.com/compute-class: COMPUTE_CLASS 
         containers:
         - name: hello-app
           image: us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0
           ports:
           - containerPort: 8080
           resources:
             requests:
               cpu: "250m"
               memory: "1Gi"

6. Crea il deployment nel cluster:

   kubectl apply -f helloweb-deploy.yaml
   

7. Per verificare che GKE abbia creato un nuovo pool di nodi per il tuo pod, recupera un elenco dei node pool nel tuo cluster:

   gcloud container node-pools list \
       --cluster=CLUSTER_NAME \
       --location=CONTROL_PLANE_LOCATION
   

   Sostituisci quanto segue:

   • CLUSTER_NAME: il nome del tuo cluster.
   • CONTROL_PLANE_LOCATION: la regione o la zona del control plane del cluster, ad esempio us-central1 o us-central1-a.

Abilita il provisioning automatico dei nodi a livello di cluster

Per attivare la creazione automatica dei pool di nodi per l'intero cluster GKE, utilizza l'impostazione di provisioning automatico dei nodi. Il provisioning automatico dei nodi consente a GKE di creare nuovi node pool per i workload in attesa nel cluster in base alla configurazione nella specifica del pod o in una classe ComputeClass. Puoi attivare il provisioning automatico dei nodi per i cluster nuovi o esistenti.

Prima di attivare il provisioning automatico dei nodi, pianifica le dimensioni dell'intervallo di indirizzi IPv4 principale della subnet VPC. GKE utilizza questo intervallo di indirizzi IP come intervallo di indirizzi IP del nodo principale. A seconda delle dimensioni e della scalabilità del cluster, l'intervallo di indirizzi IP dei nodi predefinito potrebbe non avere indirizzi IP sufficienti da assegnare ai nuovi nodi. Se aggiorni le dimensioni dell'intervallo di indirizzi IP dei nodi dopo aver creato il cluster, devi aggiornare le regole firewall del cluster GKE per consentire il traffico dai nuovi indirizzi IP.

Per ottenere i node pool creati automaticamente nelle versioni di GKE precedenti alla 1.33.3-gke.1136000, devi seguire i passaggi descritti in questa sezione. Puoi anche attivare il provisioning automatico dei nodi per un cluster esistente modificando la configurazione del cluster nella console Google Cloud .

Attenzione: se abiliti il provisioning automatico dei nodi per un cluster esistente, i workload in attesa con selettori di nodi o configurazioni ComputeClass compatibili potrebbero attivare la creazione automatica dei pool di nodi. Convalida le specifiche dei workload esistenti per ridurre al minimo il rischio di scalabilità automatica involontaria.

Per abilitare il provisioning automatico dei nodi quando crei un nuovo cluster, seleziona una delle seguenti opzioni:

Console

1. Nella console Google Cloud , vai alla pagina Crea un cluster Kubernetes.

   Vai a Crea un cluster Kubernetes

2. Nella pagina Impostazioni di base del cluster, specifica un nome e una località per il nuovo cluster.

3. Nel riquadro di navigazione, fai clic su Impostazioni avanzate.

4. Nella riga Provisioning automatico dei nodi, fai clic su Modifica configurazione.

5. Seleziona la casella di controllo Abilita provisioning automatico dei nodi. Viene visualizzata una sezione Limiti.

6. Specifica i limiti per CPU e memoria.

7. Fai clic su Salva.

8. Fai clic su Crea.

gcloud

gcloud container clusters create CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --min-cpu=MINIMUM_CPU \
    --min-memory=MINIMUM_MEMORY \
    --max-cpu=MAXIMUM_CPU \
    --max-memory=MAXIMUM_MEMORY \
    --autoprovisioning-scopes=https://www.googleapis.com/auth/logging.write,https://www.googleapis.com/auth/monitoring,https://www.googleapis.com/auth/devstorage.read_only

Sostituisci quanto segue:

• CLUSTER_NAME: il nome del cluster per cui attivare il provisioning automatico dei nodi.
• CONTROL_PLANE_LOCATION: la regione o la zona del control plane del cluster, ad esempio us-central1 o us-central1-a.
• MINIMUM_CPU: il numero minimo di core nel cluster.
• MINIMUM_MEMORY: la capacità di memoria minima, in GiB, nel cluster.
• MAXIMUM_CPU: il numero massimo di core nel cluster. Questo limite si applica alla somma dei core della CPU in tutti i nodi nuovi ed esistenti del cluster, inclusi i pool di nodi creati manualmente.
• MAXIMUM_MEMORY: la capacità di memoria massima, in GiB, nel cluster. Questo limite si applica alla somma della capacità di memoria di tutti i node pool nuovi ed esistenti nel cluster, inclusi i node pool creati manualmente.

Configura le impostazioni con un file di configurazione del provisioning automatico dei nodi

Puoi configurare i limiti delle risorse e le impostazioni di configurazione dei nodi per il provisioning automatico dei nodi utilizzando un file di configurazione YAML. Il file di configurazione consente di specificare in modo dichiarativo i valori predefiniti per i pool di nodi creati automaticamente e di eseguire la configurazione avanzata, ad esempio l'abilitazione della riparazione automatica dei nodi. Questo file non è correlato a ComputeClasses, che sono risorse personalizzate di Kubernetes. Il file di configurazione esiste come alternativa più estensibile all'utilizzo dei flag della riga di comando per specificare le impostazioni per il provisioning automatico dei nodi. Per saperne di più, consulta Impostazioni predefinite a livello di cluster con un file di configurazione.

Per creare e utilizzare un file di configurazione, segui questi passaggi:

1. In un editor di testo, crea un file YAML in un percorso a cui Google Cloud CLI può accedere.

2. Aggiungi le configurazioni che vuoi impostare o modificare, come nell'esempio seguente:

   resourceLimits:
     - resourceType: 'cpu'
       minimum: 4
       maximum: 10
     - resourceType: 'memory'
       maximum: 64
     - resourceType: 'nvidia-tesla-t4'
       maximum: 4
   management:
     autoRepair: true
     autoUpgrade: true
   shieldedInstanceConfig:
     enableSecureBoot: true
     enableIntegrityMonitoring: true
   

   Questo esempio ha le seguenti impostazioni per il provisioning automatico dei nodi:

   • resourceLimits: imposta i limiti delle risorse per CPU, capacità di memoria e GPU NVIDIA T4 nel cluster. Questi limiti si applicano alla somma della capacità delle risorse nel cluster, inclusi i node pool creati manualmente.
   • management: abilita la riparazione automatica e l'upgrade automatico dei nodi per tutti i nuovi node pool creati automaticamente nel cluster.
   • shieldedInstanceConfig: abilita l'avvio protetto e il monitoraggio dell'integrità dei nodi per tutti i nuovi node pool creati automaticamente nel cluster.

3. Fornisci il file di configurazione a GKE specificando il flag --autoprovisioning-config-file e il flag --enable-autoprovisioning per un cluster nuovo o esistente:

   gcloud container clusters create CLUSTER_NAME \
       --location=CONTROL_PLANE_LOCATION \
       --enable-autoprovisioning \
       --autoprovisioning-config-file=PATH_TO_CONFIGURATION_FILE
   

   Sostituisci quanto segue:

   • CLUSTER_NAME: il nome del cluster.
   • PATH_TO_CONFIGURATION_FILE: il percorso del file di configurazione.

Dopo aver applicato il file di configurazione al cluster, GKE utilizza le impostazioni nel file per i nuovi pool di nodi creati automaticamente nel cluster. Queste impostazioni non si applicano ai node pool esistenti creati da GKE nel cluster.

Configura i limiti delle risorse per il provisioning automatico dei nodi

Quando utilizzi il provisioning automatico dei nodi a livello di cluster, devi configurare i limiti per la quantità totale di risorse che il cluster può avere in tutti i suoi node pool. Per attivare il provisioning automatico dei nodi per un cluster, devi specificare i limiti per la capacità della CPU e della memoria nel cluster. Inoltre, per utilizzare altri tipi di risorse collegate, come GPU e TPU, devi specificare i limiti per queste risorse. Questi limiti sono obbligatori solo se attivi l'impostazione di provisioning automatico dei nodi per il tuo cluster. Se utilizzi solo ComputeClasses per ottenere pool di nodi creati automaticamente, non devi configurare i limiti delle risorse.

In alternativa, puoi configurare limiti delle risorse che hanno come target sottoinsiemi di nodi, ad esempio i nodi creati per una classe ComputeClass o i nodi che utilizzano una famiglia di macchine specifica. Per saperne di più, consulta Configura limiti di risorse granulari.

Puoi aggiungere o modificare i limiti delle risorse per la creazione automatica dei pool di nodi utilizzando uno dei seguenti metodi:

• La console Google Cloud
• Flag di gcloud CLI
• Il file di configurazione a livello di cluster

Per configurare i limiti delle risorse per un cluster esistente, seleziona una delle seguenti opzioni:

Console

1. Nella console Google Cloud , vai alla pagina Cluster Kubernetes.

   Vai ai cluster Kubernetes

2. Fai clic sul nome del cluster. Viene visualizzata la pagina Dettagli cluster.

3. Fai clic sulla scheda Dettagli.

4. Nella sezione Automazione, nella riga Provisioning automatico dei nodi, fai clic su Modifica. Viene visualizzato il riquadro Modifica provisioning automatico dei nodi.

5. Seleziona la casella di controllo Abilita provisioning automatico dei nodi.

6. Nella sezione Limiti, specifica i valori minimo e massimo per la capacità della CPU e della memoria nel cluster.

7. Per configurare i limiti per un'altra risorsa, ad esempio GPU o TPU, segui questi passaggi:

   1. Fai clic su Aggiungi risorsa.
   2. Dall'elenco a discesa Tipo di risorsa, seleziona il modello di GPU o il tipo di macchina TPU, ad esempio NVIDIA A100 80GB o ct5p.
   3. Specifica i valori minimo e massimo per la risorsa.

8. (Facoltativo) Nella sezione Località dei pool di nodi, seleziona zone specifiche in cui GKE deve creare i nodi. Ad esempio, se prevedi di eseguire workload GPU, seleziona le zone con alta affidabilità per il tipo di GPU selezionato.

9. Fai clic su Salva modifiche.

gcloud

Esegui uno dei seguenti comandi:

• Specifica i limiti delle risorse di CPU e memoria:

  gcloud container clusters update CLUSTER_NAME \
      --location=CONTROL_PLANE_LOCATION \
      --enable-autoprovisioning \
      --min-cpu=MINIMUM_CPU \
      --min-memory=MINIMUM_MEMORY \
      --max-cpu=MAXIMUM_CPU \
      --max-memory=MAXIMUM_MEMORY
  

  Sostituisci quanto segue:

  • MINIMUM_CPU: il numero minimo di core nel cluster.
  • MINIMUM_MEMORY: la capacità di memoria minima, in GiB, nel cluster.
  • MAXIMUM_CPU: il numero massimo di core nel cluster. Questo limite si applica alla somma dei core della CPU in tutti i node pool del cluster, inclusi i node pool creati manualmente.
  • MAXIMUM_MEMORY: la capacità di memoria massima, in GiB, nel cluster. Questo limite si applica alla somma della capacità di memoria di tutti i node pool del cluster, inclusi i node pool creati manualmente.

• Specifica i limiti delle risorse GPU:

  gcloud container clusters update CLUSTER_NAME \
      --location=CONTROL_PLANE_LOCATION \
      --enable-autoprovisioning \
      --min-cpu=MINIMUM_CPU \
      --min-memory=MINIMUM_MEMORY \
      --max-cpu=MAXIMUM_CPU \
      --max-memory=MAXIMUM_MEMORY \
      --min-accelerator=type=GPU_TYPE,count=MINIMUM_GPU_COUNT \
      --max-accelerator=type=GPU_TYPE,count=MAXIMUM_GPU_COUNT
  

  Sostituisci quanto segue:

  • GPU_TYPE: il tipo di GPU per cui impostare un limite, ad esempio nvidia-l4.
  • MINIMUM_GPU_COUNT: il numero minimo di GPU del tipo specificato che il cluster può avere.
  • MAXIMUM_GPU_COUNT: il numero massimo di GPU del tipo specificato che il cluster può avere.

• Specifica i limiti delle risorse TPU:

  gcloud container clusters update CLUSTER_NAME \
      --location=CONTROL_PLANE_LOCATION \
      --enable-autoprovisioning \
      --min-cpu=MINIMUM_CPU \
      --min-memory=MINIMUM_MEMORY \
      --max-cpu=MAXIMUM_CPU \
      --max-memory=MAXIMUM_MEMORY \
      --min-accelerator=type=TPU_TYPE,count=MINIMUM_TPU_COUNT \
      --max-accelerator=type=TPU_TYPE,count=MAXIMUM_TPU_COUNT
  

  Sostituisci quanto segue:

  • TPU_TYPE: il tipo di TPU per cui impostare un limite. Sono supportati i seguenti valori:
    • tpu-v4-podslice: TPU v4.
    • tpu-v5-lite-podslice: TPU v5e con tipi di macchina che iniziano con ct5lp-.
    • tpu-v5p-slice: TPU v5e con tipi di macchina che iniziano con ct5p-.
    • tpu-v6e-slice: TPU Trillium.
  • MINIMUM_TPU_COUNT: il numero minimo di chip TPU del tipo specificato che il cluster può avere. Se il valore specificato è maggiore del numero di chip TPU in una slice TPU multi-host, la slice TPU potrebbe non fare lo scale down.
  • MAXIMUM_TPU_COUNT: il numero massimo di chip TPU del tipo specificato che il cluster può avere. Per le sezioni TPU multi-host, specifica un valore maggiore del numero di chip in ogni sezione in modo che GKE possa scalare la sezione in modo atomico. Il numero di chip in una sezione è il prodotto della topologia TPU. Ad esempio, se la topologia è 2x2x2, il numero di chip nello slice è 8, il che significa che il valore di MAXIMUM_TPU_COUNT deve essere maggiore di 8.

File di configurazione

1. Nel file di configurazione, specifica uno dei seguenti insiemi di campi nel campo resourceLimits:

   • Specifica i limiti delle risorse di CPU e memoria:

     resourceLimits:
       - resourceType: 'cpu'
         minimum: MINIMUM_CPU
         maximum: MAXIMUM_CPU
       - resourceType: 'memory'
         minimum: MINIMUM_MEMORY
         maximum: MAXIMUM_MEMORY
     

     Sostituisci quanto segue:

     • MINIMUM_CPU: il numero minimo di core nel cluster.
     • MINIMUM_MEMORY: la capacità di memoria minima, in GiB, nel cluster.
     • MAXIMUM_CPU: il numero massimo di core nel cluster. Questo limite si applica alla somma dei core della CPU in tutti i node pool del cluster, inclusi i node pool creati manualmente.
     • MAXIMUM_MEMORY: la capacità di memoria massima, in GiB, nel cluster. Questo limite si applica alla somma della capacità di memoria di tutti i node pool del cluster, inclusi i node pool creati manualmente.

   • Specifica i limiti delle risorse GPU:

     resourceLimits:
       - resourceType: 'cpu'
         minimum: MINIMUM_CPU
         maximum: MAXIMUM_CPU
       - resourceType: 'memory'
         minimum: MINIMUM_MEMORY
         maximum: MAXIMUM_MEMORY
       - resourceType: 'GPU1_TYPE'
         minimum: MINIMUM_GPU1_COUNT
         maximum: MAXIMUM_GPU1_COUNT
       - resourceType: 'GPU2_TYPE'
         minimum: MINIMUM_GPU2_COUNT
         maximum: MAXIMUM_GPU2_COUNT
     

     Sostituisci quanto segue:

     • GPU1_TYPE,GPU2_TYPE: i tipi di GPU per cui impostare i limiti, ad esempio nvidia-l4.
     • MINIMUM_GPU1_COUNT,MINIMUM_GPU2_COUNT: il numero minimo di GPU dei tipi specificati che il cluster può avere.
     • MAXIMUM_GPU1_COUNT,MAXIMUM_GPU2_COUNT: il numero massimo di GPU dei tipi specificati che il cluster può avere.

   • Specifica i limiti delle risorse TPU:

     resourceLimits:
       - resourceType: 'cpu'
         minimum: MINIMUM_CPU
         maximum: MAXIMUM_CPU
       - resourceType: 'memory'
         minimum: MINIMUM_MEMORY
         maximum: MAXIMUM_MEMORY
       - resourceType: 'TPU1_TYPE'
         minimum: MINIMUM_TPU1_COUNT
         maximum: MAXIMUM_TPU1_COUNT
       - resourceType: 'TPU2_TYPE'
         minimum: MINIMUM_TPU2_COUNT
         maximum: MAXIMUM_TPU2_COUNT
     

     Sostituisci quanto segue:

     • TPU1_TYPE,TPU2_TYPE: i tipi di TPU per cui impostare i limiti. Sono supportati i seguenti valori:
       • tpu-v4-podslice: TPU v4.
       • tpu-v5-lite-podslice: TPU v5e con tipi di macchina che iniziano con ct5lp-.
       • tpu-v5p-slice: TPU v5e con tipi di macchina che iniziano con ct5p-.
       • tpu-v6e-slice: TPU Trillium.
     • MINIMUM_TPU1_COUNT,MINIMUM_TPU2_COUNT: il numero minimo di chip TPU del tipo specificato che il cluster può avere. Se il valore specificato è maggiore del numero di chip TPU in una sezione TPU multi-host, la sezione TPU potrebbe non fare lo scale down.
     • MAXIMUM_TPU1_COUNT,MAXIMUM_TPU2_COUNT: il numero massimo di chip TPU del tipo specificato che il cluster può avere. Per le sezioni TPU multi-host, specifica un valore maggiore del numero di chip in ogni sezione in modo che GKE possa scalare la sezione in modo atomico. Il numero di chip in una sezione è il prodotto della topologia TPU. Ad esempio, se la topologia per TPU1_TYPE è 2x2x2, il numero di chip nella sezione è 8, il che significa che il valore di MAXIMUM_TPU1_COUNT deve essere maggiore di 8.

2. Fornisci il file di configurazione a GKE specificando il flag --autoprovisioning-config-file e il flag --enable-autoprovisioning per un cluster nuovo o esistente:

   gcloud container clusters create CLUSTER_NAME \
       --location=CONTROL_PLANE_LOCATION \
       --enable-autoprovisioning \
       --autoprovisioning-config-file=PATH_TO_CONFIGURATION_FILE
   

   Sostituisci quanto segue:

   • CLUSTER_NAME: il nome del cluster.
   • PATH_TO_CONFIGURATION_FILE: il percorso del file di configurazione.

Contrassegna i node pool esistenti come creati automaticamente

Dopo aver attivato il provisioning automatico dei nodi a livello di cluster, puoi contrassegnare come creati automaticamente tutti i node pool esistenti nel cluster. GKE gestisce la scalabilità in questi node pool, inclusa l'eliminazione dei node pool quando sono vuoti. Puoi contrassegnare i node pool creati manualmente come creati automaticamente per consentire a GKE di gestirli al posto tuo.

Se disattivi il provisioning automatico per il cluster, GKE interrompe la gestione di tutti i node pool esistenti creati automaticamente nel cluster. Se in un secondo momento riattivi il provisioning automatico per il cluster, GKE non riprende automaticamente la gestione dei node pool esistenti. Devi contrassegnare i pool di nodi esistenti come creati automaticamente.

Per contrassegnare un pool di nodi esistente come creato automaticamente, esegui questo comando:

gcloud container node-pools update NODE_POOL_NAME \
    --cluster=CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning

Sostituisci NODE_POOL_NAME con il nome del pool di nodi.

Configura le impostazioni predefinite per i node pool creati automaticamente

GKE utilizza le specifiche di ComputeClasses e dei pod per determinare i tipi di nodi che possono eseguire in modo ottimale i pod in attesa. Se vuoi, puoi configurare le impostazioni predefinite che GKE applica ai pool di nodi creati automaticamente, ad esempio un account di servizio Identity and Access Management (IAM) personalizzato per i nodi o configurazioni personalizzate del disco di avvio. Queste impostazioni predefinite sostituiscono i valori predefiniti corrispondenti impostati da Google per i tuoi cluster. Ad esempio, puoi impostare un'immagine del nodo Ubuntu come predefinita per i node pool creati automaticamente, che sostituisce l'immagine del nodo Container-Optimized OS predefinita di GKE.

Puoi configurare le impostazioni predefinite a livello di cluster utilizzando il provisioning automatico dei nodi o a livello di workload in ComputeClasses. Prima di configurare un'impostazione a uno di questi livelli, tieni presente quanto segue:

• Le impostazioni a livello di cluster si applicano a qualsiasi pool di nodi creato automaticamente nel cluster, mentre le impostazioni di ComputeClass si applicano solo ai workload che utilizzano quella ComputeClass.
• Se specifichi la stessa impostazione predefinita in una classe ComputeClass e a livello di cluster, GKE utilizza l'impostazione della classe ComputeClass per i workload che utilizzano la classe ComputeClass.
• I valori predefiniti configurati si applicano solo ai nuovi node pool creati automaticamente. I node pool esistenti non sono interessati.

Le sezioni seguenti mostrano come configurare impostazioni predefinite specifiche.

Imposta l'immagine del nodo predefinita

Seleziona una delle seguenti opzioni:

ComputeClass

1. In un manifest ComputeClass, utilizza il campo nodePoolConfig.imageType. Questo campo è disponibile in GKE versione 1.32.4-gke.1198000 e successive.

   apiVersion: cloud.google.com/v1
   kind: ComputeClass
   metadata:
     name: COMPUTE_CLASS
   spec:
     priorities:
     - machineFamily: n4
     - machineFamily: n4d
     nodePoolConfig:
       imageType: IMAGE_TYPE
     whenUnsatisfiable: ScaleUpAnyway
     nodePoolAutoCreation:
       enabled: true
   

   Sostituisci IMAGE_TYPE con un valore per l'immagine del nodo, che può essere uno dei seguenti:

   • cos_containerd: Container-Optimized OS con containerd.
   • ubuntu_containerd: Ubuntu con containerd.

2. Applica il manifest ComputeClass al cluster:

   kubectl apply -f PATH_TO_COMPUTECLASS_MANIFEST
   

   Sostituisci PATH_TO_COMPUTECLASS_MANIFEST con il percorso del file manifest ComputeClass.

gcloud

Per impostare l'immagine del nodo predefinita dalla riga di comando, utilizza il flag --autoprovisioning-image-type:

gcloud container clusters update CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --autoprovisioning-image-type=IMAGE_TYPE

Sostituisci quanto segue:

• CLUSTER_NAME: il nome del cluster.
• IMAGE_TYPE: l'immagine del nodo, che può essere una delle seguenti:
  • cos_containerd: Container-Optimized OS con containerd.
  • ubuntu_containerd: Ubuntu con containerd.

Per impostare l'immagine del nodo predefinita in un file di configurazione, segui questi passaggi:

1. Nel file di configurazione, specifica il campo imageType:

     imageType: 'IMAGE_TYPE'
   

   Se il file di configurazione contiene altre impostazioni, non modificarle. Eventuali modifiche o rimozioni nel file di configurazione modificano anche le impostazioni corrispondenti a livello di cluster.

2. Fornisci il file di configurazione a GKE specificando il flag --autoprovisioning-config-file e il flag --enable-autoprovisioning per un cluster nuovo o esistente:

   gcloud container clusters create CLUSTER_NAME \
       --location=CONTROL_PLANE_LOCATION \
       --enable-autoprovisioning \
       --autoprovisioning-config-file=PATH_TO_CONFIGURATION_FILE
   

   Sostituisci quanto segue:

   • CLUSTER_NAME: il nome del cluster.
   • PATH_TO_CONFIGURATION_FILE: il percorso del file di configurazione.

Imposta il account di servizio IAM predefinito per i nodi

I nodi GKE utilizzano un service account IAM per le attività di sistema, come il logging e il monitoraggio. Per modificare il account di servizio IAM per i node pool creati automaticamente, seleziona una delle seguenti opzioni:

ComputeClass

1. In un manifest Computeclass, utilizza il campo nodePoolConfig.serviceAccount. Questo campo è disponibile in GKE 1.31.4-gke.1072000 e versioni successive.

   apiVersion: cloud.google.com/v1
   kind: ComputeClass
   metadata:
     name: COMPUTE_CLASS
   spec:
     priorities:
     - machineFamily: n4
     - machineFamily: n4d
     nodePoolConfig:
       serviceAccount: SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com
     whenUnsatisfiable: ScaleUpAnyway
     nodePoolAutoCreation:
       enabled: true
   

   Sostituisci quanto segue:

   • SERVICE_ACCOUNT_NAME: il nome del account di servizio IAM, ad esempio my-node-account.
   • PROJECT_ID: l'ID progetto del progetto del service account.

2. Applica il manifest ComputeClass al cluster:

   kubectl apply -f PATH_TO_COMPUTECLASS_MANIFEST
   

   Sostituisci PATH_TO_COMPUTECLASS_MANIFEST con il percorso del file manifest ComputeClass.

gcloud

Quando utilizzi gcloud CLI per configurare un account di servizio predefinito per i node pool creati automaticamente, devi anche specificare gli ambiti di accesso richiesti dai node pool per funzionare correttamente.

Per impostare il account di servizio predefinito e gli ambiti di accesso dalla riga di comando, utilizza i flag --autoprovisioning-service-account e --autoprovisioning-scopes:

gcloud container clusters update CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --autoprovisioning-service-account=SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com \
    --autoprovisioning-scopes=https://www.googleapis.com/auth/devstorage.read_only,https://www.googleapis.com/auth/service.management.readonly,https://www.googleapis.com/auth/servicecontrol,https://www.googleapis.com/auth/trace.append

Sostituisci quanto segue:

• SERVICE_ACCOUNT_NAME: il nome del account di servizio IAM, ad esempio my-node-account.
• PROJECT_ID: l'ID progetto del account di servizio.

Per impostare il account di servizio e gli ambiti di accesso predefiniti in un file di configurazione, segui questi passaggi:

1. Nel file di configurazione, specifica i campi serviceAccount e scopes:

   serviceAccount: SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com
   scopes: https://www.googleapis.com/auth/devstorage.read_only,https://www.googleapis.com/auth/service.management.readonly,https://www.googleapis.com/auth/servicecontrol,https://www.googleapis.com/auth/trace.append
   

   Se il file di configurazione contiene altre impostazioni, non modificarle. Eventuali modifiche o rimozioni nel file di configurazione modificano anche le impostazioni corrispondenti a livello di cluster.

2. Fornisci il file di configurazione a GKE specificando il flag --autoprovisioning-config-file e il flag --enable-autoprovisioning per un cluster nuovo o esistente:

   gcloud container clusters create CLUSTER_NAME \
       --location=CONTROL_PLANE_LOCATION \
       --enable-autoprovisioning \
       --autoprovisioning-config-file=PATH_TO_CONFIGURATION_FILE
   

   Sostituisci quanto segue:

   • CLUSTER_NAME: il nome del cluster.
   • PATH_TO_CONFIGURATION_FILE: il percorso del file di configurazione.

Imposta le zone predefinite per i nodi creati automaticamente

Per impostazione predefinita, GKE crea automaticamente i nodi nelle seguenti zone, a seconda del tipo di cluster:

• Cluster a livello di regione: GKE crea i nodi in tre zone casuali nella regione del cluster.
• Cluster di zona: GKE crea i nodi nella stessa zona del control plane del cluster.

Puoi specificare manualmente un elenco di zone in cui GKE crea automaticamente i nodi. Queste zone devono trovarsi nella stessa regione del control plane del cluster. Ad esempio, se hai un cluster di zona con il control plane in us-central1-a, puoi specificare qualsiasi zona nella regione us-central1 per consentire a GKE di creare automaticamente i nodi. Se modifichi le zone predefinite per i nodi creati automaticamente in un cluster esistente, le modifiche si applicano solo ai nuovi pool di nodi creati da GKE.

Per specificare le zone predefinite per i nodi creati automaticamente, seleziona una delle seguenti opzioni:

ComputeClass

1. In un manifest ComputeClass, utilizza il campo spec.priorityDefaults.location.zones. Questo campo è disponibile in GKE versione 1.33.1-gke.1545000 e successive.

   apiVersion: cloud.google.com/v1
   kind: ComputeClass
   metadata:
     name: COMPUTE_CLASS
   spec:
     priorityDefaults:
       location:
         zones: ['ZONE1','ZONE2','...']
     priorities:
     - machineFamily: n4
     - machineFamily: n4d
     whenUnsatisfiable: ScaleUpAnyway
     nodePoolAutoCreation:
       enabled: true
   

   Sostituisci ZONE1,ZONE2,... con un elenco separato da virgole delle zone predefinite per i nodi creati automaticamente, ad esempio "us-central1-a','us-central1-b', 'us-central1-f'". GKE utilizza queste zone se regole specifiche nel campo spec.priorities non includono un elenco esplicito di zone.

   (Facoltativo) Se esegui il provisioning di VM TPU, utilizza una zona AI, ad esempio us-central1-ai1a. Le zone AI sono località specializzate ottimizzate per i workload AI/ML all'interno delle regioni Google Cloud .

2. Applica il manifest ComputeClass al cluster:

   kubectl apply -f PATH_TO_COMPUTECLASS_MANIFEST
   

   Sostituisci PATH_TO_COMPUTECLASS_MANIFEST con il percorso del file manifest ComputeClass.

gcloud

Per impostare le zone predefinite per la creazione automatica pool di nodi dalla riga di comando, utilizza il flag --autoprovisioning-locations:

gcloud container clusters update CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --autoprovisioning-locations=ZONE1,ZONE2,...

Sostituisci ZONE1,ZONE2,... con un elenco separato da virgole delle zone predefinite per i nodi creati automaticamente, ad esempio "us-central1-a','us-central1-b', 'us-central1-f'".

Per impostare le zone predefinite per la creazione automatica dei pool di nodi utilizzando un file di configurazione, segui questi passaggi:

1. Specifica il campo autoprovisioningLocations nel file di configurazione:

   autoprovisioningLocations:
   - ZONE1
   - ZONE2
   

   Sostituisci ZONE1,ZONE2 con le zone predefinite per i nodi creati automaticamente, ad esempio "us-central1-a" e "us-central1-b".

   Se il file di configurazione contiene altre impostazioni, non modificarle. Eventuali modifiche o rimozioni nel file di configurazione modificano anche le impostazioni corrispondenti a livello di cluster.

2. Fornisci il file di configurazione a GKE specificando il flag --autoprovisioning-config-file e il flag --enable-autoprovisioning per un cluster nuovo o esistente:

   gcloud container clusters create CLUSTER_NAME \
       --location=CONTROL_PLANE_LOCATION \
       --enable-autoprovisioning \
       --autoprovisioning-config-file=PATH_TO_CONFIGURATION_FILE
   

   Sostituisci quanto segue:

   • CLUSTER_NAME: il nome del cluster.
   • PATH_TO_CONFIGURATION_FILE: il percorso del file di configurazione.

Imposta le chiavi di crittografia gestite dal cliente per la crittografia del disco di avvio

Puoi specificare una chiave di crittografia gestita dal cliente (CMEK) in Cloud Key Management Service che GKE utilizza per criptare i dischi di avvio dei nodi nei node pool creati automaticamente. Devi creare la chiave prima di utilizzarla con la creazione automatica dei pool di nodi. Per impostare una CMEK per i dischi di avvio dei nodi, seleziona una delle seguenti opzioni:

ComputeClass

In ComputeClasses, devi specificare la chiave in ogni regola di priorità nel campo spec.priorities della classe ComputeClass.

1. In un manifest ComputeClass, utilizza il campo priorities.storage.bootDiskKMSKey:

   apiVersion: cloud.google.com/v1
   kind: ComputeClass
   metadata:
     name: COMPUTE_CLASS
   spec:
     priorities:
     - machineFamily: n4
       storage:
         bootDiskKMSKey: projects/KEY_PROJECT_ID/locations/KEY_LOCATION/keyRings/KEY_RING/cryptoKeys/KEY_NAME
     - machineFamily: n4d
       storage:
         bootDiskKMSKey: projects/KEY_PROJECT_ID/locations/KEY_LOCATION/keyRings/KEY_RING/cryptoKeys/KEY_NAME
     whenUnsatisfiable: ScaleUpAnyway
     nodePoolAutoCreation:
       enabled: true
   

   Sostituisci quanto segue:

   • KEY_PROJECT_ID: l'ID progetto del progetto che contiene la chiave.
   • KEY_LOCATION: la posizione delle chiavi automatizzate.
   • KEY_RING: il nome delle chiavi automatizzate che contengono la chiave.
   • KEY_NAME: il nome della chiave.

2. Applica il manifest ComputeClass al cluster:

   kubectl apply -f PATH_TO_COMPUTECLASS_MANIFEST
   

   Sostituisci PATH_TO_COMPUTECLASS_MANIFEST con il percorso del file manifest ComputeClass.

gcloud

1. Specifica il campo bootDiskKmsKey nel file di configurazione:

   bootDiskKmsKey: projects/KEY_PROJECT_ID/locations/KEY_LOCATION/keyRings/KEY_RING/cryptoKeys/KEY_NAME
   

   Sostituisci quanto segue:

   • KEY_PROJECT_ID: l'ID progetto del progetto che contiene la chiave.
   • KEY_LOCATION: la posizione delle chiavi automatizzate.
   • KEY_RING: il nome delle chiavi automatizzate che contengono la chiave.
   • KEY_NAME: il nome della chiave.

   Se il file di configurazione contiene altre impostazioni, non modificarle. Eventuali modifiche o rimozioni nel file di configurazione modificano anche le impostazioni corrispondenti a livello di cluster.

2. Fornisci il file di configurazione a GKE specificando il flag --autoprovisioning-config-file e il flag --enable-autoprovisioning per un cluster nuovo o esistente:

   gcloud container clusters create CLUSTER_NAME \
       --location=CONTROL_PLANE_LOCATION \
       --enable-autoprovisioning \
       --autoprovisioning-config-file=PATH_TO_CONFIGURATION_FILE
   

   Sostituisci quanto segue:

   • CLUSTER_NAME: il nome del cluster.
   • PATH_TO_CONFIGURATION_FILE: il percorso del file di configurazione.

Configura l'integrità dei nodi e l'avvio protetto

Puoi attivare l'avvio protetto e il monitoraggio dell'integrità per i pool di nodi creati automaticamente solo utilizzando il file di configurazione del provisioning automatico dei nodi.

1. Specifica il campo shieldedInstanceConfig nel file di configurazione:

   shieldedInstanceConfig:
     enableSecureBoot: true
     enableIntegrityMonitoring: true
   

   Se il file di configurazione contiene altre impostazioni, non modificarle. Eventuali modifiche o rimozioni nel file di configurazione modificano anche le impostazioni corrispondenti a livello di cluster.

2. Fornisci il file di configurazione a GKE specificando il flag --autoprovisioning-config-file e il flag --enable-autoprovisioning per un cluster nuovo o esistente:

   gcloud container clusters create CLUSTER_NAME \
       --location=CONTROL_PLANE_LOCATION \
       --enable-autoprovisioning \
       --autoprovisioning-config-file=PATH_TO_CONFIGURATION_FILE
   

   Sostituisci quanto segue:

   • CLUSTER_NAME: il nome del cluster.
   • PATH_TO_CONFIGURATION_FILE: il percorso del file di configurazione.

Configura la riparazione e l'upgrade automatici dei nodi

Puoi modificare le impostazioni per le riparazioni automatiche dei nodi e gli upgrade automatici dei nodi nei node pool creati automaticamente. Queste funzionalità sono abilitate per impostazione predefinita in tutti i cluster e i node pool GKE. Ti consigliamo di mantenere attive queste funzionalità per migliorare l'affidabilità e la stabilità dei tuoi cluster.

Avviso: se disabiliti gli upgrade automatici quando il cluster è registrato in un canale di rilascio, GKE potrebbe non riuscire a creare nuovi node pool.

Per modificare le impostazioni di riparazione e upgrade automatici dei nodi, seleziona una delle seguenti opzioni:

ComputeClass

1. In un manifest ComputeClass, utilizza il campo autoRepair e il campo autoUpgrade nel campo spec.nodePoolConfig. Questi campi sono disponibili in GKE versione 1.34.0-gke.2201000 e successive.

   apiVersion: cloud.google.com/v1
   kind: ComputeClass
   metadata:
     name: COMPUTE_CLASS
   spec:
     nodePoolConfig:
       autoRepair: true
       autoUpgrade: true
     priorities:
     - machineFamily: n4
     - machineFamily: n4d
     whenUnsatisfiable: ScaleUpAnyway
     nodePoolAutoCreation:
       enabled: true
   

2. Applica il manifest ComputeClass al cluster:

   kubectl apply -f PATH_TO_COMPUTECLASS_MANIFEST
   

   Sostituisci PATH_TO_COMPUTECLASS_MANIFEST con il percorso del file manifest ComputeClass.

gcloud

• Per attivare le impostazioni di riparazione e upgrade automatici dalla riga di comando, utilizza i flag --enable-autoprovisioning-autorepair e --enable-autoprovisioning-autoupgrade:

  gcloud container clusters update CLUSTER_NAME \
      --location=CONTROL_PLANE_LOCATION \
      --enable-autoprovisioning \
      --enable-autoprovisioning-autorepair \
      --enable-autoprovisioning-autoupgrade
  

• Per disattivare le impostazioni di riparazione e upgrade automatici dalla riga di comando, utilizza i flag --no-enable-autoprovisioning-autorepair e --no-enable-autoprovisioning-autoupgrade:

  gcloud container clusters update CLUSTER_NAME \
      --location=CONTROL_PLANE_LOCATION \
      --enable-autoprovisioning \
      --no-enable-autoprovisioning-autorepair \
      --no-enable-autoprovisioning-autoupgrade
  

• Per modificare le impostazioni per la riparazione e l'upgrade automatici dei nodi utilizzando un file di configurazione, segui questi passaggi:

  1. Specifica i campi management.autoRepair e management.autoUpgrade nel file di configurazione:

     management:
       autoRepair: true
       autoUpgrade: true
     

     Se il file di configurazione contiene altre impostazioni, non modificarle. Eventuali modifiche o rimozioni nel file di configurazione modificano anche le impostazioni corrispondenti a livello di cluster.

  2. Fornisci il file di configurazione a GKE specificando il flag --autoprovisioning-config-file e il flag --enable-autoprovisioning per un cluster nuovo o esistente:

     gcloud container clusters create CLUSTER_NAME \
         --location=CONTROL_PLANE_LOCATION \
         --enable-autoprovisioning \
         --autoprovisioning-config-file=PATH_TO_CONFIGURATION_FILE
     

     Sostituisci quanto segue:

     • CLUSTER_NAME: il nome del cluster.
     • PATH_TO_CONFIGURATION_FILE: il percorso del file di configurazione.

Configura le impostazioni di upgrade con capacità aggiuntiva

Puoi specificare le impostazioni di upgrade con capacità aggiuntiva nei node pool creati automaticamente. Gli upgrade con capacità aggiuntiva sono la strategia di upgrade dei nodi predefinita di GKE. Per modificare le impostazioni degli upgrade di sovraccarico, devi configurare il provisioning automatico dei nodi a livello di cluster.

• Per specificare le impostazioni di upgrade con capacità aggiuntiva nella riga di comando, utilizza i flag --autoprovisioning-max-surge-upgrade e --autoprovisioning-max-unavailable-upgrade:

  gcloud container clusters update CLUSTER_NAME \
      --location=CONTROL_PLANE_LOCATION \
      --enable-autoprovisioning \
      --autoprovisioning-max-surge-upgrade=MAX_SURGE \
      --autoprovisioning-max-unavailable-upgrade=MAX_UNAVAILABLE
  

  Sostituisci quanto segue:

  • MAX_SURGE: il numero massimo di nodi che possono essere aggiunti al pool di nodi durante gli upgrade.
  • MAX_UNAVAILABLE: il numero massimo di nodi nel pool di nodi che possono non essere disponibili contemporaneamente durante gli upgrade.

• Per specificare le impostazioni di upgrade di sovraccarico utilizzando un file di configurazione, segui questi passaggi:

  1. Specifica i campi upgradeSettings.maxSurgeUpgrade e upgradeSettings.maxUnavailableUpgrade nel file di configurazione:

     upgradeSettings:
       maxSurgeUpgrade: MAX_SURGE
       maxUnavailableUpgrade: MAX_UNAVAILABLE
     

     Se il file di configurazione contiene altre impostazioni, non modificarle. Eventuali modifiche o rimozioni nel file di configurazione modificano anche le impostazioni corrispondenti a livello di cluster.

  2. Fornisci il file di configurazione a GKE specificando il flag --autoprovisioning-config-file e il flag --enable-autoprovisioning per un cluster nuovo o esistente:

     gcloud container clusters create CLUSTER_NAME \
         --location=CONTROL_PLANE_LOCATION \
         --enable-autoprovisioning \
         --autoprovisioning-config-file=PATH_TO_CONFIGURATION_FILE
     

     Sostituisci quanto segue:

     • CLUSTER_NAME: il nome del cluster.
     • PATH_TO_CONFIGURATION_FILE: il percorso del file di configurazione.

Le impostazioni di upgrade con capacità aggiuntiva specificate si applicano solo se il cluster utilizza gli upgrade con capacità aggiuntiva per eseguire l'upgrade dei node pool creati automaticamente. Per cambiare la strategia di upgrade dei nodi in upgrade di sovraccarico per i nuovi node pool creati automaticamente, esegui questo comando:

gcloud container clusters update CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --enable-autoprovisioning-surge-upgrade

Quando cambi la strategia di upgrade, GKE utilizza le impostazioni che hai configurato in precedenza per quella strategia.

Utilizza gli upgrade blu/verde per i nuovi node pool creati automaticamente

Puoi cambiare la strategia di upgrade dei nodi in upgrade blu/verde per tutti i nuovi node pool creati automaticamente e ottimizzare le impostazioni predefinite per gli upgrade blu/verde. Per modificare la strategia di upgrade, devi configurare il provisioning automatico dei nodi a livello di cluster. Le modifiche apportate si applicano solo ai nuovi pool di nodi creati automaticamente. Puoi anche aggiornare i node pool esistenti creati automaticamente per utilizzare gli upgrade blu/verde. Non puoi utilizzare gli upgrade blu/verde con scalabilità automatica (anteprima) con i node pool creati automaticamente.

• Per utilizzare gli upgrade blu/verde e le impostazioni predefinite di GKE per i nuovi node pool creati automaticamente, esegui questo comando:

  gcloud container clusters update CLUSTER_NAME \
      --location=CONTROL_PLANE_LOCATION
      --enable-autoprovisioning \
      --enable-autoprovisioning-blue-green-upgrade
  

• Per utilizzare gli upgrade blu/verde e configurare le tue impostazioni predefinite per i nuovi node pool creati automaticamente, esegui questo comando:

  gcloud container clusters update CLUSTER_NAME \
      --location=CONTROL_PLANE_LOCATION \
      --enable-autoprovisioning \
      --enable-autoprovisioning-blue-green-upgrade \
      --autoprovisioning-node-pool-soak-duration=NODE_POOL_SOAK_DURATION \
      --autoprovisioning-standard-rollout-policy=batch-node-count=BATCH_NODE_COUNT,batch-soak-duration=BATCH_SOAK_DURATION
  

  Sostituisci quanto segue:

  • NODE_POOL_SOAK_DURATION: la durata, in secondi, di attesa di GKE dopo lo svuotamento di tutti i batch di nodi nel pool blu prima di eliminarlo. Il valore predefinito è 3600.
  • BATCH_NODE_COUNT: il numero di nodi da svuotare in un batch durante la fase di svuotamento del pool blu. Il valore predefinito è 1. Se specifichi un valore pari a 0, GKE ignora la fase di svuotamento del pool blu.
  • BATCH_SOAK_DURATION: la durata, in secondi, per cui GKE attende l'avvio di un'operazione di svuotamento in batch dopo il completamento dell'operazione di svuotamento precedente. Il valore predefinito è 0.

Configura i dischi di avvio dei nodi personalizzati

Per specificare il tipo e le dimensioni dei dischi di avvio che GKE collega a ogni VM nodo in un pool di nodi creato automaticamente, seleziona una delle seguenti opzioni:

ComputeClass

1. Utilizza i campi bootDiskType e bootDiskSize nel campo spec.priorities.storage in una ComputeClass:

   apiVersion: cloud.google.com/v1
   kind: ComputeClass
   metadata:
     name: COMPUTE_CLASS
   spec:
     priorities:
     - machineType: n4-standard-16
       storage:
         bootDiskType: BOOT_DISK_TYPE
         bootDiskSize: BOOT_DISK_SIZE
     - machineType: n4d-standard-16
       storage:
         bootDiskType: BOOT_DISK_TYPE
         bootDiskSize: BOOT_DISK_SIZE
     whenUnsatisfiable: ScaleUpAnyway
     nodePoolAutoCreation:
       enabled: true
   

   Nota: per configurare l'impostazione bootDiskSize in una ComputeClass senza specificare i valori per i campi machineType o GPU, devi utilizzare GKE versione 1.34.1-gke.1431000 e successive.

   Sostituisci quanto segue:

   • BOOT_DISK_TYPE: il tipo di disco da utilizzare come disco di avvio del nodo. Il valore specificato deve essere supportato dal tipo di macchina Compute Engine utilizzato da GKE per la regola di priorità. Il valore deve essere uno dei seguenti:
     • pd-balanced: Balanced Persistent Disk.
     • pd-standard: Standard Persistent Disk.
     • pd-ssd: Persistent Disk SSD (prestazioni).
     • hyperdisk-balanced: Google Cloud Hyperdisk bilanciato.
   • BOOT_DISK_SIZE: le dimensioni, in GiB, del disco di avvio del nodo. Il valore minimo è 10.

2. Applica il manifest ComputeClass al cluster:

   kubectl apply -f PATH_TO_COMPUTECLASS_MANIFEST
   

   Sostituisci PATH_TO_COMPUTECLASS_MANIFEST con il percorso del file manifest ComputeClass.

gcloud

1. Nel file di configurazione, specifica i campi diskSizeGb e diskType:

   diskSizeGb: BOOT_DISK_SIZE
   diskType: BOOT_DISK_TYPE
   

   Sostituisci quanto segue:

   • BOOT_DISK_TYPE: il tipo di disco da utilizzare come disco di avvio del nodo. Il valore specificato deve essere supportato dal tipo di macchina Compute Engine utilizzato da GKE per la regola di priorità. Il valore deve essere uno dei seguenti:
     • pd-balanced: Balanced Persistent Disk.
     • pd-standard: Standard Persistent Disk.
     • pd-ssd: Persistent Disk SSD (prestazioni).
     • hyperdisk-balanced: Google Cloud Hyperdisk bilanciato.
   • BOOT_DISK_SIZE: le dimensioni, in GiB, del disco di avvio del nodo. Il valore minimo è 10.

   Se il file di configurazione contiene altre impostazioni, non modificarle. Eventuali modifiche o rimozioni nel file di configurazione modificano anche le impostazioni corrispondenti a livello di cluster.

2. Fornisci il file di configurazione a GKE specificando il flag --autoprovisioning-config-file e il flag --enable-autoprovisioning per un cluster nuovo o esistente:

   gcloud container clusters create CLUSTER_NAME \
       --location=CONTROL_PLANE_LOCATION \
       --enable-autoprovisioning \
       --autoprovisioning-config-file=PATH_TO_CONFIGURATION_FILE
   

   Sostituisci quanto segue:

   • CLUSTER_NAME: il nome del cluster.
   • PATH_TO_CONFIGURATION_FILE: il percorso del file di configurazione.

GKE riserva una parte del disco di avvio del nodo per le funzionalità di sistema e per l'archiviazione temporanea. Per saperne di più, consulta Archiviazione temporanea supportata dal disco di avvio del nodo.

Configura i node pool creati automaticamente per gli scenari comuni

Le sezioni seguenti mostrano come richiedere pool di nodi creati automaticamente per alcuni casi d'uso comuni di GKE. Per ulteriori informazioni su altri casi d'uso e configurazioni supportate, consulta la documentazione relativa al tuo caso d'uso specifico.

Seleziona una serie di macchine o un tipo di macchina

Per selezionare una serie di macchine o un tipo di macchina Compute Engine supportati, seleziona una delle seguenti opzioni:

ComputeClass

1. In un manifest ComputeClass, specifica uno dei seguenti campi nel campo spec.priorities. Puoi specificare entrambi i campi nello stesso manifest ComputeClass, ma non nella stessa regola di priorità.

   • Per selezionare una serie di macchine, specifica il campo machineFamily in una regola di priorità:

     apiVersion: cloud.google.com/v1
     kind: ComputeClass
     metadata:
       name: COMPUTE_CLASS
     spec:
       priorities:
       - machineFamily: MACHINE_SERIES
       whenUnsatisfiable: ScaleUpAnyway
       nodePoolAutoCreation:
         enabled: true
     

     Sostituisci MACHINE_SERIES con una serie di macchine Compute Engine, ad esempio n4.

   • Per selezionare un tipo di macchina, specifica il campo machineType in una regola di priorità:

     apiVersion: cloud.google.com/v1
     kind: ComputeClass
     metadata:
       name: COMPUTE_CLASS
     spec:
       priorities:
       - machineType: MACHINE_TYPE
       whenUnsatisfiable: ScaleUpAnyway
       nodePoolAutoCreation:
         enabled: true
     

     Sostituisci MACHINE_TYPE con un tipo di macchina Compute Engine, ad esempio c4-standard-96. In GKE versione 1.33.2-gke.1111000 e successive, puoi anche specificare tipi di macchine personalizzate in questo campo.

   Non puoi specificare il campo machineFamily e il campo machineType nella stessa regola di priorità.

2. Applica il manifest ComputeClass al cluster:

   kubectl apply -f PATH_TO_COMPUTECLASS_MANIFEST
   

   Sostituisci PATH_TO_COMPUTECLASS_MANIFEST con il percorso del file manifest ComputeClass.

3. Seleziona ComputeClass in un workload.

Specifica pod

1. In un manifest del pod, seleziona una delle seguenti etichette dei nodi:

   • Per selezionare una serie di macchine, utilizza l'etichetta del nodo cloud.google.com/machine-family:

     apiVersion: v1
     kind: Pod
     metadata:
       name: machine-series-pod
     spec:
       nodeSelector:
         cloud.google.com/machine-family: MACHINE_SERIES
       containers:
       - name: hello-app
         image: us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0
     

     Sostituisci MACHINE_SERIES con una serie di macchine Compute Engine, ad esempio n4.

   • Per selezionare un tipo di macchina predefinita, utilizza le etichette dei nodi cloud.google.com/machine-family e node.kubernetes.io/instance-type:

     apiVersion: v1
     kind: Pod
     metadata:
       name: machine-series-pod
     spec:
       nodeSelector:
         cloud.google.com/machine-family: MACHINE_SERIES
         node.kubernetes.io/instance-type: MACHINE_TYPE
       containers:
       - name: hello-app
         image: us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0
     

     Sostituisci MACHINE_TYPE con un tipo di macchina Compute Engine nella serie di macchine specificata. Ad esempio, se specifichi n4 per MACHINE_SERIES, puoi specificare n4-standard-80 per MACHINE_TYPE.

     In GKE versione 1.33.2-gke.1111000, puoi anche specificare tipi di macchine personalizzate in questo campo.

2. Crea il pod:

   kubectl apply -f PATH_TO_POD_MANIFEST
   

   Sostituisci PATH_TO_POD_MANIFEST con il percorso del manifest del pod.

Seleziona le GPU

Per richiedere GPU per i node pool creati automaticamente, seleziona una delle seguenti opzioni:

ComputeClass

1. In un manifest ComputeClass, specifica il campo spec.priorities.gpu:

   apiVersion: cloud.google.com/v1
   kind: ComputeClass
   metadata:
     name: COMPUTE_CLASS
   spec:
     priorities:
     - gpu:
         type: GPU_TYPE
         count: GPU_COUNT
         driverVersion: DRIVER_VERSION
     whenUnsatisfiable: DoNotScaleUp
     nodePoolAutoCreation:
       enabled: true
   

   Sostituisci quanto segue:

   • GPU_TYPE: il tipo di GPU da collegare, ad esempio nvidia-l4.
   • GPU_COUNT: il numero di GPU da collegare a ogni nodo. Questo valore deve essere almeno 1.
   • DRIVER_VERSION: la versione del driver della GPU da installare. Questo valore deve essere default o latest. Questo campo richiede GKE versione 1.31.1-gke.1858000 o successiva.

2. Applica il manifest ComputeClass al cluster:

   kubectl apply -f PATH_TO_COMPUTECLASS_MANIFEST
   

   Sostituisci PATH_TO_COMPUTECLASS_MANIFEST con il percorso del file manifest ComputeClass.

3. Seleziona la classe ComputeClass in un workload GPU, come nell'esempio seguente:

   apiVersion: v1
   kind: Pod
   metadata:
     name: my-gpu-pod
   spec:
     nodeSelector:
       cloud.google.com/compute-class: nvidia-l4-class
     containers:
     - name: my-gpu-container
       image: nvidia/cuda:11.0.3-runtime-ubuntu20.04
       command: ["/bin/bash", "-c", "--"]
       args: ["while true; do sleep 600; done;"]
       resources:
         limits:
         nvidia.com/gpu: 1
   

Specifica pod

Per selezionare le GPU nelle specifiche dei pod, devi configurare il provisioning automatico dei nodi a livello di cluster e impostare i limiti delle risorse per quel tipo di GPU. Per configurare i limiti delle risorse GPU e selezionare le GPU nei pod, segui questi passaggi:

1. Configura i limiti delle risorse a livello di cluster per le GPU che vuoi utilizzare, come descritto nella sezione Configura i limiti delle risorse per la creazione automatica dei pool di nodi.

2. Seleziona le GPU utilizzando le etichette dei nodi nella specifica del pod:

   apiVersion: v1
   kind: Pod
   metadata:
     name: my-gpu-pod
   spec:
     nodeSelector:
       cloud.google.com/gke-accelerator: GPU_TYPE
       cloud.google.com/gke-accelerator-count: GPU_COUNT
       cloud.google.com/gke-gpu-driver-version: DRIVER_VERSION
     containers:
     - name: my-gpu-container
       image: nvidia/cuda:11.0.3-runtime-ubuntu20.04
       command: ["/bin/bash", "-c", "--"]
       args: ["while true; do sleep 600; done;"]
       resources:
         limits:
         nvidia.com/gpu: GPU_QUANTITY
   

   Sostituisci quanto segue:

   • GPU_TYPE: il tipo di GPU da collegare, ad esempio nvidia-l4.
   • GPU_COUNT: il numero di GPU da collegare a ogni nodo. Questo valore deve essere almeno 1.
   • DRIVER_VERSION: la versione del driver della GPU da installare. Questo valore deve essere default o latest. In GKE versione 1.32.2-gke.1297000 e successive, GKE installa automaticamente la versione del driver default. Questa etichetta del nodo richiede GKE versione 1.29.2-gke.1108000 o successiva. Per saperne di più, consulta Installazione dei driver utilizzando il provisioning automatico dei nodi con GPU.
   • GPU_QUANTITY: il numero di GPU da collegare al pod. Questo valore deve essere inferiore o uguale al valore di GPU_COUNT.

Seleziona le TPU

Puoi richiedere TPU nelle specifiche di ComputeClasses o dei pod. Questa sezione presuppone che tu abbia familiarità con la selezione di Cloud TPU e che tu conosca il tipo, la topologia e il conteggio della TPU che vuoi utilizzare. I passaggi da seguire dipendono da come selezioni le TPU:

• ComputeClasses: consulta Esegui il provisioning delle TPU utilizzando classi di computing personalizzate.
• Specifica del pod:
  1. Configura i limiti delle risorse a livello di cluster per le TPU che vuoi utilizzare, come descritto nella sezione Configura i limiti delle risorse per la creazione automatica dei node pool.
  2. Configura i selettori e le richieste di risorse nelle specifiche dei pod, come descritto in Esegui il workload sui nodi di sezioni TPU.

Limita il tempo di esecuzione dei nodi creati automaticamente

Puoi specificare una durata massima dopo la quale GKE termina i nodi creati automaticamente. A questo limite di tempo si applicano le limitazioni di Compute Engine.

Seleziona una delle seguenti opzioni:

ComputeClass

1. In un manifest ComputeClass, utilizza il campo spec.priorities.maxRunDurationSeconds. Questo campo è disponibile in GKE versione 1.32.1-gke.1159000 e successive.

   apiVersion: cloud.google.com/v1
   kind: ComputeClass
   metadata:
     name: COMPUTE_CLASS
   spec:
     priorities:
     - machine-family: n4
       maxRunDurationSeconds: MAX_RUN_DURATION
     whenUnsatisfiable: DoNotScaleUp
     nodePoolAutoCreation:
       enabled: true
   

   Sostituisci MAX_RUN_DURATION con il tempo, in secondi, per cui i nodi creati automaticamente possono essere eseguiti prima che GKE li termini.

2. Applica il manifest ComputeClass al cluster:

   kubectl apply -f PATH_TO_COMPUTECLASS_MANIFEST
   

   Sostituisci PATH_TO_COMPUTECLASS_MANIFEST con il percorso del file manifest ComputeClass.

3. Seleziona ComputeClass in un workload.

Specifica pod

1. Nel manifest del pod, utilizza un selettore di nodi per l'etichetta del nodo cloud.google.com/gke-max-run-duration-seconds. Questa etichetta del nodo è disponibile in GKE versione 1.31.2-gke.1518000 e successive.

   apiVersion: v1
   kind: Pod
   metadata:
     name: machine-series-pod
   spec:
     nodeSelector:
       cloud.google.com/machine-family: n4
       cloud.google.com/gke-max-run-duration-seconds: MAX_RUN_DURATION
     containers:
     - name: hello-app
       image: us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0
   

   Sostituisci MAX_RUN_DURATION con il tempo, in secondi, per cui i nodi creati automaticamente possono essere eseguiti prima che GKE li termini.

2. Crea il pod:

   kubectl apply -f PATH_TO_POD_MANIFEST
   

   Sostituisci PATH_TO_POD_MANIFEST con il percorso del manifest del pod.

Specifica una piattaforma CPU minima

Il provisioning automatico dei nodi supporta la creazione di pool di nodi con una piattaforma CPU minima specificata. Puoi specificare la piattaforma CPU minima a livello di workload (consigliato) o di cluster.

Disabilita la creazione automatica dei pool di nodi

Le sezioni seguenti mostrano come disattivare la creazione automatica dei pool di nodi per pool di nodi specifici o per l'intero cluster. Puoi anche disattivare la creazione automatica pool di nodi in una ComputeClass specificando un valore false nel campo nodePoolAutoCreation.enabled della ComputeClass. Tuttavia, non ti consigliamo di disattivare la creazione automatica per le classi di computing, perché è un vantaggio principale delle classi di computing che ti consente di utilizzare funzionalità come la migrazione attiva e le priorità di riserva.

Disabilita la creazione automatica per pool di nodi specifici

Puoi impedire a GKE di gestire i nodi nei node pool esistenti creati automaticamente. Questa azione ha i seguenti effetti:

• Il gestore della scalabilità automatica dei cluster interrompe la creazione o l'eliminazione dei nodi nel pool di nodi. Se vuoi che GKE esegua la scalabilità automatica dei nodi, puoi attivare separatamente il gestore della scalabilità automatica dei cluster per quel node pool.
• GKE non elimina il pool di nodi quando il numero di nodi è pari a zero.
• GKE continua a posizionare i pod in attesa sui nodi esistenti nel pool di nodi che hanno disponibilità. Se il provisioning automatico dei nodi è ancora abilitato per il cluster, GKE può anche creare nuovi pool di nodi per i pod in attesa, se necessario.

Per disattivare la creazione automatica per un pool di nodi specifico, esegui questo comando:

gcloud container node-pools update NODE_POOL_NAME \
    --cluster=CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --no-enable-autoprovisioning

Disabilita il provisioning automatico dei nodi per il cluster

Puoi disattivare la creazione automatica dei pool di nodi per l'intero cluster disattivando l'impostazione del cluster di provisioning automatico dei nodi. Questa azione ha i seguenti effetti:

• Il gestore della scalabilità automatica dei cluster interrompe la creazione e l'eliminazione dei nodi nei pool di nodi esistenti creati automaticamente. I node pool creati manualmente che utilizzano il gestore della scalabilità automatica dei cluster non sono interessati.
• GKE non crea automaticamente nuovi node pool per i workload in attesa. Monitora il cluster per evitare pod bloccati.

• Se il cluster soddisfa i seguenti requisiti, GKE continua a creare nuovi pool di nodi per le classi di computing che abilitano la creazione automatica:

  • Utilizza GKE 1.33.3-gke.1136000 o versioni successive.

  Se il cluster non soddisfa questi requisiti, GKE non crea nuovi node pool per le classi di computing che abilitano la creazione automatica.

Se riattivi l'impostazione di provisioning automatico dei nodi a livello di cluster in un secondo momento, GKE non riattiva la creazione automatica dei node pool esistenti. Devi contrassegnare i singoli pool di nodi come creati automaticamente.

Per disattivare l'impostazione di provisioning automatico dei nodi a livello di cluster, seleziona una delle seguenti opzioni:

Console

1. Nella console Google Cloud , vai alla pagina Cluster Kubernetes:

   Vai ai cluster Kubernetes

2. Fai clic sul nome del cluster da modificare. Viene visualizzata la pagina Dettagli cluster.

3. Fai clic sulla scheda Dettagli.

4. Nella sezione Automazione, nella riga Provisioning automatico dei nodi, fai clic su Modifica. Viene visualizzato il riquadro Modifica provisioning automatico dei nodi.

5. Deseleziona la casella di controllo Abilita provisioning automatico dei nodi.

6. Fai clic su Salva modifiche.

gcloud

gcloud container clusters update CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --no-enable-autoprovisioning

Passaggi successivi

• Scopri di più sul gestore della scalabilità automatica dei cluster.
• Scopri di più sui pool di nodi.
• Scopri di più sulle strategie di upgrade dei nodi.
• Esegui il deployment di un cluster con il provisioning automatico dei nodi in Cluster Toolkit.