Orchestra i carichi di lavoro multi-sezione utilizzando JobSet e Kueue

Autopilot Standard

---

Questo tutorial mostra come orchestrare più carichi di lavoro multislice su Google Kubernetes Engine (GKE) per un migliore utilizzo delle risorse. Esegui il deployment di un carico di lavoro Jax come esempio, eseguilo su TPU Multislice e implementa la coda dei job con JobSet e Kueue. Kueue determina quando devono essere eseguiti i job in base alle risorse disponibili, alle quote e a una gerarchia per la condivisione equa tra i team.

Questo tutorial è rivolto a machine learning engineer e amministratori e operatori di piattaforme interessati alle funzionalità di orchestrazione dei container di Kubernetes per l'addestramento di LLM. Per scoprire di più sui ruoli comuni e sulle attività di esempio a cui facciamo riferimento nei contenuti di Google Cloud , consulta Ruoli e attività comuni degli utenti di GKE Enterprise.

Prima di leggere questa pagina, assicurati di avere familiarità con quanto segue:

• Disponibilità della versione TPU attuale con l'architettura di sistema Cloud TPU
• TPU Multislice in GKE

Obiettivi

1. Prepara l'ambiente con un cluster GKE con tre slice TPU v5e. Ogni slice TPU ha una topologia 2x4 con 8 chip. Pertanto, 24 chip TPU v5e in totale.
2. Crea le risorse Kueue per garantire che le quote siano condivise equamente tra i carichi di lavoro.
3. Esegui il workload multislice.

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.
  Nota:per le installazioni esistenti di gcloud CLI, assicurati di impostare la proprietà compute/region. Se utilizzi principalmente cluster di zona, 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.

• Installa JobSet v0.2.3 o versioni successive.

• Installa Kueue v0.4.1 o versioni successive.

Prepara l'ambiente

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

2. Imposta le variabili di ambiente predefinite utilizzando il comando gcloud config set:

   gcloud config set project PROJECT_ID
   

   Sostituisci PROJECT_ID con l'ID progetto Google Cloud .

I cluster Autopilot che eseguono la versione 1.29.2-gke.1521000 o successive abilitano le TPU per impostazione predefinita. Le TPU sui cluster Autopilot sono configurate nella specifica del workload. Per ulteriori informazioni, vedi la sezione Definisci i workload Multislice con JobSet.

Crea un cluster GKE

In Cloud Shell, crea un cluster GKE:

Autopilot

gcloud container clusters create-auto multislice-cluster \
    --location=LOCATION \
    --cluster-version 1.29.2-gke.1521000 \
    --release-channel rapid

In questo comando:

• Il flag --location specifica la posizione di Compute Engine del cluster.
• Il flag --cluster-version specifica la versione di Kubernetes per il cluster.
• Il flag --release-channel specifica il canale di rilascio per il tuo cluster. In questo caso, il canale rapido supporta le versioni più recenti disponibili in GKE.

Standard

gcloud container clusters create multislice-cluster \
    --location=LOCATION

Sostituisci LOCATION con la località in cui vuoi creare il cluster. Assicurati che abbia capacità per il tipo di macchina ct5lp-hightpu-4t. La creazione del cluster potrebbe richiedere diversi minuti.

Se utilizzi la modalità GKE Autopilot, vai alla sezione Crea le risorse Kueue. I cluster Autopilot che eseguono la versione 1.29.2-gke.1521000 o successive abilitano le TPU per impostazione predefinita.

Crea tre pool di nodi di slice TPU in modalità Standard

In questa sezione, creerai i pool di nodi TPU utilizzando il comando gcloud beta container node-pools create.

1. Crea il primo pool di nodi denominato nodepool1:

   gcloud beta container node-pools create nodepool1 \
       --location=LOCATION \
       --cluster=multislice-cluster \
       --node-locations=NODE_LOCATION \
       --machine-type=ct5lp-hightpu-4t \
       --tpu-topology=2x4 \
       --project=PROJECT_ID
   

   Sostituisci NODE_LOCATION con una o più zone nella regione del cluster in cui vuoi creare i nodi.

