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

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

Mit der A4X Max- und A4X-Serie können Sie groß angelegte KI-/ML-Cluster mit dem NVIDIA Multi-Node NVLink (MNNVL)-System ausführen, einer Lösung im Rack-Maßstab, die eine höhere GPU-Leistung ermöglicht. Diese Maschinen bieten Funktionen wie die gezielte Platzierung von Arbeitslasten, Topology Aware Scheduling und erweiterte Steuerelemente für die Clusterwartung. Weitere Informationen finden Sie unter Funktionen für die Clusterverwaltung. Mit A4X Max bietet GKE auch eine automatische Netzwerkeinrichtung, die die Clusterkonfiguration vereinfacht.

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. GKE bietet eine einzige 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 verteiltes Vortraining mit hoher Leistung, Modellabstimmung, Modellinferenz, Anwendungsbereitstellung und unterstützende Dienste ausführen. Bei Arbeitslasten, die hohe Leistung, hohen Durchsatz und niedrige Latenz erfordern, reduziert GPUDirect RDMA die Netzwerk-Hops, die für die Übertragung von Nutzlasten an und von GPUs erforderlich sind. Bei diesem Ansatz wird die verfügbare Netzwerkbandbreite effizienter genutzt. Weitere Informationen finden Sie unter GPU-Netzwerkstacks.

In diesem Dokument 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. Wenn Sie mit der gcloud CLI Cluster mit anderen Maschinentypen erstellen möchten, lesen Sie die folgenden Informationen:

Alternativ können Sie Cluster Toolkit verwenden, um Ihren Cluster schnell mit Standardeinstellungen bereitzustellen, die Best Practices für viele Anwendungsfälle entsprechen. 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 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.

Kapazität erhalten

Sie können Kapazität für A4X Max-Compute-Instanzen erhalten, indem Sie eine zukünftige 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 Abrufen von Kapazität mit einer vorausschauenden Reservierung finden Sie in der Tabelle unter Kapazität abrufen in der Zeile Vorausschauende Reservierungen in AI Hypercomputer.

Voraussetzungen

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

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

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

    Diese Versionen sorgen dafür, dass A4X Max Folgendes verwendet:

    • R580.95.05, die Mindestversion des GPU-Treibers für A4X Max, die standardmäßig aktiviert ist.
    • Coherent Driver-based Memory Management (CDMM), das standardmäßig aktiviert ist. NVIDIA empfiehlt, diesen Modus in Kubernetes-Clustern zu aktivieren, um eine Übermeldung des Arbeitsspeichers zu vermeiden. Mit CDMM kann der GPU-Speicher über den Treiber anstelle des Betriebssystems verwaltet werden. So wird vermieden, 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. GPUs mit mehreren Instanzen werden nicht unterstützt, wenn CDMM aktiviert ist. Weitere Informationen zu CDMM finden Sie unter Hardware- und Softwareunterstützung.
    • 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-Knotenimages werden nicht unterstützt.

  • Ihre GKE-Arbeitslast muss alle verfügbaren GPUs und Ihr Pod 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 Bereitstellungsmodell reservation-bound verwenden, um Cluster mit A4X Max zu erstellen. Andere Bereitstellungsmodelle 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 Maschinentyp a4x-maxgpu-4g-metal nicht unterstützt.

Hinweise zum Erstellen eines Clusters

Beachten Sie beim Erstellen eines Clusters Folgendes:

  • Clusterstandort auswählen:
    • Prüfen Sie, ob der von Ihnen ausgewählte Maschinentyp am von Ihnen verwendeten Standort 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 Flag --node-locations 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: Automatische Treiberinstallation überspringen. Sie müssen einen Treiber manuell 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:

    • Hier finden Sie Informationen zu Ihrer Reservierung, z. B. den Namen Ihrer Reservierung oder den Namen eines bestimmten Blocks in Ihrer Reservierung. Weitere Informationen zum Abrufen dieser Werte
    • 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 die folgenden Werte:

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

      Wir empfehlen außerdem, eine reservierte Zuweisung für einen Unterblock zu verwenden, damit Compute-Instanzen in einem einzelnen Unterblock innerhalb des 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 erstellen, der A4X Max und GPUDirect RDMA verwendet

