Esegui il deployment dei carichi di lavoro TPU in GKE Standard

Questo documento fornisce una base per imparare ad accelerare i workload di machine learning (ML) utilizzando le TPU in Google Kubernetes Engine (GKE). Le TPU sono progettate per l'elaborazione della moltiplicazione di matrici, ad esempio l'addestramento di modelli di deep learning su larga scala. Le TPU sono ottimizzate per gestire enormi set di dati e modelli complessi di ML e sono quindi più convenienti e a risparmio energetico per i workload di ML grazie alle loro prestazioni superiori. In questa guida imparerai a eseguire il deployment dei workload di ML utilizzando gli acceleratori Cloud TPU, a configurare le quote per le TPU, a configurare gli upgrade per i node pool che eseguono le TPU e a monitorare le metriche dei workload TPU.

Questo tutorial è rivolto a ingegneri di machine learning (ML) e amministratori e operatori di piattaforme interessati a utilizzare l'orchestrazione dei container Kubernetes per gestire workload di addestramento, ottimizzazione e inferenza di modelli su larga scala utilizzando le TPU. Per scoprire di più sui ruoli comuni e sulle attività di esempio a cui si fa riferimento nei contenuti di Google Cloud , consulta Ruoli e attività comuni degli utenti GKE.

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

Prima di iniziare

Prima di iniziare, assicurati di aver eseguito le seguenti attività:

  • Abilita l'API Google Kubernetes Engine.
  • Abilita l'API Google Kubernetes Engine
  • Per 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.

Pianifica la configurazione della TPU

Pianifica la configurazione della TPU in base al modello e alla quantità di memoria richiesta. Prima di utilizzare questa guida per eseguire il deployment dei workload su TPU, completa i passaggi di pianificazione descritti in Pianifica la configurazione della TPU.

Assicurati di avere una quota di TPU

Le sezioni seguenti ti aiutano ad assicurarti di avere una quota sufficiente quando utilizzi le TPU in GKE.

Quota per VM on demand o spot

Se stai creando un pool di nodi di sezioni TPU con VM on demand o VM spot, devi disporre di una quota TPU sufficiente nella regione che vuoi utilizzare.

La creazione di un pool di nodi di sezioni TPU che utilizza una prenotazione TPU non richiede alcuna quota TPU.1 Puoi saltare questa sezione per le TPU prenotate.

La creazione di un pool di nodi di sezioni TPU on demand o spot in GKE richiede la quota dell'API Compute Engine. La quota dell'API Compute Engine (compute.googleapis.com) non è la stessa della quota dell'API Cloud TPU (tpu.googleapis.com), necessaria per creare TPU con l'API Cloud TPU.

Per controllare il limite e l'utilizzo attuale della quota dell'API Compute Engine per le TPU, segui questi passaggi:

  1. Vai alla pagina Quote nella console Google Cloud :

    Vai a Quote

  2. Nella casella Filtro, procedi nel seguente modo:

    1. Utilizza la tabella seguente per selezionare e copiare la proprietà della quota in base alla versione della TPU e al tipo di macchina. Ad esempio, se prevedi di creare nodi TPU v5e on demand il cui tipo di macchina inizia con ct5lp-, inserisci Name: TPU v5 Lite PodSlice chips.

      Versione TPU, il tipo di macchina inizia con Proprietà e nome della quota per le istanze on demand Proprietà e nome della quota per le istanze Spot2
      TPU v3,
      ct3-
      Dimensions (e.g. location):
      tpu_family:CT3
      Non applicabile
      TPU v3,
      ct3p-
      Dimensions (e.g. location):
      tpu_family:CT3P
      Non applicabile
      TPU v4,
      ct4p-
      Name:
      TPU v4 PodSlice chips
      Name:
      Preemptible TPU v4 PodSlice chips
      TPU v5e,
      ct5lp-
      Name:
      TPU v5 Lite PodSlice chips
      Name:
      Preemptible TPU v5 Lite Podslice
      chips
      TPU v5p,
      ct5p-
      Name:
      TPU v5p chips
      Name:
      Preemptible TPU v5p chips
      TPU Trillium,
      ct6e-
      Dimensions (e.g. location):
      tpu_family:CT6E
      Name:
      Preemptible TPU slices v6e
      Ironwood (TPU7x),
      tpu7x-standard-4t
      Dimensions (e.g. location):
      tpu_family:tpu7x
      Name:
      Preemptible TPU slices tpu7x
    2. Seleziona la proprietà Dimensioni (ad es. località) e inserisci region: seguito dal nome della regione in cui prevedi di creare TPU in GKE. Ad esempio, inserisci region:us-west4 se prevedi di creare nodi di sezioni TPU nella zona us-west4-a. La quota di TPU è regionale, quindi tutte le zone della stessa regione utilizzano la stessa quota di TPU.

Se nessuna quota corrisponde al filtro inserito, al progetto non è stata concessa nessuna delle quote specificate per la regione di cui hai bisogno e devi richiedere un aggiustamento della quota TPU.

Quando viene creata una prenotazione TPU, sia il limite sia i valori di utilizzo attuali per la quota corrispondente aumentano in base al numero di chip nella prenotazione TPU. Ad esempio, quando viene creata una prenotazione per 16 chip TPU v5e il cui tipo di macchina inizia con ct5lp-, sia il Limite sia l'Utilizzo attuale per la quota TPU v5 Lite PodSlice chips nella regione pertinente aumentano di 16.

  1. Quando crei un pool di nodi di sezioni TPU, utilizza i flag --reservation e --reservation-affinity=specific per creare unistanza dedicata. Le prenotazioni TPU sono disponibili quando acquisti un impegno. ↩

  2. Quando crei un pool di nodi di una sezione TPU, utilizza il flag --spot per creare un'istanza Spot. ↩

Quote per risorse GKE aggiuntive

Potresti dover aumentare le seguenti quote relative a GKE nelle regioni in cui GKE crea le tue risorse.

  • Quota Persistent Disk SSD (GB): il disco di avvio di ogni nodo Kubernetes richiede 100 GB per impostazione predefinita. Pertanto, questa quota deve essere impostata almeno sul prodotto del numero massimo di nodi GKE che prevedi di creare e 100 GB (nodi * 100 GB).
  • Quota di indirizzi IP in uso: ogni nodo Kubernetes utilizza un indirizzo IP. Pertanto, questa quota deve essere impostata almeno sul numero massimo di nodi GKE che prevedi di creare.
  • Assicurati che max-pods-per-node sia in linea con l'intervallo della subnet: ogni nodo Kubernetes utilizza intervalli IP secondari per i pod. Ad esempio, max-pods-per-node di 32 richiede 64 indirizzi IP, che si traducono in una subnet /26 per nodo. Tieni presente che questo intervallo non deve essere condiviso con altri cluster. Per evitare di esaurire l'intervallo di indirizzi IP, utilizza il flag --max-pods-per-node per limitare il numero di pod che possono essere pianificati su un nodo. La quota per max-pods-per-node deve essere impostata almeno sul numero massimo di nodi GKE che prevedi di creare.

Per richiedere un aumento della quota, consulta Richiedi un aggiustamento della quota.

Garantisci la disponibilità delle prenotazioni

Per creare un pool di nodi di sezioni TPU utilizzando una prenotazione, quest'ultima deve avere un numero sufficiente di chip TPU disponibili al momento della creazione del pool di nodi.

Per vedere quali prenotazioni esistono all'interno di un progetto e quanti chip TPU sono disponibili all'interno di una prenotazione TPU, visualizza un elenco delle tue prenotazioni.

Crea un cluster

gcloud

Crea un cluster GKE in modalità Standard in una regione con TPU disponibili.

Best practice:

Utilizza i cluster regionali, che offrono un'alta affidabilità del control plane Kubernetes.

gcloud container clusters create CLUSTER_NAME \
  --location LOCATION \
  --cluster-version VERSION

Sostituisci quanto segue:

  • CLUSTER_NAME: il nome del nuovo cluster.
  • LOCATION: la regione con la capacità TPU disponibile.
  • VERSION: la versione di GKE, che deve supportare il tipo di macchina che vuoi utilizzare. Tieni presente che la versione GKE predefinita potrebbe non essere disponibile per la TPU di destinazione. Per scoprire quali sono le versioni minime di GKE disponibili per tipo di macchina TPU, consulta Disponibilità di TPU in GKE.

Cluster Toolkit

  1. Configura Cluster Toolkit.
  2. Esegui il deployment di un cluster TPU GKE utilizzando un progetto di Cluster Toolkit (ad esempio gke-tpu-v6e o gke-tpu-7x; per i progetti TPU v4, v5e e v5p, consulta il repository GitHub di Cluster Toolkit):

    gcluster deploy examples/gke-tpu-7x/gke-tpu-7x.yaml \
      --vars project_id=PROJECT_ID,deployment_name=DEPLOYMENT_NAME,zone=ZONE
    

    Sostituisci quanto segue:

    • DEPLOYMENT_NAME: un nome per il deployment di Cluster Toolkit (che è anche il nome del cluster GKE).
    • PROJECT_ID: il tuo ID progetto Google Cloud .
    • ZONE: il nome della zona in base alla versione della TPU che vuoi utilizzare. Per identificare una località disponibile, consulta Disponibilità di TPU in GKE. Per utilizzare la capacità riservata, assicurati di utilizzare la zona in cui hai prenotato la capacità.

Hai creato un cluster GKE con un pool di nodi che include le risorse TPU specificate. Ora puoi seguire i passaggi descritti nella sezione Esegui il workload sui nodi di sezioni TPU di questo documento.

Esegui il provisioning delle TPU

Per eseguire il provisioning delle TPU in GKE, hai a disposizione le seguenti opzioni di configurazione:
  • Crea manualmente un node pool: puoi creare un pool di nodi con una versione e una topologia TPU specifiche.
  • Utilizza il provisioning automatico dei nodi GKE: puoi attivare il provisioning automatico dei nodi a livello di cluster e poi, nel manifest del pod, utilizzare un nodeSelector per specificare la versione e la topologia della TPU. Quando un pod in attesa corrisponde a questi selettori, GKE crea automaticamente un nuovo pool di nodi che soddisfa la richiesta. Questo metodo richiede l'impostazione di limiti delle risorse a livello di cluster per le TPU.
  • Definisci ComputeClass personalizzate: puoi richiedere TPU utilizzando ComputeClass personalizzate. Le ComputeClass personalizzate consentono agli amministratori della piattaforma di definire una gerarchia di configurazioni dei nodi a cui GKE deve dare la priorità durante le decisioni di scalabilità dei nodi, in modo che i workload vengano eseguiti sull'hardware selezionato.

Crea manualmente un pool di nodi

Puoi creare un pool di nodi di sezioni TPU a host singolo o multi-host.

Crea un pool di nodi di sezioni TPU single-host

Puoi creare un pool di nodi di slice TPU single-host utilizzando Google Cloud CLI, Terraform o la console Google Cloud .

gcloud

gcloud container node-pools create NODE_POOL_NAME \
    --location=LOCATION \
    --cluster=CLUSTER_NAME \
    --node-locations=NODE_ZONES \
    --machine-type=MACHINE_TYPE \
    [--sandbox=type=gvisor]

Sostituisci quanto segue:

  • NODE_POOL_NAME: il nome del nuovo pool di nodi.
  • LOCATION: il nome della zona in base alla versione della TPU che vuoi utilizzare. Per identificare una località disponibile, consulta Disponibilità di TPU in GKE.
  • CLUSTER_NAME: il nome del cluster.
  • NODE_ZONES: l'elenco separato da virgole di una o più zone in cui GKE crea il pool di nodi.

    (Facoltativo) Utilizza una zona AI, ad esempio us-central1-ai1a. Le zone AI sono località specializzate ottimizzate per i workload AI/ML all'interno delle regioni Google Cloud .

  • MACHINE_TYPE: la versione e il tipo di TPU. Ad esempio, utilizza tpu7x-standard-4t per Ironwood (TPU7x).

