Benutzerdefinierten KI-optimierten GKE-Cluster erstellen, der A4 oder A3 Ultra verwendet

Auf dieser Seite wird beschrieben, wie Sie einen KI-optimierten Google Kubernetes Engine-Cluster (GKE) erstellen, in dem A4- oder A3-Ultra-VMs verwendet werden, um Ihre KI- und ML-Arbeitslasten zu unterstützen. Informationen zu A4X finden Sie unter Benutzerdefinierten KI-optimierten GKE-Cluster erstellen, der A4X verwendet.

Die Maschinenserien A4 und A3 Ultra wurden entwickelt, damit Sie KI-/ML-Cluster im großen Maßstab mit Funktionen wie der gezielten Platzierung von Arbeitslasten, erweiterten Steuerelementen für die Clusterwartung und dem Topology Aware Scheduling ausführen können. Weitere Informationen finden Sie unter Clusterverwaltung – Übersicht.

GKE bietet eine einheitliche Plattform, auf der Sie eine Vielzahl von Arbeitslasten für Ihre Organisationen ausführen können. So wird der Betriebsaufwand für die Verwaltung mehrerer Plattformen reduziert. Sie können Arbeitslasten wie leistungsstarkes verteiltes Vortraining, Modellabstimmung, Modellinferenz, Anwendungsbereitstellung und unterstützende Dienste ausführen.

Auf dieser Seite erfahren Sie, wie Sie einen GKE-Cluster mit der Google Cloud CLI erstellen, um Ihren Cluster basierend auf den Anforderungen Ihrer Arbeitslast maximal flexibel zu konfigurieren. Alternativ können Sie das Cluster Toolkit verwenden, um Ihren Cluster schnell mit Standardeinstellungen bereitzustellen, die Best Practices für viele Anwendungsfälle entsprechen. Eine Anleitung dazu finden Sie unter KI-optimierten GKE-Cluster mit Standardkonfiguration erstellen.

Optionen für die Clusterkonfiguration mit GPUDirect RDMA

Wenn Sie Ihren Cluster mit der Google Cloud CLI erstellen möchten, können Sie eine der folgenden Clusterkonfigurationsoptionen auswählen:

  • Wenn Sie keine verteilten KI-Arbeitslasten ausführen möchten: Erstellen Sie einen GKE-Cluster ohne GPUDirect RDMA.
  • Wenn Sie verteilte KI-Arbeitslasten ausführen möchten: Erstellen Sie einen GKE-Cluster mit GPUDirect RDMA.

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 diesen Task 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 dem Befehl gcloud components update ab. In früheren gcloud CLI-Versionen werden die Befehle in diesem Dokument möglicherweise nicht unterstützt.

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen für das Projekt zuzuweisen, damit Sie die nötigen Berechtigungen zum Erstellen und Verwalten eines GKE-Cluster haben:

Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Sie können die erforderlichen Berechtigungen auch über benutzerdefinierte Rollen oder andere vordefinierte Rollen erhalten.

Nutzungsoption auswählen und Kapazität erhalten

  1. Wählen Sie eine Option für die Nutzung aus. Treffen Sie Ihre Auswahl basierend darauf, wie Sie GPU-Ressourcen erhalten und verwenden möchten. Weitere Informationen finden Sie unter Verbrauchsoption auswählen.

    Berücksichtigen Sie für GKE die folgenden zusätzlichen Informationen, wenn Sie eine Verbrauchsoption auswählen:

  2. Kapazität erhalten: Kapazität für Ihre Verbrauchsoptionen erhalten

Voraussetzungen

Für einen KI-optimierten GKE-Cluster gelten die folgenden Anforderungen:

  • Wenn Sie das Bereitstellungsmodell „Flex-Start“ verwenden möchten, müssen Sie die GKE-Version 1.32.2-gke.1652000 oder höher verwenden.

  • Achten Sie darauf, dass Sie die Mindestversion des GPU-Treibers verwenden, die vom Maschinentyp abhängt:

    • A4: Für die B200-GPUs in A4-VMs ist mindestens die R570-Version des GPU-Treibers erforderlich. In GKE wird diese Treiberversion standardmäßig automatisch auf allen A4-Knoten installiert, auf denen die erforderliche Mindestversion für A4 ausgeführt wird, nämlich 1.32.1-gke.1729000 oder höher.
    • A3 Ultra: Für die H200-GPUs in A3 Ultra-VMs ist mindestens die GPU-Treiberversion R550 erforderlich, die in GKE-Version 1.31 als latest-Treiberversion verfügbar ist. Bei A3-Ultra-VMs müssen Sie den Wert des Felds gpu-driver-version=latest mit GKE-Version 1.31 festlegen. In GKE-Version 1.31.5-gke.1169000 oder höher installiert GKE standardmäßig R550-GPU-Treiberversionen auf A3 Ultra-Knoten, auch wenn Sie das Flag gpu-driver-version weglassen.

  • Für die Verwendung von GPUDirect RDMA gelten die folgenden zusätzlichen Anforderungen:

    • Verwenden Sie je nach Maschinentyp die folgenden Mindestversionen:
      • A4: Verwenden Sie Version 1.32.2-gke.1475000 oder höher.
      • A3 Ultra: Verwenden Sie Version 1.31.4-gke.1183000 oder höher.
    • Die GKE-Knoten müssen ein Knoten-Image für Container-Optimized OS verwenden. Ubuntu- und Windows-Knotenimages werden nicht unterstützt.
    • Ihre GKE-Arbeitslast muss alle verfügbaren GPUs und Ihr Pod alle verfügbaren sekundären Netzwerkschnittstellenkarten (NICs) auf einem einzelnen GKE-Knoten verwenden. Mehrere Pods können RDMA nicht auf einem einzelnen GKE-Knoten gemeinsam nutzen.
    • Bei dieser Einrichtung wird ein NCCL-Test ausgeführt. Um diesen NCCL-Test auszuführen, benötigen Sie ein Mindest-VM-Kontingent von 2 (d. h. 16 GPUs, wenn Sie die Maschinentypen a4-highgpu-8g oder a3-ultragpu-8g verwenden).
    • GPUDirect RDMA ist nicht mit NCCL Fast Socket oder GPUDirect TCPX/TCPXO kompatibel. Aktivieren Sie NCCL Fast Socket nicht und installieren Sie das TCPX-/TCPXO-Plug-in nicht in Clustern, die GPUDirect RDMA verwenden.

  • Achten Sie darauf, dass Sie einen Standort verwenden, an dem der von Ihnen ausgewählte Maschinentyp verfügbar ist. Weitere Informationen finden Sie unter GPU-Standorte.

