GPU-Netzwerkbandbreite in Clustern im Standardmodus maximieren

Auf dieser Seite erfahren Sie, wie Sie die Netzwerkbandbreite und den Durchsatz für leistungsstarke GPU-Arbeitslasten in Standardclustern der Google Kubernetes Engine (GKE) mithilfe von GPUDirect-TCPXO, GPUDirect-TCPX, gVNIC und Multi-Networking maximieren. Wenn Sie Autopilot-Cluster verwenden, lesen Sie den Hilfeartikel GPU-Netzwerkbandbreite in Clustern im Autopilot-Modus maximieren.

Diese Seite richtet sich an Entwickler von maschinellem Lernen (ML) und Plattformadministratoren, die ML-Arbeitslasten ermöglichen. Weitere Informationen zu gängigen Rollen und Beispielaufgaben, auf die wir in unseren Inhalten verweisen, finden Sie unter Häufig verwendete GKE Enterprise-Nutzerrollen und -Aufgaben. Google Cloud

Anwendungen für künstliche Intelligenz (KI), maschinelles Lernen (ML) und Hochleistungs-Computing (HPC) erfordern eine leistungsstarke Beschleunigung, um die Leistung zu optimieren, indem die Zeit bis zur Jobausführung verkürzt wird. Beispielsweise erfordern ML-Modelle, die sich auf konversationelle KI und Bildgenerierung konzentrieren, eine hohe Skalierbarkeit und Rechenleistung.

Machen Sie sich vor dem Lesen dieser Seite mit Netzwerktechnologien wie Netzwerkkarten (NICs) und TCP sowie mit Beschleunigertechnologien wie der NVIDIA Collective Communications Library (NCCL) vertraut.

Google Cloud GPU-Supercomputer

Google Cloud verwendet beschleunigungsoptimierte Supercomputer, die für skalierbare, riesige Modelle entwickelt wurden. Diese Maschinen bieten folgende Vorteile:

  • Acht NVIDIA B200-, H200- oder H100-GPUs pro Maschine.
  • Bis zu 200 Gbit/s Bandbreite auf der primären NIC.
  • Sekundäre NICs (bis zu acht bei A3 Mega-Maschinentypen und bis zu vier bei A3 High-Maschinentypen), die jeweils eine Bandbreite von bis zu 200 Gbit/s für die GPU-Datenübertragung unterstützen.

Ihre GKE-Arbeitslast muss alle verfügbaren GPUs und alle verfügbaren sekundären NICs auf einem einzelnen Knoten verwenden und einen erheblichen Teil der verfügbaren Bandbreite nutzen. Die in diesem Dokument beschriebene Lösung eignet sich ideal für Arbeitslasten, die eine hohe Leistung, einen hohen Durchsatz und eine geringe Latenz erfordern.

Erforderliche Funktionen für maximale Bandbreite

Verwenden Sie alle der folgenden Funktionen, um die Netzwerkbandbreite in GPU-Supercomputerknoten zu maximieren:

  • GPUDirect-Netzwerkstack: Die A3-Maschinenreihe unterstützt drei Netzwerkstacks für benutzerdefinierten Remote Direct Memory Access (RDMA):
    • Verwenden Sie bei A3 High-Maschinentypen und NVIDIA H100-GPUs GPUDirect-TCPX, um den Overhead für die Übertragung von Paketnutzlasten an und von GPUs zu reduzieren. Dadurch wird der Durchsatz im Vergleich zu GPUs, die GPUDirect nicht verwenden, erheblich verbessert.
    • Verwenden Sie bei A3 Mega-Maschinentypen und NVIDIA H100-Mega-GPUs GPUDirect-TCPXO, um die Kommunikation zwischen GPU und VM weiter zu verbessern.
    • Verwenden Sie bei A3 Ultra-Maschinentypen und NVIDIA H200-GPUs sowie A4-Maschinentypen und NVIDIA B200-GPUs GPUDirect RDMA, um verteilte KI-Arbeitslasten mit weiteren Durchsatzverbesserungen auszuführen. Erstellen Sie zuerst einen benutzerdefinierten, KI-optimierten GKE-Cluster.
  • gVNIC: Aktivieren Sie GPUDirect-Funktionen wie Paketheaderaufteilung, Flusssteuerung und Verwaltung des Zwischenspeichers. gVNIC ist erforderlich, um GPUDirect-TCPX oder GPUDirect-TCPXO zu verwenden. Weitere Informationen zu gVNIC finden Sie unter Netzwerkgeschwindigkeit für GPU-Knoten erhöhen.
  • Multi-Netzwerk: Fügen Sie der beschleunigungsoptimierten Maschine sekundäre NICs hinzu. Jede NIC ist einem separaten Subnetz in einem eigenen VPC zugeordnet, um Konflikte zu vermeiden. Weitere Informationen zur Unterstützung für mehrere Netzwerke finden Sie unter Unterstützung mehrerer Netzwerke für Pods einrichten.
  • Platzierungsrichtlinien: Mit einer Ressourcenplatzierungsrichtlinie können Sie alle GPU-Knoten für eine bestimmte Arbeitslast auf physisch nahe gelegenen Servern platzieren, um die Latenz zu minimieren. Weitere Informationen finden Sie unter Kompakte Platzierung für GKE-Knoten definieren.

Prozedurübersicht

So verwenden Sie alle diese Funktionen zusammen:

  1. Virtual Private Clouds (VPCs) und Subnetze erstellen
  2. Erstellen Sie die GKE-Umgebung.
  3. GPUDirect-Binärprogramm und NCCL-Plug-in installieren
  4. NRI-Geräte-Injector-Plug-in bereitstellen
  5. Testarbeitslast bereitstellen, um die GPUDirect-Einrichtung zu prüfen

Hinweise

Führen Sie die folgenden Aufgaben aus, bevor Sie beginnen:

  • Aktivieren Sie die Google Kubernetes Engine API.
    • Google Kubernetes Engine API aktivieren
  • Wenn Sie die Google Cloud CLI für diese Aufgabe verwenden möchten, müssen Sie die gcloud CLI installieren und dann initialisieren. Wenn Sie die gcloud CLI bereits installiert haben, rufen Sie die neueste Version mit gcloud components update ab.
  • Achten Sie darauf, dass Ihr Kontingent für H100-GPUs ausreicht. Informationen zum Anfordern eines höheren Kontingents finden Sie unter GPU-Kontingente.

Voraussetzungen

