Instanztypen mit EFA EFA- und reine EFA-Schnittstellen Voraussetzungen Knotengruppen erstellen (Optional) Testen Sie die Leistung der EFA

Helfen Sie mit, diese Seite zu verbessern

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.

Möchten Sie zu diesem Benutzerhandbuch beitragen? Wählen Sie den GitHub Link Diese Seite bearbeiten auf, der sich im rechten Bereich jeder Seite befindet. Ihre Beiträge werden dazu beitragen, dass unser Benutzerhandbuch für alle besser wird.

Führen Sie Schulungen zum maschinellen Lernen auf Amazon EKS durch mit Elastic Fabric Adapter

In diesem Thema wird beschrieben, wie der Elastic Fabric Adapter (EFA) integriert wird mit Pods in Ihrem Amazon EKS-Cluster bereitgestellt. Elastic Fabric Adapter (EFA) ist eine Netzwerkschnittstelle für EC2 Amazon-Instances, mit der Sie Anwendungen ausführen können, die ein hohes Maß an Kommunikation zwischen Knoten erfordern, in großem Umfang. AWS Die speziell für die Umgehung von Betriebssystemen entwickelte Hardware-Schnittstelle verbessert die Leistung der Instance-übergreifenden Kommunikation, was für die Skalierung dieser Anwendungen von entscheidender Bedeutung ist. Mit EFA können High Performance Computing (HPC) -Anwendungen, die das Message Passing Interface (MPI) und Machine Learning (ML) -Anwendungen verwenden, die die NVIDIA Collective Communications Library (NCCL) verwenden, auf Tausende von oder skalieren. CPUs GPUs Dadurch erhalten Sie die Anwendungsleistung von lokalen HPC-Clustern mit der On-Demand-Elastizität und Flexibilität der Cloud. AWS Durch die Integration von EFA in Anwendungen, die auf Amazon-EKS-Clustern ausgeführt werden, können Sie die Zeit für die Durchführung umfangreicher verteilter Schulungs-Workloads verkürzen, ohne dass zusätzliche Instances zu Ihrem Cluster hinzugefügt werden müssen. Weitere Informationen zu EFA finden Sie unter Elastic Fabric Adapter.

Instanztypen mit EFA

Das AWS EFA Kubernetes Device Plugin unterstützt alle EC2 Amazon-Instance-Typen, die EFA haben. Eine Liste aller Instance-Typen mit EFA finden Sie unter Unterstützte Instance-Typen im EC2 Amazon-Benutzerhandbuch. Um ML-Anwendungen schnell ausführen zu können, empfehlen wir jedoch, dass eine Instance über Hardwarebeschleunigungs-Chips verfügt, wie nVidia GPUs, AWS Inferentia-Chips oder AWS Trainium-Chips zusätzlich zu den EFA. Eine Liste der Instance-Typen mit Hardwarebeschleunigungschips und EFA finden Sie unter Accelerated Computing im EC2 Amazon-Benutzerhandbuch.

Wenn Sie Instance-Typen vergleichen, um zwischen ihnen zu wählen, sollten Sie die Anzahl der für diesen Instance-Typ verfügbaren EFA-Netzwerkkarten sowie die Anzahl der Beschleunigerkarten, die CPU-Menge und die Speichermenge berücksichtigen. Sie können bis zu einem EFA pro Netzwerkkarte zuweisen. Eine EFA zählt als Netzwerkschnittstelle. Wie viele EFA für jeden Instance-Typ mit EFA verfügbar sind, finden Sie in der Liste der Netzwerkkarten im EC2 Amazon-Benutzerhandbuch.

EFA- und reine EFA-Schnittstellen

Ein Elastic Fabric Adapter (EFA) ist eine Netzwerkschnittstelle, die die Funktionen eines Elastic Network Adapters (ENA) und einer OS-Bypass-Schnittstelle kombiniert und auf dem Scalable AWS Reliable Datagram (SRD) -Protokoll basiert. Die EFA-Funktionen ermöglichen es Anwendungen, direkt mit der Hardware zu kommunizieren, um eine Übertragung mit niedriger Latenz zu gewährleisten. Sie können sich dafür entscheiden, nur über reine EFA-Schnittstellen auf die EFA-Funktionen zuzugreifen und so die Kommunikation auf Schnittstellen innerhalb derselben Availability Zone zu beschränken.

