Benutzerdefinierten KI-optimierten GKE-Cluster erstellen, der A4X Max verwendet

In diesem Dokument wird beschrieben, wie Sie einen KI-optimierten GKE-Cluster (Google Kubernetes Engine) erstellen, der A4X Max Compute Engine-Instanzen verwendet, um Ihre KI- und ML-Arbeitslasten zu unterstützen.

Mit der A4X Max- und der A4X-Serie können Sie große KI-/ML-Cluster mit dem NVIDIA Multi-Node NVLink-System (MNNVL) ausführen, einer Lösung auf Rack-Ebene, die eine höhere GPU-Leistung ermöglicht. Diese Maschinen bieten Funktionen wie gezielte Arbeitslastplatzierung, Topologie-abhängige Planung und erweiterte Clusterwartungsfunktionen. Weitere Informationen finden Sie unter Clusterverwaltungsfunktionen. Mit A4X Max bietet GKE auch eine automatisierte Netzwerkeinrichtung, die die Clusterkonfiguration vereinfacht.

KI- und ML-Arbeitslasten wie verteiltes Training erfordern eine leistungsstarke Beschleunigung, um die Leistung zu optimieren, indem die Jobabschlusszeiten verkürzt werden. GKE bietet eine einheitliche Plattform, auf der Sie eine Vielzahl von Arbeitslasten für Ihre Organisationen ausführen können. So wird der betriebliche Aufwand für die Verwaltung mehrerer Plattformen reduziert. Sie können Arbeitslasten wie verteiltes Vortraining mit hoher Leistung, Modell-Feinabstimmung, Modellinferenz, Anwendungsbereitstellung und unterstützende Dienste ausführen. Für Arbeitslasten, die hohe Leistung, hohen Durchsatz und niedrige Latenz erfordern, reduziert GPUDirect RDMA die Anzahl der Netzwerksprünge, die für die Übertragung von Nutzlasten zu und von GPUs erforderlich sind. So wird die verfügbare Netzwerkbandbreite effizienter genutzt. Weitere Informationen finden Sie unter GPU-Netzwerk stacks.

In diesem Dokument erfahren Sie, wie Sie einen GKE-Cluster mit der Google Cloud CLI erstellen, um die Konfiguration Ihres Clusters basierend auf den Anforderungen Ihrer Arbeitslast maximal flexibel zu gestalten. Informationen zum Erstellen von Clustern mit anderen Maschinentypen mit der gcloud CLI finden Sie unter:

Alternativ können Sie mit dem Cluster Toolkit Ihren Cluster schnell mit Standardeinstellungen bereitstellen, die Best Practices für viele Anwendungsfälle widerspiegeln. Weitere Informationen finden Sie unter KI-optimierten GKE Cluster mit Standardkonfiguration erstellen.

Hinweis

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, installieren und dann initialisieren Sie die gcloud CLI. Wenn Sie die gcloud CLI bereits installiert haben, rufen Sie die neueste Version mit dem gcloud components update Befehl ab. Ältere gcloud CLI-Versionen unterstützen möglicherweise nicht die Ausführung der Befehle in diesem Dokument.

Kapazität erhalten

Sie können Kapazität für A4X Max-Compute-Instanzen erhalten, indem Sie eine vorausschauende Reservierung erstellen. Weitere Informationen zu vorausschauenden Reservierungen finden Sie in der Tabelle unter Verbrauchsoption auswählen in der Spalte Vorausschauende Reservierungen in AI Hypercomputer.

Informationen zum Erhalten von Kapazität mit einer vorausschauenden Reservierung finden Sie in der Tabelle unter Kapazität erhalten in der Zeile Vorausschauende Reservierungen in AI Hypercomputer.

Voraussetzungen