Sofern nicht anders angegeben, gelten die folgenden Anforderungen sowohl für GPUDirect-TCPX als auch für GPUDirect-TCPXO.

  • GPUDirect-TCPX wird in GKE Version 1.27 oder höher unterstützt und erfordert Folgendes:
    • * Maschinentyp a3-highgpu-8g
    • Verwenden Sie für GKE-Version 1.27 die GKE-Patchversion 1.27.7-gke.1121000 oder höher.
    • Verwenden Sie für die GKE-Version 1.28 die GKE-Patchversion 1.28.10-gke.1141000 oder höher.
    • Verwenden Sie für die GKE-Version 1.29 die GKE-Patchversion 1.29.5-gke.1121000 oder höher.

  • GPUDirect-TCPXO wird in GKE Version 1.28 oder höher unterstützt und erfordert Folgendes:

    • Maschinentyp a3-megagpu-8g
    • Verwenden Sie für die GKE-Version 1.28 die GKE-Patchversion 1.28.9-gke.1250000 oder höher.
    • Verwenden Sie für die GKE-Version 1.29 die GKE-Patchversion 1.29.4-gke.1542000 oder höher.
    • Verwenden Sie für die GKE-Version 1.30 die GKE-Patchversion 1.30.4-gke.1129000 oder höher.
    • Verwenden Sie für die GKE-Version 1.31 die GKE-Patchversion 1.31.1-gke.2008000 oder höher.
    • Verwenden Sie für die GKE-Version 1.32 die GKE-Patchversion 1.32.2-gke.1489001 oder höher.

  • Der GKE-Knoten muss ein Knoten-Image für Container-Optimized OS (COS) verwenden. Ubuntu- und Windows-Knoten-Images werden nicht unterstützt.

  • Ihre GPU-Knoten müssen die NVIDIA-Treiberversion 535 oder höher verwenden.
  • Sie müssen GKE Dataplane V2 verwenden.
  • Bei GPUDirect-TCPX- oder GPUDirect-TCPXO-Arbeitslasten, die über mehrere Knotenpools ausgeführt werden, müssen sich alle Knotenpools in denselben Compute Engine-Zonen befinden und dieselben Netzwerkgruppen wie VPCs und Subnetze verwenden.

Beschränkungen

Es gelten folgende Einschränkungen:

  • GPUDirect-TCPX und GPUDirect-TCPXO werden nicht mit GPUs mit mehreren Instanzen, GPU-Timesharing oder NVIDIA MPS unterstützt.
  • Sie können NCCL FastSocket nicht mit GPUDirect-TCPX oder GPUDirect-TCPXO verwenden .
  • Ihre GKE-Arbeitslast muss alle verfügbaren GPUs und alle verfügbaren sekundären NICs auf einem einzelnen Knoten verwenden. Mehrere Pods können GPUDirect-TCPX oder GPUDirect-TCPXO nicht auf einem einzelnen Knoten verwenden.
  • Sie können nur die Maschinentypen a3-highgpu-8g und a3-megagpu-8g verwenden. Andere A3-Maschinentypen werden nicht unterstützt.

VPCs und Subnetze erstellen

Erstellen Sie in Ihrem Projekt separate VPC-Netzwerke für jede virtuelle NIC, die Sie Ihren Knoten hinzufügen. Jedes VPC-Netzwerk muss ein Subnetz und eine Firewallregel haben, die den internen Netzwerkverkehr zulässt.

  1. Erstellen Sie die VPC-Netzwerke für GPUDirect in Ihrem Projekt, jeweils mit einem Subnetz und einer Firewallregel. Wählen Sie für A3 High-Maschinentypen den Tab „GPUDirect-TCPX“ oder für A3 Mega-Maschinentypen den Tab „GPUDirect-TCPXO“ aus und führen Sie dann die folgenden Schritte aus:

    GPUDirect-TCPXO

    Um die Bandbreite zu maximieren, empfehlen wir, acht neue Netzwerke zu erstellen.

    for N in $(seq 1 8); do
gcloud compute networks create PREFIX-net-$N \
    --subnet-mode=custom \
    --mtu=8244

gcloud compute networks subnets create PREFIX-sub-$N \
    --network=PREFIX-net-$N \
    --region=REGION \
    --range=SUBNET_RANGE

gcloud compute firewall-rules create PREFIX-internal-$N \
  --network=PREFIX-net-$N \
  --action=ALLOW \
  --rules=tcp:0-65535,udp:0-65535,icmp \
  --source-ranges=SOURCE_RANGE
done

    Ersetzen Sie Folgendes:

    • PROJECT_ID: Ihre Google Cloud -Projekt-ID.
    • REGION: die Compute Engine-Region für jedes Subnetz.
    • SUBNET_RANGE: den IP-Adressbereich jedes Subnetzes in CIDR-Notation. Dieser Beispielbefehl wird für acht Subnetze ausgeführt. Sie sollten daher eine Variable verwenden, um die IP-Adresse für jedes Subnetz zu ändern. Geben Sie beispielsweise 192.168.$N.0/24 an, damit das erste Subnetz 192.168.1.0/24, das zweite Subnetz 192.168.2.0/24 usw. verwendet.
    • SOURCE_RANGE: Der Quell-IP-Adressbereich für die Firewallregel, um eingehenden Traffic zuzulassen, in CIDR-Notation. Beispiel: 192.168.0.0/16

    GPUDirect-TCPX

    Um die Bandbreite zu maximieren, empfehlen wir, vier neue Netzwerke zu erstellen.

    for N in $(seq 1 4); do
gcloud compute networks create PREFIX-net-$N \
    --subnet-mode=custom \
    --mtu=8244

gcloud compute networks subnets create PREFIX-sub-$N \
    --network=PREFIX-net-$N \
    --region=REGION \
    --range=SUBNET_RANGE

gcloud compute firewall-rules create PREFIX-internal-$N \
  --network=PREFIX-net-$N \
  --action=ALLOW \
  --rules=tcp:0-65535,udp:0-65535,icmp \
  --source-ranges=SOURCE_RANGE
done

    Ersetzen Sie Folgendes:

    • PROJECT_ID: Ihre Google Cloud -Projekt-ID.
    • REGION: die Compute Engine-Region für jedes Subnetz.
    • SUBNET_RANGE: den IP-Adressbereich jedes Subnetzes in CIDR-Notation. Dieser Beispielbefehl wird für vier Subnetze ausgeführt. Verwenden Sie daher eine Variable, um die IP-Adresse für jedes Subnetz zu ändern. Geben Sie beispielsweise 192.168.$N.0/24 an, damit das erste Subnetz 192.168.1.0/24, das zweite Subnetz 192.168.2.0/24 usw. verwendet.
    • SOURCE_RANGE: Der Quell-IP-Adressbereich für die Firewallregel, um eingehenden Traffic zuzulassen, in CIDR-Notation. Beispiel: 192.168.0.0/16

  2. Prüfen Sie, ob die Netzwerke erstellt wurden:

    gcloud compute networks list

GKE-Umgebung erstellen

Erstellen Sie einen neuen GKE-Cluster, der Multi-Networking (Vorabversion) verwendet, und einen GPU-Knotenpool mit den folgenden Eigenschaften:

  • gVNIC aktiviert
  • Für jede sekundäre NIC angegebene Subnetze mit mehreren Netzwerken
  • A3-Maschinenserie mit H100-GPUs zur Unterstützung der Knoten
  • Neueste NVIDIA-Treiber installiert

Sie können einen vorhandenen Cluster nicht aktualisieren, um Multi-Netzwerk zu verwenden.

