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:
Vai alla pagina Quote nella console Google Cloud :
Nella casella Filtro, procedi nel seguente modo:
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-, inserisciName: 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:CT3Non applicabile TPU v3,
ct3p-Dimensions (e.g. location):
tpu_family:CT3PNon applicabile TPU v4,
ct4p-Name:
TPU v4 PodSlice chipsName:
Preemptible TPU v4 PodSlice chipsTPU v5e,
ct5lp-Name:
TPU v5 Lite PodSlice chipsName:
Preemptible TPU v5 Lite Podslice
chipsTPU v5p,
ct5p-Name:
TPU v5p chipsName:
Preemptible TPU v5p chipsTPU Trillium,
ct6e-Dimensions (e.g. location):
tpu_family:CT6EName:
Preemptible TPU slices v6eIronwood (TPU7x),
tpu7x-standard-4tDimensions (e.g. location):
tpu_family:tpu7xName:
Preemptible TPU slices tpu7xSeleziona la proprietà Dimensioni (ad es. località) e inserisci
region:seguito dal nome della regione in cui prevedi di creare TPU in GKE. Ad esempio, inserisciregion:us-west4se prevedi di creare nodi di sezioni TPU nella zonaus-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.
-
Quando crei un pool di nodi di sezioni TPU, utilizza i flag
--reservatione--reservation-affinity=specificper creare unistanza dedicata. Le prenotazioni TPU sono disponibili quando acquisti un impegno. ↩ -
Quando crei un pool di nodi di una sezione TPU, utilizza il flag
--spotper 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-nodesia in linea con l'intervallo della subnet: ogni nodo Kubernetes utilizza intervalli IP secondari per i pod. Ad esempio,max-pods-per-nodedi 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-nodeper limitare il numero di pod che possono essere pianificati su un nodo. La quota permax-pods-per-nodedeve 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.
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
- Configura Cluster Toolkit.
Esegui il deployment di un cluster TPU GKE utilizzando un progetto di Cluster Toolkit (ad esempio
gke-tpu-v6eogke-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=ZONESostituisci 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, utilizzatpu7x-standard-4tper 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-autoscalingper il pool di nodi, impostanum-nodessu0in 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
- Assicurati di utilizzare la versione 4.84.0 o successiva del provider
google. - 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 valoriTOTAL_MIN_NODESeTOTAL_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 compilareRESERVATION_LABEL_VALUESnel camporeservation_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 sutruesespotè abilitato. L'avvio flessibile è supportato in GKE versione 1.33.0-gke.1712000 o successive.
Console
Per creare un pool di nodi con TPU:
Vai alla pagina Google Kubernetes Engine nella console Google Cloud .
Nell'elenco dei cluster, fai clic sul nome del cluster da modificare.
Fai clic sulla scheda Nodi.
Fai clic su add_box Crea node pool gestito dall'utente.
Nella sezione Dettagli del pool di nodi, seleziona la casella Specifica le località dei nodi.
Seleziona la zona in base alla versione della TPU che vuoi utilizzare. Per identificare una zona disponibile, consulta Disponibilità delle TPU in GKE.
Nel riquadro di navigazione, fai clic su Nodi.
Nella sezione Configurazione macchina, seleziona TPU.
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)
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.
Nel menu a discesa Topologia TPU, seleziona la topologia fisica per la sezione TPU.
Nella finestra di dialogo Modifiche necessarie, fai clic su Apporta modifiche.
Assicurati che il Tipo di disco di avvio sia Disco permanente standard o Disco permanente SSD.
Se vuoi, seleziona la casella di controllo Abilita nodi sulle VM Spot per utilizzare le VM Spot per i nodi nel pool di nodi.
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.
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=REGIONSostituisci 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.
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=specificSostituisci 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
Per identificare una località disponibile, consulta Disponibilità di TPU in GKE.us-central1-ai1a. Le zone AI sono località specializzate ottimizzate per i workload AI/ML all'interno delle regioni Google Cloud .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
- Assicurati di utilizzare la versione 4.84.0 o successiva del provider
google. 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.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, seTPU_TOPOLOGYè4x8, allora ci sono 32 chip, il che significa cheNUM_NODESdeve 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 compilareRESERVATION_LABEL_VALUESnel camporeservation_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 inTPU_TOPOLOGY({A}x{B}x{C}) diviso per il numero di chip in ogni VM. Ad esempio, seTPU_TOPOLOGYè2x2x2, il prodotto è 8. Poiché ogni VM intpu7x-standard-4tha 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 sutruesespotè 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 inTPU_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 tuoTPU_TOPOLOGYè2x4x4(TPU v4 con quattro chip in ogni VM), ilNUM_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-autoscalinge deve essere uguale al prodotto dei valori definiti inTPU_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
- Assicurati di utilizzare la versione 4.84.0 o successiva del provider
google. 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, seTPU_TOPOLOGYè4x8, sono presenti 32 chip, il che significa cheNUM_NODESdeve 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 compilareRESERVATION_LABEL_VALUESnel camporeservation_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 inTPU_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 sutruesespotè abilitato.
Console
Per creare un pool di nodi con TPU:
Vai alla pagina Google Kubernetes Engine nella console Google Cloud .
Nell'elenco dei cluster, fai clic sul nome del cluster da modificare.
Fai clic sulla scheda Nodi.
Fai clic su add_box Crea node pool gestito dall'utente.
Nella sezione Dettagli del pool di nodi, seleziona la casella Specifica le località dei nodi.
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.
Nel riquadro di navigazione, fai clic su Nodi.
Nella sezione Configurazione macchina, seleziona TPU.
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)
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.
Nel menu a discesa Topologia TPU, seleziona la topologia fisica per la sezione TPU.
Nella finestra di dialogo Modifiche necessarie, fai clic su Apporta modifiche.
Assicurati che il Tipo di disco di avvio sia Disco permanente standard o Disco permanente SSD.
Se vuoi, seleziona la casella di controllo Abilita nodi sulle VM Spot per utilizzare le VM Spot per i nodi nel pool di nodi.
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.
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_COUNTSostituisci quanto segue:
TPU_TYPE: il tipo di TPU. Ad esempio, utilizzatpu7xper 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 diMAXIMUM_TPU_COUNTdeve essere maggiore di8.
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)
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=REGIONSostituisci quanto segue:
WORKLOAD_POLICY_NAME: un nome per la policy del workload.TPU_TOPOLOGY: la topologia TPU Ironwood (TPU7x). Ad esempio, utilizza2x2x2. 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.
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(Facoltativo) Puoi utilizzare una prenotazione o un blocco secondario specifico. Ad esempio, puoi aggiungere il seguente
specsal manifestComputeClass:reservations: affinity: Specific specific: - name: RESERVATION_NAME reservationBlock: name: RESERVATION_BLOCK_NAME reservationSubBlock: name: RESERVATION_SUB_BLOCK_NAMESostituisci 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:
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: trueSostituisci quanto segue:
TPU_TYPE: il tipo di TPU da utilizzare, ad esempiotpu-v4-podslice. Deve essere un valore supportato da GKE.TOPOLOGY: la disposizione dei chip TPU nello slice, ad esempio2x2x4. 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 perlimitserequests.
Esegui il deployment di ComputeClass:
kubectl apply -f tpu-compute-class.yamlPer ulteriori informazioni sulle ComputeClass personalizzate e sulle TPU, consulta Configurazione delle TPU.
Crea un job che utilizza le TPU
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_CHIPSSostituisci quanto segue:
NUMBER_OF_CHIPS: il numero di chip TPU che il container deve utilizzare. Deve essere lo stesso valore perlimitserequests, uguale al valoreCHIP_COUNTnella 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 perlimitserequests.
Esegui il deployment del job:
kubectl create -f tpu-job.yamlQuando 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.
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.
- Framework come JAX, PyTorch e TensorFlow accedono alle VM TPU utilizzando la libreria condivisa
libtpu.libtpuinclude il compilatore XLA, il software di runtime TPU e il driver TPU. Ogni release di PyTorch e JAX richiede una determinata versione dilibtpu.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:tpu7xTipo di TPU libtpu.soversioneIronwood (TPU7x) - Immagine AI JAX consigliata: jax0.8.1-rev1 o versioni successive
- Versione jax[tpu] consigliata: v0.8.1
TPU Trillium (v6e)
tpu-v6e-slice
- Immagine AI JAX consigliata: jax0.4.35-rev1 o versioni successive
- Versione jax[tpu] consigliata: v0.4.9 o successive
- Versione torchxla[tpuvm] consigliata: v2.1.0 o successive
TPU v5e
tpu-v5-lite-podslice
- Immagine AI JAX consigliata: jax0.4.35-rev1 o versioni successive
- Versione jax[tpu] consigliata: v0.4.9 o successive
- Versione torchxla[tpuvm] consigliata: v2.1.0 o successive
TPU v5p
tpu-v5p-slice- Immagine AI JAX consigliata: jax0.4.35-rev1 o versioni successive
- Versione jax[tpu] consigliata: 0.4.19 o successive.
- Versione torchxla[tpuvm] consigliata: si consiglia di utilizzare una build della versione nightly del 23 ottobre 2023.
TPU v4
tpu-v4-podslice- Immagine AI JAX consigliata: jax0.4.35-rev1 o versioni successive
- jax[tpu] consigliato: v0.4.4 o versioni successive
- torchxla[tpuvm] consigliato: v2.0.0 o versioni successive
TPU v3
tpu-v3-slice
tpu-v3-device- Immagine AI JAX consigliata: jax0.4.35-rev1 o versioni successive
- jax[tpu] consigliato: v0.4.4 o versioni successive
- torchxla[tpuvm] consigliato: v2.0.0 o versioni successive
- 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, utilizzatpu7x-standard-4t.TPU_TOPOLOGY: la topologia fisica della sezione TPU. Il formato della topologia dipende dalla versione della TPU. Ad esempio, utilizza2x2x2. 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, utilizzatpu7x-standard-4tper 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, utilizza2x2x2.limits.google.com/tpu: il numero di chip TPU per VM. Ad esempio, se utilizzitpu7x-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 esempiov6e-16,tpu7x-standard-4tov5e-8.TOPOLOGY: la topologia fisica corrispondente al tuo pool di nodi, ad esempio2x4o2x2x2.
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.
- 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.
- 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.
- 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
- Recupera i log di uno dei pod:
kubectl logs POD_NAME
Sostituisci
POD_NAMEcon il nome di uno dei pod creati. Ad esempio,tpu-job-podslice-0-5cd8r.L'output è simile al seguente:
TPU cores: 16
- (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.
- 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.
- 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).
- Recupera i log del pod:
kubectl logs tpu-job-jax-v5
L'output è simile al seguente:
Total TPU chips: 8
- (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.
Crea un file denominato
topology-manager-config.yamlcon i seguenti contenuti:kubeletConfig: cpuManagerPolicy: static topologyManager: policy: best-effort scope: containerQuesta 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.
Applica la configurazione
kubeleta 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 macchinatpu7x-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.yamlSostituisci 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.yamlSostituisci quanto segue:
NODE_POOL_NAME: il nome del pool di nodi.LOCATION: la regione del cluster.CLUSTER_NAME: il nome del cluster.
Crea un file denominato
tpu-jobset.yamlcon 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: 2Questo manifest definisce un
JobSetdenominatotpu7x-test, che esegue due container principali,jax-tpu-1ejax-tpu-2. Ogni container richiede due chipgoogle.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.
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.
Crea un file denominato
tpu7x-gcsfuse-multinic.yamlcon 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: falseQuesto 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_NAMEcon il nome del tuo bucket Cloud Storage.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:
Modifica
securityContextper includere i seguenti campi:securityContext: capabilities: add: ["SYS_RESOURCE"]Aumenta
ulimiteseguendo 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_cyclekubernetes.io/container/accelerator/memory_usedkubernetes.io/container/accelerator/memory_total
Nodo Kubernetes:
kubernetes.io/node/accelerator/duty_cyclekubernetes.io/node/accelerator/memory_usedkubernetes.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_utilizationkubernetes.io/container/accelerator/memory_bandwidth_utilization
Nodo Kubernetes:
kubernetes.io/node/accelerator/tensorcore_utilizationkubernetes.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_AVAILABILITYSe 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_AVAILABILITYcloud.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" doneL'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" doneL'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-typeecloud.google.com/gke-nodepool-group-name. Utilizza lo stesso nome della raccolta incloud.google.com/gke-nodepool-group-nameed 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_AVAILABILITYSe 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
- Scopri di più sulla configurazione di Ray su GKE con TPU
- Crea machine learning su larga scala su Cloud TPU con GKE
- Gestisci i modelli linguistici di grandi dimensioni (LLM) con KubeRay su TPU
- Risolvi i problemi delle TPU in GKE
- Scopri di più sul sandboxing dei workload TPU con GKE Sandbox