Facoltativamente, puoi anche utilizzare i seguenti flag:

  • --num-nodes=NUM_NODES: il numero iniziale di nodi nel pool di nodi in ciascuna zona.

    Best practice:

    Se utilizzi il flag enable-autoscaling per il pool di nodi, imposta num-nodes su 0 in modo che il gestore della scalabilità automatica esegua il provisioning di nodi aggiuntivi non appena i workload lo richiedono.

  • --reservation=RESERVATION_NAME: il nome della prenotazione utilizzata da GKE durante la creazione del pool di nodi. Se ometti questo flag, GKE utilizza le TPU disponibili. Per saperne di più sulle prenotazioni TPU, consulta Informazioni sulle prenotazioni Cloud TPU.

  • --node-labels cloud.google.com/gke-workload-type=HIGH_AVAILABILITY: indica a GKE che il pool di nodi di sezioni TPU single-host fa parte di una raccolta. Utilizza questo flag se si applicano le seguenti condizioni:

    • Il pool di nodi esegue il workload di inferenza nel nuovo pool di nodi.
    • Il pool di nodi utilizza TPU Trillium.
    • Il pool di nodi non utilizza VM spot.

    Per scoprire di più sulla gestione della pianificazione della raccolta, consulta Gestisci la pianificazione della raccolta in sezioni TPU single-host.

  • --enable-autoscaling: crea un pool di nodi con la scalabilità automatica abilitata. Richiede i seguenti flag aggiuntivi:

    • --total-min-nodes=TOTAL_MIN_NODES: il numero minimo di tutti i nodi nel pool di nodi.
    • --total-max-nodes=TOTAL_MAX_NODES: il numero massimo di tutti i nodi nel pool di nodi.
    • --location-policy=ANY: assegna la priorità all'utilizzo delle prenotazioni inutilizzate e riduci il rischio di prerilascio delle VM spot.
  • --spot: imposta il pool di nodi in modo che utilizzi VM spot per i nodi nel pool di nodi. Questa opzione non può essere modificata dopo la creazione pool di nodi.

  • --flex-start: imposta il pool di nodi in modo che utilizzi le VM con avvio flessibile. Le VM con avvio flessibile vengono create utilizzando l'opzione di consumo flex-start. Per ulteriori informazioni, vedi Esegui un workload batch di piccole dimensioni con TPU e VM con avvio flessibile.

Per un elenco completo di tutti i flag che puoi specificare, consulta la documentazione di riferimento di gcloud container clusters create.

Terraform

  1. Assicurati di utilizzare la versione 4.84.0 o successiva del provider google.
  2. Aggiungi il seguente blocco alla configurazione di Terraform:
resource "google_container_node_pool" "NODE_POOL_RESOURCE_NAME" {
  provider           = google
  project            = PROJECT_ID
  cluster            = CLUSTER_NAME
  name               = POOL_NAME
  location           = CLUSTER_LOCATION
  node_locations     = [NODE_ZONES]

  node_config {
    machine_type = MACHINE_TYPE
    reservation_affinity {
      consume_reservation_type = "SPECIFIC_RESERVATION"
      key = "compute.googleapis.com/reservation-name"
      values = [RESERVATION_LABEL_VALUES]
    }
    spot = true
    flex_start = false
  }
}

Sostituisci quanto segue:

  • NODE_POOL_RESOURCE_NAME: il nome della risorsa del pool di nodi nel template Terraform.
  • PROJECT_ID: il tuo ID progetto.
  • CLUSTER_NAME: il nome del cluster esistente.
  • POOL_NAME: il nome del pool di nodi da creare.
  • CLUSTER_LOCATION: le zona di computing del cluster. Specifica la regione in cui è disponibile la versione della TPU. Per saperne di più, consulta Seleziona una versione e una topologia TPU.
  • NODE_ZONES: l'elenco separato da virgole di una o più zone in cui GKE crea il pool di nodi.

    (Facoltativo) Utilizza una zona AI, ad esempio us-central1-ai1a. Le zone AI sono località specializzate ottimizzate per i workload AI/ML all'interno delle regioni Google Cloud .

  • MACHINE_TYPE: il tipo di macchina TPU da utilizzare. Per visualizzare i tipi di macchine compatibili con TPU, utilizza la tabella in Scegli la versione di TPU.

Facoltativamente, puoi anche utilizzare le seguenti variabili:

  • autoscaling: crea un pool di nodi con la scalabilità automatica abilitata. Per una sezione TPU single-host, GKE scala tra i valori TOTAL_MIN_NODES e TOTAL_MAX_NODES.
    • TOTAL_MIN_NODES: il numero minimo di tutti i nodi nel pool di nodi. Questo campo è facoltativo, a meno che non venga specificata anche la scalabilità automatica.
    • TOTAL_MAX_NODES: il numero massimo di tutti i nodi nel pool di nodi. Questo campo è facoltativo, a meno che non venga specificata anche la scalabilità automatica.
  • RESERVATION_NAME: se utilizzi le prenotazioni di Cloud TPU, questo è l'elenco delle etichette delle risorse di prenotazione da utilizzare durante la creazione del pool di nodi. Per scoprire di più su come compilare RESERVATION_LABEL_VALUES nel campo reservation_affinity, consulta Provider Terraform.
  • spot: imposta il pool di nodi in modo che utilizzi le VM spot per i nodi TPU. Questa opzione non può essere modificata dopo la creazione pool di nodi. Per saperne di più, consulta VM spot.
  • flex_start: imposta il pool di nodi in modo che utilizzi l'opzione di consumo avvio flessibile. Non può essere impostato su true se spot è abilitato. L'avvio flessibile è supportato in GKE versione 1.33.0-gke.1712000 o successive.

Console

Per creare un pool di nodi con TPU:

  1. Vai alla pagina Google Kubernetes Engine nella console Google Cloud .

    Vai a Google Kubernetes Engine

  2. Nell'elenco dei cluster, fai clic sul nome del cluster da modificare.

  3. Fai clic sulla scheda Nodi.

  4. Fai clic su Crea node pool gestito dall'utente.

  5. Nella sezione Dettagli del pool di nodi, seleziona la casella Specifica le località dei nodi.

  6. Seleziona la zona in base alla versione della TPU che vuoi utilizzare. Per identificare una zona disponibile, consulta Disponibilità delle TPU in GKE.

  7. Nel riquadro di navigazione, fai clic su Nodi.

  8. Nella sezione Configurazione macchina, seleziona TPU.

  9. Nel menu a discesa Serie, seleziona una delle seguenti opzioni:

    • CT3: TPU v3, dispositivo host singolo
    • CT3P: TPU v3, slice di pod multi-host
    • CT4P: TPU v4
    • CT5LP: TPU v5e
    • CT5P: TPU v5p
    • CT6E: TPU Trillium (v6e)
  10. Nel menu a discesa Tipo di macchina, seleziona il nome della macchina da utilizzare per i nodi. Utilizza la tabella Scegli la versione TPU per scoprire come definire il tipo di macchina e la topologia TPU che creano un pool di nodi di sezioni TPU single-host.

  11. Nel menu a discesa Topologia TPU, seleziona la topologia fisica per la sezione TPU.

  12. Nella finestra di dialogo Modifiche necessarie, fai clic su Apporta modifiche.

  13. Assicurati che il Tipo di disco di avvio sia Disco permanente standard o Disco permanente SSD.

  14. Se vuoi, seleziona la casella di controllo Abilita nodi sulle VM Spot per utilizzare le VM Spot per i nodi nel pool di nodi.

  15. Fai clic su Crea.

Crea un pool di nodi di slice TPU multi-host

I passaggi per creare un pool di nodi di sezioni TPU multi-host variano a seconda che utilizzi Ironwood (TPU7x) o una versione precedente di TPU.

Ironwood (TPU7x)

Puoi creare un pool di nodi di slice TPU multi-host nella versione Ironwood (TPU7x) utilizzando Google Cloud CLI o Terraform:

gcloud

Per creare un pool di nodi di sezioni TPU multi-host con Ironwood (TPU7x), devi prima creare una policy del workload.

  1. Crea una policy del workload:

    gcloud compute resource-policies create workload-policy WORKLOAD_POLICY_NAME \
        --type=HIGH_THROUGHPUT \
        --accelerator-topology=TPU_TOPOLOGY \
        --project=PROJECT_ID \
        --region=REGION
    

    Sostituisci quanto segue:

    • WORKLOAD_POLICY_NAME: un nome per la policy del workload.
    • TPU_TOPOLOGY: la topologia TPU Ironwood (TPU7x). Ad esempio, 2x2x2. Per visualizzare tutte le topologie Ironwood (TPU7x) supportate, consulta la sezione sulla topologia.
    • PROJECT_ID: il tuo ID progetto Google Cloud .
    • REGION: la regione della policy del workload. Una policy del workload è una risorsa di regione e può essere riutilizzata tra i node pool che condividono la stessa topologia.
  2. Crea il pool di nodi con la policy del workload:

    gcloud container node-pools create NODE_POOL_NAME \
      --cluster=CLUSTER_NAME \
      --machine-type=tpu7x-standard-4t \
      --placement-policy=WORKLOAD_POLICY_NAME \
      --location=CONTROL_PLANE_LOCATION \
      --node-locations=NODE_ZONE \
      --project=PROJECT_ID \
      --reservation=RESERVATION_NAME \
      --reservation-affinity=specific
    

    Sostituisci quanto segue:

    • NODE_POOL_NAME: il nome del nuovo pool di nodi.
    • CLUSTER_NAME: il nome del tuo cluster GKE.
    • WORKLOAD_POLICY_NAME: il nome della policy del workload che hai creato.
    • CONTROL_PLANE_LOCATION: la località di Compute Engine del control plane del tuo cluster. Specifica una regione per i cluster a livello di regione o una zona per i cluster a livello di zona.
    • NODE_ZONE: il nome della zona in base alla versione della TPU che vuoi utilizzare.

      (Facoltativo) Utilizza una zona AI, ad esempio us-central1-ai1a. Le zone AI sono località specializzate ottimizzate per i workload AI/ML all'interno delle regioni Google Cloud .

      Per identificare una località disponibile, consulta Disponibilità di TPU in GKE.
    • PROJECT_ID: il tuo ID progetto Google Cloud .
    • RESERVATION_NAME: il nome della prenotazione da utilizzare.

    In questo comando, il flag --tpu-topology è stato sostituito dal flag --placement-policy.