Um Knoten zu erstellen, die nur über EFA-Schnittstellen verfügen können, müssen Sie eine benutzerdefinierte EC2 Startvorlage verwenden und den Wert auf setzen. InterfaceType efa-only In Ihrer benutzerdefinierten Startvorlage können Sie die Netzwerkkarte nicht 0 auf eine reine EFA-Schnittstelle festlegen, da dies die primäre Netzwerkkarte und Netzwerkschnittstelle der Instance ist. EC2 Für reine EFA-Schnittstellen benötigen Sie die VPC CNI-Version 1.18.5 oder höher. Wenn Sie Amazon Linux 2 verwenden, muss die ami-Version v20240928 oder höher für reine EFA-Schnittstellen sein.

Das folgende Verfahren führt Sie zur Erstellung eines EKS-Clusters eksctl mit Knoten, die nVidia GPUs und EFA-Schnittstellen. Sie können eksctl damit keine Knoten und Knotengruppen erstellen, die reine EFA-Schnittstellen verwenden.

Voraussetzungen

Ein vorhandener Amazon-EKS-Cluster. Wenn Sie noch keinen Cluster haben, erstellen Sie einen mit.. Erste Schritte mit Amazon EKS Ihr Cluster muss in einer VPC bereitgestellt werden, in der mindestens ein privates Subnetz mit genügend verfügbaren IP-Adressen zum Bereitstellen von Knoten vorhanden sind. Das private Subnetz muss über einen ausgehenden Internetzugang verfügen, der von einem externen Gerät, z. B. einem NAT-Gateway, bereitgestellt wird.

Wenn Sie planen, eksctl zu verwenden, um Ihre Knotengruppe zu erstellen, kann eksctl auch einen Cluster für Sie erstellen.
Version 2.12.3 oder höher oder Version 1.27.160 oder höher der auf Ihrem Gerät installierten und konfigurierten AWS Befehlszeilenschnittstelle (AWS CLI) oder AWS CloudShell. Um Ihre aktuelle Version zu überprüfen, verwenden Sie aws --version | cut -d / -f2 | cut -d ' ' -f1. Paketmanager wieyum,apt-get, oder Homebrew for macOS liegen oft mehrere Versionen hinter der neuesten Version der AWS CLI. Informationen zur Installation der neuesten Version finden Sie unter Installation und Schnellkonfiguration mit aws configure im Benutzerhandbuch für die AWS Befehlszeilenschnittstelle. Die AWS CLI-Version, in der installiert ist, AWS CloudShell kann auch mehrere Versionen hinter der neuesten Version liegen. Informationen zur Aktualisierung finden Sie im AWS CloudShell Benutzerhandbuch unter AWS CLI in Ihrem Home-Verzeichnis installieren.
Das kubectl-Befehlszeilen-Tool ist auf Ihrem Gerät oder in der AWS CloudShell installiert. Bei der Version kann es sich um dieselbe oder nur um eine Nebenversion handeln, die früher oder später als die Kubernetes Version Ihres Clusters. Wenn Ihre Clusterversion beispielsweise 1.29 ist, können Sie kubectl-Version 1.28, 1.29, oder 1.30 damit verwenden. Informationen zum Installieren oder Aktualisieren von kubectl finden Sie unter Einrichten kubectl und eksctl.
Sie müssen die haben Amazon VPC CNI plugin for Kubernetes Version 1.7.10 oder höher installiert, bevor Worker-Knoten gestartet werden, die mehrere Elastic Fabric-Adapter unterstützen, wie z. B. p4d oderp5. Weitere Informationen zur Aktualisierung Ihres Amazon VPC CNI plugin for Kubernetes Version, sieheZuweisen IPs zu Pods mit dem Amazon VPC CNI.

Wichtig