GPUDirect-TCPXO

  1. Wählen Sie eine verfügbare GKE-Version aus, die GPUDirect-TCPXO unterstützt. Führen Sie den folgenden Befehl aus, um die Versionen aufzulisten:

    gcloud container get-server-config \
    --format="yaml(validMasterVersions)" \
    --region=REGION \
    --project=PROJECT_ID

    Ersetzen Sie Folgendes:

    • REGION: die Computing-Region für die Clustersteuerungsebene
    • PROJECT_ID: Ihre Google Cloud -Projekt-ID.

  2. Erstellen Sie einen Cluster.

    gcloud beta container clusters create CLUSTER_NAME \
  --enable-dataplane-v2 --enable-ip-alias --zone=ZONE \
  --enable-multi-networking --cluster-version=VERSION \
  --no-enable-autoupgrade \
  --project=PROJECT_ID

    Ersetzen Sie Folgendes:

    • CLUSTER_NAME: der Name des neuen Clusters.
    • VERSION: eine GKE-Version, die GPUDirect-TCPXO unterstützt, wie in den Anforderungen beschrieben.
    • ZONE ist die Computing-Zone für den Cluster.

  3. Erstellen Sie im Cluster die Ressourcen „Netzwerk“ und „GKENetworkParamSet“, die den von Ihnen erstellten VPC-Netzwerken und ‑Subnetzen entsprechen:

    kubectl apply -f - <<EOF
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc1
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc1
  type: Device
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc2
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc2
  type: Device
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc3
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc3
  type: Device
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc4
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc4
  type: Device
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc5
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc5
  type: Device
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc6
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc6
  type: Device
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc7
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc7
  type: Device
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc8
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc8
  type: Device
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc1
spec:
  vpc: PREFIX-net-1
  vpcSubnet: PREFIX-sub-1
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc2
spec:
  vpc: PREFIX-net-2
  vpcSubnet: PREFIX-sub-2
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc3
spec:
  vpc: PREFIX-net-3
  vpcSubnet: PREFIX-sub-3
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc4
spec:
  vpc: PREFIX-net-4
  vpcSubnet: PREFIX-sub-4
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc5
spec:
  vpc: PREFIX-net-5
  vpcSubnet: PREFIX-sub-5
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc6
spec:
  vpc: PREFIX-net-6
  vpcSubnet: PREFIX-sub-6
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc7
spec:
  vpc: PREFIX-net-7
  vpcSubnet: PREFIX-sub-7
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc8
spec:
  vpc: PREFIX-net-8
  vpcSubnet: PREFIX-sub-8
  deviceMode: NetDevice
EOF

    Diese Ressourcen weisen GKE an, die NICs für den GPU-Traffic im Passthrough-Modus zu konfigurieren. GKE wendet keine integrierte Netzwerkprogrammierung mit eBPF auf diesen Traffic an.

GPUDirect-TCPX

  1. Erstellen Sie einen Cluster.

    gcloud beta container clusters create CLUSTER_NAME \
  --enable-dataplane-v2 --enable-ip-alias --zone=ZONE \
  --enable-multi-networking --cluster-version=VERSION \
  --no-enable-autoupgrade \
  --project=PROJECT_ID

    Ersetzen Sie Folgendes: * CLUSTER_NAME: der Name des neuen Clusters. * VERSION: eine GKE-Version, die GPUDirect-TCPX unterstützt, wie in den Anforderungen beschrieben. * ZONE: die Computing-Zone für den Cluster.

  2. Erstellen Sie im Cluster die Ressourcen „Netzwerk“ und „GKENetworkParamSet“, die den von Ihnen erstellten VPC-Netzwerken und ‑Subnetzen entsprechen:

    kubectl apply -f - <<EOF
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc1
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc1
  type: Device
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc2
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc2
  type: Device
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc3
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc3
  type: Device
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc4
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc4
  type: Device
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc1
spec:
  vpc: PREFIX-net-1
  vpcSubnet: PREFIX-sub-1
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc2
spec:
  vpc: PREFIX-net-2
  vpcSubnet: PREFIX-sub-2
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc3
spec:
  vpc: PREFIX-net-3
  vpcSubnet: PREFIX-sub-3
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc4
spec:
  vpc: PREFIX-net-4
  vpcSubnet: PREFIX-sub-4
  deviceMode: NetDevice
EOF

    Diese Ressourcen weisen GKE an, die NICs für den GPU-Traffic im Passthrough-Modus zu konfigurieren. GKE wendet keine integrierte Netzwerkprogrammierung mit eBPF auf diesen Traffic an.

GPU-Knotenpool erstellen

GPUDirect-TCPXO

Erstellen Sie einen Knotenpool für die H100-GPUs:

gcloud beta container node-pools create NODE_POOL_NAME \
    --zone=ZONE \
    --cluster=CLUSTER_NAME \
    --project=PROJECT_ID \
    --accelerator=type=nvidia-h100-mega-80gb,count=8,gpu-driver-version=LATEST \
    --machine-type=a3-megagpu-8g \
    --num-nodes=2 \
    --additional-node-network network=PREFIX-net-1,subnetwork=PREFIX-sub-1 \
    --additional-node-network network=PREFIX-net-2,subnetwork=PREFIX-sub-2 \
    --additional-node-network network=PREFIX-net-3,subnetwork=PREFIX-sub-3 \
    --additional-node-network network=PREFIX-net-4,subnetwork=PREFIX-sub-4 \
    --additional-node-network network=PREFIX-net-5,subnetwork=PREFIX-sub-5 \
    --additional-node-network network=PREFIX-net-6,subnetwork=PREFIX-sub-6 \
    --additional-node-network network=PREFIX-net-7,subnetwork=PREFIX-sub-7 \
    --additional-node-network network=PREFIX-net-8,subnetwork=PREFIX-sub-8 \
    --enable-gvnic \
    --no-enable-autoupgrade \
    --scopes "https://www.googleapis.com/auth/cloud-platform" \
    [--placement-policy=POLICY_NAME \
    --reservation-affinity=specific \
    --reservation=RESERVATION_NAME \
    --host-maintenance-interval=PERIODIC]

Ersetzen Sie NODE_POOL_NAME durch den Namen Ihres Knotenpools.

Im Beispiel wird mit dem --scopes-Argument „https://www.googleapis.com/auth/cloud-platform“ der Bereich der Knoteninstanz zu Testzwecken auf cloud-platform festgelegt. Für die Produktion können Sie den Umfang einschränken, um detailliertere Anmeldedaten zu konfigurieren.

Verwenden Sie die Flags --placement-policy, --reservation-affinity und --reservation, wenn Sie eine Reservierung verwenden. Geben Sie diese Flags an, um den Richtliniennamen und die Reservierung im Knotenpool zu konfigurieren.

Wenn dieser Befehl fehlschlägt, haben Sie möglicherweise nicht genügend H100-GPU-Kontingent in Ihrem Projekt. Prüfen Sie, ob Ihr Kontingent ausreicht, und wiederholen Sie den Befehl.

GPUDirect-TCPX

Erstellen Sie einen Knotenpool für die H100-GPUs:

gcloud container node-pools create NODE_POOL_NAME \
    --cluster=CLUSTER_NAME \
    --location=LOCATION \
    --machine-type=a3-highgpu-8g \
    --accelerator=type=nvidia-h100-80gb,count=8,gpu-driver-version=LATEST \
    --additional-node-network=network=PREFIX-net-1,subnetwork=PREFIX-sub-1 \
    --additional-node-network=network=PREFIX-net-2,subnetwork=PREFIX-sub-2 \
    --additional-node-network=network=PREFIX-net-3,subnetwork=PREFIX-sub-3 \
    --additional-node-network=network=PREFIX-net-4,subnetwork=PREFIX-sub-4 \
    --enable-gvnic \
    --no-enable-autoupgrade

Ersetzen Sie NODE_POOL_NAME durch den Namen des Knotenpools.

Wenn dieser Befehl fehlschlägt, haben Sie möglicherweise nicht genügend H100-GPU-Kontingent in Ihrem Projekt. Prüfen Sie, ob Sie ein Kontingent haben, und wiederholen Sie den Befehl.