Terraform

  1. Assicurati di utilizzare la versione 4.84.0 o successiva del provider google.
  2. Crea una policy del workload:

    resource "google_compute_resource_policy" {
      name   = "WORKLOAD_POLICY_NAME"
      region = CLUSTER_LOCATION
      workload_policy {
        type = "HIGH_THROUGHPUT"
        accelerator_topology = "TPU_TOPOLOGY"
      }
    }
    

    Sostituisci quanto segue:

    • WORKLOAD_POLICY_NAME: un nome per la policy del workload.
    • CLUSTER_LOCATION: località di computing del cluster. Ti consigliamo di utilizzare un cluster a livello di regione per una maggiore affidabilità del control plane di Kubernetes. Puoi anche utilizzare un cluster di zona. Per saperne di più, consulta Seleziona una versione e una topologia TPU.
    • TPU_TOPOLOGY: la topologia TPU Ironwood (TPU7x). Ad esempio, 2x2x2. Per visualizzare tutte le topologie Ironwood (TPU7x) supportate, consulta Pianifica le TPU.

    Per saperne di più sul riferimento google_compute_resource_policy, consulta Provider Terraform.

  3. Nella configurazione di Terraform, aggiungi il seguente blocco:

    resource "google_container_node_pool" "NODE_POOL_RESOURCE_NAME" {
      provider           = google
      project            = PROJECT_ID
      cluster            = CLUSTER_NAME
      name               = POOL_NAME
      location           = CLUSTER_LOCATION
      node_locations     = [NODE_ZONES]
      initial_node_count = NUM_NODES
    
      autoscaling {
        max_node_count = MAX_NODES
        location_policy      = "ANY"
      }
      node_config {
        machine_type = MACHINE_TYPE
        reservation_affinity {
          consume_reservation_type = "SPECIFIC_RESERVATION"
          key = "compute.googleapis.com/reservation-name"
          values = [RESERVATION_LABEL_VALUES]
        }
        flex_start = false
        spot = true
      }
    
      placement_policy {
        policy_name = WORKLOAD_POLICY_NAME
      }
    }
    

    Sostituisci quanto segue:

    • NODE_POOL_RESOURCE_NAME: il nome della risorsa del node pool nel template Terraform.
    • PROJECT_ID: il tuo ID progetto.
    • CLUSTER_NAME: il nome del cluster esistente a cui aggiungere il pool di nodi.
    • POOL_NAME: il nome del pool di nodi da creare.
    • NODE_ZONES: l'elenco separato da virgole di una o più zone in cui GKE crea il pool di nodi.

      (Facoltativo) Utilizza una zona AI, ad esempio us-central1-ai1a. Le zone AI sono località specializzate ottimizzate per i workload AI/ML all'interno delle regioni Google Cloud .

    • NUM_NODES: il numero di nodi nel node pool. Deve essere pari a zero o al prodotto del numero di chip TPU diviso per quattro, perché nelle sezioni TPU multi-host ogni nodo della sezione TPU ha quattro chip. Ad esempio, se TPU_TOPOLOGY è 4x8, allora ci sono 32 chip, il che significa che NUM_NODES deve essere 8. Per scoprire di più sulle topologie TPU, utilizza la tabella in Scegli la versione di TPU.
    • TPU_TOPOLOGY: indica la topologia fisica selezionata per la sezione TPU. Il formato della topologia dipende dalla versione della TPU che stai utilizzando. Per scoprire di più sulle topologie TPU, utilizza la tabella in Scegli una topologia.

    Facoltativamente, puoi anche utilizzare le seguenti variabili:

    • RESERVATION_NAME: se utilizzi una prenotazione TPU, fornisci un elenco di etichette delle risorse di prenotazione da utilizzare durante la creazione del pool di nodi. Per scoprire di più su come compilare RESERVATION_LABEL_VALUES nel campo reservation_affinity, consulta Provider Terraform.
    • autoscaling: crea un pool di nodi con la scalabilità automatica abilitata. Quando GKE scala un pool di nodi di sezioni TPU multi-host, esegue lo scale up del pool di nodi in modo atomico da zero alla dimensione massima.
      • MAX_NODES: la dimensione massima del node pool. Il valore deve essere uguale al prodotto dei valori definiti in TPU_TOPOLOGY ({A}x{B}x{C}) diviso per il numero di chip in ogni VM. Ad esempio, se TPU_TOPOLOGY è 2x2x2, il prodotto è 8. Poiché ogni VM in tpu7x-standard-4t ha 4 chip, il numero di nodi è 2.
    • spot: il pool di nodi che utilizzerà le VM spot per i nodi della sezione TPU. Questa impostazione non può essere modificata dopo la creazione del pool di nodi. Per ulteriori informazioni, consulta VM spot.
    • flex_start: il pool di nodi che utilizzerà l'opzione di consumo avvio flessibile. Questa impostazione non può essere impostata su true se spot è abilitato.

Altre versioni di TPU

Puoi creare un pool di nodi di sezione TPU multi-host nella versione v3, v4, v5p, v5e e Trillium (v6e) utilizzando Google Cloud CLI, Terraform o la console Google Cloud .

gcloud

  gcloud container node-pools create POOL_NAME \
      --location=CONTROL_PLANE_LOCATION \
      --cluster=CLUSTER_NAME \
      --node-locations=NODE_ZONE \
      --machine-type=MACHINE_TYPE \
      --tpu-topology=TPU_TOPOLOGY \
      [--num-nodes=NUM_NODES] \
      [--spot \]
      [--flex-start \]
      [--enable-autoscaling \
        --max-nodes MAX_NODES]
      [--reservation-affinity=specific \
      --reservation=RESERVATION_NAME] \
      [--node-labels cloud.google.com/gke-nodepool-group-name=COLLECTION_NAME,cloud.google.com/gke-workload-type=HIGH_AVAILABILITY]
      [--placement-type=COMPACT]

Sostituisci quanto segue:

  • POOL_NAME: il nome del nuovo pool di nodi.
  • CONTROL_PLANE_LOCATION: il nome della zona in base alla versione della TPU che vuoi utilizzare. Per identificare una località disponibile, consulta Disponibilità di TPU in GKE.
  • CLUSTER_NAME: il nome del cluster.
  • NODE_ZONES: l'elenco separato da virgole di una o più zone in cui GKE crea il pool di nodi.

    (Facoltativo) Utilizza una zona AI, ad esempio us-central1-ai1a. Le zone AI sono località specializzate ottimizzate per i workload AI/ML all'interno delle regioni Google Cloud .

  • MACHINE_TYPE: il tipo di macchina da utilizzare per i nodi. Per scoprire di più sui tipi di macchine disponibili, consulta Scegli la versione della TPU.
  • TPU_TOPOLOGY: la topologia fisica della sezione TPU. Il formato della topologia dipende dalla versione della TPU. Per scoprire di più sulle topologie TPU, utilizza la tabella in Scegli una topologia.

    Per saperne di più, consulta Topologia.

    Facoltativamente, puoi anche utilizzare i seguenti flag:

  • NUM_NODES: il numero di nodi nel pool di nodi. Deve essere pari a zero o al prodotto dei valori definiti in TPU_TOPOLOGY ({A}x{B}x{C}) diviso per il numero di chip in ogni VM. Per TPU v4 e TPU v5e multi-host, il numero di chip in ogni VM è quattro. Pertanto, se il tuo TPU_TOPOLOGY è 2x4x4 (TPU v4 con quattro chip in ogni VM), il NUM_NODES è 32/4, che equivale a 8. Se ometti questo flag, il numero di nodi viene calcolato e impostato sul valore predefinito in base alla topologia e al tipo di macchina.

  • RESERVATION_NAME: il nome della prenotazione utilizzata da GKE durante la creazione del pool di nodi. Se ometti questo flag, GKE utilizza i pool di nodi di sezioni TPU disponibili. Per saperne di più sulle prenotazioni di TPU, consulta Prenotazione di TPU.

  • --spot: imposta il pool di nodi in modo che utilizzi le VM spot per i nodi della sezione TPU. Questa opzione non può essere modificata dopo la creazione pool di nodi. Per saperne di più, consulta VM spot.

  • --flex-start: imposta il pool di nodi in modo che utilizzi le VM con avvio flessibile. Le VM con avvio flessibile vengono create utilizzando l'opzione di consumo avvio flessibile, supportata in GKE versione 1.33.0-gke.1712000 o successive.

  • --enable-autoscaling: crea un pool di nodi con la scalabilità automatica abilitata. Quando GKE scala un pool di nodi di sezioni TPU multi-host, esegue lo scale up del pool di nodi in modo atomico da zero alla dimensione massima.

    • MAX_NODES: la dimensione massima del node pool. Il flag --max-nodes è obbligatorio se viene fornito --enable-autoscaling e deve essere uguale al prodotto dei valori definiti in TPU_TOPOLOGY ({A}x{B}x{C}) diviso per il numero di chip in ogni VM.
  • --node-label=cloud.google.com/gke-nodepool-group-name=COLLECTION_NAME, cloud.google.com/gke-workload-type=HIGH_AVAILABILITY: indica a GKE che il pool di nodi di slice TPU multi-host è una raccolta. Utilizza questo flag se si applicano le seguenti condizioni:

    • Il pool di nodi esegue workload di inferenza.
    • Il pool di nodi utilizza TPU Trillium.
    • Le VM spot non supportano la pianificazione della raccolta.

    Per saperne di più sulla gestione della pianificazione della raccolta, consulta Gestisci la pianificazione della raccolta in sezioni TPU multi-host.

  • --placement-type=COMPACT: crea un pool di nodi con il posizionamento compatto abilitato. Questa opzione deve essere utilizzata con il flag --tpu-topology. Per saperne di più, consulta Crea una policy di posizionamento compatto e Topologia TPU.

Terraform

  1. Assicurati di utilizzare la versione 4.84.0 o successiva del provider google.
  2. Aggiungi il seguente blocco alla configurazione di Terraform:

    resource "google_container_node_pool" "NODE_POOL_RESOURCE_NAME" {
      provider           = google
      project            = PROJECT_ID
      cluster            = CLUSTER_NAME
      name               = POOL_NAME
      location           = CLUSTER_LOCATION
      node_locations     = [NODE_ZONES]
      initial_node_count = NUM_NODES
    
      autoscaling {
        max_node_count = MAX_NODES
        location_policy      = "ANY"
      }
      node_config {
        machine_type = MACHINE_TYPE
        reservation_affinity {
          consume_reservation_type = "SPECIFIC_RESERVATION"
          key = "compute.googleapis.com/reservation-name"
          values = [RESERVATION_LABEL_VALUES]
        }
        flex_start = false
        spot = true
      }
    
      placement_policy {
        type = "COMPACT"
        tpu_topology = TPU_TOPOLOGY
      }
    }
    

    Sostituisci quanto segue:

    • NODE_POOL_RESOURCE_NAME: il nome della risorsa del node pool nel template Terraform.
    • PROJECT_ID: il tuo ID progetto.
    • CLUSTER_NAME: il nome del cluster esistente a cui aggiungere il pool di nodi.
    • POOL_NAME: il nome del pool di nodi da creare.
    • CLUSTER_LOCATION: la località di computing del cluster. Ti consigliamo di utilizzare un cluster a livello di regione per una maggiore affidabilità del control plane di Kubernetes. Puoi anche utilizzare un cluster di zona. Per saperne di più, consulta Seleziona una versione e una topologia TPU.
    • NODE_ZONES: l'elenco separato da virgole di una o più zone in cui GKE crea il pool di nodi.

      (Facoltativo) Utilizza una zona AI, ad esempio us-central1-ai1a. Le zone AI sono località specializzate ottimizzate per i workload AI/ML all'interno delle regioni Google Cloud .

    • NUM_NODES: il numero di nodi nel node pool. Deve essere pari a zero o al prodotto del numero di chip TPU diviso per quattro, perché nei nodi di sezioni TPU multi-host ogni nodo di sezione TPU ha 4 chip. Ad esempio, se TPU_TOPOLOGY è 4x8, sono presenti 32 chip, il che significa che NUM_NODES deve essere 8. Per scoprire di più sulle topologie TPU, utilizza la tabella in Scegli la versione di TPU.
    • TPU_TOPOLOGY: indica la topologia fisica della sezione TPU. Il formato della topologia dipende dalla versione della TPU che stai utilizzando. Per scoprire di più sulle topologie TPU, utilizza la tabella in Scegli una topologia.

    Facoltativamente, puoi anche utilizzare le seguenti variabili:

    • RESERVATION_NAME: se utilizzi la prenotazione TPU, questo è l'elenco delle etichette delle risorse di prenotazione da utilizzare durante la creazione del pool di nodi. Per scoprire di più su come compilare RESERVATION_LABEL_VALUES nel campo reservation_affinity, consulta Provider Terraform.
    • autoscaling: crea un pool di nodi con la scalabilità automatica abilitata. Quando GKE scala un pool di nodi di sezioni TPU multi-host, esegue lo scale up del pool di nodi in modo atomico da zero alla dimensione massima.
      • MAX_NODES: la dimensione massima del node pool. Deve essere uguale al prodotto dei valori definiti in TPU_TOPOLOGY ({A}x{B}x{C}) diviso per il numero di chip in ogni VM).
    • spot: consente al pool di nodi di utilizzare le VM spot per i nodi della sezione TPU. Questa opzione non può essere modificata dopo la creazione pool di nodi. Per ulteriori informazioni, consulta VM spot.
    • flex_start: imposta il pool di nodi in modo che utilizzi l'opzione di consumo avvio flessibile. Non può essere impostato su true se spot è abilitato.

