Allocare risorse di rete utilizzando DRANET gestito da GKE

Autopilot Standard

Google Kubernetes Engine (GKE) DRANET è una funzionalità GKE gestita che si basa sul progetto open source DRANET, che implementa l'API Kubernetes DRA per le risorse di networking. DRANET ti consente di richiedere e allocare risorse di rete ad alte prestazioni per i tuoi pod, incluse interfacce di rete che supportano l'accesso diretto alla memoria remota (RDMA). Questo approccio fornisce un'API portabile e allineata all'upstream per la gestione delle risorse di rete.

Questo documento fornisce una panoramica concettuale di GKE DRANET e mostra come allocare le risorse di rete ai workload nei cluster GKE.

Questo documento è destinato agli architetti cloud e agli specialisti di networking che progettano reti per le loro organizzazioni. Per una panoramica di tutta la documentazione di GKE, consulta Esplora la documentazione di GKE. Per scoprire di più sui ruoli e sulle attività comuni a cui viene fatto riferimento nei contenuti di Google Cloud , vedi Ruoli e attività comuni degli utenti GKE.

Prima di leggere questo documento, assicurati di conoscere quanto segue:

• Allocazione dinamica delle risorse
• Informazioni sull'allocazione dinamica delle risorse in GKE
• Concetti di base di Kubernetes
• Networking di GKE
• Nozioni di base del networking GKE

Come funziona DRANET gestito da GKE

GKE managed DRANET viene implementato tramite un DaemonSet.networking-dra-driver Questo DaemonSet viene eseguito su nodi con GPU o TPU con GKE DRANET abilitato.

Funziona come agente a livello di nodo per rendere le interfacce di rete rilevabili e allocabili ai pod tramite le API di allocazione dinamica delle risorse (DRA) di Kubernetes.

In GKE 1.34.1-gke.1829001 e versioni successive, GKE installa automaticamente le risorse DeviceClass per il networking. Queste classi definiscono i tipi di dispositivi di rete che puoi richiedere. Ad esempio, GKE crea la classe mrdma.google.com per i dispositivi compatibili con RDMA e la classe netdev.google.com per gli altri dispositivi di rete.

Per utilizzare GKE DRANET, devi prima abilitare il driver GKE DRANET su un pool di nodi con GPU o TPU.

Per richiedere dispositivi di rete per un workload, definisci un ResourceClaimTemplate. Questo modello specifica DeviceClass e la modalità di allocazione, ad esempio la richiesta di tutti i dispositivi disponibili su un nodo. Nella specifica del pod, fai riferimento a questo modello in un campo resourceClaims per concedere al pod l'accesso alle interfacce di rete richieste sul nodo.

Quando utilizzare DRANET gestito da GKE

GKE DRANET fornisce un modo standardizzato per gestire le risorse di rete che tengono conto della topologia e delle dipendenze. Questa standardizzazione lo rende una soluzione adatta per i workload di AI e ML che richiedono networking ad alte prestazioni.

I casi d'uso comuni per richiedere interfacce di rete per un pod includono:

• Richiesta di tutte le interfacce compatibili con RDMA disponibili.
• Richiesta di un numero specifico di interfacce compatibili con RDMA.
• Richiesta di tutte le interfacce non RDMA disponibili.
• Richiesta di un numero specifico di interfacce non RDMA.

Considerazioni chiave sull'utilizzo di GKE Managed DRANET per il networking

Considera i seguenti punti utilizzando GKE DRANET per il networking:

• Interfacce di rete dedicate

  Quando utilizzi GKE DRANET per richiedere un'interfaccia di rete per un pod, questa interfaccia è dedicata a quel pod. Gli altri pod sullo stesso nodo non possono condividerlo. Questo approccio contribuisce a garantire che il pod abbia accesso esclusivo alla larghezza di banda e alle risorse complete di questa interfaccia, il che è un vantaggio fondamentale per i carichi di lavoro sensibili alle prestazioni.

• Utilizzare il driver DRANET gestito da GKE in modo indipendente

  Puoi attivare il driver GKE DRA per gestire le risorse di rete senza attivare altri driver GKE DRANET. A tal fine, aggiungi l'etichetta cloud.google.com/gke-networking-dra-driver=true a un pool di nodi con GPU e TPU.