Prüfen Sie nach dem Erstellen des Knotenpools, ob jeder Knoten die angeschlossenen GPUs hat:

  1. Rufen Sie eine Liste der Knoten im Cluster ab:

    kubectl get nodes

  2. Prüfen Sie, ob jeder GPU-Knoten acht GPUs hat:

    kubectl describe node NODE_NAME

    Ersetzen Sie NODE_NAME durch den Namen des Knotens, den Sie beschreiben möchten.

    Die Ausgabe sieht etwa so aus:

    Capacity:
  ...
  nvidia.com/gpu:             8
Allocatable:
  ...
  nvidia.com/gpu:             8

GPUDirect-Binärprogramm installieren und NCCL konfigurieren

In diesem Abschnitt erfahren Sie, wie Sie das GPUDirect-Binärprogramm basierend auf Ihrem A3-Maschinentyp (GPUDirect-TCPX für A3 High, GPUDirect-TCPXO für A3 Mega) und einer bestimmten NCCL-Bibliotheksversion mithilfe eines DaemonSet installieren.

GPUDirect-TCPXO

Dieses DaemonSet hat folgende Auswirkungen:

  1. Vorinstallation zum Einrichten von GPUDirect-TCPXO-Konfigurationen.
  2. Installiert die NCCL-Bibliothek und das GPUDirect-TCPXO-Binärprogramm auf dem Knoten.
  3. Speichert die Bibliothek und das Binärprogramm im Verzeichnis /home/kubernetes/bin/nvidia/lib64 auf der VM. Standardmäßig wird dieses Verzeichnis von GKE in GPU-Containern, in denen NCCL und GPUDirect-TCPXO verwendet werden müssen, im Pfad /usr/local/nvidia/lib64 bereitgestellt.

So installieren Sie die Binärdatei und konfigurieren NCCL:

  1. Prüfen Sie das nccl-tcpxo-installer.yaml-Daemon-Set-Manifest in GitHub.

  2. Stellen Sie das DaemonSet bereit:

    kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/gpudirect-tcpxo/nccl-tcpxo-installer.yaml

    Es dauert etwa zwei Minuten, bis das NCCL-Plug-in gestartet wird.

  3. Prüfen Sie den Status der DaemonSet-Pods:

    kubectl get pods -n=kube-system -l=name=nccl-tcpxo-installer

    Die Ausgabe sieht in etwa so aus:

    # Output
nccl-tcpxo-installer-6c2pv                    1/1     Running   0          2m11s
nccl-tcpxo-installer-qgg82                    1/1     Running   0          2m11s

GPUDirect-TCPX

Dieses DaemonSet hat folgende Auswirkungen:

  1. Installiert die NCCL-Bibliothek und das GPUDirect-TCPX-Binärprogramm auf dem Knoten.
  2. Speichert die Bibliothek und das Binärprogramm im Verzeichnis /home/kubernetes/bin/nvidia/lib64 auf der VM. Standardmäßig wird dieses Verzeichnis von GKE in GPU-Containern, in denen NCCL und GPUDirect-TCPX verwendet werden müssen, im Pfad /usr/local/nvidia/lib64 bereitgestellt.

So installieren Sie das Binärprogramm und konfigurieren NCCL:

  1. Sehen Sie sich das nccl-tcpx-installer.yaml-Daemon-Set-Manifest in GitHub an.

  2. Stellen Sie das DaemonSet bereit:

    kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/gpudirect-tcpx/nccl-tcpx-installer.yaml

    Es dauert etwa zwei Minuten, bis das NCCL-Plug-in gestartet wird.

  3. Prüfen Sie den Status der DaemonSet-Pods:

    kubectl get pods -n=kube-system -l=name=nccl-tcpx-installer

    Die Ausgabe sieht in etwa so aus:

    nccl-tcpx-installer-6c2pv                    1/1     Running   0          2m11s
nccl-tcpx-installer-qgg82                    1/1     Running   0          2m11s

NRI-Geräte-Injector-Plug-in bereitstellen

In diesem Abschnitt erfahren Sie, wie Sie den NRI-Geräte-Injektor mit einem DaemonSet installieren. Für beide H100-GPU-Maschinentypen wird dasselbe NRI-Geräte-Injector-Plug-in installiert. Dieses Plug-in bietet folgende Funktionen:

  1. Aktiviert die Node Resource Interface (NRI) auf dem Knoten mit H100-GPUs. NRI ist in GKE-Version 1.29 und höher standardmäßig aktiviert.
  2. Hiermit wird ein Container für das NRI-Geräte-Injector-Plug-in bereitgestellt, das GPU-Geräte in Container einschleust, die durch Pod-Anmerkungen angegeben werden.

Gehen Sie zum Installieren des Plug-ins so vor:

  1. Prüfen Sie das nri-device-injector.yaml-Deployment-Manifest in GitHub.

  2. Stellen Sie das DaemonSet bereit:

    kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nri_device_injector/nri-device-injector.yaml

    Es dauert etwa zwei Minuten, bis das NCCL-Plug-in gestartet wird.

  3. Prüfen Sie den Status der DaemonSet-Pods:

    kubectl get pods -n=kube-system -l=name=device-injector

    Die Ausgabe sieht in etwa so aus:

    # Output
device-injector-md6hb                         1/1     Running   0       4h54m
device-injector-vh9bm                         1/1     Running   0       4h54m

Testarbeitslast bereitstellen

In diesem Abschnitt stellen Sie eine Beispielarbeitslast bereit, um zu prüfen, ob NCCL und GPUDirect-TCPX oder GPUDirect-TCPXO wie erwartet funktionieren. Diese Beispielarbeitslast tut Folgendes:

  1. Es werden zwei Pods bereitgestellt, die jeweils auf einem Knoten mit H100-GPUs ausgeführt werden.
  2. In jedem Pod wird ein Sidecar-Container bereitgestellt, damit diese Pods GPUDirect-TCPXO oder GPUDirect-TCPX verwenden können.

So stellen Sie diese Beispielarbeitslast bereit:

GPUDirect-TCPXO

Diese Arbeitslast umfasst einen Sidecar-Container namens tcpxo-daemon, in dem ein Dienst ausgeführt wird, mit dem der Pod GPUDirect-TCPXO verwenden kann. Sie müssen diesen Sidecar-Container allen Pods in Ihrer eigenen Umgebung hinzufügen, die GPUDirect-TCPXO verwenden müssen. Eine Übersicht über die erforderlichen Felder, die Sie Ihren Manifesten hinzufügen müssen, finden Sie unter GPUDirect zu Manifesten hinzufügen.

  1. Sehen Sie sich das nccl-test-latest.yaml-Manifest in GitHub an.

  2. Stellen Sie zwei Pods mit der Testarbeitslast bereit:

    kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/gpudirect-tcpxo/nccl-test-latest.yaml

  3. Nach der Bereitstellung der Pods einen All-Gather-Test auslösen:

    kubectl exec --stdin --tty --container=nccl-test nccl-test-host-1 -- /scripts/allgather.sh nccl-host-1 nccl-host-2

    Die Ausgabe sieht etwa so aus:

    #                                                              out-of-place                       in-place