2. Crea il secondo pool di nodi denominato nodepool2:

   gcloud beta container node-pools create nodepool2 \
       --location=LOCATION \
       --cluster=multislice-cluster \
       --node-locations=NODE_LOCATION \
       --machine-type=ct5lp-hightpu-4t \
       --tpu-topology=2x4 \
       --project=PROJECT_ID
   

3. Crea il terzo pool di nodi denominato nodepool3:

   gcloud beta container node-pools create nodepool3 \
       --location=LOCATION \
       --cluster=multislice-cluster \
       --node-locations=NODE_LOCATION \
       --machine-type=ct5lp-hightpu-4t \
       --tpu-topology=2x4 \
       --project=PROJECT_ID
   

GKE crea tre node pool. Ogni pool di nodi è una sezione TPU separata.

Nei passaggi precedenti, hai utilizzato il comando gcloud beta container node-pools create per creare i node pool. Questi comandi utilizzano i seguenti flag:

• --node-locations: l'elenco separato da virgole di una o più zone in cui GKE crea i node pool.
• --machine-type: il tipo di macchina da utilizzare per i nodi. In questo caso, hai utilizzato ct5lp-hightpu-4t. Per saperne di più sui tipi di macchina compatibili con le TPU, utilizza la tabella in Scegliere la versione della TPU.
• --tpu-topology: la topologia TPU da utilizzare per il pool di nodi. In questo caso, hai utilizzato 2x4. Per maggiori informazioni sulle topologie TPU, consulta la sezione Scegliere la topologia TPU.

Crea le risorse Kueue

1. Crea il seguente manifest kueue.yaml:

   apiVersion: kueue.x-k8s.io/v1beta1
   kind: ResourceFlavor
   metadata:
     name: "vlp-24"
   spec:
     nodeLabels:
       cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
       cloud.google.com/gke-tpu-topology: 2x4
   ---
   apiVersion: kueue.x-k8s.io/v1beta1
   kind: ClusterQueue
   metadata:
     name: "cluster-queue"
   spec:
     namespaceSelector: {}
     queueingStrategy: BestEffortFIFO
     resourceGroups:
     - coveredResources: ["google.com/tpu"]
       flavors:
       - name: "vlp-24"
         resources:
         - name: "google.com/tpu"
           nominalQuota: 24
   
   ---
   apiVersion: kueue.x-k8s.io/v1beta1
   kind: LocalQueue
   metadata:
     namespace: default
     name: multislice-queue
   spec:
     clusterQueue: cluster-queue
   

2. Applica il manifest kueue.yaml:

   kubectl apply -f kueue.yaml
   

GKE crea le seguenti risorse Kueue:

• ResourceFlavor: Un'astrazione delle risorse in un cluster. In questo esempio, GKE crea tre slice TPU con topologia 2x4. Ogni sezione TPU ha una topologia 2x4 con 8 chip (24 chip TPU in totale).
• ClusterQueue: Una coda globale che gestisce i carichi di lavoro e le risorse del cluster.
• LocalQueue: Raggruppa i workload strettamente correlati che in genere vengono eseguiti da un singolo tenant (utente). Ogni LocalQueue punta a una ClusterQueue da cui vengono allocate le risorse per eseguire i carichi di lavoro. Un carico di lavoro Kueue è un'astrazione che rappresenta un carico di lavoro batch. In questo caso, ogni carico di lavoro è un JobSet.

Definisci i tuoi workload multislice con JobSet

In questa sezione, creerai tre JobSet. Un Jobset è un'API per i carichi di lavoro che ti consente di gestire un gruppo di job Kubernetes come un'unica unità. Il caso d'uso più comune per un JobSet è l'addestramento distribuito, ma puoi utilizzarlo anche per eseguire workload batch.

I seguenti JobSet eseguono un carico di lavoro Jax che restituisce il numero globale di chip TPU nella slice, quindi sospende per 60 secondi per simulare un po' di tempo di addestramento del modello, quindi esce.

1. Installa l'API JobSet nel cluster:

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