Eine wichtige Überlegung, die für die Einführung von EFA erforderlich ist Kubernetes konfiguriert und verwaltet Huge Pages als Ressource im Cluster. Weitere Informationen finden Sie unter Riesige Seiten verwalten im Kubernetes -Dokumentation. EC2 Amazon-Instances, auf denen der EFA-Treiber installiert ist, weisen 5128 Huge Pages mit 2 MiB vorab zu, die Sie als Ressourcen anfordern können, die Sie in Ihren Jobspezifikationen nutzen können.

Knotengruppen erstellen

Das folgende Verfahren hilft Ihnen dabei, eine Knotengruppe mit einer p4d.24xlarge gesicherten Knotengruppe mit EFA-Schnittstellen und GPUDirect RDMA zu erstellen und einen Beispieltest der NVIDIA Collective Communications Library (NCCL) für die NCCL-Leistung mit mehreren Knoten durchzuführen. EFAs Das Beispiel kann als Vorlage für verteiltes Deep-Learning-Training auf Amazon EKS verwendet EFAs werden.

Ermitteln Sie, welche EC2 Amazon-Instance-Typen, die EFA unterstützen, in der AWS Region verfügbar sind, in der Sie Knoten bereitstellen möchten. region-codeErsetzen Sie es durch die AWS Region, in der Sie Ihre Knotengruppe bereitstellen möchten.
```
aws ec2 describe-instance-types --region region-code \
    --filters Name=network-info.efa-supported,Values=true \
    --query "InstanceTypes[*].[InstanceType]" --output text
```
Wenn Sie Knoten bereitstellen, muss der Instance-Typ, den Sie bereitstellen möchten, in der AWS Region verfügbar sein, in der sich Ihr Cluster befindet.
Bestimmen Sie, in welchen Availability Zones der Instance-Typ bereitgestellt werden soll. In diesem Tutorial wird der p5.48xlarge Instance-Typ verwendet und muss in der Ausgabe für die AWS Region zurückgegeben werden, die Sie im vorherigen Schritt angegeben haben. Wenn Sie Knoten in einem Produktionscluster bereitstellen, p5.48xlarge ersetzen Sie ihn durch einen beliebigen Instance-Typ, der im vorherigen Schritt zurückgegeben wurde.
```
aws ec2 describe-instance-type-offerings --region region-code \
    --location-type availability-zone --filters Name=instance-type,Values=p4d.24xlarge,p5.48xlarge \
    --query 'InstanceTypeOfferings[*].Location' --output text
```
Eine Beispielausgabe sieht wie folgt aus.
```
us-west-2a    us-west-2c    us-west-2b
```
Beachten Sie, dass Availability Zones zur Verwendung in späteren Schritten zurückgegeben wurden Wenn Sie Knoten in einem Cluster bereitstellen, muss Ihre VPC über Subnetze mit verfügbaren IP-Adressen in einer der in der Ausgabe zurückgegebenen Availability Zones verfügen.
Erstellen Sie eine Knotengruppe miteksctl. Sie benötigen eine Version 0.199.0 oder höher des eksctl Befehlszeilentools, das auf Ihrem Gerät installiert ist oder AWS CloudShell. Informationen zum Installieren und Aktualisieren von eksctl finden Sie in der Dokumentation zu eksctl unter Installation.
1. Kopieren Sie den folgenden Inhalt in eine Datei namens efa-cluster.yaml. Ersetzen Sie das example values durch Ihr eigenes. Sie können p5.48xlarge mit einer anderen Instance ersetzen. Wenn Sie dies tun, stellen Sie sicher, dass die Werte für availabilityZones Availability Zones sind, die in Schritt 1 für den Instance-Typ zurückgegeben wurden.
```
apiVersion: eksctl.io/v1alpha5
kind: ClusterConfig

metadata:
  name: my-efa-cluster
  region: region-code
  version: "1.XX"

iam:
  withOIDC: true

availabilityZones: ["us-west-2a", "us-west-2c"]

managedNodeGroups:
  - name: my-efa-ng
    instanceType: p5.48xlarge
    minSize: 1
    desiredCapacity: 2
    maxSize: 3
    availabilityZones: ["us-west-2a"]
    volumeSize: 300
    privateNetworking: true
    efaEnabled: true
```
2. Erstellen einer verwalteten Knotengruppe in einem bestehenden Cluster
```
eksctl create nodegroup -f efa-cluster.yaml
```
  Wenn Sie noch keinen Cluster haben, können Sie den folgenden Befehl ausführen, um einen Cluster und die Knotengruppe zu erstellen.