Die folgenden Anforderungen gelten für einen KI-optimierten GKE-Cluster mit A4X Max-Compute-Instanzen:

  • Für A4X Max müssen Sie eine der folgenden Versionen verwenden:

    • Für 1.35 oder höher verwenden Sie GKE-Version 1.35.0-gke.2745000 oder höher.
    • Für 1.34 verwenden Sie GKE-Version 1.34.3-gke.1318000 oder höher.

    Mit diesen Versionen wird sichergestellt, dass A4X Max Folgendes verwendet:

    • R580.95.05, die GPU-Mindesttreiberversion für A4X Max, die standardmäßig aktiviert ist.
    • Coherent Driver-based Memory Management (CDMM), das standardmäßig aktiviert ist. NVIDIA empfiehlt, diesen Modus für Kubernetes-Cluster zu aktivieren, um zu hohe Arbeitsspeicherangaben zu vermeiden. Mit CDMM kann der GPU-Arbeitsspeicher über den Treiber anstelle des Betriebssystems verwaltet werden. So können Sie vermeiden, dass das Betriebssystem den GPU-Arbeitsspeicher online schaltet, und der GPU-Arbeitsspeicher wird dem Betriebssystem als NUMA-Knoten (Non-Uniform Memory Access) zur Verfügung gestellt. Multi-Instanz-GPUs werden nicht unterstützt, wenn CDMM aktiviert ist. Weitere Informationen zu CDMM finden Sie unter Hardware- und Software Support.
    • GPUDirect RDMA und MNNVL, die empfohlen werden, damit A4X Max-Knotenpools die Netzwerkfunktionen von A4X Max nutzen können.

  • Die GKE-Knoten müssen ein Knoten-Image für Container-Optimized OS verwenden. Ubuntu- und Windows-Knoten-Images werden nicht unterstützt.

  • Ihre GKE-Arbeitslast muss alle verfügbaren GPUs verwenden und Ihr Pod muss alle verfügbaren sekundären NICs auf einem einzelnen GKE-Knoten verwenden. Mehrere Pods können RDMA nicht auf einem einzelnen GKE-Knoten gemeinsam nutzen.

  • Sie müssen das reservierungsgebundene Bereitstellungsmodell verwenden, um Cluster mit A4X Max zu erstellen. Andere Bereitstellungs modelle werden nicht unterstützt.

  • In dieser Anleitung wird DRANET verwendet, um einen KI-optimierten GKE-Cluster mit A4X Max zu konfigurieren. Multi-Networking wird für den a4x-maxgpu-4g-metal Maschinentyp nicht unterstützt.

Überlegungen zum Erstellen eines Clusters

Beachten Sie beim Erstellen eines Clusters die folgenden Informationen:

  • Clusterstandort auswählen:
    • Verwenden Sie einen Standort, an dem der von Ihnen ausgewählte Maschinentyp verfügbar ist. Weitere Informationen finden Sie unter Verfügbarkeit von Beschleunigern.
    • Wenn Sie Knotenpools in einem regionalen Cluster erstellen, die für Produktionsarbeitslasten empfohlen werden, können Sie mit dem --node-locations Flag die Zonen für Ihre GKE-Knoten angeben.
  • 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: Überspringen Sie die automatische Treiberinstallation. Sie müssen manuell einen Treiber installieren, nachdem Sie den Knotenpool erstellt haben.
    • Weitere Informationen zu den Standard- und neuesten GPU-Treiberversionen für GKE-Knotenversionen finden Sie in der Tabelle im Abschnitt NVIDIA-GPU-Treiber manuell installieren.

  • Reservierungsaffinität auswählen:

    • Sie können Informationen zu Ihrer Reservierung abrufen, z. B. den Namen Ihrer Reservierung oder den Namen eines bestimmten Blocks in Ihrer Reservierung. Informationen zum Abrufen dieser Werte finden Sie unter Zukünftige Reservierungsanfragen anzeigen .
    • Das Flag --reservation-affinity kann die Werte specific oder any annehmen. 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 die folgenden Werte:

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

      Wir empfehlen außerdem, eine Reservierung für einen Unterblock zu verwenden, damit Compute-Instanzen in einem einzelnen Unterblock innerhalb von BLOCK_NAME platziert werden. Fügen Sie am Ende des Pfads Folgendes hinzu:

      /reservationSubBlocks/SUB_BLOCK_NAME

      Ersetzen Sie SUB_BLOCK_NAME durch den Namen des Unterblocks.