• Utilizzare altri driver GKE DRA

  Per ottenere un throughput più elevato nei workload di AI/ML impegnativi, combina l'API DRA per gli acceleratori (come GPU e TPU) con il networking gestito DRANET di GKE. Questo approccio combinato migliora l'allineamento delle risorse e la consapevolezza della topologia. Per scoprire di più sull'utilizzo di DRA per altre risorse, consulta Preparare l'infrastruttura GKE per i workload DRA.

• Evitare configurazioni in conflitto

  Il driver GKE DRANET gestisce le interfacce RDMA e le gVNIC che non hanno intervalli di indirizzi IP secondari configurati. Non utilizzare sia il driver GKE DRANET sia l'API GKE multi-network con una risorsa di rete di tipo Device nello stesso cluster. L'utilizzo combinato del driver e dell'API non è supportato perché entrambe le API tentano di gestire lo stesso insieme di NIC, il che può portare a una configurazione errata e a un comportamento imprevedibile.

• Ciclo di vita gestito del driver DRANET

  In GKE versione 1.34 e successive, GKE crea automaticamente lo spazio dei nomi gke-managed-networking-dra-driver gestito nel cluster. Analogamente a diversi altri carichi di lavoro di sistema GKE, i pod del driver DRANET vengono eseguiti solo sui nodi pertinenti (ad esempio nodi con GPU, TPU e altro hardware specializzato). Sui nodi in cui il driver non è pertinente, non vengono eseguiti pod per questo driver. Non modificare manualmente il DaemonSet networking-dra-driver. Le modifiche manuali, ad esempio l'aggiornamento del campo nodeAffinity, possono interferire con la gestione della funzionalità DRANET da parte di GKE e causare la pianificazione dei pod del daemon DRANET su nodi non supportati.

Requisiti

Per utilizzare GKE managed DRANET, il tuo ambiente deve soddisfare i seguenti requisiti:

• Standard: 1.34.1-gke.1829001 o versioni successive.
• Autopilot: 1.35.2-gke.1842000 o versioni successive.
• GKE Dataplane V2 è abilitato sul cluster.

Devi utilizzare uno dei seguenti tipi di macchine ottimizzate per l'acceleratore:

Serie di macchine	Tipo di macchina	Modello di acceleratore	Tecnologia di networking
A3 Ultra	a3-ultragpu-8g	GPU NVIDIA H200	RDMA
A4	a4-highgpu-8g	GPU NVIDIA B200	RDMA
A4X	a4x-highgpu-4g	GPU NVIDIA GB200	RDMA
A4X Max	a4x-maxgpu-4g-metal	GPU NVIDIA B300	RDMA
TPU v7	tpu7x-standard-4t	TPU v7	NetDevice
TPU v6e	ct6e-standard-8t	TPU Trillium	NetDevice
TPU v6e	ct6e-standard-4t	TPU Trillium	NetDevice
TPU v6e	ct6e-standard-1t	TPU Trillium	NetDevice

Limitazioni

GKE DRANET presenta le seguenti limitazioni:

• Non puoi utilizzare GKE DRANET per allocare la scheda di interfaccia di rete (NIC) predefinita o le NIC virtuali (come veth).
• Alcuni tipi di istanze, in particolare i nodi bare metal come a4x-max, sono incompatibili con i cluster di scalabilità automatica e Autopilot.

Considerazioni specifiche per la macchina

A4X Max bare metal

• Esegui il deployment di asapd-lite: quando utilizzi nodi GPU bare metal, come A4X Max, devi eseguire il deployment del DaemonSet asapd-lite nel cluster. asapd-lite DaemonSet configura le schede di interfaccia di rete (NIC) RDMA. Senza, le interfacce secondarie non vengono create e il driver dranet filtra le NIC RDMA, impedendo la funzionalità RDMA all'interno dei pod. Per le istruzioni di configurazione complete, consulta Configurare le NIC MRDMA con asapd-lite.

Prima di iniziare

Prima di iniziare, assicurati di aver eseguito le seguenti operazioni:

• Attiva l'API Google Kubernetes Engine.
Attiva l'API Google Kubernetes Engine
• 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.
  Nota: per le installazioni esistenti di gcloud CLI, assicurati di impostare la proprietà compute/region. Se utilizzi principalmente cluster zonali, imposta invece compute/zone. Se imposti una località predefinita, puoi evitare errori in gcloud CLI come il seguente: One of [--zone, --region] must be supplied: Please specify location. Potresti dover specificare la posizione in determinati comandi se la posizione del cluster è diversa da quella predefinita che hai impostato.

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per creare pool di nodi e allocare risorse di rete, chiedi all'amministratore di concederti il ruolo IAM Kubernetes Engine Admin (roles/container.admin) nel progetto. Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Potresti anche riuscire a ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