```
eksctl create cluster -f efa-cluster.yaml
```
  Anmerkung
  Da der in diesem Beispiel verwendete Instanztyp dies getan hat GPUs, installiert eksctl automatisch das NVIDIA Kubernetes-Geräte-Plug-In auf jeder Instanz für Sie.
Stellen Sie das EFA Kubernetes Geräte-Plugin bereit.

Das EFA Kubernetes Geräte-Plugin erkennt und bewirbt EFA-Schnittstellen als zuweisbare Ressourcen für Kubernetes. Eine Anwendung kann den erweiterten Ressourcentyp vpc.amazonaws.com/efa in einem Pod Anforderungsspezifikationen genau wie CPU und Speicher. Weitere Informationen finden Sie unter Nutzung erweiterter Ressourcen in der Kubernetes -Dokumentation. Nach der Anfrage weist das Plugin dem automatisch eine EFA-Schnittstelle zu und bindet sie ein Pod. Die Verwendung des Geräte-Plugins vereinfacht die EFA-Einrichtung und erfordert keine Pod um im privilegierten Modus zu laufen.
```
helm repo add eks https://aws.github.io/eks-charts
helm install aws-efa-k8s-device-plugin --namespace kube-system eks/aws-efa-k8s-device-plugin
```

(Optional) Testen Sie die Leistung der EFA

Wir empfehlen Ihnen, das EFA-Setup zu testen. Sie können die NCCL-Tests im Repository am aws-samples/awsome-distributed-training verwenden. GitHub NCCL-Tests bewerten die Leistung des Netzwerks mithilfe der Nvidia Collective Communication Library. Mit den folgenden Schritten werden NCCL-Tests auf Amazon EKS eingereicht.

Stellen Sie den Kubeflow MPI Operator bereit:

Für die NCCL-Tests können Sie den Kubeflow MPI Operator anwenden. Der MPI Operator macht es einfach, auf Kubernetes verteiltes Training im Allreduce-Stil durchzuführen. Weitere Informationen finden Sie unter MPI-Operator auf GitHub.

Führen Sie den NCCL-Leistungstest mit mehreren Knoten aus, um RDMA/EFA zu überprüfen: GPUDirect

Um die NCCL-Leistung zu überprüfen mit GPUDirectRDMA Führen Sie über EFA den standardmäßigen NCCL-Leistungstest aus. Weitere Informationen finden Sie im offiziellen NCCL-Tests-Repo unter GitHub.

Gehen Sie wie folgt vor, um einen Zweiknotenbetrieb auszuführen NCCL Performance Test. Im Beispiel NCCL Bei einem Testjob fordert jeder Worker acht GPUs, 5210 Mi hugepages-2Mi EFAs, vier und 8000 Mi Arbeitsspeicher an, was praktisch bedeutet, dass jeder Worker alle Ressourcen einer Instanz verbraucht. p5.48xlarge

Erstellen Sie das Manifest: MPIJob

Kopieren Sie Folgendes in eine Datei mit dem Namennccl-tests.yaml:


apiVersion: kubeflow.org/v2beta1
kind: MPIJob
metadata:
  name: nccl-tests