KI-optimierten GKE-Cluster erstellen

Folgen Sie der Anleitung in diesem Abschnitt, um einen GKE-Cluster zu erstellen, der die Anforderungen für KI-optimierte GKE-Cluster erfüllt. Sie können einen Cluster mit oder ohne GPUDirect RDMA erstellen.

Hinweise zum Erstellen eines Clusters

Beachten Sie beim Erstellen eines Clusters Folgendes:

  • Clusterstandort auswählen:
    • Achten Sie darauf, dass Sie einen Standort verwenden, an dem der von Ihnen ausgewählte Maschinentyp verfügbar ist. Weitere Informationen finden Sie unter GPU-Standorte.
    • Für dichte Reservierungen können Sie einen zonalen Cluster erstellen. Ersetzen Sie in diesem Fall das Flag --region durch das Flag --zone=COMPUTE_ZONE, wobei COMPUTE_ZONE die Zone Ihrer Steuerungsebene ist.
    • Für Arbeitslasten,die auf mehr als 1.000 Knoten ausgeführt werden und eine niedrige Netzwerklatenz zwischen Knoten erfordern, können Sie einen regionalen Cluster erstellen. Wenn Sie Ihre leistungsintensiven Knoten physisch zusammenstellen möchten, erstellen Sie Ihre GPU-Knotenpools in einer einzelnen Zone mit dem Flag --node-locations.
  • Treiberversion auswählen:
    • Die Treiberversion kann einen der folgenden Werte haben:
      • default: Installieren Sie die Standardtreiberversion für Ihre GKE-Knotenversion. Weitere Informationen zu den Anforderungen an Standardtreiberversionen finden Sie im Abschnitt Anforderungen.
      • latest: Installieren Sie die neueste verfügbare Treiberversion für Ihre GKE-Version. Diese Option ist nur für Knoten verfügbar, die Container-Optimized OS verwenden.
      • disabled: Automatische Treiberinstallation überspringen. Sie müssen einen Treiber manuell installieren, nachdem Sie den Knotenpool erstellt haben.
    • Weitere Informationen zu den standardmäßigen und neuesten GPU-Treiberversionen für GKE-Knotenversionen finden Sie unter NVIDIA-GPU-Treiber manuell installieren.

  • Reservierungsaffinität auswählen:

    • Hier finden Sie Informationen zu Ihrer Reservierung, z. B. den Namen Ihrer Reservierung oder den Namen eines bestimmten Blocks in Ihrer Reservierung. Informationen zum Ermitteln dieser Werte finden Sie unter Zukünftige Reservierungsanfragen anzeigen.
    • Das Flag --reservation-affinity kann die Werte specific oder any haben. Für verteilte KI-Arbeitslasten mit hoher Leistung empfehlen wir jedoch, eine bestimmte Reservierung zu verwenden.

    • Wenn Sie eine bestimmte Reservierung verwenden, einschließlich freigegebener Reservierungen, geben Sie den Wert des Flags --reservation im folgenden Format an:

      projects/PROJECT_ID/reservations/RESERVATION_NAME/reservationBlocks/BLOCK_NAME

      Ersetzen Sie Folgendes:

      • PROJECT_ID: Projekt-ID in Google Cloud .
      • RESERVATION_NAME: der Name Ihrer Reservierung.
      • BLOCK_NAME: der Name eines bestimmten Blocks innerhalb der Reservierung.

Cluster ohne GPUDirect RDMA erstellen