KI-optimierten GKE-Cluster mit A4X Max und GPUDirect RDMA erstellen

Für verteilte KI-Arbeitslasten werden häufig mehrere GPU-Knoten miteinander verbunden, um als ein einzelner Computer zu fungieren. A4X Max ist eine Exascale-Plattform, die auf der NVIDIA GB300 NVL72-Architektur auf Rack-Ebene basiert. A4X Max-Compute-Instanzen verwenden eine mehrschichtige, hierarchische Netzwerkarchitektur mit einem auf Schienen ausgerichteten Design, um die Leistung für verschiedene Kommunikationstypen zu optimieren. Dieser Maschinentyp ermöglicht die Skalierung und Zusammenarbeit über mehrere GPUs hinweg und bietet eine leistungsstarke Cloud-Umgebung für KI-Arbeitslasten. Weitere Informationen zur Netzwerkarchitektur für A4X Max, einschließlich der Netzwerkbandbreite und der NIC-Anordnung, finden Sie unter A4X Max Maschinentyp (Bare Metal).

Führen Sie die Schritte in den folgenden Abschnitten aus, um einen GKE-Standardcluster mit A4X Max zu erstellen, der GPUDirect RDMA und MNNVL verwendet:

  1. GKE-Cluster erstellen
  2. Arbeitslastrichtlinie erstellen
  3. Knotenpool mit A4X Max erstellen
  4. MRDMA-NICs mit asapd-lite konfigurieren
  5. NVIDIA Compute Domain CRD und DRA-Treiber installieren
  6. Arbeitslastmanifest für RDMA- und IMEX-Domain konfigurieren

In dieser Anleitung werden Beschleunigernetzwerk profile verwendet, um VPC-Netzwerke und Subnetze für Ihre A4X Max-Knoten automatisch zu konfigurieren. Alternativ können Sie Ihr VPC-Netzwerk und Ihre Subnetze explizit angeben.

GKE-Cluster erstellen

  1. Erstellen Sie einen GKE-Standardcluster:

    gcloud container clusters create CLUSTER_NAME \
  --enable-dataplane-v2 \
  --enable-ip-alias \
  --location=COMPUTE_REGION \
  --cluster-version=CLUSTER_VERSION \
  --no-enable-shielded-nodes [\
  --services-ipv4-cidr=SERVICE_CIDR \
  --cluster-ipv4-cidr=POD_CIDR \
  --addons=GcpFilestoreCsiDriver=ENABLED]

    Ersetzen Sie Folgendes:

    • CLUSTER_NAME: Der Name Ihres Clusters.
    • CLUSTER_VERSION: Die Version Ihres neuen Clusters. Weitere Informationen dazu, welche GKE-Version Ihre Konfiguration unterstützt, finden Sie in diesem Dokument unter 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. Beispiel: betrachten Sie SERVICE_CIDR=10.65.0.0/19 und POD_CIDR=10.64.0.0/19. Weitere Informationen finden Sie unter Pod-IPv4-Adressbereiche hinzufügen.

  2. Stellen Sie eine Verbindung zu Ihrem Cluster her, um die kubectl-Befehle in den nächsten Abschnitten auszuführen:

    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.

Arbeitslastrichtlinie erstellen

Zum Erstellen einer Partition ist eine Arbeitslastrichtlinie erforderlich. Weitere Informationen finden Sie unter Arbeitslastrichtlinie für MIGs.

Erstellen Sie eine HIGH_THROUGHPUT-Arbeitslastrichtlinie, wobei das Feld accelerator_topology auf 1x72 gesetzt ist.

gcloud beta compute resource-policies create workload-policy WORKLOAD_POLICY_NAME \
    --type HIGH_THROUGHPUT \
    --accelerator-topology 1x72 \
    --project PROJECT \
    --region COMPUTE_REGION

