Esegui carichi di lavoro Autopilot nei cluster GKE Standard

Gli amministratori dei cluster e gli operatori delle applicazioni possono usufruire dei vantaggi di Google Kubernetes Engine (GKE) Autopilot, come prezzi e impostazioni preconfigurate, nei cluster in modalità Standard. Questa pagina mostra come utilizzare ComputeClasses per eseguire il deployment di un workload Autopilot in un cluster Standard. Dovresti già avere familiarità con i seguenti concetti:

Informazioni sulle classi di computing Autopilot

GKE fornisce risorse personalizzate di Kubernetes denominate ComputeClasses che possono essere implementate nel cluster come qualsiasi altra risorsa Kubernetes. Una ComputeClass definisce un elenco di configurazioni dei nodi, come i tipi di macchine o le VM spot. Puoi selezionare ComputeClass nei tuoi carichi di lavoro, il che indica a GKE che tutti i nuovi nodi devono utilizzare una delle configurazioni nell'elenco.

Se un carico di lavoro seleziona una ComputeClass con il campo autopilot abilitato, GKE esegue i pod in modalità Autopilot. I nodi creati da GKE sono gestiti da Google e includono molte delle impostazioni di sicurezza e delle funzionalità Autopilot predefinite. Per ulteriori informazioni sulle implicazioni dell'esecuzione di un workload Autopilot nei cluster Standard, incluse le differenze che potresti notare quando esegui il deployment di questi workload, consulta Informazioni sui workload in modalità Autopilot in GKE Standard.

Tipi di classi di computing Autopilot

GKE fornisce ComputeClass Autopilot integrate che puoi utilizzare per la maggior parte dei carichi di lavoro generici. Puoi anche configurare una classe Compute personalizzata nuova o esistente per utilizzare la modalità Autopilot. Il tipo di ComputeClass Autopilot che utilizzi dipende dal fatto che i tuoi carichi di lavoro richiedano hardware specifico, come segue:

  • Carichi di lavoro generici: utilizza una delle ComputeClass Autopilot integrate, che posizionano i pod sulla piattaforma di calcolo ottimizzata per i container.
  • Carichi di lavoro che richiedono hardware specifico: abilita la modalità Autopilot per qualsiasi ComputeClass personalizzata, esegui il deployment di ComputeClass nel cluster e seleziona ComputeClass nei tuoi carichi di lavoro.

Per ulteriori informazioni su queste opzioni, su quando utilizzarle e sui prezzi per ciascuna opzione, consulta Selezione dell'hardware nelle classi di computing Autopilot.

Prezzi

I prezzi di GKE Autopilot si applicano ai carichi di lavoro e ai nodi che utilizzano una ComputeClass Autopilot. Il modello di prezzi applicabile dipende dal fatto che utilizzi una classe di computing Autopilot integrata o una classe di computing Autopilot personalizzata. Per ulteriori informazioni, consulta Prezzi in "Informazioni sui workload in modalità Autopilot in GKE Standard".

Prima di iniziare

Prima di iniziare, assicurati di aver eseguito le seguenti operazioni:

  • Attiva l'API Google Kubernetes Engine.
    • Attiva l'API Google Kubernetes Engine
  • Se vuoi utilizzare Google Cloud CLI per questa attività, installala e poi inizializza gcloud CLI. Se hai già installato gcloud CLI, scarica l'ultima versione eseguendo gcloud components update.

Requisiti

  • Almeno un pool di nodi nel cluster non deve avere taint dei nodi.

    Questo pool di nodi è necessario per eseguire i pod di sistema GKE Standard che non possono essere eseguiti sui nodi Autopilot nei cluster Standard a causa dei taint che GKE aggiunge a questi nodi.

  • Shielded GKE Nodes è obbligatorio ed è abilitato per impostazione predefinita.

  • Devi utilizzare un cluster nativo di VPC.