#        size         count      type   redop    root     time   algbw   busbw #wrong     time   algbw   busbw #wrong
#         (B)    (elements)                               (us)  (GB/s)  (GB/s)            (us)  (GB/s)  (GB/s)
            0             0     float    none      -1     0.24    0.00    0.00      0     0.18    0.00    0.00      0
            0             0     float    none      -1     0.19    0.00    0.00      0     0.17    0.00    0.00      0
            0             0     float    none      -1     0.17    0.00    0.00      0     0.17    0.00    0.00      0
            0             0     float    none      -1     0.17    0.00    0.00      0     0.17    0.00    0.00      0
            0             0     float    none      -1     0.17    0.00    0.00      0     0.17    0.00    0.00      0
          256             4     float    none      -1    235.2    0.00    0.00      0    235.1    0.00    0.00      0
          512             8     float    none      -1    241.0    0.00    0.00      0    236.1    0.00    0.00      0
         1024            16     float    none      -1    236.3    0.00    0.00      0    233.3    0.00    0.00      0
         2048            32     float    none      -1    234.1    0.01    0.01      0    233.4    0.01    0.01      0
         4096            64     float    none      -1    237.1    0.02    0.02      0    235.3    0.02    0.02      0
         8192           128     float    none      -1    236.2    0.03    0.03      0    235.2    0.03    0.03      0
        16384           256     float    none      -1    236.6    0.07    0.06      0    238.5    0.07    0.06      0
        32768           512     float    none      -1    237.9    0.14    0.13      0    238.8    0.14    0.13      0
        65536          1024     float    none      -1    242.3    0.27    0.25      0    239.4    0.27    0.26      0
       131072          2048     float    none      -1    263.0    0.50    0.47      0    275.1    0.48    0.45      0
       262144          4096     float    none      -1    279.2    0.94    0.88      0    269.9    0.97    0.91      0
       524288          8192     float    none      -1    273.5    1.92    1.80      0    273.5    1.92    1.80      0
      1048576         16384     float    none      -1    315.1    3.33    3.12      0    314.1    3.34    3.13      0
      2097152         32768     float    none      -1    319.2    6.57    6.16      0    311.5    6.73    6.31      0
      4194304         65536     float    none      -1    331.8   12.64   11.85      0    331.3   12.66   11.87      0
      8388608        131072     float    none      -1    356.3   23.54   22.07      0    353.8   23.71   22.23      0
     16777216        262144     float    none      -1    409.1   41.01   38.45      0    405.2   41.40   38.81      0
     33554432        524288     float    none      -1    451.4   74.34   69.69      0    447.7   74.94   70.26      0
     67108864       1048576     float    none      -1    713.4   94.07   88.19      0    713.8   94.01   88.13      0
    134217728       2097152     float    none      -1   1122.1  119.62  112.14      0   1116.3  120.23  112.72      0
    268435456       4194304     float    none      -1   1785.8  150.32  140.92      0   1769.2  151.72  142.24      0
    536870912       8388608     float    none      -1   2859.7  187.74  176.00      0   2852.6  188.20  176.44      0
   1073741824      16777216     float    none      -1   5494.1  195.44  183.22      0   5568.2  192.83  180.78      0
   2147483648      33554432     float    none      -1    10841  198.09  185.71      0    10798  198.88  186.45      0
   4294967296      67108864     float    none      -1    21453  200.21  187.70      0    21490  199.86  187.37      0
   8589934592     134217728     float    none      -1    42603  201.63  189.03      0    42670  201.31  188.73      0
# Out of bounds values : 0 OK
# Avg bus bandwidth    : 45.7587
#

GPUDirect-TCPX

Diese Arbeitslast umfasst einen Sidecar-Container namens tcpx-daemon, der einen Dienst ausführt, mit dem der Pod GPUDirect-TCPX verwenden kann. Sie müssen diesen Sidecar-Container allen Pods in Ihrer eigenen Umgebung hinzufügen, die GPUDirect-TCPX verwenden müssen. Eine Übersicht über die erforderlichen Felder, die Sie Ihren Manifesten hinzufügen müssen, finden Sie unter GPUDirect zu Manifesten hinzufügen.

  1. Prüfen Sie das ConfigMap-Manifest nccl-config.yaml in GitHub. Dieses Manifest stellt Scripts bereit, die einen NCCL-Allgather-Test initialisieren und NCCL-spezifische Konfigurationseinstellungen festlegen.

  2. Prüfen Sie das nccl-test-latest.yaml-Deployment-Manifest in GitHub.

  3. Stellen Sie die ConfigMap und die Testarbeitslast bereit:

    kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/gpudirect-tcpx/nccl-config.yaml
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/gpudirect-tcpx/nccl-test-latest.yaml

  4. Führen Sie die folgenden Befehle aus, um einen NCCL-Test-All-Gather-Test für die Knoten auszulösen:

    kubectl exec \
  --stdin --tty --container=nccl-test nccl-test-host-1 \
  -- /configs/allgather.sh nccl-host-1 nccl-host-2

    Die Ausgabe sieht in etwa so aus:

    #                                                              out-of-place                       in-place
#       size         count      type   redop    root     time   algbw   busbw #wrong     time   algbw   busbw #wrong
#        (B)    (elements)                               (us)  (GB/s)  (GB/s)            (us)  (GB/s)  (GB/s)
    1048576         16384     float    none      -1    696.8    1.50    1.41      0    729.0    1.44    1.35      0
    2097152         32768     float    none      -1    776.4    2.70    2.53      0    726.7    2.89    2.71      0
    4194304         65536     float    none      -1    774.3    5.42    5.08      0    805.1    5.21    4.88      0
    8388608        131072     float    none      -1    812.1   10.33    9.68      0    817.6   10.26    9.62      0
   16777216        262144     float    none      -1   1035.2   16.21   15.19      0   1067.8   15.71   14.73      0
   33554432        524288     float    none      -1   1183.3   28.36   26.59      0   1211.8   27.69   25.96      0
   67108864       1048576     float    none      -1   1593.4   42.12   39.49      0   1510.5   44.43   41.65      0
  134217728       2097152     float    none      -1   2127.8   63.08   59.13      0   2312.7   58.03   54.41      0
  268435456       4194304     float    none      -1   3603.0   74.50   69.85      0   3586.2   74.85   70.17      0
  536870912       8388608     float    none      -1   7101.7   75.60   70.87      0   7060.9   76.03   71.28      0
# Out of bounds values : 0 OK
# Avg bus bandwidth    : 29.8293

Erforderliche NCCL-Konfigurationseinstellungen zur Leistungsverbesserung verwenden

Die folgenden Schlüssel/Wert-Paare sind die erforderlichen NCCL-Konfigurationseinstellungen für GPUDirect-TCPX und GPUDirect-TCPXO. Wenn Sie Arbeitslasten bereitstellen, die NCCL verwenden, legen Sie sie als Umgebungsvariablen fest, um die Leistung zu optimieren.

GPUDirect-TCPXO