Wenn Sie einen Cluster ohne GPUDirect RDMA erstellen möchten, folgen Sie der Anleitung unten, um einen Cluster mit einem CPU-basierten Standardknotenpool und zusätzlichen Knotenpools mit GPUs zu erstellen. So können im Standardknotenpool andere Dienste ausgeführt werden.

  1. Erstellen Sie den Cluster:

      gcloud container clusters create CLUSTER_NAME \
      --cluster-version=CLUSTER_VERSION \
      --region=COMPUTE_REGION

    Ersetzen Sie Folgendes:

    • CLUSTER_NAME: Der Name des neuen Clusters.
    • CLUSTER_VERSION ist die Version Ihres neuen Clusters. Weitere Informationen dazu, welche GKE-Version Ihre Konfiguration unterstützt, finden Sie im Abschnitt Anforderungen.
    • COMPUTE_REGION: Die Region Ihres neuen Clusters. Wenn Sie einen zonalen Cluster erstellen möchten, verwenden Sie anstelle des Flags --region das Flag --zone, z. B.: --zone=COMPUTE_ZONE. Ersetzen Sie COMPUTE_ZONE durch die Zone der Steuerungsebene.

  2. Erstellen Sie den GPU-basierten Knotenpool mit einem der folgenden Befehle. Der Befehl, den Sie ausführen müssen, hängt von der Verbrauchsoption ab, die Sie für Ihre Bereitstellung verwenden. Wählen Sie den Tab aus, der dem Bereitstellungsmodell Ihrer Verbrauchsoption entspricht.

    Reservierungsgebunden

    Führen Sie für die reservierungsgebundene Bereitstellung den folgenden Befehl aus:

      gcloud container node-pools create NODE_POOL_NAME \
      --region COMPUTE_REGION --cluster CLUSTER_NAME \
      --node-locations COMPUTE_ZONE \
      --accelerator type=GPU_TYPE,count=AMOUNT,gpu-driver-version=DRIVER_VERSION \
      --machine-type MACHINE_TYPE \
      --num-nodes=NUM_NODES \
      --reservation-affinity=specific \
      --reservation=RESERVATION_NAME/reservationBlocks/BLOCK_NAME

    Ersetzen Sie Folgendes:

    • NODE_POOL_NAME ist der Name des Knotenpools.
    • COMPUTE_REGION: Die Region des neuen Clusters.
    • CLUSTER_NAME: Der Name des neuen Clusters.
    • COMPUTE_ZONE: die Zone des Knotenpools.

    • GPU_TYPE: Der Typ des GPU-Beschleunigers:

      • A4-VMs: Geben Sie nvidia-b200 ein.
      • A3-Ultra-VMs: Geben Sie nvidia-h200-141gb ein.

    • AMOUNT: Die Anzahl der GPUs, die an Knoten im Knotenpool angehängt werden sollen. Sowohl für a4-highgpu-8g- als auch für a3-ultragpu-8g-VMs ist die Anzahl der GPUs beispielsweise 8.

    • DRIVER_VERSION: die zu installierende NVIDIA-Treiberversion. Er kann einen der folgenden Werte haben: default, latest oder disabled.

    • MACHINE_TYPE: Der Compute Engine-Maschinentyp für die Knoten. Verwenden Sie beispielsweise a4-highgpu-8g für A4-VMs und a3-ultragpu-8g für A3-Ultra-VMs.

    • NUM_NODES: Die Anzahl der Knoten für den Knotenpool.

    • RESERVATION_NAME: Der Name Ihrer Reservierung. Informationen zum Ermitteln dieses Werts finden Sie unter Zukünftige Reservierungsanfragen anzeigen.

    • BLOCK_NAME: der Name eines bestimmten Blocks innerhalb der Reservierung. Weitere Informationen zum Ermitteln dieses Werts

    Flex-Start

    Führen Sie für die Bereitstellung mit flexiblem Start den folgenden Befehl aus:

      gcloud container node-pools create NODE_POOL_NAME \
      --region COMPUTE_REGION --cluster CLUSTER_NAME \
      --node-locations COMPUTE_ZONE \
      --accelerator type=GPU_TYPE,count=AMOUNT,gpu-driver-version=DRIVER_VERSION \
      --machine-type MACHINE_TYPE \
      --flex-start --enable-autoscaling --num-nodes=0 \
      --total-max-nodes TOTAL_MAX_NODES \
      --no-enable-autorepair --location-policy=ANY \
      --reservation-affinity=none [\
      --enable-queued-provisioning]

    Ersetzen Sie Folgendes:

    • NODE_POOL_NAME ist der Name des Knotenpools.
    • COMPUTE_REGION: Die Region des neuen Clusters.
    • CLUSTER_NAME: Der Name des neuen Clusters.
    • COMPUTE_ZONE: die Zone des Knotenpools.

    • GPU_TYPE: Der Typ des GPU-Beschleunigers:

      • A4-VMs: Geben Sie nvidia-b200 ein.
      • A3-Ultra-VMs: Geben Sie nvidia-h200-141gb ein.

    • AMOUNT: Die Anzahl der GPUs, die an Knoten im Knotenpool angehängt werden sollen. Sowohl für a4-highgpu-8g- als auch für a3-ultragpu-8g-VMs ist die Anzahl der GPUs beispielsweise 8.

    • DRIVER_VERSION: die zu installierende NVIDIA-Treiberversion. Er kann einen der folgenden Werte haben: default, latest oder disabled.

    • MACHINE_TYPE: Der Compute Engine-Maschinentyp für die Knoten. Verwenden Sie beispielsweise a4-highgpu-8g für A4-VMs und a3-ultragpu-8g für A3-Ultra-VMs.

    • TOTAL_MAX_NODES: Die maximale Anzahl von Knoten, die automatisch für den gesamten Knotenpool skaliert werden sollen.

      Wenn Sie Flex-Start mit der Bereitstellung in der Warteschlange verwenden möchten, fügen Sie das Flag --enable-queued-provisioning hinzu.

      Weitere Informationen zur Verwendung von Flex-Start finden Sie unter Große Arbeitslast mit Flex-Start und Bereitstellung in der Warteschlange ausführen.

    Spot

    Führen Sie für die Spot-Bereitstellung den folgenden Befehl aus:

      gcloud container node-pools create NODE_POOL_NAME \
      --region COMPUTE_REGION --cluster CLUSTER_NAME \
      --node-locations COMPUTE_ZONE \
      --accelerator type=GPU_TYPE,count=AMOUNT,gpu-driver-version=DRIVER_VERSION \
      --machine-type MACHINE_TYPE \
      --num-nodes=NUM_NODES \
      --spot

    Ersetzen Sie Folgendes:

    • NODE_POOL_NAME ist der Name des Knotenpools.
    • COMPUTE_REGION: Die Region des neuen Clusters.
    • CLUSTER_NAME: Der Name des neuen Clusters.
    • COMPUTE_ZONE: die Zone des Knotenpools.

    • GPU_TYPE: Der Typ des GPU-Beschleunigers:

      • A4-VMs: Geben Sie nvidia-b200 ein.
      • A3-Ultra-VMs: Geben Sie nvidia-h200-141gb ein.

    • AMOUNT: Die Anzahl der GPUs, die an Knoten im Knotenpool angehängt werden sollen. Sowohl für a4-highgpu-8g- als auch für a3-ultragpu-8g-VMs ist die Anzahl der GPUs beispielsweise 8.

    • DRIVER_VERSION: die zu installierende NVIDIA-Treiberversion. Er kann einen der folgenden Werte haben: default, latest oder disabled.

    • MACHINE_TYPE: Der Compute Engine-Maschinentyp für die Knoten. Verwenden Sie beispielsweise a4-highgpu-8g für A4-VMs und a3-ultragpu-8g für A3-Ultra-VMs.

    • NUM_NODES: Die Anzahl der Knoten für den Knotenpool.

      Weitere Informationen zum Erstellen von Clustern mit Spot-VMs finden Sie unter Mit Spot-VMs fehlertolerante Arbeitslasten zu geringeren Kosten ausführen.

  3. Stellen Sie eine Verbindung zu Ihrem Cluster her, damit Sie die kubectl-Befehle in den nächsten Abschnitten ausführen können:

      gcloud container clusters get-credentials CLUSTER_NAME --location=COMPUTE_REGION

    Ersetzen Sie Folgendes:

Cluster mit GPUDirect RDMA erstellen

Bei verteilten KI-Arbeitslasten werden häufig mehrere GPU-Knoten miteinander verbunden, um als ein einzelner Computer zu fungieren. Die A4- und A3 Ultra-VMs sind mit dem Titanium ML-Netzwerkadapter ausgestattet, der auf NVIDIA ConnectX-7 (CX7)-NICs basiert. Sowohl A4- als auch A3 Ultra-VMs bieten nicht blockierenden GPU-zu-GPU-Traffic zwischen Knoten mit 3,2 Tbit/s über RDMA over Converged Ethernet (RoCE). RoCE ermöglicht die Skalierung und Zusammenarbeit über mehrere GPUs hinweg, indem es eine leistungsstarke Cloud-Umgebung für KI-Arbeitslasten bietet.

Weitere Informationen zum Erstellen von GKE-Clustern mit der Google Cloud CLI und GPUDirect TCPX (A3-High-VMs) oder TCPXO (A3-Mega-VMs) finden Sie unter GPU-Netzwerkbandbreite in Autopilot-Clustern maximieren oder GPU-Netzwerkbandbreite in Standardclustern maximieren.

Führen Sie die folgenden Schritte aus, um Ihre GKE-Cluster im Autopilot- oder Standardmodus mit GPUDirect RDMA zu erstellen. Die einzelnen Schritte werden in den nächsten Abschnitten beschrieben:

  1. VPCs und Subnetze erstellen
  2. GKE-Cluster mit Multi-Networking erstellen
  3. GKE-Netzwerkobjekte erstellen
  4. RDMA-Binärprogramm installieren und NCCL konfigurieren
  5. NCCL-Test bereitstellen und ausführen
  6. Pod-Manifeste für GPUDirect-RDMA konfigurieren

VPCs und Subnetze erstellen

Sowohl A4- als auch A3 Ultra-VMs haben die folgende Konfiguration:

  • Acht NVIDIA B200- (A4) oder H200-GPUs (A3 Ultra) pro virtueller Maschine, die über NVLink verbunden sind
  • Zwei Intel Emerald Rapids-CPUs
  • Acht 400‑Gbit/s-CX‑7-Netzwerkkarten für die GPU‑zu‑GPU-Vernetzung
  • Zwei Google Titanium-NICs mit 200 Gbit/s für externe Dienste

KI- und ML-Arbeitslasten wie verteiltes Training erfordern eine leistungsstarke Beschleunigung, um die Leistung zu optimieren, indem die Ausführungszeiten von Jobs verkürzt werden. Für Arbeitslasten, die hohe Leistung, hohen Durchsatz und geringe Latenz erfordern, reduziert GPUDirect RDMA die Netzwerk-Hops, die für die Übertragung von Nutzlasten an und von GPUs erforderlich sind. Dadurch wird die verfügbare Netzwerkbandbreite effizienter genutzt. GPUDirect RDMA wurde entwickelt, um den Durchsatz im Vergleich zu GPUs, die GPUDirect nicht verwenden, erheblich zu verbessern.

Eine der Google Titanium-NICs, die der CPU zugeordnet ist, verwendet das Standardnetzwerk in GKE. Sie müssen keine neue VPC für diese NIC erstellen, wenn Sie genügend IP-Adressbereiche für das Standardnetzwerk haben.

Mit diesen Befehlen können Sie eine VPC für die zweite CPU-Titanium-NIC (gVNIC) und eine weitere VPC für die acht CX-7-RDMA-NICs erstellen.

  1. Legen Sie Umgebungsvariablen fest, die Ihrer Bereitstellung entsprechen:

    export REGION="COMPUTE_REGION"
