**Unterstützung für die Verbesserung dieser Seite beitragen**
Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
Um zu diesem Benutzerhandbuch beizutragen, wählen Sie den GitHub Link **Diese Seite bearbeiten auf**, der sich im rechten Bereich jeder Seite befindet.
Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# P6e-GB200 UltraServers Mit Amazon EKS verwenden
In diesem Thema wird beschrieben, wie Sie Amazon EKS mit konfigurieren und verwenden P6e-GB200 UltraServers. Der `p6e-gb200.36xlarge` Instance-Typ mit 4 NVIDIA Blackwell-GPUs ist nur als verfügbar. P6e-GB200 UltraServers Es gibt zwei Typen von. P6e-GB200 UltraServers Der `u-p6e-gb200x36` UltraServer hat 9 `p6e-gb200.36xlarge` Instanzen und der `u-p6e-gb200x72` UltraServer hat 18 `p6e-gb200.36xlarge` Instanzen.
Weitere Informationen finden Sie auf der [Amazon EC2 P6e-GB200 UltraServers EC2-Webseite](https://aws.amazon.com/ec2/instance-types/p6/).
## Überlegungen
+ Amazon EKS unterstützt P6e-GB200 UltraServers Kubernetes-Versionen 1.33 und höher. Diese Kubernetes-Version bietet Unterstützung für [Dynamic Resource Allocation](https://kubernetes.io/docs/concepts/scheduling-eviction/dynamic-resource-allocation/) (DRA), die standardmäßig in EKS und in den beschleunigten [ EKS-optimized AL2023-AMIs](https://docs.aws.amazon.com/eks/latest/userguide/ml-eks-optimized-ami.html) aktiviert ist. DRA ist eine Voraussetzung für die Verwendung von mit EKS. P6e-GB200 UltraServers DRA wird im automatischen Modus von Karpenter oder EKS nicht unterstützt, und es wird empfohlen, selbstverwaltete EKS-Knotengruppen oder EKS-verwaltete Knotengruppen zu verwenden, wenn Sie mit EKS verwenden. P6e-GB200 UltraServers
+ P6e-GB200 UltraServers werden über [EC2 Capacity](https://aws.amazon.com/ec2/capacityblocks/) Blocks für ML zur Verfügung gestellt. Informationen [Rechenressourcen für AI/ML Workloads auf Amazon EKS verwalten](ml-compute-management.md) zum Starten von EKS-Knoten mit Capacity Blocks finden Sie unter.
+ Wenn Sie von EKS verwaltete Knotengruppen mit Kapazitätsblöcken verwenden, müssen Sie benutzerdefinierte Startvorlagen verwenden. Wenn Sie von EKS verwaltete Knotengruppen mit aktualisieren P6e-GB200 UltraServers, müssen Sie `0` vor dem Upgrade die gewünschte Größe der Knotengruppe auf einstellen.
+ Es wird empfohlen, die AL2023 ARM NVIDIA-Variante der EKS-optimized beschleunigten AMIs zu verwenden. Dieses AMI enthält die erforderlichen Knotenkomponenten und die Konfiguration, mit der gearbeitet werden kann P6e-GB200 UltraServers. Wenn Sie sich entscheiden, Ihr eigenes AMI zu erstellen, sind Sie für die Installation und Überprüfung der Kompatibilität der Knoten- und Systemsoftware, einschließlich der Treiber, verantwortlich. Weitere Informationen finden Sie unter [Verwenden Sie EKS-optimierte beschleunigte AMIs GPU-Instanzen](ml-eks-optimized-ami.md).
+ Es wird empfohlen, die EKS-optimized AMI-Version `v20251103` oder höher zu verwenden, die die NVIDIA-Treiberversion 580 enthält. Diese NVIDIA-Treiberversion ermöglicht Coherent Driver-Based Memory (CDMM), um potenziellen Speicherüberschüssen entgegenzuwirken. Wenn CDMM aktiviert ist, werden die folgenden Funktionen nicht unterstützt: NVIDIA Multi-Instance GPU (MIG) und vGPU. Weitere Informationen zu CDMM finden Sie unter [NVIDIA Coherent Driver-based Memory Management (](https://nvdam.widen.net/s/gpqp6wmz7s/cuda-whitepaper—cdmm-pdf)CDMM).
+ Wenn Sie den [NVIDIA-GPU-Operator](https://docs.nvidia.com/datacenter/cloud-native/gpu-operator/latest/overview.html) mit dem EKS-optimized AL2023 NVIDIA AMI verwenden, müssen Sie die Installation des Treibers und des Toolkits durch den Operator deaktivieren, da diese bereits im AMI enthalten sind. Die EKS-optimized AL2023 NVIDIA-AMIs enthalten weder das NVIDIA Kubernetes-Geräte-Plugin noch den NVIDIA DRA-Treiber und müssen separat installiert werden.
+ Jede `p6e-gb200.36xlarge` Instanz kann mit bis zu 17 Netzwerkkarten konfiguriert werden und EFA für die Kommunikation zwischen den Instanzen nutzen. UltraServers Der Netzwerkverkehr kann Workloads durchqueren UltraServers, aber für eine optimale Leistung wird empfohlen, Workloads nach demselben Schema zu planen und dabei IMEX für die GPU-interne Kommunikation zu UltraServer nutzen. UltraServer Weitere Informationen finden Sie unter [EFA-Konfiguration](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-acc-inst-types.html#efa-for-p6e) für Instances. P6e-GB200
+ Jede `p6e-gb200.36xlarge` Instance verfügt über 3 x 7,5 TB [Instance-Speicher](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/InstanceStorage.html). Standardmäßig formatiert und mountet das EKS-optimized AMI die Instance-Speicher nicht. Der kurzlebige Speicher des Knotens kann von Pods gemeinsam genutzt werden, die kurzlebigen Speicher anfordern, und von Container-Images, die auf den Knoten heruntergeladen werden. Wenn Sie das AL2023 EKS-optimized AMI verwenden, kann dies als Teil des Knoten-Bootstraps in den Benutzerdaten konfiguriert werden, indem die lokale Speicherrichtlinie der Instanz [NodeConfig](https://docs.aws.amazon.com/eks/latest/eksctl/node-bootstrapping.html#configuring-the-bootstrapping-process)auf RAID0 gesetzt wird. Die Einstellung auf RAID0 verteilt die Instance, speichert und konfiguriert die Container-Runtime und das Kubelet, um diesen kurzlebigen Speicher zu nutzen.
## Komponenten
Die folgenden Komponenten werden für die Ausführung von Workloads auf EKS mit dem empfohlen. P6e-GB200 UltraServers Sie können optional den [NVIDIA-GPU-Operator](https://docs.nvidia.com/datacenter/cloud-native/gpu-operator/latest/overview.html) verwenden, um die NVIDIA-Knotenkomponenten zu installieren. Wenn Sie den NVIDIA-GPU-Operator mit dem EKS-optimized AL2023 NVIDIA AMI verwenden, müssen Sie die Installation des Treibers und des Toolkits durch den Operator deaktivieren, da diese bereits im AMI enthalten sind.
- ** EKS-optimized beschleunigtes AMI **
- Kernel 6.12
- NVIDIA-GPU-Treiber
- NVIDIA CUDA-Benutzermodus-Treiber
- NVIDIA-Container-Toolkit
- NVIDIA-Fabric-Manager
- NVIDIA IMEX-Treiber
- NVIDIA NVLink Subnetzmanager
- EFA-Treiber
- ** Komponenten, die auf dem Knoten ausgeführt werden **
- VPC CNI
- EFA-DRA-Treiber oder EFA-Geräte-Plugin
- NVIDIA K8s-Geräte-Plugin
- NVIDIA DRA-Treiber
- Erkennung von NVIDIA-Knotenfunktionen (NFD)
- Erkennung von NVIDIA-GPU-Features (GFD)
Die Knotenkomponenten in der obigen Tabelle erfüllen die folgenden Funktionen:
+ **VPC CNI**: Weist VPC-IPs als primäre Netzwerkschnittstelle für Pods zu, die auf EKS ausgeführt werden
+ **EFA-DRA-Treiber oder EFA-Geräte-Plugin: Weist EFA-Geräte als** sekundäre Netzwerke für Pods zu, die auf EKS ausgeführt werden. Verantwortlich für den Netzwerkverkehr zwischen. P6e-GB200 UltraServers Bei Workloads mit mehreren Knoten UltraServer kann der GPU-to-GPU Datenverkehr innerhalb eines Systems über NVLink mit mehreren Knoten fließen. Der EFA-DRA-Treiber wird für Kubernetes 1.34 und höher empfohlen und ermöglicht eine topologieorientierte Zuweisung und gemeinsame Nutzung von Geräten. Das EFA-Geräte-Plugin wird für alle Kubernetes-Versionen unterstützt. Weitere Informationen finden Sie unter [EFA-Geräte auf Amazon EKS verwalten](device-management-efa.md).
+ **NVIDIA Kubernetes-Geräte-Plugin**: Weist GPUs als Geräte für Pods zu, die auf EKS ausgeführt werden. Es wird empfohlen, das NVIDIA Kubernetes-Geräte-Plugin zu verwenden, bis die GPU-Zuweisungsfunktion des NVIDIA DRA-Treibers den experimentellen Status erreicht hat. Aktuelle Informationen finden Sie in den [NVIDIA-DRA-Treiberversionen](https://github.com/kubernetes-sigs/nvidia-dra-driver-gpu/releases).
+ **NVIDIA-DRA-Treiber**: Ermöglicht ComputeDomain benutzerdefinierte Ressourcen, die die Erstellung von IMEX-Domänen erleichtern, die Workloads folgen, auf denen ausgeführt wird. P6e-GB200 UltraServers
+ Die ComputeDomain Ressource beschreibt eine IMEX-Domäne (Internode Memory Exchange). Wenn Workloads mit einem ResourceClaim for a auf dem Cluster bereitgestellt ComputeDomain werden, erstellt der NVIDIA DRA-Treiber automatisch ein IMEX, DaemonSet das auf passenden Knoten ausgeführt wird, und richtet die IMEX-Kanäle zwischen den Knoten ein, bevor der Workload gestartet wird. Weitere Informationen zu IMEX finden Sie in [der Übersicht über NVIDIA IMEX](https://docs.nvidia.com/multi-node-nvlink-systems/imex-guide/overview.html) für NVLink-Systeme mit mehreren Knoten.
+ Der NVIDIA-DRA-Treiber verwendet ein von NVIDIA GFD angewendetes Clique-ID-Label (`nvidia.com/gpu.clique`), das das Wissen über die Netzwerktopologie und die NVLink-Domäne weitergibt.
+ Es hat sich bewährt, einen Job pro Workload zu erstellen. ComputeDomain
+ **NVIDIA Node Feature Discovery (NFD)**: Erforderliche Abhängigkeit für GFD, um Knotenbezeichnungen auf der Grundlage der erkannten Attribute auf Knotenebene anzuwenden.
+ **NVIDIA GPU Feature Discovery (GFD)**: Wendet ein NVIDIA-Standard-Topologie-Label an, das auf die Knoten aufgerufen wird. `nvidia.com/gpu.clique` Knoten innerhalb derselben Gruppe `nvidia.com/gpu.clique` haben mehrere Knoten NVLink-reachability, und Sie können Pod-Affinitäten in Ihrer Anwendung verwenden, um Pods für dieselbe NVLink-Domäne einzuplanen.
## Verfahren
Im folgenden Abschnitt wird davon ausgegangen, dass Sie über einen EKS-Cluster verfügen, auf dem Kubernetes Version 1.33 oder höher ausgeführt wird, mit einer oder mehreren Knotengruppen, auf P6e-GB200 UltraServers denen das AL2023 ARM NVIDIA Accelerated AMI ausgeführt wird. EKS-optimized Die erforderlichen Schritte [Rechenressourcen für AI/ML Workloads auf Amazon EKS verwalten](ml-compute-management.md) für selbstverwaltete EKS-Knoten und verwaltete Knotengruppen finden Sie unter den Links unter.
Das folgende Verfahren verwendet die folgenden Komponenten.
| Name | Version | Description |
| --- | --- | --- |
| NVIDIA-GPU-Betreiber | 25.3.4\+ | Für das Lebenszyklusmanagement erforderlicher Plugins wie das NVIDIA Kubernetes-Geräte-Plugin und. NFD/GFD |
| NVIDIA DRA-Treiber | 25.8.0 oder höher | Für ComputeDomain CRDs und IMEX-Domainmanagement. |
| EFA-DRA-Treiber (DRANET) | Neueste | Für die übergreifende UltraServer Kommunikation mit topologieorientierter Zuordnung. Empfohlen für Kubernetes 1.34\+. |
| EFA-Geräte-Plugin | 0.5.14\+ | Für die übergreifende Kommunikation. UltraServer Wird für alle Kubernetes-Versionen unterstützt. |
## Installieren Sie den NVIDIA GPU-Operator
Der NVIDIA-GPU-Operator vereinfacht die Verwaltung der Komponenten, die für die Verwendung von GPUs in Kubernetes-Clustern erforderlich sind. Da der NVIDIA-GPU-Treiber und das Container-Toolkit als Teil des EKS-optimized beschleunigten AMI installiert werden, müssen diese `false` in der Helm-Wertekonfiguration auf eingestellt werden.
1. 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
```
1. 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
```
## Installieren Sie den NVIDIA DRA-Treiber
Ab der NVIDIA-GPU-Operatorversion `v25.3.4` muss der NVIDIA-DRA-Treiber separat installiert werden. Es wird empfohlen, die [Versionshinweise](https://github.com/NVIDIA/gpu-operator/releases) zum NVIDIA-GPU-Operator zu lesen, da sich dies in einer future Version ändern kann.
1. Erstellen Sie eine Helm-Wertedatei `dra-values.yaml` mit dem Namen der folgenden Konfiguration. Beachten Sie das `nodeAffinity` und `tolerations` das konfiguriert den DRA-Treiber so, 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
```
1. 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
```
1. Nach der Installation erstellt der DRA-Treiber `DeviceClass` Ressourcen, die es Kubernetes ermöglichen, Ressourcen zu verstehen und zuzuweisen`ComputeDomain`, sodass das IMEX-Management 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
```
## Installieren Sie EFA für die übergreifende Kommunikation UltraServer
Um die EFA-Kommunikation zwischen zu nutzen UltraServers, installieren Sie den EFA-DRA-Treiber (DRANET) oder das EFA-Geräte-Plugin. P6e-GB200 Instanzen können mit bis zu [17 Netzwerkkarten](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-acc-inst-types.html#efa-for-p6e) konfiguriert werden, und das primäre NCI (Index 0) muss vom Typ sein `interface` und bis zu 100 Gbit/s ENA-Bandbreite unterstützen. Konfigurieren Sie Ihre EFA- und ENA-Schnittstellen bei der Knotenbereitstellung gemäß Ihren Anforderungen. Weitere Informationen zur [EFA-Konfiguration finden Sie in der AWS Dokumentation zur EFA-Konfiguration für P6e-GB200 Instances](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-acc-inst-types.html#efa-for-p6e).
**Wichtig**
Installieren Sie den EFA-DRA-Treiber und das EFA-Geräte-Plug-In nicht auf demselben Knoten. Die beiden Mechanismen können nicht gleichzeitig auf demselben Knoten existieren.
### Option 1: Installieren Sie den EFA-DRA-Treiber (DRANET)
1. Erstellen Sie eine Helm-Wertedatei `efa-values.yaml` mit dem Namen der folgenden Konfiguration.
```
tolerations:
- key: nvidia.com/gpu
operator: Exists
effect: NoSchedule
```
1. 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
```
1. 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 60s
```
1. 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
```
Weitere Informationen zur Verwendung des EFA-DRA-Treibers, einschließlich topologieorientierter Zuweisung und Gerätefreigabe, finden Sie unter. [EFA-Geräte auf Amazon EKS verwalten](device-management-efa.md)
### Option 2: Installieren Sie das EFA-Geräte-Plugin
1. Erstellen Sie eine Helm-Wertedatei `efa-values.yaml` mit dem Namen der folgenden Konfiguration.
```
tolerations:
- key: nvidia.com/gpu
operator: Exists
effect: NoSchedule
```
1. 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
```
1. 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 60s
```
1. Stellen Sie sicher, dass Ihren Knoten EFA-Geräte zugewiesen werden können. Wenn Sie Ihre Instances beispielsweise mit einer reinen EFA-Schnittstelle in jeder [NCI-Gruppe](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-acc-inst-types.html#efa-for-p6e) konfiguriert haben, wird davon ausgegangen, dass pro Knoten 4 zuweisbare EFA-Geräte vorhanden sind.
```
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
```
## Multi-Node Validieren Sie IMEX über NVLink
[Einen NVLINK-NCCL-Test mit mehreren Knoten und andere Mikrobenchmarks finden Sie im Awesome-Distributed-Training Repository.](https://github.com/aws-samples/awsome-distributed-training/tree/main/micro-benchmarks/nccl-tests) GitHub Die folgenden Schritte zeigen, wie Sie einen NVLink-Test mit mehreren Knoten mit nvbandwidth durchführen.
1. 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
```
1. Erstellen Sie eine Datei mit dem Namen`nvbandwidth-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 NVLink-Erreichbarkeit bietet Multi-Node . Im folgenden Beispiel wird ein CE-Read-Memcpy-Test mit mehreren Knoten von Gerät zu Gerät unter Verwendung von cu ausgeführt und die Ergebnisse werden 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 Informationen zu Updates finden Sie in den neuesten [Versionshinweisen zum NVIDIA DRA-Treiber](https://github.com/kubernetes-sigs/nvidia-dra-driver-gpu/releases).
Pro Knoten kann es nur einen ComputeDomain (IMEX-Kanal) geben. Ändern Sie nicht die Adresse `All` für `allocationMode` die ComputeDomain Ressource, da dies verhindern kann, dass die ComputeDomain und Pods, die auf diese Ressource ComputeDomain zugreifen, korrekt zugewiesen und geplant werden. Weitere Informationen finden Sie unter [Ausgabe \#353 des NVIDIA-DRA-Treibers](https://github.com/kubernetes-sigs/dra-driver-nvidia-gpu/issues/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
```
\+. ComputeDomain Bei der Erstellung können Sie sehen, dass der Workload zwei Knoten ComputeDomain hat:
\+
```
kubectl get computedomains.resource.nvidia.com -o yaml
```
\+
```
status:
nodes:
- cliqueID: .
ipAddress:
name:
- cliqueID: .
ipAddress:
name:
status: Ready
```
\+. Überprüfen Sie die Ergebnisse des Jobs mit dem folgenden Befehl.
\+
```
kubectl logs --tail=-1 -l job-name=nvbandwidth-test-launcher
```
\+ Ein erfolgreicher Test zeigt Bandbreitenstatistiken GB/s für den Memcpy-Test mit mehreren Knoten. 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
```