Ersetzen Sie Folgendes:

  • WORKLOAD_POLICY_NAME: Der Name Ihrer Arbeitslast richtlinie.
  • PROJECT: Der Name Ihres Projekts.
  • COMPUTE_REGION: Der Name der Compute-Region.

Knotenpool mit A4X Max erstellen

  1. Erstellen Sie die folgende Konfigurationsdatei, um Huge Pages mit dem Knotenpool vorab zuzuweisen:

    cat > node_custom.yaml <<EOF
linuxConfig:
  hugepageConfig:
    hugepage_size2m: 4096
EOF

export NODE_CUSTOM=node_custom.yaml

  2. Erstellen Sie einen A4X Max-Knotenpool:

    gcloud container node-pools create NODE_POOL_NAME \
    --cluster=CLUSTER_NAME \
    --location=COMPUTE_REGION \
    --node-locations=COMPUTE_ZONE \
    --num-nodes=NODE_COUNT \
    --placement-policy=WORKLOAD_POLICY_NAME \
    --machine-type=a4x-maxgpu-4g-metal \
    --accelerator=type=nvidia-gb300,count=4,gpu-driver-version=latest \
    --system-config-from-file=${NODE_CUSTOM} \
    --accelerator-network-profile=auto \
    --node-labels=cloud.google.com/gke-networking-dra-driver=true,cloud.google.com/gke-dpv2-unified-cni=cni-migration \
    --reservation-affinity=specific \
    --reservation=RESERVATION_NAME/reservationBlocks/BLOCK_NAME/reservationSubBlocks/SUB_BLOCK_NAME

    Ersetzen Sie Folgendes:

    • NODE_POOL_NAME ist der Name des Knotenpools.
    • CLUSTER_NAME: Der Name Ihres Clusters.
    • COMPUTE_REGION: Die Compute-Region des Clusters.
    • COMPUTE_ZONE: Die Zone Ihres Knotenpools.
    • NODE_COUNT: Die Anzahl der Knoten für den Knotenpool. Sie muss 18 oder weniger betragen. Wir empfehlen, 18 Knoten zu verwenden, um die GPU-Topologie 1x72 in einem Unterblock mit einer NVLink-Domain zu erhalten.
    • WORKLOAD_POLICY_NAME: Der Name der zuvor erstellten Arbeitslastrichtlinie.
    • RESERVATION_NAME: Der Name Ihrer Reservierung. Informationen zum Abrufen dieses Werts finden Sie unter Zukünftige Reservierungs anfragen anzeigen.
    • BLOCK_NAME: Der Name eines bestimmten Blocks innerhalb der Reservierung. Informationen zum Abrufen dieses Werts finden Sie unter Zukünftige Reservierungs anfragen anzeigen.

    Mit diesem Befehl wird automatisch ein Netzwerk erstellt, das alle A4X Max-Knoten in einer einzelnen Zone mit dem Beschleunigernetzwerkprofil auto verbindet. Wenn Sie einen Knotenpool mit dem Flag --accelerator-network-profile=auto erstellen, fügt GKE den Knoten automatisch das Label gke.networks.io/accelerator-network-profile: auto hinzu. Wenn Sie Arbeitslasten auf diesen Knoten planen möchten, müssen Sie dieses Label in das Feld nodeSelector Ihrer Arbeitslast einfügen.

MRDMA-NICs mit asapd-lite konfigurieren

Das asapd-lite-DaemonSet konfiguriert die MRDMA-NICs. Ein fehlerhaftes asapd-lite-DaemonSet kann darauf hinweisen, dass keine RDMA-Verbindung besteht.

  1. Installieren Sie das DaemonSet:

    kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/refs/heads/master/asapd-lite-installer/asapd-lite-installer-a4x-max-bm-cos.yaml

  2. Prüfen Sie die Replikate im asapd-lite-DaemonSet:

    kubectl get daemonset -n kube-system asapd-lite

    Die Ausgabe sieht etwa so aus:

    NAME         DESIRED   CURRENT   READY   UP-TO-DATE   AVAILABLE   NODE SELECTOR   AGE