Limitazioni

  • È supportato solo il canale di rilascio rapido.
  • Per aggiornare le risorse ComputeClass esistenti nel cluster in modo che utilizzino la modalità Autopilot, devi ricreare ComputeClass con una specifica aggiornata. Per saperne di più, consulta Abilitare Autopilot per una classe di computing personalizzata esistente.
  • Non puoi utilizzare la regola di priorità podFamily nel tuo ComputeClasses. Questa regola è disponibile solo nelle ComputeClass Autopilot integrate.
  • Le ComputeClass Autopilot integrate non supportano l'attivazione dei nodi GKE confidenziali per l'intero cluster. Se abiliti Confidential GKE Nodes per il cluster, tutti i nuovi pod che selezionano le ComputeClass Autopilot integrate rimangono nello stato Pending indefinitamente.

Ruoli e autorizzazioni richiesti

Per ottenere le autorizzazioni necessarie per eseguire il deployment di ComputeClass, chiedi all'amministratore di concederti il ruolo IAM Kubernetes Engine Developer (roles/container.developer) nel cluster o nel progetto . Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

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

Seleziona una classe di computing Autopilot in un workload

Per selezionare una classe di computing Autopilot in un workload, utilizza un selettore di nodi per l'etichetta cloud.google.com/compute-class. Si tratta della stessa etichetta che utilizzi per selezionare qualsiasi altra ComputeClass in GKE. I seguenti passaggi mostrano come creare un deployment di esempio che seleziona una ComputeClass e verificare che i pod vengano eseguiti in modalità Autopilot:

  1. Salva il seguente esempio di deployment come autopilot-cc-deployment.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: "4Gi"

    Sostituisci COMPUTE_CLASS con il nome della classe di calcolo da utilizzare. Questo valore può essere uno dei seguenti:

  2. Esegui il deployment del carico di lavoro:

    kubectl apply -f autopilot-cc-deployment.yaml

  3. Per verificare che i pod utilizzino Autopilot, controlla i nomi dei nodi host:

    kubectl get pods -l=app=hello -o wide

    L'output è simile al seguente:

    NAME                       READY   STATUS    RESTARTS   AGE     IP             NODE                                         NOMINATED NODE   READINESS GATES
helloweb-79b9f6f75-5wwc9   1/1     Running   0          152m    10.102.1.135   gk3-cluster-1-nap-10abc8ya1-f66c6cef-wg5g   <none>           <none>
helloweb-79b9f6f75-9skb9   1/1     Running   0          4d3h    10.102.0.140   gk3-cluster-1-nap-10abc8ya1-632bac02-hjl6   <none>           <none>
helloweb-79b9f6f75-h7bdv   1/1     Running   0          152m    10.102.1.137   gk3-cluster-1-nap-10abc8ya1-f66c6cef-wg5g   <none>           <none>

    In questo output, il prefisso gk3- nella colonna Nodo indica che il nodo è gestito da Autopilot.

Configura una classe di computing Autopilot personalizzata

Puoi configurare ComputeClass personalizzate per utilizzare Autopilot. Utilizza una ComputeClass Autopilot personalizzata se i tuoi carichi di lavoro richiedono hardware specifico per essere eseguiti in modo ottimale, come GPU o una determinata serie di macchine Compute Engine.

Se i tuoi carichi di lavoro non richiedono hardware specifico, ti consigliamo di utilizzare una delle ComputeClass Autopilot integrate. Per selezionare una ComputeClass Autopilot integrata, consulta la sezione Selezionare una ComputeClass Autopilot in un workload precedente.

Crea una nuova ComputeClass Autopilot personalizzata

  1. Salva il seguente manifest di ComputeClass come autopilot-n2-class.yaml:

    apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: autopilot-n2-class