Crea un cluster

Crea un cluster GKE Standard che utilizza GKE Dataplane V2:

gcloud container clusters create CLUSTER_NAME \
    --enable-dataplane-v2 \
    --region=CONTROL_PLANE_LOCATION \
    --project=PROJECT_ID \
    --cluster-version=CLUSTER_VERSION

Sostituisci quanto segue:

• CLUSTER_NAME: il nome del nuovo cluster.
• CONTROL_PLANE_LOCATION: la regione o la zona per il control plane del cluster, ad esempio us-central1 o us-central1-a.
• PROJECT_ID: il tuo ID progetto Google Cloud .
• CLUSTER_VERSION: la versione di GKE per il tuo cluster. Questa versione deve essere 1.34.1-gke.1829001 o successiva.

Utilizzare interfacce RDMA da un pool di nodi GPU

Le sezioni seguenti descrivono come configurare un pool di nodi GPU e un workload per utilizzare interfacce di rete RDMA con GKE DRANET.

Abilita il driver DRANET gestito da GKE su un pool di nodi GPU

Per abilitare il driver GKE DRANET su un pool di nodi GPU che supporta RDMA, aggiungi l'etichetta cloud.google.com/gke-networking-dra-driver=true quando crei il node pool.

gcloud beta container node-pools create NODE_POOL_NAME \
  --region=REGION \
  --cluster=CLUSTER_NAME \
  --node-locations=NODE_LOCATIONS \
  --accelerator type=ACCELERATOR_TYPE,count=ACCELERATOR_COUNT,gpu-driver-version=DRIVER_VERSION \
  --machine-type=MACHINE_TYPE \
  --num-nodes=NUM_NODES \
  --reservation-affinity=specific \
  --reservation=projects/RESERVATION_PROJECT/reservations/RESERVATION_NAME/reservationBlocks/RESERVATION_BLOCK \
  --accelerator-network-profile=auto \
  --node-labels=cloud.google.com/gke-networking-dra-driver=true

Sostituisci quanto segue:

• NODE_POOL_NAME: il nome del nuovo pool di nodi.
• REGION: la Google Cloud regione del cluster.
• CLUSTER_NAME: il nome del tuo cluster.

• ACCELERATOR_TYPE: il tipo di acceleratore GPU:

  Ad esempio:

  • VM A4: inserisci nvidia-b200.
  • VM A3 Ultra: inserisci nvidia-h200-141gb.

• ACCELERATOR_COUNT: il numero di GPU da collegare ai nodi nel pool di nodi. Ad esempio, per le VM a4-highgpu-8g e a3-ultragpu-8g, la quantità di GPU è 8.

• DRIVER_VERSION: la versione del driver GPU da utilizzare. Ad esempio: default o latest.

• MACHINE_TYPE: il tipo di macchina per il pool di nodi, ad esempio a3-ultragpu-8g.

• NUM_NODES: il numero di nodi per il pool di nodi. Per l'avvio flessibile, questo valore deve essere impostato su 0.

• RESERVATION_PROJECT: l'ID progetto della prenotazione.

• RESERVATION_NAME: il nome della prenotazione. Per trovare questo valore, consulta Visualizzare le richieste di prenotazione futura.

• RESERVATION_BLOCK: il nome di un blocco specifico all'interno della prenotazione. Per trovare questo valore, consulta Visualizzare le richieste di prenotazione futura.

Questo comando utilizza i profili di rete dell'acceleratore per configurare automaticamente le reti e le subnet VPC per le VM con acceleratore. In alternativa, puoi specificare esplicitamente la tua rete VPC e le subnet.

Esegui il deployment delle risorse RDMA di un workload

Per allocare risorse RDMA per un pod, specifica un ResourceClaimTemplate.

1. Crea un ResourceClaimTemplate per definire come allocare i dispositivi RDMA. Il seguente manifest richiede tutti i dispositivi mrdma disponibili sul nodo. Salva il manifest come all-mrdma-template.yaml:

   apiVersion: resource.k8s.io/v1
   kind: ResourceClaimTemplate
   metadata:
     name: all-mrdma
   spec:
     spec:
       devices:
         requests:
         - name: req-mrdma
           exactly:
             deviceClassName: mrdma.google.com
             allocationMode: All
   