asapd-lite   18        18        18      18           18          <none>          5m

    Die Anzahl der READY-Replikate sollte mit der Anzahl der Knoten übereinstimmen, die im Knotenpool erstellt wurden und fehlerfrei sind.

NVIDIA Compute Domain CRD und DRA-Treiber installieren

Mit den folgenden Schritten werden die NVIDIA Compute Domain CRD und der DRA-Treiber installiert, um die Verwendung von MNNVL zu ermöglichen. Weitere Informationen finden Sie unter NVIDIA DRA Driver for GPUs.

  1. Prüfen Sie, ob Helm in Ihrer Entwicklungsumgebung installiert ist. Helm ist in Cloud Shell vorinstalliert.

    Es gibt keine spezifischen Anforderungen an die Helm-Version. Sie können jedoch mit dem folgenden Befehl prüfen, ob Helm installiert ist.

    helm version

    Wenn die Ausgabe ähnlich wie Command helm not found aussieht, können Sie die Helm CLI installieren:

    curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/master/scripts/get-helm-3 \
  && chmod 700 get_helm.sh \
  && ./get_helm.sh

  2. Fügen Sie das NVIDIA-Helm-Repository hinzu:

    helm repo add nvidia https://helm.ngc.nvidia.com/nvidia \
  && helm repo update

  3. Erstellen Sie ein ResourceQuota-Objekt für den DRA-Treiber:

    export POD_QUOTA=POD_QUOTA

kubectl create ns nvidia-dra-driver-gpu

kubectl apply -n nvidia-dra-driver-gpu -f - << EOF
apiVersion: v1
kind: ResourceQuota
metadata:
  name: nvidia-dra-driver-gpu-quota
spec:
  hard:
    pods: ${POD_QUOTA}
  scopeSelector:
    matchExpressions:
    - operator: In
      scopeName: PriorityClass
      values:
        - system-node-critical
        - system-cluster-critical
EOF

    Ersetzen Sie POD_QUOTA durch eine Zahl, die mindestens das Doppelte der Anzahl der A4X Max-Knoten im Cluster plus 1 beträgt. Wenn Sie beispielsweise 18 A4X Max-Knoten in Ihrem Cluster haben, müssen Sie die Variable auf mindestens 37 setzen.

  4. Installieren Sie die ComputeDomain CRD und den DRA-Treiber:

    helm install nvidia-dra-driver-gpu nvidia/nvidia-dra-driver-gpu \
    --set controller.args.v=4 --set kubeletPlugin.args.v=4 \
    --version="25.8.0" \
    --create-namespace \
    --namespace nvidia-dra-driver-gpu \
    -f <(cat <<EOF
nvidiaDriverRoot: /home/kubernetes/bin/nvidia
resources:
  gpus:
    enabled: false

controller:
  affinity:
      nodeAffinity:
        requiredDuringSchedulingIgnoredDuringExecution:
          nodeSelectorTerms:
          - matchExpressions:
            - key: "nvidia.com/gpu"
              operator: "DoesNotExist"

kubeletPlugin:
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
          - matchExpressions:
              - key: cloud.google.com/gke-accelerator
                operator: In
                values:
                  - nvidia-gb300
              - key: kubernetes.io/arch
                operator: In
                values:
                  - arm64

  tolerations:
    - key: nvidia.com/gpu
      operator: Equal
      value: present
      effect: NoSchedule
    - key: kubernetes.io/arch
      operator: Equal
      value: arm64
      effect: NoSchedule
EOF
)

Arbeitslastmanifest für RDMA- und IMEX-Domain konfigurieren

  1. Fügen Sie eine Knotenaffinitätsregel hinzu, um die Arbeitslast auf Arm-Knoten zu planen:

    spec:
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        -   matchExpressions:
          -   key: kubernetes.io/arch
            operator: In
            values:
            -   arm64

  2. Fügen Sie der Pod-Spezifikation das folgende Volume hinzu:

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

  3. Fügen Sie dem Container, der GPUs anfordert, die folgenden Volume-Bereitstellungen, die Umgebungsvariable und die Ressource hinzu. Ihr Arbeitslastcontainer muss alle vier GPUs anfordern:

    containers:
  - name: my-container
    volumeMounts:
      - name: library-dir-host
        mountPath: /usr/local/nvidia

    env:
      - name: LD_LIBRARY_PATH
        value: /usr/local/nvidia/lib64
    resources:
      limits:
        nvidia.com/gpu: 4

  4. Erstellen Sie die ComputeDomain-Ressource für die Arbeitslast:

    apiVersion: resource.nvidia.com/v1beta1