export ZONE="COMPUTE_ZONE"
export PROJECT="PROJECT_ID"
export GVNIC_NETWORK_PREFIX="GVNIC_NETWORK_PREFIX"
export RDMA_NETWORK_PREFIX="RDMA_NETWORK_PREFIX"

    Ersetzen Sie die folgenden Variablen:

    • COMPUTE_REGION: Die Region Ihres Clusters.
    • COMPUTE_ZONE: die Zone des Knotenpools.
    • PROJECT_ID: Projekt-ID in Google Cloud .
    • GVNIC_NETWORK_PREFIX: entweder a4high-gvnic für A4-VMs oder a3ultra-gvnic für A3-Ultra-VMs.
    • RDMA_NETWORK_PREFIX: entweder a4high-rdma für A4-VMs oder a3ultra-rdma für A3-Ultra-VMs.

  2. Zwei VPC-Netzwerke erstellen:

    # Create a VPC for the additional Google Titanium CPU NIC
gcloud compute --project=${PROJECT} \
  networks create \
  ${GVNIC_NETWORK_PREFIX}-net \
  --subnet-mode=custom

gcloud compute --project=${PROJECT} \
  networks subnets create \
  ${GVNIC_NETWORK_PREFIX}-sub \
  --network=${GVNIC_NETWORK_PREFIX}-net \
  --region=${REGION} \
  --range=192.168.0.0/24

gcloud compute --project=${PROJECT} \
  firewall-rules create \
  ${GVNIC_NETWORK_PREFIX}-internal \
  --network=${GVNIC_NETWORK_PREFIX}-net \
  --action=ALLOW \
  --rules=tcp:0-65535,udp:0-65535,icmp \
  --source-ranges=192.168.0.0/16

# Create HPC VPC for the RDMA NICs with 8 subnets.
gcloud beta compute --project=${PROJECT} \
  networks create ${RDMA_NETWORK_PREFIX}-net \
  --network-profile=${ZONE}-vpc-roce \
  --subnet-mode=custom

# Create subnets for the HPC VPC.
for N in $(seq 0 7); do
  gcloud compute --project=${PROJECT} \
    networks subnets create \
    ${RDMA_NETWORK_PREFIX}-sub-$N \
    --network=${RDMA_NETWORK_PREFIX}-net \
    --region=${REGION} \
    --range=192.168.$((N+1)).0/24 &  # offset to avoid overlap with gvnics
done

GKE-Cluster mit Multi-Networking erstellen

Autopilot

  1. So erstellen Sie einen GKE Autopilot-Cluster mit mehreren Netzwerken:

    gcloud container clusters create-auto CLUSTER_NAME \
    --enable-multi-networking \
    --cluster-version=CLUSTER_VERSION \
    --region=COMPUTE_REGION

    Ersetzen Sie Folgendes:

    • CLUSTER_NAME: Der Name Ihres Clusters.
    • CLUSTER_VERSION: die Version Ihres neuen Clusters. Welche GKE-Version Ihre Konfiguration unterstützt, erfahren Sie im Abschnitt Anforderungen.
    • COMPUTE_REGION: der Name der Compute-Region.

  2. Stellen Sie eine Verbindung zu Ihrem Cluster her, damit Sie die kubectl-Befehle in den nächsten Abschnitten ausführen können:

    gcloud container clusters get-credentials CLUSTER_NAME --location=COMPUTE_REGION

    Ersetzen Sie Folgendes:

    • CLUSTER_NAME: Der Name Ihres Clusters.
    • COMPUTE_REGION: der Name der Compute-Region.

    Weitere Informationen finden Sie unter kubectl installieren und Clusterzugriff konfigurieren.

Standard