2. Crea il seguente manifest jobsets-multislice.yaml:

   Autopilot

   apiVersion: jobset.x-k8s.io/v1alpha2
   kind: JobSet
   metadata:
     name: multislice-1slice
     labels:
       kueue.x-k8s.io/queue-name: multislice-queue
     annotations:
       alpha.jobset.sigs.k8s.io/exclusive-topology: cloud.google.com/gke-nodepool
   spec:
     failurePolicy:
       maxRestarts: 4
     replicatedJobs:
       - name: slice
         replicas: 1
         template:
           spec:
             parallelism: 2
             completions: 2
             backoffLimit: 0
             template:
               spec:
                 nodeSelector:
                   cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
                   cloud.google.com/gke-tpu-topology: 2x4
                 containers:
                 - name: jax-tpu
                   image: python:3.8
                   ports:
                   - containerPort: 8471
                   - containerPort: 8080
                   command:
                   - bash
                   - -c
                   - |
                     pip install "jax[tpu]" -f https://storage.googleapis.com/jax-releases/libtpu_releases.html
                     python -c 'import jax; print("Global device count:", jax.device_count())'
                   resources:
                     limits:
                       google.com/tpu: 4
   
   ---
   apiVersion: jobset.x-k8s.io/v1alpha2
   kind: JobSet
   metadata:
     name: multislice-2slice
     labels:
       kueue.x-k8s.io/queue-name: multislice-queue
     annotations:
       alpha.jobset.sigs.k8s.io/exclusive-topology: cloud.google.com/gke-nodepool
   spec:
     failurePolicy:
       maxRestarts: 4
     replicatedJobs:
       - name: slice
         replicas: 2
         template:
           spec:
             parallelism: 2
             completions: 2
             backoffLimit: 0
             template:
               spec:
                 nodeSelector:
                   cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
                   cloud.google.com/gke-tpu-topology: 2x4
                 containers:
                 - name: jax-tpu
                   image: python:3.8
                   ports:
                   - containerPort: 8471
                   - containerPort: 8080
                   command:
                   - bash
                   - -c
                   - |
                     pip install "jax[tpu]" -f https://storage.googleapis.com/jax-releases/libtpu_releases.html
                     python -c 'import jax; print("Global device count:", jax.device_count())'
                     sleep 60
                   resources:
                     limits:
                       google.com/tpu: 4
   ---
   apiVersion: jobset.x-k8s.io/v1alpha2
   kind: JobSet
   metadata:
     name: multislice-3slice
     labels:
       kueue.x-k8s.io/queue-name: multislice-queue
     annotations:
       alpha.jobset.sigs.k8s.io/exclusive-topology: cloud.google.com/gke-nodepool
   spec:
     failurePolicy:
       maxRestarts: 4
     replicatedJobs:
       - name: slice
         replicas: 3
         template:
           spec:
             parallelism: 2
             completions: 2
             backoffLimit: 0
             template:
               spec:
                 nodeSelector:
                   cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
                   cloud.google.com/gke-tpu-topology: 2x4
                 containers:
                 - name: jax-tpu
                   image: python:3.8
                   ports:
                   - containerPort: 8471
                   - containerPort: 8080
                   command:
                   - bash
                   - -c
                   - |
                     sleep 60
                   resources:
                     limits:
                       google.com/tpu: 4
   

   Standard

   apiVersion: jobset.x-k8s.io/v1alpha2
   kind: JobSet
   metadata:
     name: multislice-1slice
     labels:
       kueue.x-k8s.io/queue-name: multislice-queue
     annotations:
       alpha.jobset.sigs.k8s.io/exclusive-topology: cloud.google.com/gke-nodepool
   spec:
     failurePolicy:
       maxRestarts: 4
     replicatedJobs:
       - name: slice
         replicas: 1
         template:
           spec:
             parallelism: 2
             completions: 2
             backoffLimit: 0
             template:
               spec:
                 hostNetwork: true
                 dnsPolicy: ClusterFirstWithHostNet
                 nodeSelector:
                   cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
                   cloud.google.com/gke-tpu-topology: 2x4
                 containers:
                 - name: jax-tpu
                   image: python:3.8
                   ports:
                   - containerPort: 8471
                   - containerPort: 8080
                   securityContext:
                     privileged: true
                   command:
                   - bash
                   - -c
                   - |
                     pip install "jax[tpu]" -f https://storage.googleapis.com/jax-releases/libtpu_releases.html
                     python -c 'import jax; print("Global device count:", jax.device_count())'
                   resources:
                     limits:
                       google.com/tpu: 4
   
   ---
   apiVersion: jobset.x-k8s.io/v1alpha2
   kind: JobSet
   metadata:
     name: multislice-2slice
     labels:
       kueue.x-k8s.io/queue-name: multislice-queue
     annotations:
       alpha.jobset.sigs.k8s.io/exclusive-topology: cloud.google.com/gke-nodepool
   spec:
     failurePolicy:
       maxRestarts: 4
     replicatedJobs:
       - name: slice
         replicas: 2
         template:
           spec:
             parallelism: 2
             completions: 2
             backoffLimit: 0
             template:
               spec:
                 hostNetwork: true
                 dnsPolicy: ClusterFirstWithHostNet
                 nodeSelector:
                   cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
                   cloud.google.com/gke-tpu-topology: 2x4
                 containers:
                 - name: jax-tpu
                   image: python:3.8
                   ports:
                   - containerPort: 8471
                   - containerPort: 8080
                   securityContext:
                     privileged: true
                   command:
                   - bash
                   - -c
                   - |
                     pip install "jax[tpu]" -f https://storage.googleapis.com/jax-releases/libtpu_releases.html
                     python -c 'import jax; print("Global device count:", jax.device_count())'
                     sleep 60
                   resources:
                     limits:
                       google.com/tpu: 4
   ---
   apiVersion: jobset.x-k8s.io/v1alpha2
   kind: JobSet
   metadata:
     name: multislice-3slice
     labels:
       kueue.x-k8s.io/queue-name: multislice-queue
     annotations:
       alpha.jobset.sigs.k8s.io/exclusive-topology: cloud.google.com/gke-nodepool
   spec:
     failurePolicy:
       maxRestarts: 4
     replicatedJobs:
       - name: slice
         replicas: 3
         template:
           spec:
             parallelism: 2
             completions: 2
             backoffLimit: 0
             template:
               spec:
                 hostNetwork: true
                 dnsPolicy: ClusterFirstWithHostNet
                 nodeSelector:
                   cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
                   cloud.google.com/gke-tpu-topology: 2x4
                 containers:
                 - name: jax-tpu
                   image: python:3.8
                   ports:
                   - containerPort: 8471
                   - containerPort: 8080
                   securityContext:
                     privileged: true
                   command:
                   - bash
                   - -c
                   - |
                     sleep 60
                   resources:
                     limits:
                       google.com/tpu: 4
   