Console

Per creare un pool di nodi con TPU:

  1. Vai alla pagina Google Kubernetes Engine nella console Google Cloud .

    Vai a Google Kubernetes Engine

  2. Nell'elenco dei cluster, fai clic sul nome del cluster da modificare.

  3. Fai clic sulla scheda Nodi.

  4. Fai clic su Crea node pool gestito dall'utente.

  5. Nella sezione Dettagli del pool di nodi, seleziona la casella Specifica le località dei nodi.

  6. Seleziona il nome della zona in base alla versione della TPU che vuoi utilizzare. Per identificare una località disponibile, consulta Disponibilità di TPU in GKE.

  7. Nel riquadro di navigazione, fai clic su Nodi.

  8. Nella sezione Configurazione macchina, seleziona TPU.

  9. Nel menu a discesa Serie, seleziona una delle seguenti opzioni:

    • CT3: TPU v3, dispositivo single-host
    • CT3P: TPU v3, slice di pod multi-host
    • CT4P: TPU v4
    • CT5LP: TPU v5e
    • CT5P: TPU v5p
    • CT6E: TPU Trillium (v6e)
  10. Nel menu a discesa Tipo di macchina, seleziona il nome della macchina da utilizzare per i nodi. Utilizza la tabella Scegli la versione TPU per scoprire come definire il tipo di macchina e la topologia TPU che creano un pool di nodi di sezioni TPU multi-host.

  11. Nel menu a discesa Topologia TPU, seleziona la topologia fisica per la sezione TPU.

  12. Nella finestra di dialogo Modifiche necessarie, fai clic su Apporta modifiche.

  13. Assicurati che il Tipo di disco di avvio sia Disco permanente standard o Disco permanente SSD.

  14. Se vuoi, seleziona la casella di controllo Abilita nodi sulle VM Spot per utilizzare le VM Spot per i nodi nel pool di nodi.

  15. Fai clic su Crea.

Utilizza il provisioning automatico dei nodi GKE

Puoi configurare GKE in modo da creare ed eliminare automaticamente i pool di nodi per soddisfare le esigenze di risorse dei tuoi workload TPU.

  1. Per abilitare il provisioning automatico dei pool di nodi, modifica i limiti delle risorse TPU del cluster:

      gcloud container clusters update CLUSTER_NAME \
          --location=CONTROL_PLANE_LOCATION \
          --enable-autoprovisioning \
          --min-cpu=MINIMUM_CPU \
          --min-memory=MINIMUM_MEMORY \
          --max-cpu=MAXIMUM_CPU \
          --max-memory=MAXIMUM_MEMORY \
          --min-accelerator=type=TPU_TYPE,count=MINIMUM_TPU_COUNT \
          --max-accelerator=type=TPU_TYPE,count=MAXIMUM_TPU_COUNT
    

    Sostituisci quanto segue:

    • TPU_TYPE: il tipo di TPU. Ad esempio, utilizza tpu7x per Ironwood (TPU7x).
    • MINIMUM_TPU_COUNT: il numero minimo di chip TPU del tipo specificato che il cluster può avere. Se il valore specificato è maggiore del numero di chip TPU in una sezione TPU multi-host, GKE rimuove tutti i nodi della sezione. I pool di nodi multi-host scalano tra 0 e il numero di nodi nello slice, senza valori intermedi.
    • MAXIMUM_TPU_COUNT: il numero massimo di chip TPU del tipo specificato che il cluster può avere. Per le sezioni TPU multi-host, specifica un valore maggiore del numero di chip in ogni sezione in modo che GKE possa scalare la sezione in modo atomico. Il numero di chip in una sezione è il prodotto della topologia TPU. Ad esempio, se la topologia è 2x2x2, il numero di chip nello slice è 8, il che significa che il valore di MAXIMUM_TPU_COUNT deve essere maggiore di 8.

Definisci ComputeClass personalizzate

Puoi anche configurare GKE in modo che richieda TPU durante le operazioni di scalabilità che creano nuovi nodi utilizzando ComputeClass personalizzate.

Puoi specificare le opzioni di configurazione della TPU nella specifica della ComputeClass personalizzata. Quando un workload GKE utilizza questa ComputeClass personalizzata, GKE tenta di eseguire il provisioning delle TPU che utilizzano la configurazione specificata durante lo scale up.

Le sezioni seguenti mostrano come creare una ComputeClass personalizzata e poi un job che utilizza le TPU definite nella ComputeClass.

Crea una ComputeClass personalizzata

I passaggi per creare una ComputeClass personalizzata che segue le regole TPU variano a seconda che utilizzi Ironwood (TPU7x) o una versione TPU precedente.

Ironwood (TPU7x)

  1. Crea una policy del workload. Questo passaggio è obbligatorio solo se stai creando un pool di nodi multi-host, che dipende dalla topologia scelta. Se utilizzi un pool di nodi single-host, salta questo passaggio.

    gcloud compute resource-policies create workload-policy WORKLOAD_POLICY_NAME \
        --type=HIGH_THROUGHPUT \
        --accelerator-topology=TPU_TOPOLOGY \
        --project=PROJECT_ID \
        --region=REGION
    

    Sostituisci quanto segue:

    • WORKLOAD_POLICY_NAME: un nome per la policy del workload.
    • TPU_TOPOLOGY: la topologia TPU Ironwood (TPU7x). Ad esempio, utilizza 2x2x2. Per saperne di più su tutte le topologie Ironwood (TPU7x) supportate, consulta la sezione sulla topologia.
    • PROJECT_ID: l'ID progetto Google Cloud .
    • REGION: la regione della policy del workload. Una policy dei workload è una risorsa di regione e puoi utilizzarla in più pool di nodi.
  2. Salva il seguente manifest come tpu-compute-class.yaml:

    apiVersion: cloud.google.com/v1
    kind: ComputeClass
    metadata:
      name: tpu-class
    spec:
      priorities:
        - tpu:
            type: tpu7x
            topology: TPU_TOPOLOGY
            count: 4
          placement:
            policyName: WORKLOAD_POLICY_NAME
      nodePoolAutoCreation:
        enabled: true
    
  3. (Facoltativo) Puoi utilizzare una prenotazione o un blocco secondario specifico. Ad esempio, puoi aggiungere il seguente specs al manifest ComputeClass:

      reservations:
        affinity: Specific
        specific:
          - name: RESERVATION_NAME
            reservationBlock:
              name: RESERVATION_BLOCK_NAME
              reservationSubBlock:
                name: RESERVATION_SUB_BLOCK_NAME
    

    Sostituisci quanto segue:

    • RESERVATION_NAME: il nome della prenotazione della capacità di Compute Engine.
    • RESERVATION_BLOCK_NAME: il nome del blocco di prenotazione della capacità di Compute Engine.
    • RESERVATION_SUB_BLOCK_NAME: il nome del blocco secondario di prenotazione della capacità di Compute Engine.

    Per saperne di più, consulta Utilizzo delle risorse di zona prenotate.

Altre versioni di TPU

Per eseguire il provisioning di TPU v3, v4, v5p, v5e o v6e (Trillium) utilizzando una ComputeClass personalizzata configurata per le TPU, completa i seguenti passaggi:

  1. Salva il seguente manifest come tpu-compute-class.yaml:

    apiVersion: cloud.google.com/v1
    kind: ComputeClass
    metadata:
      name: tpu-class
    spec:
      priorities:
      - tpu:
          type: TPU_TYPE
          count: NUMBER_OF_CHIPS
          topology: TOPOLOGY
      - spot: true
        tpu:
          type: TPU_TYPE
          count: NUMBER_OF_CHIPS
          topology: TOPOLOGY
      - flexStart:
          enabled: true
        tpu:
          type: TPU_TYPE
          count: NUMBER_OF_CHIPS
          topology: TOPOLOGY
      nodePoolAutoCreation:
        enabled: true
    

    Sostituisci quanto segue:

    • TPU_TYPE: il tipo di TPU da utilizzare, ad esempio tpu-v4-podslice. Deve essere un valore supportato da GKE.
    • TOPOLOGY: la disposizione dei chip TPU nello slice, ad esempio 2x2x4. Deve essere una topologia supportata per il tipo di TPU selezionato.
    • NUMBER_OF_CHIPS: il numero di chip TPU che il container deve utilizzare. Deve essere lo stesso valore per limits e requests.
  2. Esegui il deployment di ComputeClass:

    kubectl apply -f tpu-compute-class.yaml
    

    Per ulteriori informazioni sulle ComputeClass personalizzate e sulle TPU, consulta Configurazione delle TPU.

Crea un job che utilizza le TPU

  1. Salva il seguente manifest come tpu-job.yaml:

    apiVersion: v1
    kind: Service
    metadata:
      name: headless-svc
    spec:
      clusterIP: None
      selector:
        job-name: tpu-job
    ---
    apiVersion: batch/v1
    kind: Job
    metadata:
      name: tpu-job
    spec:
      backoffLimit: 0
      completions: 4
      parallelism: 4
      completionMode: Indexed
      template:
        spec:
          subdomain: headless-svc
          restartPolicy: Never
          nodeSelector:
            cloud.google.com/compute-class: tpu-class
          containers:
          - name: tpu-job
            image: us-docker.pkg.dev/cloud-tpu-images/jax-ai-image/tpu:latest
            ports:
            - containerPort: 8471 # Default port using which TPU VMs communicate
            - containerPort: 8431 # Port to export TPU runtime metrics, if supported.
            command:
            - bash
            - -c
            - |
              python -c 'import jax; print("TPU cores:", jax.device_count())'
            resources:
              requests:
                cpu: 10
                memory: MEMORY_SIZE
                google.com/tpu: NUMBER_OF_CHIPS
              limits:
                cpu: 10
                memory: MEMORY_SIZE
                google.com/tpu: NUMBER_OF_CHIPS
    

    Sostituisci quanto segue:

    • NUMBER_OF_CHIPS: il numero di chip TPU che il container deve utilizzare. Deve essere lo stesso valore per limits e requests, uguale al valore CHIP_COUNT nella ComputeClass personalizzata selezionata.
    • MEMORY_SIZE: la quantità massima di memoria utilizzata dalla TPU. I limiti di memoria dipendono dalla versione e dalla topologia della TPU che utilizzi. Per saperne di più, consulta Valori minimi e massimi per gli acceleratori.
    • NUMBER_OF_CHIPS: il numero di chip TPU che il container deve utilizzare. Deve essere lo stesso valore per limits e requests.
  2. Esegui il deployment del job:

    kubectl create -f tpu-job.yaml
    

    Quando crei questo job, GKE esegue automaticamente quanto segue:

    • Esegue il provisioning dei nodi per l'esecuzione dei pod. A seconda del tipo di TPU, della topologia e delle richieste di risorse che hai specificato, questi nodi sono sezioni single-host o multi-host. A seconda della disponibilità delle risorse TPU nella priorità più alta, GKE potrebbe passare a priorità più basse per massimizzare la flessibilità, l'efficienza e la disponibilità della capacità dell'acceleratore.
    • Aggiunge incompatibilità ai pod e tolleranze ai nodi per impedire l'esecuzione di altri workload sugli stessi nodi dei workload TPU.

    Per saperne di più, consulta Informazioni sulle ComputeClass personalizzate.

  3. Al termine di questa sezione, puoi evitare l'addebito di ulteriori costi eliminando le risorse create:

    kubectl delete -f tpu-job.yaml
    