GKE-Standardcluster und GPU-Knotenpool mit mehreren Netzwerken erstellen:

  1. Erstellen Sie den Cluster:

    gcloud container clusters create CLUSTER_NAME \
  --region=COMPUTE_REGION \
  --cluster-version=CLUSTER_VERSION \
  --enable-dataplane-v2 --enable-ip-alias --enable-multi-networking [\
  --services-ipv4-cidr=SERVICE_CIDR \
  --cluster-ipv4-cidr=POD_CIDR]

    Ersetzen Sie Folgendes:

    • CLUSTER_NAME: Der Name Ihres Clusters.
    • CLUSTER_VERSION: die Version Ihres neuen Clusters. Welche GKE-Version Ihre Konfiguration unterstützt, erfahren Sie im Abschnitt Anforderungen.
    • COMPUTE_REGION: der Name der Compute-Region.

    Optional können Sie die sekundären CIDR-Bereiche für Dienste und Pods explizit angeben. Wenn Sie diese optionalen Flags verwenden, ersetzen Sie die folgenden Variablen:

    • SERVICE_CIDR: der sekundäre CIDR-Bereich für Dienste.
    • POD_CIDR: der sekundäre CIDR-Bereich für Pods.

    Wenn Sie diese Flags verwenden, müssen Sie prüfen, ob sich die CIDR-Bereiche nicht mit Subnetzbereichen für zusätzliche Knotennetzwerke überschneiden. Die Bereiche in den Werten SERVICE_CIDR=10.65.0.0/19 und POD_CIDR=10.64.0.0/19 überschneiden sich beispielsweise nicht. Weitere Informationen finden Sie unter Pod-IPv4-Adressbereiche hinzufügen.

  2. Erstellen Sie den Knotenpool. Der Befehl, den Sie ausführen müssen, hängt von der Verbrauchsoption ab, die Sie für Ihre Bereitstellung verwenden. Wählen Sie den Tab aus, der dem Bereitstellungsmodell Ihrer Verbrauchsoption entspricht.

    Reservierungsgebunden

    Führen Sie für die reservierungsgebundene Bereitstellung den folgenden Befehl aus:

    gcloud container node-pools create NODE_POOL_NAME \
  --region COMPUTE_REGION --cluster CLUSTER_NAME \
  --node-locations COMPUTE_ZONE \
  --accelerator type=GPU_TYPE,count=AMOUNT,gpu-driver-version=DRIVER_VERSION \
  --machine-type MACHINE_TYPE \
  --num-nodes=NUM_NODES \
  --reservation-affinity=specific \
  --reservation=RESERVATION_NAME/reservationBlocks/BLOCK_NAME  \
  --additional-node-network network=${GVNIC_NETWORK_PREFIX}-net,subnetwork=${GVNIC_NETWORK_PREFIX}-sub \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-0 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-1 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-2 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-3 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-4 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-5 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-6 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-7

    Ersetzen Sie Folgendes:

    • NODE_POOL_NAME ist der Name des Knotenpools.
    • COMPUTE_REGION: Die Region des neuen Clusters.
    • CLUSTER_NAME: Der Name des neuen Clusters.
    • COMPUTE_ZONE: die Zone des Knotenpools.

    • GPU_TYPE: Der Typ des GPU-Beschleunigers:

      • A4-VMs: Geben Sie nvidia-b200 ein.
      • A3-Ultra-VMs: Geben Sie nvidia-h200-141gb ein.

    • AMOUNT: Die Anzahl der GPUs, die an Knoten im Knotenpool angehängt werden sollen. Sowohl für a4-highgpu-8g- als auch für a3-ultragpu-8g-VMs ist die Anzahl der GPUs beispielsweise 8.

    • DRIVER_VERSION: die zu installierende NVIDIA-Treiberversion. Er kann einen der folgenden Werte haben: default, latest oder disabled.

    • MACHINE_TYPE: Der Compute Engine-Maschinentyp für die Knoten. Verwenden Sie beispielsweise a4-highgpu-8g für A4-VMs und a3-ultragpu-8g für A3-Ultra-VMs.

    • MACHINE_TYPE: Der Compute Engine-Maschinentyp für die Knoten. Verwenden Sie beispielsweise a4-highgpu-8g für A4-VMs und a3-ultragpu-8g für A3-Ultra-VMs.

    • NUM_NODES: Die Anzahl der Knoten für den Knotenpool. Bei flex-start muss dieser Wert auf 0 festgelegt werden.

    • RESERVATION_NAME: Der Name Ihrer Reservierung. Informationen zum Ermitteln dieses Werts finden Sie unter Zukünftige Reservierungsanfragen anzeigen.

    • BLOCK_NAME: der Name eines bestimmten Blocks innerhalb der Reservierung. Weitere Informationen zum Ermitteln dieses Werts

    Flex-Start

    Führen Sie für die Bereitstellung mit flexiblem Start den folgenden Befehl aus:

    gcloud container node-pools create NODE_POOL_NAME \
  --region COMPUTE_REGION --cluster CLUSTER_NAME \
  --node-locations COMPUTE_ZONE \
  --accelerator type=GPU_TYPE,count=AMOUNT,gpu-driver-version=DRIVER_VERSION \
  --machine-type MACHINE_TYPE \
  --num-nodes=NUM_NODES \
  --flex-start --num-nodes=0 --enable-autoscaling \
  --total-max-nodes TOTAL_MAX_NODES \
  --no-enable-autorepair --location-policy=ANY \
  --reservation-affinity=none \
  [--enable-queued-provisioning \]
  --additional-node-network network=${GVNIC_NETWORK_PREFIX}-net,subnetwork=${GVNIC_NETWORK_PREFIX}-sub \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-0 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-1 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-2 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-3 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-4 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-5 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-6 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-7

    Ersetzen Sie Folgendes:

    • NODE_POOL_NAME ist der Name des Knotenpools.
    • COMPUTE_REGION: Die Region des neuen Clusters.
    • CLUSTER_NAME: Der Name des neuen Clusters.
    • COMPUTE_ZONE: die Zone des Knotenpools.

    • GPU_TYPE: Der Typ des GPU-Beschleunigers:

      • A4-VMs: Geben Sie nvidia-b200 ein.
      • A3-Ultra-VMs: Geben Sie nvidia-h200-141gb ein.

    • AMOUNT: Die Anzahl der GPUs, die an Knoten im Knotenpool angehängt werden sollen. Sowohl für a4-highgpu-8g- als auch für a3-ultragpu-8g-VMs ist die Anzahl der GPUs beispielsweise 8.

    • DRIVER_VERSION: die zu installierende NVIDIA-Treiberversion. Er kann einen der folgenden Werte haben: default, latest oder disabled.

    • MACHINE_TYPE: Der Compute Engine-Maschinentyp für die Knoten. Verwenden Sie beispielsweise a4-highgpu-8g für A4-VMs und a3-ultragpu-8g für A3-Ultra-VMs.

    • MACHINE_TYPE: Der Compute Engine-Maschinentyp für die Knoten. Verwenden Sie beispielsweise a4-highgpu-8g für A4-VMs und a3-ultragpu-8g für A3-Ultra-VMs.

    • NUM_NODES: Die Anzahl der Knoten für den Knotenpool. Bei flex-start muss dieser Wert auf 0 festgelegt werden.

    • TOTAL_MAX_NODES: Die maximale Anzahl von Knoten, die automatisch für den gesamten Knotenpool skaliert werden sollen.

    Wenn Sie Flex-Start mit der Bereitstellung in der Warteschlange verwenden möchten, fügen Sie das Flag --enable-queued-provisioning hinzu.

    Weitere Informationen zur Verwendung von Flex-Start finden Sie unter Große Arbeitslast mit Flex-Start und Bereitstellung in der Warteschlange ausführen.

  3. Stellen Sie eine Verbindung zu Ihrem Cluster her, damit Sie die kubectl-Befehle in den nächsten Abschnitten ausführen können:

    gcloud container clusters get-credentials CLUSTER_NAME --location=COMPUTE_REGION

    Ersetzen Sie Folgendes:

    • CLUSTER_NAME: Der Name Ihres Clusters.
    • COMPUTE_REGION: der Name der Compute-Region.

    Weitere Informationen finden Sie unter kubectl installieren und Clusterzugriff konfigurieren.