3. Applica il manifest jobsets-multislice.yaml:

   kubectl apply -f jobsets-multislice.yaml
   

GKE crea i job con le seguenti richieste di risorse:

• Il multislice-1slice JobSet crea un job che richiede una sezione TPU in totale.
• Il multislice-2slice JobSet crea due job che richiedono in totale due sezioni TPU.
• Il multislice-3slice JobSet crea tre job che richiedono tre sezioni TPU in totale.

Poiché il cluster ha solo tre slice TPU, non tutti i JobSet possono essere eseguiti contemporaneamente. Quando Kueue mette in coda tutti e tre i JobSet di multislice-3slice, i relativi job vengono eseguiti da soli fino al completamento. multislice-1slice e multislice-2slice attendono e vengono eseguiti insieme in un secondo momento.

Nota :per mitigare eventuali problemi, assicurati che il cluster soddisfi tutti i prerequisiti elencati nella sezione Prima di iniziare della documentazione sull'installazione di JobSet. Se riscontri problemi dopo aver verificato che il cluster soddisfi i requisiti, visita la pagina Risoluzione dei problemi relativi a JobSet.

Verifica che Kueue abbia ammesso i carichi di lavoro

1. Controlla i workload in coda in Kueue:

   kubectl get workloads
   

   L'output è simile al seguente:

   NAME                             QUEUE              ADMITTED BY     AGE
   jobset-multislice-1slice-2530a   multislice-queue                   3s
   jobset-multislice-2slice-ffb02   multislice-queue                   4s
   jobset-multislice-3slice-8c695   multislice-queue   cluster-queue   10s
   

