P6e-GB200 UltraServers Mit Amazon EKS verwenden

Erstellen Sie eine Helm-Wertedatei gpu-operator-values.yaml mit dem Namen der folgenden Konfiguration.

devicePlugin:
  enabled: true
nfd:
  enabled: true
gfd:
  enabled: true
driver:
  enabled: false
toolkit:
  enabled: false
migManager:
  enabled: false

Installieren Sie den NVIDIA-GPU-Operator für Ihren Cluster mithilfe der gpu-operator-values.yaml Datei, die Sie im vorherigen Schritt erstellt haben.

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

helm install gpu-operator nvidia/gpu-operator \
 --namespace gpu-operator \
 --create-namespace \
 --version v25.3.4 \
 --values gpu-operator-values.yaml

Erstellen Sie eine Helm-Wertedatei dra-values.yaml mit dem Namen der folgenden Konfiguration. Beachten Sie die nodeAffinity undtolerations, die den DRA-Treiber so konfigurieren, dass er nur auf Knoten mit einer NVIDIA-GPU bereitgestellt wird.

resources:
  gpus:
    enabled: false # set to false to disable experimental gpu support
  computeDomains:
    enabled: true

controller:
  nodeSelector: null
  affinity: null
  tolerations: []

kubeletPlugin:
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchExpressions:
          - key: "nvidia.com/gpu.present"
            operator: In
            values:
            - "true"
  tolerations:
    - key: "nvidia.com/gpu"
      operator: Exists
      effect: NoSchedule

Installieren Sie den NVIDIA DRA-Treiber für Ihren Cluster mithilfe der dra-values.yaml Datei, die Sie im vorherigen Schritt erstellt haben.

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

helm install nvidia-dra-driver-gpu nvidia/nvidia-dra-driver-gpu \
  --version="25.8.0" \
  --namespace nvidia-dra-driver-gpu \
  --create-namespace \
  -f dra-values.yaml

Nach der Installation erstellt der DRA-Treiber DeviceClass Ressourcen, die es Kubernetes ermöglichen, Ressourcen zu verstehen und zuzuweisenComputeDomain, sodass die IMEX-Verwaltung für verteilte GPU-Workloads möglich ist. P6e-GB200 UltraServers

Stellen Sie mit den folgenden Befehlen sicher, dass die DRA-Ressourcen verfügbar sind.

kubectl api-resources | grep resource.k8s.io

deviceclasses           resource.k8s.io/v1  false        DeviceClass
resourceclaims          resource.k8s.io/v1  true         ResourceClaim
resourceclaimtemplates  resource.k8s.io/v1  true         ResourceClaimTemplate
resourceslices          resource.k8s.io/v1  false        ResourceSlice

kubectl get deviceclasses

NAME
compute-domain-daemon.nvidia.com
compute-domain-default-channel.nvidia.com

Erstellen Sie eine Helm-Wertedatei efa-values.yaml mit dem Namen der folgenden Konfiguration.

tolerations:
  - key: nvidia.com/gpu
    operator: Exists
    effect: NoSchedule

Fügen Sie das EKS-Helm-Chart-Repository hinzu und installieren Sie den EFA-DRA-Treiber.

helm repo add eks https://aws.github.io/eks-charts
helm repo update

helm install aws-dranet eks/aws-dranet --namespace kube-system -f efa-values.yaml

Stellen Sie sicher, dass das DRANET läuft. DaemonSet

kubectl get daemonset -n kube-system aws-dranet

NAME          DESIRED   CURRENT   READY   UP-TO-DATE   AVAILABLE   NODE SELECTOR   AGE
aws-dranet    2         2         2       2            2           <none>          60s

Stellen Sie sicher, dass die ResourceSlice Objekte DeviceClass und verfügbar sind.

kubectl get deviceclass efa.networking.k8s.aws

NAME                    AGE
efa.networking.k8s.aws  60s

kubectl get resourceslices -l resource.k8s.io/driver=dra.net

Erstellen Sie eine Helm-Wertedatei efa-values.yaml mit dem Namen der folgenden Konfiguration.

tolerations:
  - key: nvidia.com/gpu
    operator: Exists
    effect: NoSchedule

Fügen Sie das EKS-Helm-Chart-Repository hinzu und installieren Sie das EFA-Geräte-Plugin.

helm repo add eks https://aws.github.io/eks-charts
helm repo update

helm install efa eks/aws-efa-k8s-device-plugin -n kube-system -f efa-values.yaml

Stellen Sie sicher, dass das EFA-Geräte-Plugin DaemonSet läuft.