2. Applica il manifest:

   kubectl apply -f all-mrdma-template.yaml
   

3. Esegui il deployment del workload e fai riferimento a ResourceClaimTemplate. Il seguente manifest esegue il deployment di un pod che fa riferimento al modello all-mrdma, che concede al pod l'accesso alle interfacce RDMA sul nodo. Salva il manifest come agnhost-rdma-pod.yaml:

   apiVersion: v1
   kind: Pod
   metadata:
     name: agnhost-rdma
     namespace: default
     labels:
       app: agnhost
   spec:
     containers:
     - name: agnhost
       image: registry.k8s.io/e2e-test-images/agnhost:2.39
       args: ["netexec", "--http-port", "80"]
       ports:
       - name: agnhost-port
         containerPort: 80
       resources:
         claims:
         - name: rdma
         limits:
           nvidia.com/gpu: 1
     resourceClaims:
     - name: rdma
       resourceClaimTemplateName: all-mrdma
   

4. Applica il manifest:

   kubectl apply -f agnhost-rdma-pod.yaml
   

5. Verifica che le interfacce di rete aggiuntive allocate siano visibili all'interno del pod.

   kubectl exec agnhost-rdma -- ls /sys/class/net
   

   L'output di esempio seguente mostra le interfacce eth0 e lo predefinite, nonché le interfacce RDMA allocate, come gpu0rdma0. Il numero e i nomi delle interfacce di rete (NIC) variano in base al tipo di macchina del nodo GKE.

   eth0
   gpu0rdma0
   gpu1rdma0
   gpu2rdma0
   gpu3rdma0
   lo
   

Utilizzare interfacce di rete non RDMA in un pool di nodi TPU

Le sezioni seguenti descrivono come configurare un pool di nodi TPU e un workload per utilizzare interfacce di rete non RDMA con GKE DRANET.

Verifica di DeviceClasses di rete

Verifica che le risorse DeviceClass per il networking esistano nel cluster.

kubectl get deviceclass netdev.google.com

L'output è simile al seguente:

NAME                AGE
netdev.google.com   2d22h

Abilita il driver DRANET gestito da GKE in un pool di nodi di slice TPU

Per abilitare il driver GKE DRANET durante la creazione di un pool di nodi di sezioni TPU, aggiungi l'etichetta cloud.google.com/gke-networking-dra-driver=true.

gcloud beta container node-pools create NODE_POOL_NAME \
    --location=LOCATION \
    --cluster=CLUSTER_NAME \
    --node-locations=NODE_LOCATIONS \
    --machine-type=MACHINE_TYPE \
    --tpu-topology=TPU_TOPOLOGY \
    --num-nodes=NUM_NODES \
    --accelerator-network-profile=auto \
    --node-labels=cloud.google.com/gke-networking-dra-driver=true

Sostituisci quanto segue:

• NODE_POOL_NAME: il nome del nuovo pool di nodi.
• LOCATION: La Google Cloud regione o la zona del cluster.
• CLUSTER_NAME: il nome del cluster.
• NODE_LOCATIONS: Le Google Cloud zone per i nodi nel pool di nodi.
• MACHINE_TYPE: Il tipo di macchina da utilizzare per i nodi. Per ulteriori informazioni sui tipi di macchina compatibili con le TPU, vedi Scegliere la versione della TPU.
• TPU_TOPOLOGY: la topologia TPU, ad esempio 2x4x4. Il formato della topologia dipende dalla versione della TPU. Per scoprire di più sulle topologie TPU, consulta Scegliere una topologia.
• NUM_NODES: Il numero di nodi nel pool di nodi.

Per saperne di più, consulta Crea un pool di nodi slice TPU single-host.

Esegui il deployment di un carico di lavoro che rivendica tutti i dispositivi di rete

Per allocare dispositivi di rete non RDMA per un pod, specifica un ResourceClaimTemplate.

1. Crea un ResourceClaimTemplate che faccia riferimento a netdev.google.com DeviceClass. Il seguente manifest richiede tutti i dispositivi di rete non RDMA disponibili sul nodo.

   Salva il manifest come all-netdev-template.yaml:

   apiVersion: resource.k8s.io/v1
   kind: ResourceClaimTemplate
   metadata:
     name: all-netdev
   spec:
     spec:
       devices:
         requests:
         - name: req-netdev
           exactly:
             deviceClassName: netdev.google.com
             allocationMode: All
   