Kueue mette in coda uno o più workload, a seconda delle risorse TPU che richiedono.

Monitorare i workload

Le metriche e i dashboard di osservabilità di JobSet e del pool di nodi nella Google Cloud console sono disponibili a livello generale.

Dashboard

Per visualizzare lo stato dei tuoi node pool TPU multi-host su GKE, vai alla dashboard Stato del node pool TPU GKE fornita da Cloud Monitoring:

Vai a Stato del node pool GKE TPU

Per saperne di più, consulta Monitorare le metriche di integrità per i nodi TPU e i pool di nodi.

Nella pagina Kubernetes Engine AI/ML della consoleGoogle Cloud , la scheda Deployment AI > Job mostra una dashboard di monitoraggio di JobSet con informazioni complete sull'integrità e sul rendimento di JobSet e della relativa infrastruttura sottostante, come lo stato di JobSet, la disponibilità delle repliche e lo stato delle repliche. La dashboard include anche metriche dell'infrastruttura, tra cui metriche di CPU, GPU, TPU, memoria e spazio di archiviazione. Per saperne di più, vedi Monitorare l'integrità di JobSet con le metriche.

Monitorare quali pod sono in esecuzione

kubectl get pods

L'output è simile al seguente:

NAME                                READY   STATUS      RESTARTS   AGE
multislice-1slice-slice-0-0-pf2ll   1/1     Running     0          1s
multislice-1slice-slice-0-1-55g62   1/1     Running     0          1s
multislice-2slice-slice-0-0-f4hf7   1/1     Running     0          3s
multislice-2slice-slice-0-1-c8kv7   1/1     Running     0          3s
multislice-2slice-slice-1-0-7h46t   1/1     Running     0          3s
multislice-2slice-slice-1-1-lj9hb   1/1     Running     0          3s
multislice-3slice-slice-0-0-wzq9t   0/1     Completed   0          2m31s
multislice-3slice-slice-0-1-zf4dp   0/1     Completed   0          2m30s
multislice-3slice-slice-1-0-hbfn5   0/1     Completed   0          2m31s
multislice-3slice-slice-1-1-45fgl   0/1     Completed   0          2m30s
multislice-3slice-slice-2-0-wjbp4   0/1     Completed   0          2m30s
multislice-3slice-slice-2-1-lwnvs   0/1     Completed   0          2m30s

Verifica che GKE abbia pianificato, creato ed eseguito i pod per multislice-3slice per primi. Poi, GKE ha eseguito i pod da multislice-1slice e multislice-2slice JobSet.

Monitorare lo stato di JobSet con le metriche

Per capire se un JobSet è in esecuzione come previsto o per dedurre se è stato interrotto, puoi utilizzare le metriche Prometheus del pacchetto di metriche JobSet, ad esempio kube_jobset_succeeded_replicas.

Tieni presente che le metriche sullo stato di integrità di JobSet sono supportate solo in GKE versione 1.32.1-gke.135700 o successive. Le metriche di integrità di JobSet sono abilitate per impostazione predefinita nei cluster appena creati con le versioni supportate. Per i cluster esistenti di cui è stato eseguito l'upgrade alle versioni supportate, i clienti devono attivare manualmente il pacchetto di metriche JobSet. Per saperne di più, consulta la documentazione.

Per questo tutorial, controlla il completamento di JobSet con questa query PromQL:

kube_jobset_succeeded_replicas{
  cluster="multislice-cluster",
  jobset_name=~"mulitslice-.*"}

Monitorare l'uptime, i tempi di ripristino (TTR) e i tempi tra le interruzioni (TBI) del set di job

Le seguenti metriche sono utili per monitorare la disponibilità di un JobSet:

• kubernetes.io/jobset/uptime: tempo totale di disponibilità del set di job.
• kubernetes.io/jobset/times_to_recover: Distribuzione del periodo di recupero per un JobSet. Ogni campione indica un singolo evento di recupero da un periodo di inattività per il JobSet.
• kubernetes.io/jobset/times_between_interruptions: distribuzione dell'intervallo tra la fine dell'interruzione precedente e l'inizio di quella attuale per un set di job. Ogni campione indica una singola durata tra l'interruzione precedente e quella attuale.

Queste metriche si applicano ai set di job con esattamente un job replicato GPU o TPU. Il calcolo delle metriche si basa solo sulla disponibilità di questo singolo job replicato. Le metriche sono supportate in tutte le versioni di GKE.

Per visualizzare l'uptime dei JobSet utilizzati in questo tutorial, esegui la seguente query PromQL:

avg_over_time(
  kubernetes_io:jobset_uptime{
    monitored_resource="k8s_entity", entity_type="jobset",
    entity_name=~"multislice-.*",cluster_name="multislice-cluster"}[${__interval}])

Per visualizzare le distribuzioni TBI per i JobSet di questo tutorial, esegui la seguente query PromQL:

histogram_quantile(0.50,
  sum_over_time(
    kubernetes_io:jobset_times_between_interruptions_bucket{
      monitored_resource="k8s_entity",entity_type="jobset",
      entity_name=~"multislice-.*",cluster_name="multislice-cluster"}[${__interval}]))

Puoi estendere l'intervallo della query a un orizzonte temporale più lungo, ad esempio 7 giorni, e calcolare il tempo medio tra le interruzioni (MTBI) in questo periodo:

sum(sum_over_time(
  kubernetes_io:jobset_times_between_interruptions_sum{
    monitored_resource="k8s_entity",entity_type="jobset",
    entity_name=~"multislice-.*",cluster_name="multislice-cluster"}[${__interval}]))
/
sum(sum_over_time(
  kubernetes_io:jobset_times_between_interruptions_count{
    monitored_resource="k8s_entity",entity_type="jobset",
    entity_name=~"multislice-.*",cluster_name="multislice-cluster"}[${__interval}]))

Per visualizzare le distribuzioni TTR, puoi eseguire le seguenti query PromQL:

histogram_quantile(0.50,
  sum_over_time(
    kubernetes_io:jobset_times_to_recover_bucket{
      monitored_resource="k8s_entity",entity_type="jobset",
      entity_name=~"multislice-.*",cluster_name="multislice-cluster"}[${__interval}]))

Dopo aver aumentato l'intervallo di query a un orizzonte temporale più lungo, ad esempio 7 giorni, puoi calcolare il tempo medio di ripristino (MTTR) in questo periodo:

sum(sum_over_time(
  kubernetes_io:jobset_times_to_recover_sum{
    monitored_resource="k8s_entity",entity_type="jobset",
    entity_name=~"multislice-.*",cluster_name="multislice-cluster"}[${__interval}]))
/
sum(sum_over_time(
  kubernetes_io:jobset_times_to_recover_count{
    monitored_resource="k8s_entity",entity_type="jobset",
    entity_name=~"multislice-.*",cluster_name="multislice-cluster"}[${__interval}]))

Operazione riuscita: hai eseguito correttamente tre workload Multislice Jax.

Abilita le priorità e la preemption dei workload di Kueue

Se vuoi, puoi assegnare priorità ai carichi di lavoro Kueue, che determinano l'ordine in cui i carichi di lavoro in coda vengono ammessi da Kueue.

Nota: a seconda della configurazione della norma di preemptive di ClusterQueue, potrebbero verificarsi alcuni scenari di preemptive. Ad esempio, GKE può interrompere un workload in esecuzione per eseguire un workload con priorità più alta se non ci sono risorse sufficienti per eseguire entrambi i workload contemporaneamente. GKE interrompe e rimette in coda un workload preempted per continuare l'elaborazione quando possibile.

