Allocare risorse di rete utilizzando DRANET gestito da GKE

Autopilot Standard

Google Kubernetes Engine (GKE) DRANET è una funzionalità GKE gestita basata sul progetto open source DRANET, che implementa l'API DRA di Kubernetes per le risorse di rete. DRANET ti consente di richiedere e allocare risorse di rete ad alte prestazioni per i tuoi pod, incluse le 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 carichi di lavoro 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 si fa riferimento nei Google Cloud contenuti, consulta Ruoli e attività comuni degli utenti GKE.

Prima di leggere questo documento, assicurati di conoscere i seguenti argomenti:

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

Come funziona GKE DRANET gestito

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

Funziona come un 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.

Nelle versioni GKE 1.34.1-gke.1829001 e 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 con funzionalità RDMA e la classe netdev.google.com per 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 carico di lavoro, definisci un ResourceClaimTemplate. Questo modello specifica la 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 GKE DRANET gestito

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 carichi di lavoro di AI e ML che richiedono un networking ad alte prestazioni.

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

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

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

Tieni presente i seguenti punti quando utilizzi 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. Altri pod sullo stesso nodo non possono condividerla. Questo approccio contribuisce a garantire che il pod abbia accesso esclusivo alla larghezza di banda e alle risorse complete di questa interfaccia, un vantaggio fondamentale per i carichi di lavoro sensibili alle prestazioni.

• Utilizza il driver GKE DRANET gestito in modo indipendente

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

• Utilizza altri driver GKE DRA

  Per ottenere una velocità effettiva maggiore nei carichi di lavoro di AI/ML impegnativi, combina l'API DRA per gli acceleratori (come GPU e TPU) con il networking gestito di GKE DRANET. Questo approccio combinato migliora l'allineamento delle risorse e la consapevolezza della topologia. Per saperne di più sull'utilizzo di DRA per altre risorse, consulta Preparare l'infrastruttura GKE per i carichi di lavoro DRA.

• Evita 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 multi-rete GKE con una risorsa Network 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 set 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 gestito gke-managed-networking-dra-driver nel cluster. Analogamente a diversi altri carichi di lavoro di sistema GKE, i pod del driver DRANET vengono eseguiti solo sui nodi in cui sono 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 networking-dra-driver DaemonSet. Le modifiche manuali, come 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 DRANET gestito, 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 (ad esempio veth).
• Alcuni tipi di istanze, in particolare i nodi bare metal come a4x-max, non sono compatibili con i cluster Autopilot e con la scalabilità automatica.

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
• Se vuoi utilizzare Google Cloud CLI per questa attività, installala e poi inizializza gcloud CLI. Se hai già installato gcloud CLI, scarica l'ultima versione eseguendo il gcloud components update comando. 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 compute/region proprietà. 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 node pool e allocare risorse di rete, chiedi all'amministratore di concederti il ruolo IAM Amministratore di Kubernetes Engine (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 del piano di controllo del cluster, ad esempio us-central1 o us-central1-a.
• PROJECT_ID: l'ID del tuo Google Cloud progetto.
• CLUSTER_VERSION: la versione GKE del cluster. Questa versione deve essere 1.34.1-gke.1829001 o successiva.

Utilizza le interfacce RDMA da un pool di nodi GPU

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

Abilita il driver GKE DRANET gestito 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 pool di nodi.

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 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 Visualizza le richieste di prenotazione futura.

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

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

Esegui il deployment di un carico di lavoro con risorse RDMA

Per allocare le 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 carico di lavoro 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 allocate aggiuntive siano visibili all'interno del pod.

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

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

   eth0
   gpu0rdma0
   gpu1rdma0
   gpu2rdma0
   gpu3rdma0
   lo
   

Utilizza le interfacce di rete non RDMA in un pool di nodi TPU

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

Verifica le DeviceClass di networking

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 GKE DRANET gestito su un pool di nodi di sezioni 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 regione o la zona del cluster. Google Cloud
• CLUSTER_NAME: il nome del cluster.
• NODE_LOCATIONS: Le Google Cloud zone dei nodi nel pool di nodi.
• MACHINE_TYPE: il tipo di macchina da utilizzare per i nodi. Per saperne di più sui tipi di macchine compatibili con TPU, consulta Scegliere la versione della TPU.
• TPU_TOPOLOGY: la topologia TPU, ad esempio 2x4x4. Il formato della topologia dipende dalla versione della TPU. Per saperne di più sulle topologie TPU, consulta Scegliere una topologia.
• NUM_NODES: il numero di nodi nel pool di nodi.

Per saperne di più, consulta Creare un node pool di sezioni TPU a host singolo.

Esegui il deployment di un carico di lavoro che richiede 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 DeviceClass netdev.google.com. 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 carico di lavoro 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'esempio di output 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 GKE DRANET gestito 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 abilita 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"
     ...
   

Richiedi 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 in 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 Configurare il networking automatizzato per le VM con acceleratore.