Bei verteilten 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 Rack-Scale-Architektur NVIDIA GB300 NVL72 basiert. A4X Max-Compute-Instanzen verwenden eine mehrschichtige, hierarchische Netzwerkarchitektur mit einem schienenorientierten 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 für KI-Arbeitslasten. Weitere Informationen zur Netzwerkarchitektur für A4X Max, einschließlich der Netzwerkbandbreite und der Anordnung der NICs, finden Sie unter A4X Max-Maschinentyp (Bare Metal).

So erstellen Sie einen GKE-Standardcluster mit A4X Max, 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 Beschleunigernetzwerkprofile 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. GKE-Standardcluster erstellen:

    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 ist 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 mit Subnetzbereichen für zusätzliche Knotennetzwerke überschneiden. Beispiel: 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, bei der das Feld accelerator_topology auf 1x72 festgelegt 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 Arbeitslastrichtlinie.
  • PROJECT: 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. A4X Max-Knotenpool erstellen:

    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 des Knotenpools.
    • NODE_COUNT: Die Anzahl der Knoten für den Knotenpool, die maximal 18 betragen darf. Wir empfehlen, 18 Knoten zu verwenden, um die GPU-Topologie von 1x72 in einem Subblock mit einer NVLink-Domain zu erhalten.
    • WORKLOAD_POLICY_NAME: Der Name der Workload-Richtlinie, die Sie zuvor erstellt haben.
    • RESERVATION_NAME: der Name Ihrer Reservierung. Informationen zum Ermitteln dieses Werts finden Sie unter Zukünftige Reservierungsanfragen ansehen.
    • BLOCK_NAME: der Name eines bestimmten Blocks innerhalb der Reservierung. Informationen zum Ermitteln dieses Werts finden Sie unter Zukünftige Reservierungsanfragen ansehen.

    Mit diesem Befehl wird automatisch ein Netzwerk erstellt, das alle A4X Max-Knoten in einer einzelnen Zone über das 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 aufnehmen.

Konfigurieren Sie die MRDMA-NICs mit asapd-lite.

Das DaemonSet asapd-lite 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 der Anzahl der Knoten entsprechen, 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 der Cloud Shell vorinstalliert.

    Es gibt keine spezielle Helm-Versionsanforderung. Sie können jedoch mit dem folgenden Befehl prüfen, ob Helm installiert ist.

    helm version

    Wenn die Ausgabe in etwa so aussieht: Command helm not found, 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 festlegen.

  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 Einbindungen, Umgebungsvariablen und Ressourcen hinzu. Der 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 Ressource ComputeDomain 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 ein 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. Prüfen Sie, ob die Userspace-Bibliotheken und die libnccl-Pakete im Nutzer-Container-Image installiert sind:

    apt update -y
apt install -y curl
export DOCA_URL="https://linux.mellanox.com/public/repo/doca/3.1.0/ubuntu22.04/arm64-sbsa/"
BASE_URL=$([ "${DOCA_PREPUBLISH:-false}" = "true" ] && echo https://doca-repo-prod.nvidia.com/public/repo/doca || echo https://linux.mellanox.com/public/repo/doca)
DOCA_SUFFIX=${DOCA_URL#*public/repo/doca/}; DOCA_URL="$BASE_URL/$DOCA_SUFFIX"
curl $BASE_URL/GPG-KEY-Mellanox.pub | gpg --dearmor > /etc/apt/trusted.gpg.d/GPG-KEY-Mellanox.pub
echo "deb [signed-by=/etc/apt/trusted.gpg.d/GPG-KEY-Mellanox.pub] $DOCA_URL ./" > /etc/apt/sources.list.d/doca.list
apt update
apt -y install doca-ofed-userspace
# The installed libnccl2 is 2.27.7, to upgrade to 2.28.9 as we recommend
apt install --only-upgrade --allow-change-held-packages -y libnccl2 libnccl-dev

Eine ausgefüllte 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 bereitgestellter 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.

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

Nächste Schritte