"LD_LIBRARY_PATH=\"${LD_LIBRARY_PATH}:/usr/local/nvidia/lib64\"",
"NCCL_FASTRAK_CTRL_DEV=eth0",
"NCCL_FASTRAK_IFNAME=eth1,eth2,eth3,eth4,eth5,eth6,eth7,eth8",
"NCCL_SOCKET_IFNAME=eth0",
"NCCL_CROSS_NIC=0",
"NCCL_ALGO=Ring,Tree",
"NCCL_PROTO=Simple,LL128",
"NCCL_MIN_NCHANNELS=4",
"NCCL_TUNER_PLUGIN=libnccl-tuner.so",
"NCCL_TUNER_CONFIG_PATH=/usr/local/nvidia/lib64/a3plus_tuner_config.textproto",
"NCCL_SHIMNET_GUEST_CONFIG_CHECKER_CONFIG_FILE=/usr/local/nvidia/lib64/a3plus_guest_config.textproto",
"NCCL_DYNAMIC_CHUNK_SIZE=524288",
"NCCL_P2P_NET_CHUNKSIZE=524288",
"NCCL_P2P_PCI_CHUNKSIZE=524288",
"NCCL_P2P_NVL_CHUNKSIZE=1048576",
"NCCL_FASTRAK_NUM_FLOWS=2",
"NCCL_FASTRAK_USE_SNAP=1",
"NCCL_FASTRAK_PLUGIN_ACCEPT_TIMEOUT_MS=600000",
"NCCL_FASTRAK_ENABLE_CONTROL_CHANNEL=0",
"NCCL_BUFFSIZE=8388608",
"CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7",
"NCCL_NET_GDR_LEVEL=PIX",
"NCCL_FASTRAK_ENABLE_HOTPATH_LOGGING=0",
"NCCL_FASTRAK_USE_LLCM=1",
"NCCL_NVLS_ENABLE=0"

Optional können Sie alle Konfigurationen gleichzeitig festlegen. Gehen Sie dazu so vor:

  1. Fügen Sie dem Containermanifest Ihrer Arbeitslast das folgende Schlüssel/Wert-Paar als Umgebungsvariable hinzu:

    NCCL_LIB_DIR="/usr/local/nvidia/lib64"

  2. Das nccl-env-profile.sh-Script muss beim Starten des Arbeitslastcontainers ausgeführt werden. Sie können dies beispielsweise in Ihrer Pod-Spezifikation tun, indem Sie den Befehl des Containers überschreiben, um Folgendes anzugeben:

    source ${NCCL_LIB_DIR}/nccl-env-profile.sh

LL128-Unterstützung

Das NCCL-Kommunikationsprotokoll NVIDIA LL128 (Low Latency 128) kann die Leistung für kleine bis mittelgroße Gruppen erheblich verbessern. GPUDirect-TCPXO unterstützt das LL128-Protokoll.

Wenn Sie LL128 verwenden möchten, muss die Datei nccl-tcpxo-installer.yaml im Abschnitt GPUDirect-Binärprogramm installieren und NCCL konfigurieren die folgende Container-Image-Version oder eine neuere verwenden:

us-docker.pkg.dev/gce-ai-infra/gpudirect-tcpxo/nccl-plugin-gpudirecttcpx-
dev:v1.0.8-1

So richten Sie LL128 ein:

  • Für die us-docker.pkg.dev/gce-ai-infra/gpudirect-tcpxo/nccl-plugin-gpudirecttcpx- dev:v1.0.8-1-Version des NCCL-Plug-ins gehen Sie so vor:

    1. Legen Sie in Ihrem Arbeitslastmanifest die folgende Umgebungsvariable fest:

      NCCL_LIB_DIR="/usr/local/nvidia/lib64

    2. Konfigurieren Sie Ihre Arbeitslast so, dass das nccl-env-profile-ll128.sh-Script beim Starten des Containers ausgeführt wird. Legen Sie in Ihrem Arbeitslastmanifest den folgenden Befehl fest:

      source ${NCCL_LIB_DIR}/nccl-env-profile-ll128.sh

      Das nccl-env-profile-ll128.sh-Script hat die folgenden Umgebungsvariablen:

      NCCL_PROTO=Simple,LL128
NCCL_TUNER_CONFIG_PATH=/usr/local/nvidia/lib64/a3plus_tuner_config_ll128.textproto
NCCL_SHIMNET_GUEST_CONFIG_CHECKER_CONFIG_FILE=/usr/local/nvidia/lib64/a3plus_guest_config_ll128.textproto

  • Ab der NCCL-Plug-in-Version us-docker.pkg.dev/gce-ai-infra/gpudirect-tcpxo/nccl-plugin-gpudirecttcpx-dev:v1.0.9-1 ist LL128 ein Standardparameter. Wenn Sie also ein nccl-env-profile.sh- oder nccl-env-profile-ll128.sh-Script verwenden, wird LL128 aktiviert. So deaktivieren Sie LL128:

    1. Legen Sie in Ihrem Arbeitslastmanifest die folgende Umgebungsvariable fest:

      NCCL_LIB_DIR="/usr/local/nvidia/lib64

    2. Konfigurieren Sie Ihre Arbeitslast so, dass das nccl-env-profile-ll128.sh-Script beim Starten des Containers ausgeführt wird. Legen Sie in Ihrem Arbeitslastmanifest den folgenden Befehl fest:

      source ${NCCL_LIB_DIR}/nccl-env-profile-simple.sh

      Das nccl-env-profile-simple.sh-Script hat die folgenden Umgebungsvariablen:

      NCCL_PROTO=Simple
NCCL_TUNER_CONFIG_PATH=/usr/local/nvidia/lib64/a3plus_tuner_config_simple.textproto
NCCL_SHIMNET_GUEST_CONFIG_CHECKER_CONFIG_FILE=/usr/local/nvidia/lib64/a3plus_tuner_config_simple.textproto

GPUDirect-TCPX

"LD_LIBRARY_PATH=\"${LD_LIBRARY_PATH}:/usr/local/tcpx/lib64\"",
"NCCL_SOCKET_IFNAME=\"eth0\"",
"NCCL_ALGO=Ring",
"NCCL_PROTO=Simple",
"NCCL_CROSS_NIC=0",
"NCCL_NET_GDR_LEVEL=PIX",
"NCCL_P2P_PXN_LEVEL=0",
"NCCL_GPUDIRECTTCPX_SOCKET_IFNAME=eth1,eth2,eth3,eth4",
"NCCL_GPUDIRECTTCPX_CTRL_DEV=eth0",
"NCCL_DYNAMIC_CHUNK_SIZE=524288",
"NCCL_P2P_NET_CHUNKSIZE=524288",
"NCCL_P2P_PCI_CHUNKSIZE=524288",
"NCCL_P2P_NVL_CHUNKSIZE=1048576",
"NCCL_BUFFSIZE=4194304",
"NCCL_NSOCKS_PERTHREAD=4",
"NCCL_SOCKET_NTHREADS=1",
"NCCL_GPUDIRECTTCPX_TX_BINDINGS=\"eth1:8-21,112-125;eth2:8-21,112-125;eth3:60-73,164-177;eth4:60-73,164-177\"",
"NCCL_GPUDIRECTTCPX_RX_BINDINGS=\"eth1:22-35,126-139;eth2:22-35,126-139;eth3:74-87,178-191;eth4:74-87,178-191\"",
"NCCL_GPUDIRECTTCPX_PROGRAM_FLOW_STEERING_WAIT_MICROS=500000"

NCCL-Fehlerbehebungsprotokolle erfassen

Wenn Sie NCCL-Fehler protokollieren möchten, empfehlen wir, die folgende NCCL-Konfiguration hinzuzufügen:

NCCL_DEBUG=INFO
NCCL_DEBUG_SUBSYS=INIT,NET,ENV,COLL,GRAPH
NCCL_DEBUG_FILE=/DIRECTORY/FILE_NAME.%h.%p
  • NCCL_DEBUG=INFO: Gibt Informationen zur Fehlerbehebung aus.
    • Bei großen Arbeitslasten (64 Knoten oder mehr) kann es zu umfangreicher Protokollierung kommen. Um dieses Szenario zu vermeiden, empfehlen wir, NCCL_DEBUG=WARN festzulegen, sofern Sie nicht NCCL_DEBUG_FILE angegeben haben, um Protokolle nur auf Fehler zu beschränken.

  • NCCL_DEBUG_SUBSYS: Filtert die Subsysteme, für die NCCL Debugging-Informationen erfasst. Wir empfehlen, Protokolle für die folgenden Subsysteme zu erfassen:

    • INIT: die Initialisierungsphase von NCCL.
    • NET: das NCCL-Netzwerk.
    • ENV: die Umgebungsvariablen, die von NCCL verwendet werden.
    • COLL: Sammelvorgänge.
    • GRAPH: Topologieerkennung und Graphensuche.

    Wenn Sie Protokolle für verschiedene Subsysteme erfassen möchten, finden Sie in der NCCL-Dokumentation unter NCCL_DEBUG_SUBSYS eine Liste der zulässigen Werte.

  • NCCL_DEBUG_FILE (optional): Leitet die NCCL-Debugprotokollausgabe an eine von Ihnen angegebene Datei weiter. Mit dieser Variablen werden NCCL-Protokolle in Standarddateien geschrieben, um zu verhindern, dass sich die Protokollausgabe mit der Anwendungsausgabe vermischt. Außerdem werden mit dieser Variablen Protokolle aus verschiedenen NCCL-Rängen in verschiedene Dateien geschrieben, um eine Vermischung der Protokolle zu verhindern.

    Verwenden Sie das folgende Dateinamenformat:

    /DIRECTORY/FILE_NAME.%h.%p

    Ersetzen Sie Folgendes:

    • DIRECTORY: das Verzeichnis, in dem die Protokolldateien gespeichert werden sollen.
    • FILE_NAME: der Name der Protokolldateien.

    Der Platzhalter %h wird in den Hostnamen des Knotens aufgelöst, während %p in die Prozess-ID (PID) des Prozesses aufgelöst wird, der das Protokoll generiert.

Weitere Informationen zum Beheben von NCCL-Logs finden Sie unter Fehlerbehebung bei GPUs in GKE.

GPUDirect zu Manifesten hinzufügen

In diesem Abschnitt werden die erforderlichen Felder aufgeführt, die Sie Ihren Kubernetes-Manifesten hinzufügen müssen, damit Ihre Pods GPUDirect verwenden können.

Gehen Sie je nach GPUDirect-Typ so vor:

GPUDirect-TCPXO

  1. Fügen Sie den Pod-Metadaten die folgenden Anmerkungen hinzu. Ohne diese Anmerkungen ist hostNetwork:true für den Pod und privileged:true für den tcpxo-daemon-Container erforderlich. 

    metadata:
  annotations:
    devices.gke.io/container.tcpxo-daemon: |+
      - path: /dev/nvidia0
      - path: /dev/nvidia1
      - path: /dev/nvidia2
      - path: /dev/nvidia3
      - path: /dev/nvidia4
      - path: /dev/nvidia5
      - path: /dev/nvidia6
      - path: /dev/nvidia7
      - path: /dev/nvidiactl
      - path: /dev/nvidia-uvm
      - path: /dev/dmabuf_import_helper
    networking.gke.io/default-interface: 'eth0'
    networking.gke.io/interfaces: |
      [
        {"interfaceName":"eth0","network":"default"},
        {"interfaceName":"eth1","network":"vpc1"},
        {"interfaceName":"eth2","network":"vpc2"},
        {"interfaceName":"eth3","network":"vpc3"},
        {"interfaceName":"eth4","network":"vpc4"},
        {"interfaceName":"eth5","network":"vpc5"},
        {"interfaceName":"eth6","network":"vpc6"},
        {"interfaceName":"eth7","network":"vpc7"},
        {"interfaceName":"eth8","network":"vpc8"}
      ]

  2. Fügen Sie der Pod-Spezifikation die folgenden Felder hinzu:

    spec:
  volumes:
  - name: libraries
    hostPath:
      path: /home/kubernetes/bin/nvidia/lib64
  - name: sys
    hostPath:
      path: /sys
  - name: proc-sys
    hostPath:
      path: /proc/sys
  - name: aperture-devices
    hostPath:
      path: /dev/aperture_devices

  3. Fügen Sie dem Manifest den folgenden Container hinzu, um den tcpxo-daemon-Dienst auszuführen. Ersetzen Sie (TCPXO_DAEMON_IMAGE) durch das neueste Bild, us-docker.pkg.dev/gce-ai-infra/gpudirect-tcpxo/tcpgpudmarxd-dev:v1.0.15:

    - name: tcpxo-daemon
  image: TCPXO_DAEMON_IMAGE
  imagePullPolicy: Always
  command: ["/bin/sh", "-c"]
  args:
    - |
      set -ex
      chmod 755 /fts/entrypoint_rxdm_container.sh
      /fts/entrypoint_rxdm_container.sh --num_hops=2 --num_nics=8 --uid= --alsologtostderr
  securityContext:
    capabilities:
      add:
        - NET_ADMIN
        - NET_BIND_SERVICE
  volumeMounts:
    - name: libraries
      mountPath: /usr/local/nvidia
    - name: sys
      mountPath: /hostsysfs
    - name: proc-sys
      mountPath: /hostprocsysfs
  env:
    - name: LD_LIBRARY_PATH
      value: /usr/local/nvidia/lib64

  4. Fügen Sie jedem GPU-Container die folgende Umgebungsvariable hinzu:

    env:
- name: LD_LIBRARY_PATH
  value: /usr/local/nvidia/lib64
- name: NCCL_FASTRAK_LLCM_DEVICE_DIRECTORY
  value: /dev/aperture_devices

  5. Fügen Sie jedem GPU-Container die folgenden volumeMounts hinzu. Ohne aperture_devices-Konfigurationen ist privileged:true für GPU-Container erforderlich:

    volumeMounts:
  - name: aperture-devices
    mountPath: /dev/aperture_devices

  6. Fügen Sie Umgebungsvariablen hinzu, um NCCL-Optionen zu konfigurieren. Weitere Informationen finden Sie unter Empfohlene NCCL-Konfigurationseinstellungen zur Leistungsverbesserung verwenden.

Eine fertige Pod-Spezifikation sieht so aus:

apiVersion: v1
kind: Pod
metadata:
name: a3plus-workloads
annotations:
  devices.gke.io/container.tcpxo-daemon: |+
    - path: /dev/nvidia0
    - path: /dev/nvidia1
    - path: /dev/nvidia2
    - path: /dev/nvidia3
    - path: /dev/nvidia4
    - path: /dev/nvidia5
    - path: /dev/nvidia6
    - path: /dev/nvidia7
    - path: /dev/nvidiactl
    - path: /dev/nvidia-uvm
    - path: /dev/dmabuf_import_helper
  networking.gke.io/default-interface: 'eth0'
  networking.gke.io/interfaces: |
    [
      {"interfaceName":"eth0","network":"default"},
      {"interfaceName":"eth1","network":"vpc1"},
      {"interfaceName":"eth2","network":"vpc2"},
      {"interfaceName":"eth3","network":"vpc3"},
      {"interfaceName":"eth4","network":"vpc4"},
      {"interfaceName":"eth5","network":"vpc5"},
      {"interfaceName":"eth6","network":"vpc6"},
      {"interfaceName":"eth7","network":"vpc7"},
      {"interfaceName":"eth8","network":"vpc8"}
    ]