GKE-Netzwerkobjekte erstellen

Die im vorherigen Abschnitt erstellten VPC-Netzwerke müssen über GKE-Netzwerkparametersätze konfiguriert werden. Die zweite Titanium-CPU-NIC (gVNIC) muss im NetDevice-Modus konfiguriert werden und jede der acht CX-7-RDMA-NICs muss im RDMA-Modus konfiguriert werden.

Dieser Befehl verwendet die folgenden Namen:

  • Die VPC für die CPU-Titanium-NIC (gVNIC) heißt ${GVNIC_NETWORK_PREFIX}-net mit dem Subnetz ${GVNIC_NETWORK_PREFIX}-sub.
  • Die VPC für CX-7-RDMA-NICs heißt ${RDMA_NETWORK_PREFIX}-net und die Subnetze heißen ${RDMA_NETWORK_PREFIX}-sub-[0…7].

Erstellen Sie die GKE-Netzwerkobjekte mit dem folgenden Befehl:

kubectl apply -f - <<EOF
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: gvnic-1
spec:
  vpc: ${GVNIC_NETWORK_PREFIX}-net
  vpcSubnet: ${GVNIC_NETWORK_PREFIX}-sub
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: gvnic-1
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: gvnic-1
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-0
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-0
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-0
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-0
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-1
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-1
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-1
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-1
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-2
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-2
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-2
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-2
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-3
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-3
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-3
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-3
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-4
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-4
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-4
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-4
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-5
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-5
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-5
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-5
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-6
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-6
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-6
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-6
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-7
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-7
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-7
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-7
EOF

RDMA-Binärprogramm installieren und NCCL konfigurieren

Wenden Sie das folgende DaemonSet an, um die RDMA-Binärdateien und die NCCL-Bibliothek auf jedem Knoten zu installieren. Auf jeder zugrunde liegenden VM werden die RDMA-Binärdateien im Verzeichnis /home/kubernetes/bin/gib und die NCCL-Bibliothek im Verzeichnis /home/kubernetes/bin/nvidia/lib64 installiert.

Autopilot

Führen Sie für den GKE Autopilot-Modus den folgenden Befehl aus:

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

Standard

Führen Sie für den GKE-Standardmodus den folgenden Befehl aus:

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

NCCL-Tests ausführen

Um die Funktionalität des bereitgestellten Clusters zu prüfen, können Sie einen NCCL-Test ausführen. Eine Anleitung finden Sie unter NCCL-Test bereitstellen und ausführen.

Pod-Manifeste für GPUDirect RDMA konfigurieren

Wenn Sie Ihre Arbeitslasten mit GPUDirect RDMA ausführen möchten, konfigurieren Sie Ihre Pod-Manifeste so:

  1. Fügen Sie den Pod-Metadaten die folgenden Annotationen hinzu.

    Autopilot

    Verwenden Sie die folgende Annotation für den GKE Autopilot-Modus:

    metadata:
annotations:
  networking.gke.io/default-interface: 'eth0'
  networking.gke.io/interfaces: |
    [
      {"interfaceName":"eth0","network":"default"},
      {"interfaceName":"eth1","network":"gvnic-1"},
      {"interfaceName":"eth2","network":"rdma-0"},
      {"interfaceName":"eth3","network":"rdma-1"},
      {"interfaceName":"eth4","network":"rdma-2"},
      {"interfaceName":"eth5","network":"rdma-3"},
      {"interfaceName":"eth6","network":"rdma-4"},
      {"interfaceName":"eth7","network":"rdma-5"},
      {"interfaceName":"eth8","network":"rdma-6"},
      {"interfaceName":"eth9","network":"rdma-7"}
    ]

    Standard

    Die folgende Annotation für den GKE Standard-Modus enthält keine gvnic-1-Spezifikation. Sie können sie jedoch hinzufügen, wenn Ihre Arbeitslasten dies erfordern.

    Verwenden Sie die folgende Annotation für den GKE Standard-Modus:

    metadata:
annotations:
  networking.gke.io/default-interface: 'eth0'
  networking.gke.io/interfaces: |
    [
      {"interfaceName":"eth0","network":"default"},
      {"interfaceName":"eth2","network":"rdma-0"},
      {"interfaceName":"eth3","network":"rdma-1"},
      {"interfaceName":"eth4","network":"rdma-2"},
      {"interfaceName":"eth5","network":"rdma-3"},
      {"interfaceName":"eth6","network":"rdma-4"},
      {"interfaceName":"eth7","network":"rdma-5"},
      {"interfaceName":"eth8","network":"rdma-6"},
      {"interfaceName":"eth9","network":"rdma-7"}
    ]

  2. Geben Sie den ausgewählten GPU-Typ und die spezifische Reservierung mit Knotenselektoren an:

    spec:
  nodeSelector:
    cloud.google.com/gke-accelerator: ACCELERATOR
    cloud.google.com/reservation-name: RESERVATION_NAME
    cloud.google.com/reservation-affinity: "specific"

    Ersetzen Sie Folgendes:

    • ACCELERATOR: Der Beschleuniger, den Sie in der Compute Engine-Kapazitätsreservierung reserviert haben. Sie müssen einen der folgenden Werte verwenden:
      • nvidia-b200: NVIDIA B200 (180 GB) für A4-VMs
      • nvidia-h200-141gb: NVIDIA H200 (141 GB) für A3 Ultra-VMs
    • RESERVATION_NAME: der Name der Compute Engine-Kapazitätsreservierung.

    Informationen zum Nutzen freigegebener Reservierungen oder bestimmter Blöcke und Unterblöcke von Reservierungen finden Sie in den entsprechenden Abschnitten unter Reservierte zonale Pfadressourcen nutzen.

  3. Fügen Sie der Pod-Spezifikation die folgenden Volumes hinzu:

    spec:
  volumes:
    - name: library-dir-host
      hostPath:
        path: /home/kubernetes/bin/nvidia
    - name: gib
      hostPath:
        path: /home/kubernetes/bin/gib

  4. Fügen Sie dem Container, der GPUs anfordert, die folgenden Einbindungen von Volumes, Umgebungsvariablen und Ressourcen hinzu. Der Arbeitslastcontainer muss alle acht GPUs anfordern:

    Autopilot

    Konfigurieren Sie für den GKE Autopilot-Modus die folgenden Ressourcen:

    containers:
  - name: my-container
    volumeMounts:
      - name: library-dir-host
        mountPath: /usr/local/nvidia
        readOnly: true
      - name: gib
        mountPath: /usr/local/gib
        readOnly: true
    env:
      - name: LD_LIBRARY_PATH
        value: /usr/local/nvidia/lib64
    resources:
      limits:
        nvidia.com/gpu: 8

    Standard

    Konfigurieren Sie für den GKE Standard-Modus die folgenden Ressourcen:

    containers:
  - name: my-container
    volumeMounts:
      - name: library-dir-host
        mountPath: /usr/local/nvidia
      - name: gib
        mountPath: /usr/local/gib
    env:
      - name: LD_LIBRARY_PATH
        value: /usr/local/nvidia/lib64
    resources:
      limits:
        nvidia.com/gpu: 8

  5. Legen Sie alle erforderlichen Umgebungsvariablen fest, um NCCL zu konfigurieren. Verwenden Sie dazu das folgende Shell-Skript aus dem Arbeitslastcontainer:

    source /usr/local/gib/scripts/set_nccl_env.sh

Die folgenden Tabs enthalten Beispiele für vollständige Pod-Manifeste.

Autopilot

Für den GKE Autopilot-Modus sollte ein vollständiges Pod-Manifest so aussehen:

apiVersion: apps/v1
kind: Pod
metadata:
  name: my-pod
  labels:
    k8s-app: my-pod
  annotations:
    networking.gke.io/default-interface: 'eth0'
    networking.gke.io/interfaces: |
      [
        {"interfaceName":"eth0","network":"default"},
        {"interfaceName":"eth1","network":"gvnic-1"},
        {"interfaceName":"eth2","network":"rdma-0"},
        {"interfaceName":"eth3","network":"rdma-1"},
        {"interfaceName":"eth4","network":"rdma-2"},
        {"interfaceName":"eth5","network":"rdma-3"},
        {"interfaceName":"eth6","network":"rdma-4"},
        {"interfaceName":"eth7","network":"rdma-5"},
        {"interfaceName":"eth8","network":"rdma-6"},
        {"interfaceName":"eth9","network":"rdma-7"}
      ]
spec:
  ...
  volumes:
    - name: library-dir-host
      hostPath:
        path: /home/kubernetes/bin/nvidia
    - name: gib
      hostPath:
        path: /home/kubernetes/bin/gib
  containers:
    - name: my-container
      volumeMounts:
        - name: library-dir-host
          mountPath: /usr/local/nvidia
          readOnly: true
        - name: gib
          mountPath: /usr/local/gib
          readOnly: true
      env:
        - name: LD_LIBRARY_PATH
          value: /usr/local/nvidia/lib64
      resources:
        limits:
          nvidia.com/gpu: 8
          ...

Standard

In GKE Standard-Modus sollte ein vollständiges Pod-Manifest in etwa so aussehen:

apiVersion: apps/v1
kind: Pod
metadata:
  name: my-pod
  labels:
    k8s-app: my-pod
  annotations:
    networking.gke.io/default-interface: 'eth0'
    networking.gke.io/interfaces: |
      [
        {"interfaceName":"eth0","network":"default"},
        {"interfaceName":"eth2","network":"rdma-0"},
        {"interfaceName":"eth3","network":"rdma-1"},
        {"interfaceName":"eth4","network":"rdma-2"},
        {"interfaceName":"eth5","network":"rdma-3"},
        {"interfaceName":"eth6","network":"rdma-4"},
        {"interfaceName":"eth7","network":"rdma-5"},
        {"interfaceName":"eth8","network":"rdma-6"},
        {"interfaceName":"eth9","network":"rdma-7"}
      ]
spec:
  ...
  volumes:
    - name: library-dir-host
      hostPath:
        path: /home/kubernetes/bin/nvidia
    - name: gib
      hostPath:
        path: /home/kubernetes/bin/gib
  containers:
    - name: my-container
      volumeMounts:
        - name: library-dir-host
          mountPath: /usr/local/nvidia
        - name: gib
          mountPath: /usr/local/gib
      env:
        - name: LD_LIBRARY_PATH
          value: /usr/local/nvidia/lib64
      resources:
        limits:
          nvidia.com/gpu: 8
          ...

Netzwerkleistung für Cluster testen, die GPUDirect RDMA verwenden

Wir empfehlen, die Funktionalität der bereitgestellten Cluster zu prüfen. Verwenden Sie dazu NCCL/gIB-Tests, die NVIDIA Collective Communications Library (NCCL)-Tests sind, die für die Google-Umgebung optimiert wurden.

Nächste Schritte