2. Applica il manifest:

   kubectl apply -f all-netdev-template.yaml
   

3. Esegui il deployment del workload e fai riferimento a ResourceClaimTemplate. Il seguente manifest esegue il deployment di un pod che utilizza il modello all-netdev per concedere al pod l'accesso a tutti i dispositivi di rete non RDMA sul nodo. Salva il manifest come netdev-pod.yaml:

   apiVersion: v1
   kind: Pod
   metadata:
     name: agnhost-netdev
     namespace: default
     labels:
       app: agnhost
   spec:
     containers:
     - name: agnhost
       image: registry.k8s.io/e2e-test-images/agnhost:2.39
       args: ["netexec", "--http-port", "80"]
       ports:
       - name: agnhost-port
         containerPort: 80
       resources:
         claims:
         - name: netdev
         limits:
           google.com/tpu: 4
     nodeSelector:
       cloud.google.com/gke-tpu-accelerator: TPU_ACCELERATOR
       cloud.google.com/gke-tpu-topology: TPU_TOPOLOGY
     resourceClaims:
     - name: netdev
       resourceClaimTemplateName: all-netdev
   

   Sostituisci quanto segue:

   • TPU_ACCELERATOR: il tipo di acceleratore TPU, ad esempio tpu-v5p-slice.
   • TPU_TOPOLOGY: la topologia TPU, ad esempio 2x4x4.

4. Applica il manifest:

   kubectl apply -f netdev-pod.yaml
   

5. Verifica che le interfacce di rete allocate aggiuntive siano visibili all'interno del pod.

   kubectl exec agnhost-netdev -- ls /sys/class/net
   

   L'output di esempio seguente mostra le interfacce eth0 e lo predefinite, insieme ai dispositivi di rete allocati, che hanno nomi come eth1 e eth2. Il numero di NIC e i relativi nomi variano in base al tipo di macchina del nodo GKE.

   eth0
   eth1
   eth2
   lo
   

Abilita DRANET con ComputeClass personalizzata

Per utilizzare DRANET gestito da GKE nei cluster Autopilot o con il provisioning automatico dei nodi nei cluster Standard, devi utilizzare una risorsa ComputeClass personalizzata per attivare la funzionalità.

1. Crea un manifest ComputeClass che attiva il driver DRANET e imposta il profilo di rete dell'acceleratore su auto:

   apiVersion: cloud.google.com/v1
   kind: ComputeClass
   metadata:
     name: dranet-compute-class
   spec:
     nodePoolAutoCreation:
       enabled: true
     nodePoolConfig:
       dra:
         networking:
           enabled: true
     priorities:
     - machineType: MACHINE_TYPE
       gpu:
         count: GPU_COUNT
         type: GPU_TYPE
       acceleratorNetworkProfile: auto
   

   Sostituisci quanto segue:

   • MACHINE_TYPE: il tipo di macchina per il pool di nodi, ad esempio a3-ultragpu-8g.
   • GPU_COUNT: il numero di GPU per il tipo di macchina.
   • GPU_TYPE: il tipo di GPU, ad esempio nvidia-h200.

2. Applica il manifest:

   kubectl apply -f COMPUTE_CLASS_FILENAME.yaml
   

3. Nella specifica del pod, fai riferimento a ComputeClass utilizzando il selettore di nodi cloud.google.com/compute-class:

   apiVersion: v1
   kind: Pod
   metadata:
     name: dranet-pod
   spec:
     nodeSelector:
       cloud.google.com/compute-class: "dranet-compute-class"
     ...
   

Richiedere un numero specifico di dispositivi di rete

Gli esempi precedenti mostrano come richiedere tutti i dispositivi di rete disponibili di un determinato tipo impostando allocationMode su All. Se invece devi richiedere un numero specifico di dispositivi, puoi impostare allocationMode su ExactCount nel tuo ResourceClaimTemplate.

L'esempio seguente richiede due dispositivi di rete RDMA:

apiVersion: resource.k8s.io/v1
kind: ResourceClaimTemplate
metadata:
  name: two-mrdma
spec:
  spec:
    devices:
      requests:
      - name: req-mrdma
        exactly:
          deviceClassName: mrdma.google.com
          allocationMode: ExactCount
          count: 2

Passaggi successivi

• Scopri di più sull'allocazione dinamica delle risorse.
• Scopri di più su Configura il networking automatizzato per le VM con acceleratore.