spec:
  runPolicy:
    cleanPodPolicy: Running
    backoffLimit: 20
  slotsPerWorker: 8
  mpiReplicaSpecs:
    Launcher:
      replicas: 1
      template:
         spec:
          restartPolicy: OnFailure
          containers:
          - image: public.ecr.aws/hpc-cloud/nccl-tests:latest
            imagePullPolicy: IfNotPresent
            name: test-nccl-launcher
            env:
             - name: PATH
               value: $PATH:/opt/amazon/efa/bin:/usr/bin
             - name: LD_LIBRARY_PATH
               value: /opt/amazon/openmpi/lib:/opt/nccl/build/lib:/opt/amazon/efa/lib:/opt/aws-ofi-nccl/install/lib:/usr/local/nvidia/lib:$LD_LIBRARY_PATH
             - name: NCCL_DEBUG
               value: INFO
             - name: NCCL_BUFFSIZE
               value: '8388608'
             - name: NCCL_P2P_NET_CHUNKSIZE
               value: '524288'
             - name: NCCL_TUNER_PLUGIN
               value: /opt/aws-ofi-nccl/install/lib/libnccl-ofi-tuner.so
            command:
            - /opt/amazon/openmpi/bin/mpirun
            - --allow-run-as-root
            - --tag-output
            - -np
            - "16"
            - -N
            - "8"
            - --bind-to
            - none
            - -x
            - PATH
            - -x
            - LD_LIBRARY_PATH
            - -x
            - NCCL_DEBUG=INFO
            - -x
            - NCCL_BUFFSIZE
            - -x
            - NCCL_P2P_NET_CHUNKSIZE
            - -x
            - NCCL_TUNER_PLUGIN
            - --mca
            - pml
            - ^cm,ucx
            - --mca
            - btl
            - tcp,self
            - --mca
            - btl_tcp_if_exclude
            - lo,docker0,veth_def_agent
            - /opt/nccl-tests/build/all_reduce_perf
            - -b
            - "8"
            - -e
            - "16G"
            - -f
            - "2"
            - -g
            - "1"
            - -c
            - "1"
            - -n
            - "100"
    Worker:
      replicas: 2
      template:
        spec:
          nodeSelector:
            node.kubernetes.io/instance-type: "p5.48xlarge"
          containers:
          - image: public.ecr.aws/hpc-cloud/nccl-tests:latest
            imagePullPolicy: IfNotPresent
            name: nccl-tests-worker
            volumeMounts:
            - name: shmem
              mountPath: /dev/shm
            resources:
              limits:
                nvidia.com/gpu: 8
                hugepages-2Mi: 5120Mi
                vpc.amazonaws.com/efa: 32
                memory: 32000Mi
              requests:
                nvidia.com/gpu: 8
                hugepages-2Mi: 5120Mi
                vpc.amazonaws.com/efa: 32
                memory: 32000Mi
          volumes:
          - name: shmem
            hostPath:
              path: /dev/shm

Wenden Sie die NCCL-Tests MPIJob an:

Reichen Sie das ein, MPIJob indem Sie das Manifest anwenden. Dadurch werden zwei p5.48xlarge EC2 Amazon-Instances erstellt.
```
kubectl apply -f nccl-tests.yaml
```
Eine Beispielausgabe sieht wie folgt aus.
```
mpijob.kubeflow.org/nccl-tests created
```

Stellen Sie sicher, dass der Job Pods gestartet hat:

Sehen Sie sich Ihren Lauf an Pods.


kubectl get pods

Eine Beispielausgabe sieht wie folgt aus.


NAME                             READY   STATUS     RESTARTS   AGE
nccl-tests-launcher-nbql9    0/1     Init:0/1   0          2m49s
nccl-tests-worker-0          1/1     Running    0          2m49s
nccl-tests-worker-1          1/1     Running    0          2m49s

Der MPI Operator erstellt einen Launcher Pod und 2 Arbeiter Pods (einer auf jedem Knoten).

Stellen Sie anhand der Protokolle sicher, dass der Job erfolgreich ausgeführt wird:

Sehen Sie sich das Protokoll für den an nccl-tests-launcher Pod. Ersetze es nbql9 durch den Wert aus deiner Ausgabe.
```
kubectl logs -f nccl-tests-launcher-nbql9
```

Wenn der Test erfolgreich abgeschlossen wurde, können Sie Ihre Anwendungen bereitstellen, die Nvidia Collective Communication Library.

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Verfälschen Sie GPU-Knoten

Bereiten Sie Inferentia-Cluster vor