kubectl get daemonset -n kube-system aws-efa-k8s-device-plugin-daemonset

NAME                                  DESIRED   CURRENT   READY   UP-TO-DATE   AVAILABLE   NODE SELECTOR   AGE
aws-efa-k8s-device-plugin-daemonset   2         2         2       2            2           <none>          60s

Stellen Sie sicher, dass Ihre Knoten über zuweisbare EFA-Geräte verfügen. Wenn Sie beispielsweise Ihre Instances mit einer reinen EFA-Schnittstelle in jeder NCI-Gruppe konfiguriert haben, werden voraussichtlich 4 zuweisbare EFA-Geräte pro Knoten angezeigt.

kubectl get nodes "-o=custom-columns=NAME:.metadata.name,EFA:.status.allocatable.vpc\.amazonaws\.com/efa"

NAME                                           EFA
ip-192-168-11-225.us-west-2.compute.internal   4
ip-192-168-24-96.us-west-2.compute.internal    4

Um einen Bandbreitentest mit mehreren Knoten auf zwei Knoten in der NVL72-Domäne durchzuführen, installieren Sie zunächst den MPI-Operator:

kubectl create -f https://github.com/kubeflow/mpi-operator/releases/download/v0.7.0/mpi-operator.yaml

Erstellen Sie eine Datei mit dem Namennvbandwidth-test-job.yaml, der das Testmanifest definiert. Beachten Sie die nvidia.com/gpu.clique Pod-Affinität, die Worker in derselben NVLink-Domäne einzuplanen, die über Multi-Node NVLink erreichbar ist. Im folgenden Beispiel wird ein CE-Read-Memcpy-Test von Gerät zu Gerät mit mehreren Knoten unter Verwendung von cu ausgeführt und die Ergebnisse in den Protokollen gedruckt. MemcpyAsync

Ab der NVIDIA DRA-Treiberversion v25.8.0 ComputeDomains sind sie elastisch und .spec.numNodes können in der Definition auf eingestellt werden. 0 ComputeDomain Updates finden Sie in den aktuellen Versionshinweisen zum NVIDIA DRA-Treiber.

Pro Knoten kann es nur einen ComputeDomain (IMEX-Kanal) geben. Ändern Sie nicht den Wert All für allocationMode die ComputeDomain Ressource, da dies verhindern kann, dass die ComputeDomain und die Pods, die darauf ComputeDomain zugreifen, korrekt zugewiesen und geplant werden. Weitere Informationen finden Sie unter NVIDIA DRA-Treiberausgabe #353.

---
apiVersion: resource.nvidia.com/v1beta1
kind: ComputeDomain
metadata:
  name: nvbandwidth-test-compute-domain
spec:
  numNodes: 0 # This can be set to 0 from NVIDIA DRA Driver version v25.8.0+
  channel:
    resourceClaimTemplate:
      name: nvbandwidth-test-compute-domain-channel

---
apiVersion: kubeflow.org/v2beta1
kind: MPIJob
metadata:
  name: nvbandwidth-test
spec:
  slotsPerWorker: 4 # 4 GPUs per worker node
  launcherCreationPolicy: WaitForWorkersReady
  runPolicy:
    cleanPodPolicy: Running
  sshAuthMountPath: /home/mpiuser/.ssh
  mpiReplicaSpecs:
    Launcher:
      replicas: 1
      template:
        metadata:
          labels:
            nvbandwidth-test-replica: mpi-launcher
        spec:
          affinity:
            nodeAffinity:
              requiredDuringSchedulingIgnoredDuringExecution:
                nodeSelectorTerms:
                - matchExpressions:
                  # Only schedule on NVIDIA GB200/GB300 nodes
                  - key: node.kubernetes.io/instance-type
                    operator: In
                    values:
                    - p6e-gb200.36xlarge
                    - p6e-gb300.36xlarge
          containers:
          - image: ghcr.io/nvidia/k8s-samples:nvbandwidth-v0.7-8d103163
            name: mpi-launcher
            securityContext:
              runAsUser: 1000
            command:
            - mpirun
            args:
            - --bind-to
            - core
            - --map-by
            - ppr:4:node
            - -np
            - "8"
            - --report-bindings
            - -q
            - nvbandwidth
            - -t
            - multinode_device_to_device_memcpy_read_ce
    Worker:
      replicas: 2 # 2 worker nodes
      template:
        metadata:
          labels:
            nvbandwidth-test-replica: mpi-worker
        spec:
          affinity:
            nodeAffinity:
              requiredDuringSchedulingIgnoredDuringExecution:
                nodeSelectorTerms:
                - matchExpressions:
                  # Only schedule on NVIDIA GB200/GB300 nodes
                  - key: node.kubernetes.io/instance-type
                    operator: In
                    values:
                    - p6e-gb200.36xlarge
                    - p6e-gb300.36xlarge
            podAffinity:
              requiredDuringSchedulingIgnoredDuringExecution:
              - labelSelector:
                  matchExpressions:
                  - key: nvbandwidth-test-replica
                    operator: In
                    values:
                    - mpi-worker
                topologyKey: nvidia.com/gpu.clique
          containers:
          - image: ghcr.io/nvidia/k8s-samples:nvbandwidth-v0.7-8d103163
            name: mpi-worker
            securityContext:
              runAsUser: 1000
            env:
            command:
            - /usr/sbin/sshd
            args:
            - -De
            - -f
            - /home/mpiuser/.sshd_config
            resources:
              limits:
                nvidia.com/gpu: 4  # Request 4 GPUs per worker
              claims:
              - name: compute-domain-channel # Link to IMEX channel
          resourceClaims:
          - name: compute-domain-channel
            resourceClaimTemplateName: nvbandwidth-test-compute-domain-channel