Prepara i workload

I workload TPU devono soddisfare i seguenti requisiti di preparazione.

  1. Framework come JAX, PyTorch e TensorFlow accedono alle VM TPU utilizzando la libreria condivisa libtpu. libtpu include il compilatore XLA, il software di runtime TPU e il driver TPU. Ogni release di PyTorch e JAX richiede una determinata versione di libtpu.so. Per evitare conflitti tra le versioni dei pacchetti, ti consigliamo di utilizzare un'immagine AI JAX. Per utilizzare le TPU in GKE, assicurati di utilizzare le seguenti versioni: tpu7x
    Tipo di TPU libtpu.so versione
    Ironwood (TPU7x)
    TPU Trillium (v6e)
    tpu-v6e-slice
    TPU v5e
    tpu-v5-lite-podslice
    TPU v5p
    tpu-v5p-slice
    TPU v4
    tpu-v4-podslice
    TPU v3
    tpu-v3-slice
    tpu-v3-device
  2. Nel manifest del workload, aggiungi i selettori dei nodi Kubernetes per assicurarti che GKE pianifichi il workload TPU sul tipo di macchina TPU e sulla topologia TPU che hai definito:

      nodeSelector:
        cloud.google.com/gke-tpu-accelerator: TPU_ACCELERATOR
        cloud.google.com/gke-tpu-topology: TPU_TOPOLOGY
        cloud.google.com/placement-policy-name: WORKLOAD_POLICY # Required only for Ironwood (TPU7x)
      

    Sostituisci quanto segue:

    • TPU_ACCELERATOR: il nome dell'acceleratore TPU. Ad esempio, utilizza tpu7x-standard-4t.
    • TPU_TOPOLOGY: la topologia fisica della sezione TPU. Il formato della topologia dipende dalla versione della TPU. Ad esempio, utilizza 2x2x2. Per saperne di più, consulta Pianifica le TPU in GKE.
    • WORKLOAD_POLICY: il nome della policy del workload che vuoi utilizzare per posizionare i pod di TPU. Questo selettore di nodi è obbligatorio solo per Ironwood (TPU7x).

Una volta completata la preparazione del workload, puoi eseguire un job che utilizza le TPU.

Le sezioni seguenti mostrano esempi di come eseguire un job che esegue calcoli di base con le TPU.

Esegui il workload sui nodi di una sezione TPU

Questa sezione spiega come preparare i workload e fornisce esempi di come eseguirli.

Esempio 1: esegui un deployment che richiede TPU nella specifica del pod

gcloud

GKE utilizza la configurazione nel pod o in ComputeClass per determinare la configurazione dei nodi TPU. Il seguente manifest è un esempio di specifica di un deployment che richiede TPU nella specifica del pod. Se l'impostazione di provisioning automatico dei nodi a livello di cluster è abilitata, questo deployment attiva la creazione automatica del pool di nodi. Quando crei questo deployment di esempio, GKE crea un pool di nodi che contiene una sezione TPU v4 con una topologia 2x2x2 e due macchine ct4p-hightpu-4t.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: tpu-workload
  labels:
    app: tpu-workload
spec:
  replicas: 2
  template:
    spec:
      nodeSelector:
        cloud.google.com/gke-tpu-accelerator: tpu-v4-podslice
        cloud.google.com/gke-tpu-topology: 2x2x2
      containers:
      - name: tpu-job
        image: us-docker.pkg.dev/cloud-tpu-images/jax-ai-image/tpu:latest
        ports:
        - containerPort: 8431 # Port to export TPU runtime metrics, if supported.
        securityContext:
          privileged: true # Required for GKE versions earlier than 1.28 to access TPUs.
        command:
        - bash
        - -c
        - |
          python -c 'import jax; print("Total TPU chips:", jax.device_count())'
        resources:
          requests:
            google.com/tpu: 4
          limits:
            google.com/tpu: 4
        ports:
        - containerPort: 80

In questo manifest, i seguenti campi definiscono la configurazione della TPU:

  • cloud.google.com/gke-tpu-accelerator: tipo e versione TPU. Ad esempio, utilizza tpu7x-standard-4t per Ironwood (TPU7x).
  • cloud.google.com/gke-tpu-topology: la topologia con il numero e la disposizione fisica dei chip TPU all'interno di una sezione TPU. Ad esempio, utilizza 2x2x2.
  • limits.google.com/tpu: il numero di chip TPU per VM. Ad esempio, se utilizzi tpu7x-standard-4t, il numero di chip TPU per VM è 4.

Cluster Toolkit

Invia il workload utilizzando il comando gcluster job submit. Per ulteriori informazioni sulle opzioni di invio dei job, consulta la guida all'invio dei job di Cluster Toolkit:

gcluster job submit \
  --name=WORKLOAD_NAME \
  --cluster=DEPLOYMENT_NAME \
  --project=PROJECT_ID \
  --location=ZONE \
  --compute-type=COMPUTE_TYPE \
  --topology=TOPOLOGY \
  --num-slices=1 \
  --image=us-docker.pkg.dev/cloud-tpu-images/jax-ai-image/tpu:latest \
  --command="python -c 'import jax; print(\"TPU cores:\", jax.device_count())'"

Sostituisci quanto segue:

  • WORKLOAD_NAME: il nome del tuo workload.
  • DEPLOYMENT_NAME: il nome del deployment di Cluster Toolkit (che è anche il nome del cluster GKE).
  • PROJECT_ID: il tuo ID progetto Google Cloud .
  • ZONE: il nome della zona in base alla versione della TPU che vuoi utilizzare. Per identificare una località disponibile, consulta Disponibilità di TPU in GKE.
  • COMPUTE_TYPE: il tipo di computing corrispondente al tipo di acceleratore del pool di nodi, ad esempio v6e-16, tpu7x-standard-4t o v5e-8.
  • TOPOLOGY: la topologia fisica corrispondente al tuo pool di nodi, ad esempio 2x4 o 2x2x2.

Esempio 2: esegui un workload che mostra il numero di chip TPU disponibili in un pool di nodi di sezioni TPU

Il seguente workload restituisce il numero di chip TPU in tutti i nodi di una sezione TPU multi-host. Per creare una sezione multi-host, il workload ha i seguenti parametri:

  • Versione TPU: TPU v4
  • Topologia: 2x2x4

La selezione di questa versione e di questa topologia genera uno slice multi-host.

  1. Salva il seguente manifest come available-chips-multihost.yaml:
    apiVersion: v1
    kind: Service
    metadata:
      name: headless-svc
    spec:
      clusterIP: None
      selector:
        job-name: tpu-available-chips
    ---
    apiVersion: batch/v1
    kind: Job
    metadata:
      name: tpu-available-chips
    spec:
      backoffLimit: 0
      completions: 4
      parallelism: 4
      completionMode: Indexed
      template:
        spec:
          subdomain: headless-svc
          restartPolicy: Never
          nodeSelector:
            cloud.google.com/gke-tpu-accelerator: tpu-v4-podslice # Node selector to target TPU v4 slice nodes.
            cloud.google.com/gke-tpu-topology: 2x2x4 # Specifies the physical topology for the TPU slice.
          containers:
          - name: tpu-job
            image: us-docker.pkg.dev/cloud-tpu-images/jax-ai-image/tpu:latest
            ports:
            - containerPort: 8471 # Default port using which TPU VMs communicate
            - containerPort: 8431 # Port to export TPU runtime metrics, if supported.
            securityContext:
              privileged: true # Required for GKE versions earlier than 1.28 to access TPUs.
            command:
            - bash
            - -c
            - |
              python -c 'import jax; print("TPU cores:", jax.device_count())' # Python command to count available TPU chips.
            resources:
              requests:
                cpu: 10
                memory: 407Gi
                google.com/tpu: 4 # Request 4 TPU chips for this workload.
              limits:
                cpu: 10
                memory: 407Gi
                google.com/tpu: 4 # Limit to 4 TPU chips for this workload.
  2. Esegui il deployment del manifest:
    kubectl create -f available-chips-multihost.yaml
    

    GKE esegue una sezione TPU v4 con quattro VM (sezione TPU multi-host). La sezione ha 16 chip TPU interconnessi.

  3. Verifica che il job abbia creato quattro pod:
    kubectl get pods
    

    L'output è simile al seguente:

    NAME                       READY   STATUS      RESTARTS   AGE
    tpu-job-podslice-0-5cd8r   0/1     Completed   0          97s
    tpu-job-podslice-1-lqqxt   0/1     Completed   0          97s
    tpu-job-podslice-2-f6kwh   0/1     Completed   0          97s
    tpu-job-podslice-3-m8b5c   0/1     Completed   0          97s
    
  4. Recupera i log di uno dei pod:
    kubectl logs POD_NAME
    

    Sostituisci POD_NAME con il nome di uno dei pod creati. Ad esempio, tpu-job-podslice-0-5cd8r.

    L'output è simile al seguente:

    TPU cores: 16
    
  5. (Facoltativo) Rimuovi il workload:
    kubectl delete -f available-chips-multihost.yaml
    

Esempio 3: esegui un workload che mostra il numero di chip TPU disponibili nella sezione TPU

Il seguente workload è un pod statico che mostra il numero di chip TPU collegati a un nodo specifico. Per creare un nodo single-host, il workload ha i seguenti parametri:

  • Versione TPU: TPU v5e
  • Topologia: 2x4

La selezione di questa versione e di questa topologia genera uno slice con un singolo host.

  1. Salva il seguente manifest come available-chips-singlehost.yaml:
    apiVersion: v1
    kind: Pod
    metadata:
      name: tpu-job-jax-v5
    spec:
      restartPolicy: Never
      nodeSelector:
        cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice # Node selector to target TPU v5e slice nodes.
        cloud.google.com/gke-tpu-topology: 2x4 # Specify the physical topology for the TPU slice.
      containers:
      - name: tpu-job
        image: us-docker.pkg.dev/cloud-tpu-images/jax-ai-image/tpu:latest
        ports:
        - containerPort: 8431 # Port to export TPU runtime metrics, if supported.
        securityContext:
          privileged: true # Required for GKE versions earlier than 1.28 to access TPUs.
        command:
        - bash
        - -c
        - |
          python -c 'import jax; print("Total TPU chips:", jax.device_count())'
        resources:
          requests:
            google.com/tpu: 8 # Request 8 TPU chips for this container.
          limits:
            google.com/tpu: 8 # Limit to 8 TPU chips for this container.
  2. Esegui il deployment del manifest:
    kubectl create -f available-chips-singlehost.yaml
    

    GKE esegue il provisioning dei nodi con otto sezioni TPU single-host che utilizzano TPU v5e. Ogni nodo TPU ha otto chip TPU (sezione TPU single-host).

  3. Recupera i log del pod:
    kubectl logs tpu-job-jax-v5
    

    L'output è simile al seguente:

    Total TPU chips: 8
    
  4. (Facoltativo) Rimuovi il workload:
      kubectl delete -f available-chips-singlehost.yaml
      

Esempio 4: esegui un workload che ha come target due nodi NUMA