...
containers:
  - name: tcpxo-daemon
    image: TCPXO_DAEMON_IMAGE
    imagePullPolicy: Always
    command: ["/bin/sh", "-c"]
    args:
      - |
        set -ex
        chmod 755 /fts/entrypoint_rxdm_container.sh
        /fts/entrypoint_rxdm_container.sh --num_hops=2 --num_nics=8 --uid= --alsologtostderr
    securityContext:
      capabilities:
        add:
          - NET_ADMIN
          - NET_BIND_SERVICE
    volumeMounts:
      - name: libraries
        mountPath: /usr/local/nvidia
      - name: sys
        mountPath: /hostsysfs
      - name: proc-sys
        mountPath: /hostprocsysfs
    env:
      - name: LD_LIBRARY_PATH
        value: /usr/local/nvidia/lib64
  - name: main-application-container
...
   env:
      - name: LD_LIBRARY_PATH
        value: /usr/local/nvidia/lib64
      - name: NCCL_FASTRAK_LLCM_DEVICE_DIRECTORY
        value: /dev/aperture_devices
    securityContext:
    volumeMounts:
      - name: aperture-devices
        mountPath: /dev/aperture_devices
    resources:
      limits:
        nvidia.com/gpu: 8
volumes:
  - name: libraries
    hostPath:
      path: /home/kubernetes/bin/nvidia
  - name: sys
    hostPath:
      path: /sys
  - name: proc-sys
    hostPath:
      path: /proc/sys
  - name: aperture-devices
    hostPath:
      path: /dev/aperture_devices

GPUDirect-TCPX

  1. Fügen Sie den Pod-Metadaten die folgenden Anmerkungen hinzu. Ohne diese Anmerkungen ist hostNetwork:true für den Pod und privileged:true für den tcpx-daemon-Container erforderlich. 

    metadata:
  annotations:
    devices.gke.io/container.tcpx-daemon: |+
      - path: /dev/nvidia0
      - path: /dev/nvidia1
      - path: /dev/nvidia2
      - path: /dev/nvidia3
      - path: /dev/nvidia4
      - path: /dev/nvidia5
      - path: /dev/nvidia6
      - path: /dev/nvidia7
      - path: /dev/nvidiactl
      - path: /dev/nvidia-uvm
    networking.gke.io/default-interface: 'eth0'
    networking.gke.io/interfaces: |
      [
        {"interfaceName":"eth0","network":"default"},
        {"interfaceName":"eth1","network":"vpc1"},
        {"interfaceName":"eth2","network":"vpc2"},
        {"interfaceName":"eth3","network":"vpc3"},
        {"interfaceName":"eth4","network":"vpc4"},
      ]

  2. Fügen Sie der Pod-Spezifikation die folgenden Felder hinzu:

    spec:
  volumes:
  - name: libraries
    hostPath:
      path: /home/kubernetes/bin/nvidia/lib64
  - name: sys
    hostPath:
      path: /sys
  - name: proc-sys
    hostPath:
      path: /proc/sys

  3. Fügen Sie dem Manifest den folgenden Container hinzu, um den Dienst tcpx-daemon auszuführen:

    - name: tcpx-daemon
  image: us-docker.pkg.dev/gce-ai-infra/gpudirect-tcpx/tcpgpudmarxd-dev:v2.0.9
  command:
    - /tcpgpudmarxd/build/app/tcpgpudmarxd
    - --gpu_nic_preset
    - a3vm
    - --gpu_shmem_type
    - fd
    - --uds_path
    - /run/tcpx
    - --setup_param
    - \"--verbose 128 2 0 \"
  securityContext:
    capabilities:
        add:
          - NET_ADMIN
  volumeMounts:
    - name: libraries
      mountPath: /usr/local/nvidia/lib64
    - name: tcpx-socket
      mountPath: /run/tcpx
    - name: sys
      mountPath: /hostsysfs
    - name: proc-sys
      mountPath: /hostprocsysfs
  env:
    - name: LD_LIBRARY_PATH
      value: /usr/local/nvidia/lib64

  4. Fügen Sie allen Containern, die GPUs anfordern, die folgenden Volume-Bereitstellungen hinzu:

    volumeMounts:
- name: tcpx-socket
  mountPath: /tmp
- name: libraries
  mountPath: /usr/local/nvidia/lib64

  5. Fügen Sie Umgebungsvariablen hinzu, um NCCL-Optionen zu konfigurieren. Weitere Informationen finden Sie in diesem Dokument im Abschnitt Empfohlene NCCL-Konfigurationseinstellungen zur Leistungsverbesserung verwenden.

  6. Fügen Sie jedem GPU-Container die folgende Umgebungsvariable hinzu:

    env:
- name: LD_LIBRARY_PATH
  value: /usr/local/nvidia/lib64

Eine fertige Pod-Spezifikation sieht so aus:

apiVersion: v1
kind: Pod
metadata:
name: a3-gpu-workloads-example
labels:
  name: a3-gpu-workloads-example
annotations:
  devices.gke.io/container.tcpx-daemon: |+
        - path: /dev/nvidia0
        - path: /dev/nvidia1
        - path: /dev/nvidia2
        - path: /dev/nvidia3
        - path: /dev/nvidia4
        - path: /dev/nvidia5
        - path: /dev/nvidia6
        - path: /dev/nvidia7
        - path: /dev/nvidiactl
        - path: /dev/nvidia-uvm
  networking.gke.io/default-interface: 'eth0'
  networking.gke.io/interfaces: |
    [
      {"interfaceName":"eth0","network":"default"},
      {"interfaceName":"eth1","network":"vpc1"},
      {"interfaceName":"eth2","network":"vpc2"},
      {"interfaceName":"eth3","network":"vpc3"},
      {"interfaceName":"eth4","network":"vpc4"}
    ]
spec:
containers:
  - name: tcpx-daemon
    image: us-docker.pkg.dev/gce-ai-infra/gpudirect-tcpx/tcpgpudmarxd-dev:v2.0.11
    imagePullPolicy: Always
    command:
      - /tcpgpudmarxd/build/app/tcpgpudmarxd
      - --gpu_nic_preset
      - a3vm
      - --gpu_shmem_type
      - fd
      - --uds_path
      - /run/tcpx
      - --setup_param
      - \"--verbose 128 2 0 \"
    securityContext:
capabilities:
        add:
          - NET_ADMIN
    volumeMounts:
      - name: libraries
        mountPath: /usr/local/nvidia/lib64
        readOnly: true
      - name: tcpx-socket
        mountPath: /run/tcpx
      - name: sys
        mountPath: /hostsysfs
      - name: proc-sys
        mountPath: /hostprocsysfs
    env:
      - name: LD_LIBRARY_PATH
        value: /usr/local/nvidia/lib64
  - name: a3-gpu-workloads-example
    ...
    volumeMounts:
      - name: tcpx-socket
        mountPath: /tmp
      - name: libraries
        mountPath: /usr/local/nvidia/lib64
        readOnly: true
    resources:
      limits:
        nvidia.com/gpu: 8
    env:
      - name: LD_LIBRARY_PATH
        value: /usr/local/nvidia/lib64
...
volumes:
  - name: libraries
    hostPath:
      path: /home/kubernetes/bin/nvidia/lib64
  - name: tcpx-socket
    emptyDir:
  - name: sys
    hostPath:
      path: /sys
  - name: proc-sys
    hostPath:
      path: /proc/sys

Nächste Schritte