kind: ComputeDomain
metadata:
  name: a4x-max-compute-domain
spec:
  numNodes: NUM_NODES
  channel:
    resourceClaimTemplate:
      name: a4x-max-compute-domain-channel

    Ersetzen Sie NUM_NODES durch die Anzahl der Knoten, die für die Arbeitslast erforderlich sind.

  5. Erstellen Sie eine ResourceClaimTemplate, um Netzwerkressourcen mit DRANET zuzuweisen und RDMA-Geräte für Ihren Pod anzufordern:

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

  6. Geben Sie die ResourceClaimTemplate an, die der Pod verwendet:

    spec:
  ...
  volumes:
    ...
  containers:
    - name: my-container
      ...
      resources:
        limits:
          nvidia.com/gpu: 4
  claims:
          - name: compute-domain-channel
          - name: rdma
        ...
resourceClaims:
  - name: compute-domain-channel
    resourceClaimTemplateName: a4x-max-compute-domain-channel
  - name: rdma
    resourceClaimTemplateName: all-mrdma

  7. Installieren Sie die neuesten Userspace-Bibliotheken in Ihrem Container-Image:

    Debian 12+/Ubuntu 20.04+ (.deb-Paket)

    apt update
apt install curl

# Fetch DOCA OFED userspace libraries
export DOCA_URL="https://linux.mellanox.com/public/repo/doca/latest/ubuntu22.04/arm64-sbsa/"
export BASE_URL="https://linux.mellanox.com/public/repo/doca"
curl "${BASE_URL}/GPG-KEY-Mellanox.pub" | gpg --dearmor -o /etc/apt/trusted.gpg.d/GPG-KEY-Mellanox.pub
echo "deb [signed-by=/etc/apt/trusted.gpg.d/GPG-KEY-Mellanox.pub] ${DOCA_URL} ./" | tee /etc/apt/sources.list.d/doca.list

apt update
apt install doca-ofed-userspace

# Upgrade to latest NCCL for best compatibility
apt install --only-upgrade --allow-change-held-packages libnccl2 libnccl-dev

Eine vollständige Pod-Spezifikation sieht so aus:

apiVersion: resource.nvidia.com/v1beta1
kind: ComputeDomain
metadata:
  name: a4x-max-compute-domain
spec:
  numNodes:  NUM_NODES
  channel:
    resourceClaimTemplate:
      name: a4x-max-compute-domain-channel
---
apiVersion: apps/v1
kind: Pod
metadata:
  name: my-pod
  labels:
    k8s-app: my-pod
spec:
  ...
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchExpressions:
          - key: kubernetes.io/arch
            operator: In
            values:
            - arm64
  volumes:
    - name: library-dir-host
      hostPath:
        path: /home/kubernetes/bin/nvidia
  hostNetwork: true
  containers:
    - name: my-container
      volumeMounts:
        - name: library-dir-host
          mountPath: /usr/local/nvidia
      env:
        - name: LD_LIBRARY_PATH
          value: /usr/local/nvidia/lib64
      resources:
        limits:
          nvidia.com/gpu: 4
        claims:
          - name: compute-domain-channel
          - name: rdma
        ...
  resourceClaims:
    - name: compute-domain-channel
      resourceClaimTemplateName: a4x-max-compute-domain-channel
    - name: rdma
      resourceClaimTemplateName: all-mrdma

Netzwerkleistung testen

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

Weitere Informationen finden Sie unter NCCL auf benutzerdefinierten GKE-Clustern mit A4X Max ausführen.

Nächste Schritte