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. Questo documento 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 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 il comando gcloud components update. Le versioni precedenti di gcloud CLI potrebbero non supportare l'esecuzione dei comandi in questo documento.

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.

  • Se utilizzi Kubernetes NetworkPolicies, il cluster deve utilizzare GKE Dataplane V2. Per impostazione predefinita, tutti i nuovi cluster utilizzano GKE Dataplane V2.

    Se il tuo cluster non utilizza GKE Dataplane V2, devi disattivare l'applicazione delle policy di rete.

Limitazioni

  • È supportato solo il canale di rilascio rapido.
  • Per aggiornare le ComputeClass esistenti nel cluster in modo che utilizzino la modalità Autopilot, devi ricrearle 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 nella tua 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.
  • L'applicazione dei criteri di rete Calico non è supportata. Devi utilizzare GKE Dataplane V2 o disattivare l'applicazione dei criteri di rete.
  • Il nome di ComputeClass non può iniziare con gke o autopilot, che sono prefissi riservati.

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: "1Gi"

    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 n4-class.yaml:

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

    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 N4.
    • activeMigration: consente a GKE di eseguire la migrazione dei pod a configurazioni con priorità più alta nell'elenco quando le risorse diventano disponibili.

  2. Esegui il deployment di ComputeClass:

    kubectl apply -f n4-class.yaml

  3. Verifica che ComputeClass esista:

    kubectl get computeclasses

    L'output è simile al seguente:

    NAME                  AGE
n4-class              3s

Abilitare Autopilot per una ComputeClass personalizzata esistente

Puoi abilitare Autopilot nelle ComputeClass personalizzate esistenti che si trovano in un cluster Standard. L'abilitazione di Autopilot in una ComputeClass 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