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

Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Prepara l'ambiente

1. Nella Google Cloud console, 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 il tuo Google Cloud ID progetto.

I cluster Autopilot che eseguono la versione 1.29.2-gke.1521000 o successive attivano le TPU per impostazione predefinita. Le TPU sui cluster Autopilot vengono configurate nella specifica del workload. Per ulteriori informazioni, consulta la sezione Definire i carichi di lavoro multislice con JobSet.

Crea un cluster GKE

In Cloud Shell, crea un cluster GKE:

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

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

Sostituisci LOCATION con la posizione in cui vuoi creare il cluster. Assicurati che abbia la 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 Creare le risorse Kueue. I cluster Autopilot che eseguono la versione 1.29.2-gke.1521000 o successive attivano le TPU per impostazione predefinita.

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

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

1. Crea il primo node pool 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 node pool 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 node pool 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 pool di nodi. 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 ulteriori informazioni sui tipi di macchine compatibili con le TPU, consulta la tabella in Scegliere la versione TPU.
• --tpu-topology: la topologia TPU da utilizzare per il pool di nodi. In questo caso, hai utilizzato 2x4. Per ulteriori informazioni sulle topologie TPU, consulta 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 sezioni 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: agrupa i workload strettamente correlati che in genere vengono eseguiti da un singolo tenant (utente). Ogni coda locale rimanda a una coda cluster da cui vengono allocate le risorse per l'esecuzione dei relativi 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 carichi di lavoro multislice con JobSet

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

I seguenti set di job eseguono un carico di lavoro Jax che restituisce il numero globale di chip TPU nel segmento, quindi rimane inattivo per 60 secondi per simulare il 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 JobSet multislice-1slice crea un job che richiede un totale di una sezione TPU.
• Il set di job multislice-2slice crea due job che richiedono due sezioni TPU in totale.
• Il set di job multislice-3slice 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 rimangono in attesa e vengono eseguiti insieme in un secondo momento.

Verifica che Kueue abbia accettato i carichi di lavoro

1. Controlla i carichi di lavoro 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 richieste.

Monitora i workload

Le metriche e le dashboard di osservabilità dei set di job e dei pool di nodi nella Google Cloud console sono disponibili a livello generale.

Dashboard

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

Vai allo stato del node pool TPU GKE

Per ulteriori informazioni, consulta Monitorare le metriche di stato per i nodi TPU e i pool di nodi.

Nella pagina IA/ML di Kubernetes Engine della console, la scheda Deployment IA > Job mostra una dashboard di monitoraggio dei set di job con informazioni complete sullo stato e sul rendimento dei set di job e della relativa infrastruttura di base, ad esempio lo stato del set di job, l'idoneità delle repliche e lo stato delle repliche.Google Cloud La dashboard include anche le metriche di infrastruttura, tra cui CPU, GPU, TPU, memoria e spazio di archiviazione. Per ulteriori informazioni, vedi Monitorare lo stato di integrità di JobSet con le metriche.

Monitora i pod 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. GKE ha poi eseguito i pod da multislice-1slice e multislice-2slice JobSet.

Monitora l'integrità del 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 relative allo stato del set di job sono supportate solo in GKE versione 1.32.1-gke.135700 o successive. Le metriche relative allo stato del set di job 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 delle metriche del set di job. Per saperne di più, consulta la documentazione.

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

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

Monitora il tempo di attività del JobSet, i tempi di recupero (TTR) e i tempi tra le interruzioni (TBI)

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 tempo di riposo per il set di job.
• kubernetes.io/jobset/times_between_interruptions: distribuzione dell'intervallo tra la fine dell'interruzione precedente e l'inizio dell'interruzione corrente per un JobSet. Ogni campione indica una singola durata tra l'interruzione precedente e quella attuale.

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

Per visualizzare il tempo di attività 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 (TMI) 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 recupero (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}]))

Attivare le priorità e la preemption dei carichi di lavoro Kueue

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

1. Aggiorna ClusterQueue in modo da avere un criterio 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 un criterio di prelazione che definisce in che modo Kueue assegna le risorse disponibili. Il criterio specifica che un carico di lavoro può essere prelevato se un carico di lavoro con priorità più elevata ha bisogno delle risorse. I carichi di lavoro con un valore di priorità inferiore hanno maggiori probabilità di essere prelevati da carichi di lavoro con priorità più alta.