Esegui il deployment di un sistema batch utilizzando Kueue

Autopilot Standard

---

Questo tutorial mostra come eseguire il deployment di un sistema batch utilizzando Kueue, un programmatore di job cloud-native per eseguire l'accodamento dei job su Google Kubernetes Engine (GKE). Completa questo tutorial per scoprire come configurare GKE e Kueue per eseguire i job in ordine di arrivo (FIFO).

Sfondo

I job sono applicazioni che vengono eseguite fino al completamento, ad esempio machine learning, rendering, simulazione, analisi, CI/CD e carichi di lavoro simili.

Kueue è un programma di pianificazione dei job cloud-native che funziona con il programma di pianificazione Kubernetes predefinito, il controller dei job e il gestore della scalabilità automatica del cluster per fornire un sistema batch end-to-end. Kueue implementa la coda dei job, decidendo quando devono attendere e quando devono iniziare, in base alle quote e a una gerarchia per la condivisione delle risorse in modo equo tra i team.

Kueue presenta le seguenti caratteristiche:

• È ottimizzato per le architetture cloud, in cui le risorse sono eterogenee, intercambiabili e scalabili.
• Fornisce un insieme di API per gestire le quote elastiche e la coda dei job.
• Non reimplementa funzionalità esistenti come l'autoscaling, la programmazione dei pod o la gestione del ciclo di vita dei job.
• Kueue supporta l'API Kubernetesbatch/v1.Job integrata.
• Può essere integrato con altre API di job.

Kueue si riferisce ai job definiti con qualsiasi API come Workload, per evitare confusione con l'API Job Kubernetes specifica.

Obiettivi

Questo tutorial è rivolto agli operatori di cluster e ad altri utenti che vogliono implementare un sistema batch su Kubernetes. In questo tutorial, configuri un cluster condiviso per due team di tenant. Ogni team ha il proprio spazio dei nomi in cui creare job e condividere le stesse risorse globali controllate con le quote corrispondenti.

Questo tutorial illustra i seguenti passaggi:

1. Crea un cluster GKE
2. Crea ResourceFlavor
3. Crea ClusterQueue
4. Crea LocalQueue
5. Crea job e osserva i workload ammessi

Costi

Questo tutorial utilizza i seguenti componenti fatturabili di Google Cloud:

• GKE

Utilizza il Calcolatore prezzi per generare una stima dei costi in base all'utilizzo previsto.

Al termine di questo tutorial, evita la fatturazione continua eliminando le risorse che hai creato. Per ulteriori informazioni, vedi Pulizia.

Prima di iniziare

Configura il progetto

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. In the Google Cloud console, on the project selector page, click Create project to begin creating a new Google Cloud project.

   Go to project selector

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

4. Enable the GKE API.

   Enable the API

5. In the Google Cloud console, on the project selector page, click Create project to begin creating a new Google Cloud project.

   Go to project selector

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

7. Enable the GKE API.

   Enable the API

Impostare i valori predefiniti per Google Cloud CLI

1. Nella console Google Cloud, avvia un'istanza Cloud Shell:
   Apri Cloud Shell

2. Scarica il codice sorgente di questa app di esempio:

   git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
   cd kubernetes-engine-samples/batch/kueue-intro
   

3. Imposta le variabili di ambiente predefinite:

   gcloud config set project PROJECT_ID
   gcloud config set compute/region COMPUTE_REGION
   

   Sostituisci i seguenti valori:

   • PROJECT_ID: il tuo ID progetto Google Cloud.
   • COMPUTE_REGION: la regione Compute Engine.

Crea un cluster GKE

1. Crea un cluster GKE Autopilot denominato kueue-autopilot:

   gcloud container clusters create-auto kueue-autopilot \
     --release-channel "rapid" --region COMPUTE_REGION
   

   I cluster Autopilot sono completamente gestiti e dispongono della scalabilità automatica integrata. Scopri di più su GKE Autopilot.

   Kueue supporta anche GKE Standard con il provisioning automatico dei nodi e i pool di nodi con scalabilità automatica regolari.

   Nota: la creazione del cluster Autopilot può richiedere fino a cinque minuti.

   Una volta creato il cluster, il risultato è simile al seguente:

     NAME: kueue-autopilot
     LOCATION: us-central1
     MASTER_VERSION: 1.26.2-gke.1000
     MASTER_IP: 35.193.173.228
     MACHINE_TYPE: e2-medium
     NODE_VERSION: 1.26.2-gke.1000
     NUM_NODES: 3
     STATUS: RUNNING
   

   Dove STATUS è RUNNING per kueue-autopilot.

2. Recupera le credenziali di autenticazione per il cluster:

   gcloud container clusters get-credentials kueue-autopilot
   

3. Installa Kueue sul cluster:

   VERSION=VERSION
   kubectl apply --server-side -f \
     https://github.com/kubernetes-sigs/kueue/releases/download/$VERSION/manifests.yaml
   

   Sostituisci VERSION con la versione più recente di Kueue. Per ulteriori informazioni sulle versioni di Kueue, consulta Uscite di Kueue.