Per ottimizzare le prestazioni dei workload, GKE ti consente di eseguirne il deployment in una configurazione multi-container. In questo modo, ogni container viene associato alle risorse di CPU, memoria e TPU all'interno di un determinato nodo NUMA. Per saperne di più sull'associazione NUMA, consulta Informazioni su Ironwood (TPU7x) in GKE.

  1. Crea un file denominato topology-manager-config.yaml con i seguenti contenuti:

    kubeletConfig:
      cpuManagerPolicy: static
      topologyManager:
        policy: best-effort
        scope: container
    

    Questa configurazione allinea le richieste di risorse di un container a un singolo nodo NUMA. Questa configurazione è necessaria affinché GKE ammetta e assegni correttamente i chip ai workload TPU multi-container. Per altre opzioni delle policy, consulta Policy di Topology Manager.

  2. Applica la configurazione kubelet a un pool di nodi creando un nuovo pool di nodi o aggiornandone uno esistente. Questo pool di nodi deve utilizzare nodi Ironwood (TPU7x), ad esempio il tipo di macchina tpu7x-standard-4t, per corrispondere al selettore di nodi nel passaggio successivo.

    • Per creare un nuovo pool di nodi con Topology Manager abilitato:

      gcloud container node-pools create NODE_POOL_NAME \
          --location=LOCATION \
          --cluster=CLUSTER_NAME \
          --node-locations=NODE_ZONES \
          --machine-type=tpu7x-standard-4t \
          --system-config-from-file=topology-manager-config.yaml
      

      Sostituisci quanto segue:

      • NODE_POOL_NAME: il nome del nuovo pool di nodi.
      • LOCATION: la regione del cluster.
      • CLUSTER_NAME: il nome del cluster.
      • NODE_ZONES: elenco separato da virgole di una o più zone per il pool di nodi.
    • Per aggiornare un pool di nodi esistente con Topology Manager abilitato:

      gcloud container node-pools update NODE_POOL_NAME \
          --location=LOCATION \
          --cluster=CLUSTER_NAME \
          --system-config-from-file=topology-manager-config.yaml
      

      Sostituisci quanto segue:

      • NODE_POOL_NAME: il nome del pool di nodi.
      • LOCATION: la regione del cluster.
      • CLUSTER_NAME: il nome del cluster.
  3. Crea un file denominato tpu-jobset.yaml con il seguente manifest:

    apiVersion: jobset.x-k8s.io/v1alpha2
    kind: JobSet
    metadata:
      name: tpu7x-test
    spec:
      failurePolicy:
        maxRestarts: 0
      replicatedJobs:
        - name: tpu7x
          replicas: 1
          template:
            spec:
              parallelism: 2
              completions: 2
              backoffLimit: 0
              template:
                spec:
                  subdomain: test
                  restartPolicy: Never
                  nodeSelector:
                    cloud.google.com/gke-tpu-accelerator: tpu7x
                    cloud.google.com/gke-tpu-topology: 2x2x2
                  containers:
                  - name: jax-tpu-1
                    image: us-docker.pkg.dev/cloud-tpu-images/jax-ai-image/tpu:latest
                    securityContext:
                      privileged: false
                    command:
                    - bash
                    - -c
                    - |
                      set -ex
                      python -c 'import jax; print("local devices:", jax.local_device_count(), "devices:", jax.device_count())'
                    resources:
                      requests:
                        google.com/tpu: 2
                      limits:
                        google.com/tpu: 2
                  - name: jax-tpu-2
                    image: us-docker.pkg.dev/cloud-tpu-images/jax-ai-image/tpu:latest
                    securityContext:
                      privileged: false
                    command:
                    - bash
                    - -c
                    - |
                      set -ex
    
                      python -c 'import jax; print("local devices:", jax.local_device_count(), "devices:", jax.device_count())'
                    resources:
                      requests:
                        google.com/tpu: 2
                      limits:
                        google.com/tpu: 2
    

    Questo manifest definisce un JobSet denominato tpu7x-test, che esegue due container principali, jax-tpu-1 e jax-tpu-2. Ogni container richiede due chip google.com/tpu. Questi due chip provengono dallo stesso nodo NUMA. Ogni container esegue quindi uno script Python per verificare l'accesso di JAX alle TPU.

    Questa configurazione di JobSet mostra che più container all'interno dello stesso pod possono accedere e utilizzare chip TPU separati.

  4. Applica il manifest:

    kubectl apply -f tpu-jobset.yaml
    

Esempio 5: esegui un workload TPU multi-container con volumi Cloud Storage FUSE multi-NIC

Questo esempio estende l'Esempio 4 per includere il montaggio dei bucket Cloud Storage FUSE come volumi utilizzando Cloud Storage FUSE. Questa configurazione sfrutta le funzionalità multi-NIC per migliorare potenzialmente le prestazioni della rete.

  1. Crea un file denominato tpu7x-gcsfuse-multinic.yaml con il seguente manifest:

    apiVersion: jobset.x-k8s.io/v1alpha2
    kind: JobSet
    metadata:
      name: tpu7x-gcsfuse-multinic
    spec:
      failurePolicy:
        maxRestarts: 0
      replicatedJobs:
        - name: tpu7x
          replicas: 1
          template:
            spec:
              parallelism: 2
              completions: 2
              backoffLimit: 0
              template:
                spec:
                  subdomain: test
                  restartPolicy: Never
                  nodeSelector:
                    cloud.google.com/gke-tpu-accelerator: tpu7x
                    cloud.google.com/gke-tpu-topology: 2x2x2
                  hostNetwork: true
                  volumes:
                  - name: gcs0
                    csi:
                      driver: gcsfuse.csi.storage.gke.io
                      volumeAttributes:
                        bucketName: BUCKET_NAME
                        multiNICIndex: "0"
                        mountOptions: implicit-dirs
                        hostNetworkPodKSA: "true"
                  - name: gcs1
                    csi:
                      driver: gcsfuse.csi.storage.gke.io
                      volumeAttributes:
                        bucketName: BUCKET_NAME
                        multiNICIndex: "1"
                        mountOptions: implicit-dirs
                        hostNetworkPodKSA: "true"
                  containers:
                  - name: jax-tpu-1
                    image: us-docker.pkg.dev/cloud-tpu-images/jax-ai-image/tpu:latest
                    securityContext:
                      privileged: false
                    command:
                    - bash
                    - -c
                    - |
                      set -ex
                      python -c 'import jax; print("local devices:", jax.local_device_count(), "devices:", jax.device_count())'
                      echo "Use /gcs${WORKLOAD_NIC_PREFERRED_NUMA}/ for Cloud Storage access"
                    resources:
                      requests:
                        google.com/tpu: 2
                      limits:
                        google.com/tpu: 2
                    volumeMounts:
                    - name: gcs0
                      mountPath: /gcs0
                      readOnly: false
                    - name: gcs1
                      mountPath: /gcs1
                      readOnly: false
                  - name: jax-tpu-2
                    image: us-docker.pkg.dev/cloud-tpu-images/jax-ai-image/tpu:latest
                    securityContext:
                      privileged: false
                    command:
                    - bash
                    - -c
                    - |
                      set -ex
    
                      python -c 'import jax; print("local devices:", jax.local_device_count(), "devices:", jax.device_count())'
                      echo "Use /gcs${WORKLOAD_NIC_PREFERRED_NUMA}/ for Cloud Storage access"
                    resources:
                      requests:
                        google.com/tpu: 2
                      limits:
                        google.com/tpu: 2
                    volumeMounts:
                    - name: gcs0
                      mountPath: /gcs0
                      readOnly: false
                    - name: gcs1
                      mountPath: /gcs1
                      readOnly: false
    

    Questo manifest aggiunge i seguenti montaggi dei volumi Cloud Storage FUSE all'Esempio 4.

    • multiNICIndex è specificato negli attributi del volume per utilizzare l'interfaccia di rete sul nodo NUMA corrispondente per ogni volume.
    • Il workload utilizza la variabile di ambiente ${WORKLOAD_NIC_PREFERRED_NUMA} per selezionare il volume Cloud Storage FUSE, associato al nodo NUMA a cui è assegnato il container. GKE inserisce questa variabile nei container sui workload Cloud TPU.

    Sostituisci BUCKET_NAME con il nome del tuo bucket Cloud Storage.

  2. Applica il manifest:

    kubectl apply -f tpu7x-gcsfuse-multinic.yaml
    

Esegui l'upgrade dei node pool utilizzando acceleratori (GPU e TPU)

GKE esegue automaticamente l'upgrade dei cluster Standard, inclusi i node pool. Puoi anche eseguire l'upgrade manuale dei node pool se vuoi che i nodi siano su una versione successiva prima. Per controllare il funzionamento degli upgrade per il tuo cluster, utilizza i canali di rilascio, i periodi di manutenzione ed esclusioni e la sequenza di implementazione.

Puoi anche configurare una strategia di upgrade dei nodi per il tuo pool di nodi, ad esempio upgrade di sovraccarico, upgrade blu/verde o upgrade di breve durata. Configurando queste strategie, puoi assicurarti che l'upgrade dei node pool venga eseguito in modo da ottenere l'equilibrio ottimale tra velocità e interruzione per il tuo ambiente. Per i node pool di sezioni TPU multi-host, invece di utilizzare la strategia di upgrade dei nodi configurata, GKE ricrea in modo atomico l'intero pool di nodi in un unico passaggio. Per saperne di più, consulta la definizione di atomicità in Terminologia relativa alle TPU in GKE.

L'utilizzo di una strategia di upgrade dei nodi richiede temporaneamente a GKE di eseguire il provisioning di risorse aggiuntive, a seconda della configurazione. Se Google Cloud ha una capacità limitata per le risorse del tuo pool di nodi, ad esempio se visualizzi errori di disponibilità delle risorse quando provi a creare più nodi con GPU o TPU, consulta Esegui l'upgrade in un ambiente con risorse limitate.

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questa guida, valuta la possibilità di eliminare i pool di nodi di sezioni TPU che non hanno più workload pianificati. Se i workload in esecuzione devono essere terminati in modo controllato, utilizza kubectl drain per eseguire la pulizia dei workload prima di eliminare il nodo.

gcloud

Elimina un pool di nodi di sezioni TPU:

  gcloud container node-pools delete POOL_NAME \
      --location=LOCATION \
      --cluster=CLUSTER_NAME

Sostituisci quanto segue:

  • POOL_NAME: il nome del pool di nodi.
  • LOCATION: la località di computing del cluster.
  • CLUSTER_NAME: il nome del cluster.

Cluster Toolkit

Elimina il deployment di Cluster Toolkit:

  gcluster destroy DEPLOYMENT_NAME

Sostituisci DEPLOYMENT_NAME con il nome della directory di deployment creata durante il deployment del blueprint.

Configura le impostazioni aggiuntive

Le sezioni seguenti descrivono le configurazioni aggiuntive che puoi applicare ai tuoi workload TPU.

Usa Multislice

Puoi aggregare slice più piccole in un multislice per gestire workload di addestramento più grandi. Per saperne di più, consulta TPU Multislice in GKE.

Esegui la migrazione della prenotazione TPU

Se hai prenotazioni TPU esistenti, devi prima eseguirne la migrazione a un nuovo sistema di prenotazione basato su Compute Engine. Puoi anche creare un sistema di prenotazione basato su Compute Engine in cui non è necessaria alcuna migrazione. Per scoprire come eseguire la migrazione delle prenotazioni TPU, consulta Prenotazione TPU.

Abilita il logging

I log emessi dai container in esecuzione sui nodi GKE, incluse le VM TPU, vengono raccolti dall'agente Logging di GKE, inviati a Logging e sono visibili in Logging.

Configura la riparazione automatica per i nodi di una sezione TPU