1. Aggiorna il tuo ClusterQueue in modo che abbia una policy di prelazione:

   apiVersion: kueue.x-k8s.io/v1beta1
   kind: ResourceFlavor
   metadata:
     name: "vlp-24"
   spec:
     nodeLabels:
       cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
       cloud.google.com/gke-tpu-topology: 2x4
   ---
   apiVersion: kueue.x-k8s.io/v1beta1
   kind: ClusterQueue
   metadata:
     name: "cluster-queue"
   spec:
     namespaceSelector: {}
     resourceGroups:
     - coveredResources: ["google.com/tpu"]
       flavors:
       - name: "vlp-24"
         resources:
         - name: "google.com/tpu"
           nominalQuota: 24
     preemption:
       reclaimWithinCohort: Any
       withinClusterQueue: LowerPriority
   ---
   apiVersion: kueue.x-k8s.io/v1beta1
   kind: LocalQueue
   metadata:
     namespace: default
     name: multislice-queue
   spec:
     clusterQueue: cluster-queue
   

2. Crea un PriorityClass per ogni livello di priorità distinto che vuoi assegnare ai workload:

   apiVersion: scheduling.k8s.io/v1
   kind: PriorityClass
   metadata:
     name: low-priority
   value: 100
   globalDefault: false
   description: "This low priority class should be used for some Pods only."
   

3. Assegna priorityClassName al tuo JobSet:

   Autopilot

   apiVersion: jobset.x-k8s.io/v1alpha2
   kind: JobSet
   metadata:
     name: low-priority
     labels:
       kueue.x-k8s.io/queue-name: multislice-queue
     annotations:
       alpha.jobset.sigs.k8s.io/exclusive-topology: cloud.google.com/gke-nodepool
   spec:
     failurePolicy:
       maxRestarts: 4
     replicatedJobs:
       - name: slice
         replicas: 1
         template:
           spec:
             parallelism: 2
             completions: 2
             backoffLimit: 0
             template:
               spec:
                 nodeSelector:
                   cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
                   cloud.google.com/gke-tpu-topology: 2x4
                 priorityClassName: low-priority
                 containers:
                 - name: jax-tpu
                   image: python:3.8
                   ports:
                   - containerPort: 8471
                   - containerPort: 8080
                   command:
                   - bash
                   - -c
                   - |
                     sleep 60
                   resources:
                     limits:
                       google.com/tpu: 4 # Number of TPU chips per worker
   

   Standard

   apiVersion: jobset.x-k8s.io/v1alpha2
   kind: JobSet
   metadata:
     name: low-priority
     labels:
       kueue.x-k8s.io/queue-name: multislice-queue
     annotations:
       alpha.jobset.sigs.k8s.io/exclusive-topology: cloud.google.com/gke-nodepool
   spec:
     failurePolicy:
       maxRestarts: 4
     replicatedJobs:
       - name: slice
         replicas: 1
         template:
           spec:
             parallelism: 2
             completions: 2
             backoffLimit: 0
             template:
               spec:
                 hostNetwork: true
                 dnsPolicy: ClusterFirstWithHostNet
                 nodeSelector:
                   cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
                   cloud.google.com/gke-tpu-topology: 2x4
                 priorityClassName: low-priority
                 containers:
                 - name: jax-tpu
                   image: python:3.8
                   ports:
                   - containerPort: 8471
                   - containerPort: 8080
                   securityContext:
                     privileged: true
                   command:
                   - bash
                   - -c
                   - |
                     sleep 60
                   resources:
                     limits:
                       google.com/tpu: 4 # Number of TPU chips per worker
   

GKE include una policy di preempt, che definisce il modo in cui Kueue assegna le risorse disponibili. Il criterio specifica che un workload può essere prerilasciato se un workload con priorità più elevata ha bisogno delle risorse. I workload con un valore di priorità inferiore hanno maggiori probabilità di essere preempted da workload con priorità più alta.

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 che hai 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 URL appspot.com, 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 le risorse Kueue:

   kubectl delete -f jobsets-multislice.yaml
   kubectl delete -f kueue.yaml
   

2. Elimina il cluster:

   gcloud container clusters delete multislice-cluster --region=LOCATION
   

Passaggi successivi

• Scopri di più su Kueue.
• Scopri come Implementare un sistema di accodamento dei job con condivisione della quota tra gli spazi dei nomi su GKE.