4. Attendi che i pod Kueue siano pronti:

   watch kubectl -n kueue-system get pods
   

   Prima di poter continuare, l'output dovrebbe essere simile al seguente:

   NAME                                        READY   STATUS    RESTARTS   AGE
   kueue-controller-manager-66d8bb946b-wr2l2   2/2     Running   0          3m36s
   

   Nota: questo passaggio potrebbe richiedere fino a tre minuti.

5. Crea due nuovi spazi dei nomi denominati team-a e team-b:

   kubectl create namespace team-a
   kubectl create namespace team-b
   

Crea la risorsa ResourceFlavor

Un ResourceFlavor è un oggetto che rappresenta le variazioni dei nodi disponibili nel cluster associandole a etichette e contaminazioni dei nodi. Ad esempio, puoi utilizzare ResourceFlavors per rappresentare VM con diverse garanzie di provisioning (ad esempio, on demand rispetto a spot), architetture (ad esempio, CPU x86 rispetto a ARM), brand e modelli (ad esempio, GPU Nvidia A100 rispetto a T4).

In questo tutorial, il cluster kueue-autopilot ha risorse omogenee. Di conseguenza, crea un singolo ResourceFlavor per CPU, memoria, archiviazione temporanea e GPU, senza etichette o contaminazioni.

apiVersion: kueue.x-k8s.io/v1beta1
kind: ResourceFlavor
metadata:
  name: default-flavor # This ResourceFlavor will be used for all the resources

Esegui il deployment di ResourceFlavor:

kubectl apply -f flavors.yaml

Crea ClusterQueue

Un ClusterQueue è un oggetto con ambito a livello di cluster che gestisce un pool di risorse come CPU, memoria e GPU. Gestisce le risorse Flavor, limita l'utilizzo e determina l'ordine in cui vengono ammessi i carichi di lavoro.

apiVersion: kueue.x-k8s.io/v1beta1
kind: ClusterQueue
metadata:
  name: cluster-queue
spec:
  namespaceSelector: {} # Available to all namespaces
  queueingStrategy: BestEffortFIFO # Default queueing strategy
  resourceGroups:
  - coveredResources: ["cpu", "memory", "nvidia.com/gpu", "ephemeral-storage"]
    flavors:
    - name: "default-flavor"
      resources:
      - name: "cpu"
        nominalQuota: 10
      - name: "memory"
        nominalQuota: 10Gi
      - name: "nvidia.com/gpu"
        nominalQuota: 10
      - name: "ephemeral-storage"
        nominalQuota: 10Gi

Esegui il deployment di ClusterQueue:

kubectl apply -f cluster-queue.yaml

L'ordine di consumo è determinato da .spec.queueingStrategy, dove sono presenti due configurazioni:

• BestEffortFIFO

  • La configurazione predefinita della strategia di coda.
  • L'ammissione del carico di lavoro segue la regola first in first out (FIFO), ma se non è disponibile una quota sufficiente per ammettere il carico di lavoro all'inizio della coda, viene provato quello successivo in linea.

• StrictFIFO

  • Garantisce la semantica FIFO.
  • Il carico di lavoro all'inizio della coda può bloccare la coda finché non può essere accettato.

In cluster-queue.yaml, crea una nuova coda ClusterQueue denominata cluster-queue. Questo ClusterQueue gestisce quattro risorse, cpu, memory, nvidia.com/gpu e ephemeral-storage con il flavor creato in flavors.yaml. La quota viene consumata dalle richieste nelle specifiche del pod del workload.

Ogni versione include limiti di utilizzo rappresentati come .spec.resourceGroups[].flavors[].resources[].nominalQuota. In questo caso, ClusterQueue ammette i carichi di lavoro se e solo se:

• La somma delle richieste della CPU è inferiore o uguale a 10
• La somma delle richieste di memoria è inferiore o uguale a 10 GB
• La somma delle richieste di GPU è inferiore o uguale a 10
• La somma dello spazio di archiviazione utilizzato è inferiore o uguale a 10 GB

Crea la coda locale

Una coda locale è un oggetto con spazio dei nomi che accetta i workload dagli utenti nello spazio dei nomi. Le code locali di spazi dei nomi diversi possono puntare allo stesso ClusterQueue, dove possono condividere la quota delle risorse. In questo caso, LocalQueue dello spazio dei nomi team-a e team-b punta allo stesso ClusterQueue cluster-queue in .spec.clusterQueue.

apiVersion: kueue.x-k8s.io/v1beta1
kind: LocalQueue
metadata:
  namespace: team-a # LocalQueue under team-a namespace
  name: lq-team-a
spec:
  clusterQueue: cluster-queue # Point to the ClusterQueue
---
apiVersion: kueue.x-k8s.io/v1beta1
kind: LocalQueue
metadata:
  namespace: team-b # LocalQueue under team-b namespace
  name: lq-team-b
spec:
  clusterQueue: cluster-queue # Point to the ClusterQueue

Ogni team invia i propri carichi di lavoro alla coda locale nel proprio spazio dei nomi. A cui vengono poi allocate le risorse da ClusterQueue.

Esegui il deployment di LocalQueues:

kubectl apply -f local-queue.yaml