spec:
  autopilot:
    enabled: true
  priorities:
  - machineFamily: n2
    spot: true
    minCores: 64
  - machineFamily: n2
    spot: true
  - machineFamily: n2
    spot: false
  activeMigration:
    optimizeRulePriority: true
  whenUnsatisfiable: DoNotScaleUp

    Questo manifest include i seguenti campi:

    • autopilot: attiva la modalità Autopilot per ComputeClass. Se specifichi questo campo in una ComputeClass di cui esegui il deployment in un cluster Autopilot, GKE lo ignora.
    • priorities: definisce un array di tre diverse configurazioni della famiglia di macchine N2.
    • activeMigration: consente a GKE di eseguire la migrazione dei pod a configurazioni con priorità più alta nell'elenco quando le risorse diventano disponibili.
    • whenUnsatisfiable: il valore di DoNotScaleUp in questo campo rende obbligatorio per GKE utilizzare una delle regole nel campo priorities per i nuovi nodi. Se nessuna di queste regole di priorità può essere soddisfatta, GKE lascia il pod nello stato Pending finché non sono disponibili risorse. DoNotScaleUp è il valore predefinito e consigliato per questo campo.

  2. Esegui il deployment di ComputeClass:

    kubectl apply -f autopilot-n2-class.yaml

  3. Verifica che ComputeClass esista:

    kubectl get computeclasses

    L'output è simile al seguente:

    NAME                  AGE
autopilot-n2-class    3s

Abilitare Autopilot per una ComputeClass personalizzata esistente

Puoi abilitare Autopilot nelle ComputeClass personalizzate esistenti che si trovano in un cluster Standard e hanno il campo nodePoolAutoCreation.enabled nella specifica impostato su true. L'attivazione di Autopilot in una classe di computing che si trova in un cluster Autopilot non ha alcun effetto, perché l'intero cluster utilizza la modalità Autopilot.

Dopo aver abilitato Autopilot per una ComputeClass esistente, GKE utilizza Autopilot per eseguire i nuovi pod che selezionano la ComputeClass. Se hai pod esistenti sui nodi Standard che selezionano la classe di computing Autopilot, questi pod utilizzano Autopilot solo quando vengono ricreati.

Per aggiornare una ComputeClass personalizzata esistente in modo da utilizzare la modalità Autopilot, segui questi passaggi:

  1. In un editor di testo, aggiorna il file manifest per la ComputeClass esistente per aggiungere il campo spec.autopilot:

    spec:
  autopilot:
    enabled: true

  2. Sostituisci la risorsa ComputeClass esistente nell'API Kubernetes con la specifica aggiornata:

    kubectl replace --force -f PATH_TO_UPDATED_MANIFEST

    Sostituisci PATH_TO_UPDATED_MANIFEST con il percorso del file manifest aggiornato.

  3. Per attivare la creazione di nuovi nodi, ricrea tutti i carichi di lavoro che utilizzano la classe di calcolo.

Dopo aver applicato il manifest aggiornato, tutti i nuovi nodi che GKE crea per questa ComputeClass utilizzano Autopilot. GKE non modifica i nodi esistenti creati prima dell'aggiornamento.

Verifica che il tuo workload utilizzi Autopilot

  • Ottieni un elenco dei pod nel cluster utilizzando il comando kubectl get:

    kubectl get pods --output=custom-columns=Pod:.metadata.name,Node:.spec.nodeName

    L'output è simile al seguente:

    Pod                         Node
helloweb-84c865764b-nzhxt   gk3-cluster-1-pool-3-68fc8dca-t54b
# lines omitted for clarity

    Il prefisso gk3- nel nome del nodo indica che il pod è in esecuzione in modalità Autopilot.

Applica una classe di computing Autopilot per impostazione predefinita

GKE ti consente di impostare un oggetto ComputeClass come predefinito per uno spazio dei nomi. La classe predefinita dello spazio dei nomi si applica a tutti i pod in quello spazio dei nomi che non selezionano esplicitamente una ComputeClass diversa. Se imposti una ComputeClass Autopilot come predefinita, puoi eseguire tutti i pod in uno spazio dei nomi in modalità Autopilot per impostazione predefinita, a meno che il workload non selezioni un'opzione diversa.

Per maggiori informazioni, vedi Configurare una ComputeClass predefinita per uno spazio dei nomi.

Passaggi successivi