Se un nodo di una sezione TPU in un pool di nodi di sezioni TPU multi-host non è integro, l'intero pool di nodi viene ricreato. Invece, in un pool di nodi di sezioni TPU single-host, viene riparato automaticamente solo il nodo TPU non integro.

Le condizioni che determinano nodi di slice TPU non integri includono:

  • Qualsiasi nodo di una sezione TPU con condizioni del nodo comuni.
  • Qualsiasi nodo di slice TPU con un numero di TPU non allocabili maggiore di zero.
  • Qualsiasi istanza VM in una sezione TPU che viene arrestata (a causa del prerilascio) o terminata.
  • Manutenzione dei nodi: se un nodo di una sezione TPU all'interno di un node pool di sezioni TPU multi-host non è disponibile per la manutenzione dell'host, GKE ricrea l'intero pool di nodi di sezioni TPU.

Puoi visualizzare lo stato della riparazione (incluso il motivo dell'errore) nella cronologia delle operazioni. Se l'errore è causato da una quota insufficiente, contatta il tuo rappresentante dell'accountGoogle Cloud per aumentare la quota corrispondente.

Configura l'arresto controllato per i nodi di una sezione TPU

Nei cluster GKE con il control plane che esegue la versione 1.29.1-gke.1425000 o successive, i nodi di sezioni TPU supportano gli indicatori SIGTERM che avvisano il nodo di un arresto imminente. La notifica di arresto imminente è configurabile fino a cinque minuti nei nodi TPU.

Per configurare GKE in modo che termini i workload in modo controllato entro questo periodo di tempo di notifica, segui i passaggi descritti in Gestisci l'interruzione dei nodi GKE per GPU e TPU.

Evita i deadlock di pianificazione

Quando esegui più job TPU o più repliche di un job, i pod di job diversi possono essere pianificati nello stesso pool di nodi TPU. Ciò può causare un deadlock di pianificazione in cui nessuno dei job può proteggere un numero sufficiente di nodi per completare la propria topologia.

Per ridurre il rischio di deadlock di pianificazione, applica una delle seguenti configurazioni:

  • Utilizza le regole di anti-affinità dei pod per assicurarti che i pod di job diversi non siano pianificati nello stesso pool di nodi TPU o nello stesso dominio di topologia.
  • Utilizza l'annotazione jobset.sigs.k8s.io/exclusive-topology, che fa sì che il JobSet rivendichi il dominio di topologia specificato (come un pool di nodi) esclusivamente per i propri pod.

Per esempi di configurazione dettagliati e passaggi per la risoluzione dei problemi, consulta Deadlock di pianificazione.

Esegui i container senza la modalità con privilegi

I container in esecuzione nei nodi in GKE 1.28 o versioni successive non devono avere la modalità con privilegi abilitata per accedere alle TPU. I nodi in GKE versione 1.28 e precedenti richiedono la modalità con privilegi.

Se il nodo della sezione TPU esegue versioni precedenti alla 1.28, leggi la sezione seguente:

Un container in esecuzione su una VM in una sezione TPU deve accedere a limiti più elevati di memoria bloccata in modo che il driver possa comunicare con i chip TPU tramite l'accesso diretto alla memoria (DMA). Per abilitare questa opzione, devi configurare un valore più elevato per ulimit. Se vuoi ridurre l'ambito delle autorizzazioni sul container, completa i seguenti passaggi:

  1. Modifica securityContext per includere i seguenti campi:

    securityContext:
      capabilities:
        add: ["SYS_RESOURCE"]
    
  2. Aumenta ulimit eseguendo il comando seguente all'interno del container prima di configurare i workload in modo che utilizzino le risorse TPU:

    ulimit -l 68719476736
    

Per TPU v5e, l'esecuzione di container senza modalità con privilegi è disponibile nei cluster nella versione 1.27.4-gke.900 e successive.

Osservabilità e metriche

Dashboard

L'osservabilità dei node pool nella consoleGoogle Cloud è in disponibilità generale. Per visualizzare lo stato dei 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 TPU GKE

Questa dashboard fornisce insight completi sull'integrità dei node pool TPU multi-host. Per saperne di più, consulta Monitora le metriche di integrità per i nodi e i pool di nodi TPU.

Nella pagina Cluster Kubernetes della consoleGoogle Cloud , la scheda Osservabilità mostra anche le metriche di osservabilità delle TPU, come l'utilizzo delle TPU, sotto l'intestazione Acceleratori > TPU. Per saperne di più, consulta Visualizza le metriche di osservabilità.

La dashboard TPU viene compilata solo se hai abilitato le metriche di sistema nel tuo cluster GKE.

Metriche di runtime

In GKE 1.27.4-gke.900 o versioni successive, i workload TPU che utilizzano JAX 0.4.14 o versioni successive e specificano containerPort: 8431 esportano le metriche di utilizzo della TPU come metriche di sistema di GKE. In Cloud Monitoring sono disponibili le seguenti metriche per monitorare le prestazioni di runtime del workload TPU:

  • Ciclo di lavoro: percentuale di tempo nell'ultimo periodo di campionamento (60 secondi) durante il quale i TensorCore hanno eseguito attivamente l'elaborazione su un chip TPU. Una percentuale più alta indica un migliore utilizzo della TPU.
  • Memoria utilizzata: quantità di memoria dell'acceleratore allocata in byte. Campionamento eseguito ogni 60 secondi.
  • Memoria totale: memoria totale dell'acceleratore in byte. Campionamento eseguito ogni 60 secondi.

Queste metriche si trovano nello schema del nodo Kubernetes (k8s_node) e del container Kubernetes (k8s_container).

Container Kubernetes:

  • kubernetes.io/container/accelerator/duty_cycle
  • kubernetes.io/container/accelerator/memory_used
  • kubernetes.io/container/accelerator/memory_total

Nodo Kubernetes:

  • kubernetes.io/node/accelerator/duty_cycle
  • kubernetes.io/node/accelerator/memory_used
  • kubernetes.io/node/accelerator/memory_total

Monitora le metriche di integrità per i nodi e i pool di nodi TPU

Quando un job di addestramento presenta un errore o termina con un errore, puoi controllare le metriche relative all'infrastruttura sottostante per capire se l'interruzione è stata causata da un problema con il nodo o il pool di nodi sottostante.

Stato nodo

In GKE versione 1.32.1-gke.1357001 o successive, la seguente metrica di sistema GKE espone la condizione di un nodo GKE:

  • kubernetes.io/node/status_condition

Il campo condition segnala le condizioni sul nodo, ad esempio Ready, DiskPressure e MemoryPressure. Il campo status mostra lo stato segnalato della condizione, che può essere True, False o Unknown. Questa è una metrica con il tipo di risorsa monitorata k8s_node.

Questa query PromQL mostra se un determinato nodo è Ready:

kubernetes_io:node_status_condition{
    monitored_resource="k8s_node",
    cluster_name="CLUSTER_NAME",
    node_name="NODE_NAME",
    condition="Ready",
    status="True"}

Per risolvere i problemi in un cluster, potresti voler esaminare i nodi che hanno mostrato altre condizioni:

kubernetes_io:node_status_condition{
    monitored_resource="k8s_node",
    cluster_name="CLUSTER_NAME",
    condition!="Ready",
    status="True"}

Potresti voler esaminare in modo specifico i nodi che non sono Ready:

kubernetes_io:node_status_condition{
    monitored_resource="k8s_node",
    cluster_name="CLUSTER_NAME",
    condition="Ready",
    status="False"}

Se non sono presenti dati, i nodi sono pronti. La condizione di stato viene campionata ogni 60 secondi.

Puoi utilizzare la seguente query per comprendere lo stato dei nodi nel parco risorse:

avg by (condition,status)(
  avg_over_time(
    kubernetes_io:node_status_condition{monitored_resource="k8s_node"}[${__interval}]))

Stato del node pool

La seguente metrica di sistema GKE per la risorsa monitorata k8s_node_pool espone lo stato di un pool di nodi GKE:

  • kubernetes.io/node_pool/status

Questa metrica viene registrata solo per i node pool TPU multi-host.

Il campo status indica lo stato del pool di nodi, ad esempio Provisioning, Running, Error, Reconciling o Stopping. Gli aggiornamenti dello stato vengono eseguiti al termine delle operazioni dell'API GKE.

Per verificare se un determinato pool di nodi ha lo stato Running, utilizza la seguente query PromQL:

kubernetes_io:node_pool_status{
    monitored_resource="k8s_node_pool",
    cluster_name="CLUSTER_NAME",
    node_pool_name="NODE_POOL_NAME",
    status="Running"}

Per monitorare il numero di node pool nel tuo progetto raggruppati per stato, utilizza la seguente query PromQL:

count by (status)(
  count_over_time(
    kubernetes_io:node_pool_status{monitored_resource="k8s_node_pool"}[${__interval}]))

Disponibilità del node pool

La seguente metrica di sistema GKE mostra se è disponibile un pool di nodi TPU multi-host:

  • kubernetes.io/node_pool/multi_host/available

La metrica ha un valore pari a True se tutti i nodi nel pool di nodi sono disponibili, altrimenti è pari a False. La metrica viene campionata ogni 60 secondi.

Per verificare la disponibilità dei pool di nodi TPU multi-host nel tuo progetto, utilizza la seguente query PromQL:

avg by (node_pool_name)(
  avg_over_time(
    kubernetes_io:node_pool_multi_host_available{
      monitored_resource="k8s_node_pool",
      cluster_name="CLUSTER_NAME"}[${__interval}]))

Conteggio interruzioni dei nodi

La seguente metrica di sistema GKE indica il numero di interruzioni per un nodo GKE dall'ultimo campionamento (la metrica viene campionata ogni 60 secondi):

  • kubernetes.io/node/interruption_count

I campi interruption_type (ad esempio TerminationEvent, MaintenanceEvent o PreemptionEvent) e interruption_reason (ad esempio HostError, Eviction o AutoRepair) possono aiutare a fornire il motivo per cui un nodo è stato interrotto.

Per ottenere un'analisi dettagliata delle interruzioni e delle relative cause nei nodi TPU nei cluster del tuo progetto, utilizza la seguente query PromQL:

  sum by (interruption_type,interruption_reason)(
    sum_over_time(
      kubernetes_io:node_interruption_count{monitored_resource="k8s_node"}[${__interval}]))

Per visualizzare solo gli eventi di manutenzione dell'host, aggiorna la query per filtrare il valore HW/SW Maintenance per interruption_reason. Utilizza la seguente query PromQL:

  sum by (interruption_type,interruption_reason)(
    sum_over_time(
      kubernetes_io:node_interruption_count{monitored_resource="k8s_node", interruption_reason="HW/SW Maintenance"}[${__interval}]))

Per visualizzare il conteggio delle interruzioni aggregate per pool di nodi, utilizza la seguente query PromQL:

  sum by (node_pool_name,interruption_type,interruption_reason)(
    sum_over_time(
      kubernetes_io:node_pool_interruption_count{monitored_resource="k8s_node_pool", interruption_reason="HW/SW Maintenance", node_pool_name=NODE_POOL_NAME }[${__interval}]))

Tempo di ripristino (TTR) dei node pool

La seguente metrica di sistema GKE indica la distribuzione delle durate del periodo di recupero per i node pool TPU multi-host GKE:

  • kubernetes.io/node_pool/accelerator/times_to_recover

Ogni campione registrato in questa metrica indica un singolo evento di recupero per il pool di nodi da un periodo di inattività.

Questa metrica è utile per monitorare il tempo di recupero e il tempo tra le interruzioni del pool di nodi TPU multi-host.

Puoi utilizzare la seguente query PromQL per calcolare il tempo medio di ripristino (MTTR) degli ultimi 7 giorni nel tuo cluster:

sum(sum_over_time(
  kubernetes_io:node_pool_accelerator_times_to_recover_sum{
    monitored_resource="k8s_node_pool", cluster_name="CLUSTER_NAME"}[7d]))
/
sum(sum_over_time(
  kubernetes_io:node_pool_accelerator_times_to_recover_count{
    monitored_resource="k8s_node_pool",cluster_name="CLUSTER_NAME"}[7d]))

Tempo tra le interruzioni (TBI) dei node pool

La seguente metrica di sistema GKE indica la distribuzione dei tempi tra la fine dell'interruzione più recente e l'inizio dell'interruzione corrente per i node pool TPU multi-host GKE:

  • kubernetes.io/node_pool/accelerator/times_between_interruptions

Ogni campione registrato in questa metrica indica una singola durata tra l'interruzione più recente e quella corrente.

Utilizza la seguente query PromQL per calcolare il tempo medio tra le interruzioni (MTBI) nel tuo cluster per i 7 giorni precedenti:

sum(sum_over_time(
  kubernetes_io:node_pool_accelerator_times_between_interruptions_sum{
    monitored_resource="k8s_node_pool", cluster_name="CLUSTER_NAME"}[7d]))
/
sum(sum_over_time(
  kubernetes_io:node_pool_accelerator_times_between_interruptions_count{
    monitored_resource="k8s_node_pool",cluster_name="CLUSTER_NAME"}[7d]))

Metriche host

In GKE 1.28.1-gke.1066000 o versioni successive, le VM in una sezione TPU esportano le metriche di utilizzo della TPU come metriche di sistema di GKE. In Cloud Monitoring sono disponibili le seguenti metriche per monitorare le prestazioni dell'host TPU:

  • Utilizzo di TensorCore: percentuale attuale di TensorCore utilizzata. Il valore TensorCore è uguale alla somma delle unità di moltiplicazione a matrice (MXU) più l'unità vettoriale. Il valore di utilizzo di TensorCore è la divisione delle operazioni TensorCore eseguite nell'ultimo periodo di campionamento (60 secondi) per il numero di operazioni TensorCore supportate nello stesso periodo. Un valore più alto indica un utilizzo migliore.
  • Utilizzo larghezza di banda memoria: percentuale attuale della larghezza di banda della memoria dell'acceleratore in uso. Questo valore viene calcolato dividendo la larghezza di banda della memoria utilizzata in un periodo di campionamento (60 s) per la larghezza di banda massima supportata nello stesso periodo di campionamento.

Queste metriche si trovano nello schema del nodo Kubernetes (k8s_node) e del container Kubernetes (k8s_container).

Container Kubernetes:

  • kubernetes.io/container/accelerator/tensorcore_utilization
  • kubernetes.io/container/accelerator/memory_bandwidth_utilization

Nodo Kubernetes:

  • kubernetes.io/node/accelerator/tensorcore_utilization
  • kubernetes.io/node/accelerator/memory_bandwidth_utilization

Per saperne di più, consulta Metriche di Kubernetes e Metriche di sistema GKE.

Gestisci la pianificazione della raccolta

In TPU Trillium, puoi utilizzare la pianificazione delle raccolte per raggruppare i nodi di sezioni TPU. Il raggruppamento di questi nodi di sezioni TPU semplifica la regolazione del numero di repliche per soddisfare la domanda del workload. Google Cloud controlla gli aggiornamenti software per garantire che siano sempre disponibili sezioni sufficienti all'interno della raccolta per gestire il traffico.

TPU Trillium supporta la pianificazione della raccolta per i node pool single-host e multi-host che eseguono workload di inferenza. Di seguito viene descritto come il comportamento di pianificazione della raccolta dipende dal tipo di sezione TPU che utilizzi:

  • Slice TPU multi-host: GKE raggruppa le slice TPU multi-host per formare una raccolta. Ogni pool di nodi GKE è una replica all'interno di questa raccolta. Per definire una raccolta, crea una sezione TPU multi-host e assegna un nome univoco alla raccolta. Per aggiungere altre sezioni TPU alla raccolta, crea un altro pool di nodi di sezioni TPU multi-host con lo stesso nome della raccolta e lo stesso tipo di workload.
  • Sezione TPU single-host: GKE considera l'intero pool di nodi della sezione TPU single-host come una raccolta. Per aggiungere altre sezioni TPU alla raccolta, puoi ridimensionare il pool di nodi di sezioni TPU single-host.

Per gestire una raccolta, esegui una di queste azioni in base al tipo di pool di nodi che utilizzi.

Gestisci la pianificazione della raccolta nei pool di nodi di sezioni TPU multi-host

Utilizza le seguenti attività per gestire i pool di nodi di sezioni TPU multi-host.

  • Per verificare se un pool di sezioni TPU multi-host fa parte di una raccolta, esegui questo comando:

    gcloud container node-pools describe NODE_POOL_NAME \
        --location LOCATION \
        --cluster CLUSTER_NAME \
        --format="json" | jq -r \
        '"nodepool-group-name: \(.config.labels["cloud.google.com/gke-nodepool-group-name"] // "")\ngke-workload-type: \(.config.labels["cloud.google.com/gke-workload-type"] // "")"'
    

    L'output è simile al seguente:

    nodepool-group-name: <code><var>NODE_POOL_COLLECTION_NAME</var></code>
    gke-workload-type: HIGH_AVAILABILITY
    

    Se il pool di sezioni TPU multi-host fa parte di una raccolta, l'output contiene le seguenti etichette:

    • cloud.google.com/gke-workload-type: HIGH_AVAILABILITY
    • cloud.google.com/gke-nodepool-group-name: <code><var>COLLECTION_NAME</var></code>
  • Per visualizzare l'elenco delle raccolte nel cluster, esegui questo comando:

    #!/bin/bash
    
    # Replace with your cluster name, project, and location
    CLUSTER_NAME=CLUSTER_NAME
    PROJECT=PROJECT_ID
    LOCATION=LOCATION
    
    declare -A collection_names
    
    node_pools=$(gcloud container node-pools list --cluster "$CLUSTER_NAME" --project "$PROJECT" --location "$LOCATION" --format="value(name)")
    
    # Iterate over each node pool
    for pool in $node_pools; do
        # Describe the node pool and extract labels using jq
        collection_name=$(gcloud container node-pools describe "$pool" \
            --cluster "$CLUSTER_NAME" \
            --project "$PROJECT" \
            --location "$LOCATION" \
            --format="json" | jq -r '.config.labels["cloud.google.com/gke-nodepool-group-name"]')
    
        # Add the collection name to the associative array if it's not empty
        if [[ -n "$collection_name" ]]; then
            collection_names["$collection_name"]=1
        fi
    done
    
    # Print the unique node pool collection names
    echo "Unique cloud.google.com/gke-nodepool-group-name values:"
    for name in "${!collection_names[@]}"; do
        echo "$name"
    done
    

    L'output è simile al seguente:

    Unique cloud.google.com/gke-nodepool-group-name values: {COLLECTION_NAME_1}, {COLLECTION_NAME_2}, {COLLECTION_NAME_3}
    
  • Per ottenere un elenco dei node pool appartenenti a una raccolta, esegui questo comando:

    #!/bin/bash
    
    TARGET_COLLECTION_NAME=COLLECTION_NAME
    CLUSTER_NAME=CLUSTER_NAME
    PROJECT=PROJECT_ID
    LOCATION=LOCATION
    
    matching_node_pools=()
    
    # Get the list of all node pools in the cluster
    node_pools=$(gcloud container node-pools list --cluster "$CLUSTER_NAME" --project "$PROJECT" --location "$LOCATION" --format="value(name)")
    
    # Iterate over each node pool
    for pool in $node_pools; do
        # Get the value of the cloud.google.com/gke-nodepool-group-name label
        collection_name=$(gcloud container node-pools describe "$pool" \
            --cluster "$CLUSTER_NAME" \
            --project "$PROJECT" \
            --location "$LOCATION" \
            --format="json" | jq -r '.config.labels["cloud.google.com/gke-nodepool-group-name"]')
    
        # Check if the group name matches the target value
        if [[ "$collection_name" == "$TARGET_COLLECTION_NAME" ]]; then
            matching_node_pools+=("$pool")
        fi
    done
    
    # Print the list of matching node pools
    echo "Node pools with collection name '$TARGET_COLLECTION_NAME':"
    for pool in "${matching_node_pools[@]}"; do
        echo "$pool"
    done
    

    L'output è simile al seguente:

    Node pools with collection name 'COLLECTION_NAME':
    {NODE_POOL_NAME_1}
    {NODE_POOL_NAME_2}
    {NODE_POOL_NAME_3}
    
  • Per fare lo scale up della raccolta, crea un altro pool di nodi di slice TPU multi-host e aggiungi cloud.google.com/gke-workload-type e cloud.google.com/gke-nodepool-group-name. Utilizza lo stesso nome della raccolta in cloud.google.com/gke-nodepool-group-name ed esegui lo stesso tipo di workload. Se il provisioning automatico dei nodi è abilitato sul cluster, GKE crea automaticamente i pool in base alle esigenze del workload.

  • Per fare lo scale down della raccolta, elimina il node pool.

  • Per eliminare la raccolta, rimuovi tutti i node pool collegati. Puoi eliminare il node pool o eliminare il cluster. L'eliminazione del cluster comporta la rimozione di tutte le raccolte al suo interno.

Gestisci la pianificazione della raccolta nei pool di nodi di sezioni TPU single-host

Utilizza le seguenti attività per gestire i pool di nodi di sezioni TPU single-host.

  • Per verificare se un pool di sezioni TPU single-host ha la pianificazione della raccolta abilitata, esegui questo comando:

    gcloud container node-pools describe NODE_POOL_NAME \
        --cluster CLUSTER_NAME \
        --project PROJECT_NAME \
        --location LOCATION \
        --format="json" | jq -r '.config.labels["cloud.google.com/gke-workload-type"]'
    

    L'output è simile al seguente:

    gke-workload-type: HIGH_AVAILABILITY
    

    Se il pool di sezioni TPU single-host fa parte di una raccolta, l'output ha l'etichetta cloud.google.com/gke-workload-type: HIGH_AVAILABILITY.

  • Per fare lo scale up della raccolta, ridimensiona il pool di nodi manualmente o automaticamente con il provisioning automatico dei nodi.

  • Per fare lo scale down della raccolta, elimina il node pool.

  • Per eliminare la raccolta, rimuovi tutti i node pool collegati. Puoi eliminare il node pool o eliminare il cluster. L'eliminazione del cluster rimuove tutte le raccolte al suo interno.

Problemi noti

  • Il gestore della scalabilità automatica dei cluster potrebbe calcolare in modo errato la capacità dei nuovi nodi di sezioni TPU prima che questi nodi segnalino le TPU disponibili. Il gestore della scalabilità automatica dei cluster potrebbe quindi eseguire un ulteriore scale up e, di conseguenza, creare più nodi del necessario. Il gestore della scalabilità automatica dei cluster fa lo scale down dei nodi aggiuntivi, se non sono necessari, dopo la normale operazione di fare lo scale down.
  • Il gestore della scalabilità automatica dei cluster annulla lo scale up dei node pool di sezioni TPU che rimangono in stato di attesa per più di 10 ore. Il gestore della scalabilità automatica dei cluster riprova queste operazioni di scale up in un secondo momento. Questo comportamento potrebbe ridurre la disponibilità di TPU per i clienti che non utilizzano le prenotazioni.
  • I workload non TPU che hanno una tolleranza per la contaminazione TPU possono impedire fare lo scale down del pool di nodi se vengono ricreati durante lo svuotamento del pool di nodi della sezione TPU.
  • La metrica di utilizzo della larghezza di banda della memoria non è disponibile per le TPU v5e.

Passaggi successivi