Crea job e osserva i workload ammessi

apiVersion: batch/v1
kind: Job
metadata:
  namespace: team-a # Job under team-a namespace
  generateName: sample-job-team-a-
  annotations:
    kueue.x-k8s.io/queue-name: lq-team-a # Point to the LocalQueue
spec:
  ttlSecondsAfterFinished: 60 # Job will be deleted after 60 seconds
  parallelism: 3 # This Job will have 3 replicas running at the same time
  completions: 3 # This Job requires 3 completions
  suspend: true # Set to true to allow Kueue to control the Job when it starts
  template:
    spec:
      nodeSelector:
        cloud.google.com/gke-accelerator: "nvidia-tesla-t4" # Specify the GPU hardware
      containers:
      - name: dummy-job
        image: gcr.io/k8s-staging-perf-tests/sleep:latest
        args: ["10s"] # Sleep for 10 seconds
        resources:
          requests:
            cpu: "500m"
            memory: "512Mi"
            ephemeral-storage: "512Mi"
            nvidia.com/gpu: "1"
          limits:
            cpu: "500m"
            memory: "512Mi"
            ephemeral-storage: "512Mi"
            nvidia.com/gpu: "1"
      restartPolicy: Never

I job vengono creati nello spazio dei nomi team-a. Questo job punta alla coda locale lq-team-a. Per richiedere risorse GPU, nodeSelector è impostato su nvidia-tesla-t4.

Il job è composto da tre pod che rimangono inattivi per 10 secondi in parallelo. I job vengono ripuliti dopo 60 secondi in base a ttlSecondsAfterFinished.

Questo job richiede 1500 milliCPU, 1536 Mi di memoria, 1536 Mi di spazio di archiviazione temporaneo e tre GPU poiché sono presenti tre pod.

I job vengono creati anche nel file job-team-b.yaml dove il relativo spazio dei nomi appartiene a team-b, con richieste per rappresentare diversi team con esigenze diverse.

Per saperne di più, consulta la sezione Eseguire il deployment dei carichi di lavoro GPU in Autopilot.

1. In un nuovo terminale, osserva lo stato di ClusterQueue che si aggiorna ogni due secondi:

   watch -n 2 kubectl get clusterqueue cluster-queue -o wide
   

2. In un nuovo terminale, osserva lo stato dei nodi:

   watch -n 2 kubectl get nodes -o wide
   

3. In un nuovo terminale, crea job per la coda locale dallo spazio dei nomi team-a e team-b ogni 10 secondi:

   ./create_jobs.sh job-team-a.yaml job-team-b.yaml 10
   

4. Osserva i job in coda, ammessi in ClusterQueue e i nodi avviati con GKE Autopilot.

   Nota: è normale visualizzare un avviso per i pod con il messaggio Unschedulable durante l'aumento di dimensione dei nodi.

5. Ottieni un job dallo spazio dei nomi team-a:

   kubectl -n team-a get jobs
   

   Il risultato è simile al seguente:

   NAME                      COMPLETIONS   DURATION   AGE
   sample-job-team-b-t6jnr   3/3           21s        3m27s
   sample-job-team-a-tm7kc   0/3                      2m27s
   sample-job-team-a-vjtnw   3/3           30s        3m50s
   sample-job-team-b-vn6rp   0/3                      40s
   sample-job-team-a-z86h2   0/3                      2m15s
   sample-job-team-b-zfwj8   0/3                      28s
   sample-job-team-a-zjkbj   0/3                      4s
   sample-job-team-a-zzvjg   3/3           83s        4m50s
   

6. Copia il nome di un job dal passaggio precedente e osserva lo stato di ammissione e gli eventi di un job tramite l'API Workloads:

   kubectl -n team-a describe workload JOB_NAME
   

7. Quando i job in attesa iniziano ad aumentare da ClusterQueue, termina lo script premendo CTRL + C sullo script in esecuzione.

8. Una volta completati tutti i job, noterai che i nodi vengono ridotti.

   Nota: il processo di fare lo scale down può richiedere fino a due minuti.

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 il progetto

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.
1. In the Google Cloud console, go to the Manage resources page.

   Go to Manage resources

2. In the project list, select the project that you want to delete, and then click Delete.
3. In the dialog, type the project ID, and then click Shut down to delete the project.

Elimina la singola risorsa

1. Elimina il sistema di quote Kueue:

   kubectl delete -n team-a localqueue lq-team-a
   kubectl delete -n team-b localqueue lq-team-b
   kubectl delete clusterqueue cluster-queue
   kubectl delete resourceflavor default-flavor
   

2. Elimina il file manifest di Kueue:

   VERSION=VERSION
   kubectl delete -f \
     https://github.com/kubernetes-sigs/kueue/releases/download/$VERSION/manifests.yaml
   

3. Elimina il cluster:

   gcloud container clusters delete kueue-autopilot --region=COMPUTE_REGION
   

Passaggi successivi

• Consulta la documentazione di GKE.

• Scopri di più su Jobs.

• Scopri di più su Kueue

• Scopri come configurare Kueue per la condivisione delle quote tra gli spazi dei nomi