Erstellen Sie den ComputeDomain und starten Sie den Job mit dem folgenden Befehl.

kubectl apply -f nvbandwidth-test-job.yaml

Nach der ComputeDomain Erstellung können Sie sehen, dass der Workload zwei Knoten ComputeDomain hat:

kubectl get computedomains.resource.nvidia.com -o yaml

status:
  nodes:
  - cliqueID: <ClusterUUID>.<Clique ID>
    ipAddress: <node-ip>
    name: <node-hostname>
  - cliqueID: <ClusterUUID>.<Clique ID>
    ipAddress: <node-ip>
    name: <node-hostname>
  status: Ready

Überprüfen Sie die Ergebnisse des Jobs mit dem folgenden Befehl.

kubectl logs --tail=-1 -l job-name=nvbandwidth-test-launcher

Bei erfolgreichem Test werden Bandbreitenstatistiken GB/s für den Memcpy-Test mit mehreren Knoten angezeigt. Ein Beispiel für eine erfolgreiche Testausgabe ist unten dargestellt.

...
nvbandwidth Version: ...
Built from Git version: ...

MPI version: ...
CUDA Runtime Version: ...
CUDA Driver Version: ...
Driver Version: ...

Process 0 (nvbandwidth-test-worker-0): device 0: NVIDIA GB200 (...)
Process 1 (nvbandwidth-test-worker-0): device 1: NVIDIA GB200 (...)
Process 2 (nvbandwidth-test-worker-0): device 2: NVIDIA GB200 (...)
Process 3 (nvbandwidth-test-worker-0): device 3: NVIDIA GB200 (...)
Process 4 (nvbandwidth-test-worker-1): device 0: NVIDIA GB200 (...)
Process 5 (nvbandwidth-test-worker-1): device 1: NVIDIA GB200 (...)
Process 6 (nvbandwidth-test-worker-1): device 2: NVIDIA GB200 (...)
Process 7 (nvbandwidth-test-worker-1): device 3: NVIDIA GB200 (...)

Running multinode_device_to_device_memcpy_read_ce.
memcpy CE GPU(row) -> GPU(column) bandwidth (GB/s)
           0         1         2         3         4         5         6         7
 0       N/A    821.45    822.18    821.73    822.05    821.38    822.61    821.89
 1    822.34       N/A    821.67    822.12    821.94    820.87    821.53    822.08
 2    821.76    822.29       N/A    821.58    822.43    821.15    821.82    822.31
 3    822.19    821.84    822.05       N/A    821.67    821.23    820.95    822.47
 4    821.63    822.38    821.49    822.17       N/A    821.06    821.78    822.22
 5    822.08    821.52    821.89    822.35    821.27       N/A    821.64    822.13
 6    821.94    822.15    821.68    822.04    821.39    820.92       N/A    822.56
 7    822.27    821.73    822.11    821.86    822.38    821.04    821.49       N/A

SUM multinode_device_to_device_memcpy_read_ce ...

NOTE: The reported results may not reflect the full capabilities of the platform.
Performance can vary with software drivers, hardware clocks, and system topology.

Wenn der Test abgeschlossen ist, löschen Sie ihn mit dem folgenden Befehl.

kubectl delete -f nvbandwidth-test-job.yaml