Types d'instances avec EFA Interfaces EFA et EFA uniquement Prérequis Créer un groupe de nœuds (Facultatif) Testez les performances de l'EFA

Aidez à améliorer cette page

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Vous souhaitez contribuer à ce guide de l'utilisateur ? Choisissez le GitHub lien Modifier cette page sur qui se trouve dans le volet droit de chaque page. Vos contributions aideront à améliorer notre guide de l'utilisateur pour tout le monde.

Organisez une formation de machine learning sur Amazon EKS avec Elastic Fabric Adapter

Cette rubrique décrit comment intégrer Elastic Fabric Adapter (EFA) à Pods déployé dans votre cluster Amazon EKS. Elastic Fabric Adapter (EFA) est une interface réseau pour les instances EC2 Amazon qui vous permet d'exécuter des applications nécessitant des niveaux élevés de communications entre nœuds à grande échelle. AWS Son interface matérielle sur mesure de contournement du système d'exploitation améliore les performances des communications entre instances, ce qui est essentiel à la mise à l'échelle de ces applications. Avec EFA, les applications de calcul à haute performance (HPC) utilisant l'interface MPI (Message Passing Interface) et les applications Machine Learning (ML) utilisant la bibliothèque de communications collectives (NCCL) de NVIDIA peuvent atteindre des milliers de ou. CPUs GPUs Vous bénéficiez ainsi des performances applicatives des clusters HPC sur site avec l'élasticité et la flexibilité à la demande du AWS cloud. L'intégration d'EFA aux applications exécutées sur des clusters Amazon EKS permet de réduire le temps nécessaire à l'exécution des applications d'entraînement distribué à grande échelle sans avoir à ajouter d'autres instances à votre cluster. Pour plus d'informations sur l'EFA, consultez Elastic Fabric Adapter.

Types d'instances avec EFA

Le plugin AWS EFA Kubernetes Device prend en charge tous les types d' EC2 instances Amazon dotés d'EFA. Pour consulter la liste de tous les types d'instances dotés de l'EFA, consultez la section Types d'instances pris en charge dans le guide de EC2 l'utilisateur Amazon. Toutefois, pour exécuter rapidement des applications ML, nous recommandons qu'une instance dispose de puces d'accélération matérielle telles que nVidia GPUs, des puces AWS Inferentia ou des puces AWS Trainium, en plus de l'EFA. Pour consulter la liste des types d'instances dotés de puces d'accélération matérielle et d'EFA, consultez la section Accelerated computing dans le guide de EC2 l'utilisateur Amazon.

Lorsque vous comparez les types d'instance pour choisir entre eux, prenez en compte le nombre de cartes réseau EFA disponibles pour ce type d'instance ainsi que le nombre de cartes accélératrices, la quantité de processeur et la quantité de mémoire. Vous pouvez attribuer un EFA maximum par carte réseau. Un EFA est considéré comme une interface réseau. Pour savoir combien d'EFA sont disponibles pour chaque type d'instance doté d'EFA, consultez la liste des cartes réseau dans le guide de EC2 l'utilisateur Amazon.

Interfaces EFA et EFA uniquement

Un Elastic Fabric Adapter (EFA) est une interface réseau qui combine les fonctionnalités d'un adaptateur réseau élastique (ENA) et d'une interface de contournement du système d'exploitation, alimentée par AWS le protocole Scalable Reliable Datagram (SRD). Les fonctionnalités EFA permettent aux applications de communiquer directement avec le matériel pour un transport à faible latence. Vous pouvez choisir d'accéder uniquement aux fonctionnalités EFA à l'aide d'interfaces EFA uniquement, en limitant les communications aux interfaces situées au sein de la même zone de disponibilité.

Pour créer des nœuds pouvant avoir des interfaces uniquement EFA, vous devez utiliser un modèle de EC2 lancement personnalisé et définir le paramètre sur. InterfaceType efa-only Dans votre modèle de lancement personnalisé, vous ne pouvez pas configurer la carte 0 réseau sur une interface uniquement EFA, car il s'agit de la carte réseau principale et de l'interface réseau de l'instance. EC2 Vous devez disposer de la version VPC CNI 1.18.5 ou d'une version ultérieure pour les interfaces EFA uniquement. Si vous utilisez Amazon Linux 2, la version ami doit être v20240928 ou ultérieure pour les interfaces EFA uniquement.

La procédure suivante vous guide pour créer un cluster EKS eksctl avec des nœuds qui ont nVidia GPUs et interfaces EFA. Vous ne pouvez pas l'utiliser eksctl pour créer des nœuds et des groupes de nœuds utilisant uniquement des interfaces EFA.

Prérequis

Un cluster Amazon EKS existant. Si vous n'avez pas de cluster existant, créez-en un à l'aide deMise en route avec Amazon EKS.. Votre cluster doit être déployé dans un VPC disposant d'au moins un sous-réseau privé ayant suffisamment d'adresses IP disponibles dans lequel déployer des nœuds. Le sous-réseau privé doit disposer d'un accès Internet sortant fourni par un appareil externe, tel qu'une passerelle NAT.

Si vous prévoyez d'utiliser eksctl pour créer votre groupe de nœuds, eksctl peut également créer un cluster pour vous.
Version 2.12.3 ou version ultérieure 1.27.160 ou version ultérieure de l'interface de ligne de AWS commande (AWS CLI) installée et configurée sur votre appareil ou AWS CloudShell. Pour vérifier votre version actuelle, utilisez aws --version | cut -d / -f2 | cut -d ' ' -f1. Des gestionnaires de packages tels que yumapt-get, ou Homebrew for macOS ont souvent plusieurs versions de retard sur la dernière version de la AWS CLI. Pour installer la dernière version, consultez la section Installation et configuration rapide avec aws configure dans le Guide de l'utilisateur de l'interface de ligne de AWS commande. La version de la AWS CLI installée AWS CloudShell peut également avoir plusieurs versions de retard par rapport à la dernière version. Pour le mettre à jour, consultez la section Installation de la AWS CLI dans votre répertoire de base dans le guide de AWS CloudShell l'utilisateur.
L'outil de ligne de commande kubectl est installé sur votre appareil ou AWS CloudShell. La version peut être identique ou supérieure à une version mineure antérieure ou ultérieure à Kubernetes version de votre cluster. Par exemple, si la version de votre cluster est 1.29, vous pouvez utiliser la version kubectl 1.28, 1.29 ou 1.30. Pour installer ou mettre à niveau kubectl, veuillez consulter Configurez kubectl et eksctl.
Vous devez avoir Amazon VPC CNI plugin for Kubernetes version 1.7.10 ou ultérieure installée avant le lancement de nœuds de travail prenant en charge plusieurs adaptateurs Elastic Fabric, tels que le p4d oup5. Pour plus d'informations sur la mise à jour de votre Amazon VPC CNI plugin for Kubernetes version, voirAttribuer IPs à Pods avec le Amazon VPC CNI.

Important

Une considération importante à prendre en compte pour adopter l'EFA avec Kubernetes est en train de configurer et de gérer Huge Pages en tant que ressource dans le cluster. Pour plus d'informations, consultez la section Gérer les pages volumineuses dans le Kubernetes . Les EC2 instances Amazon sur lesquelles le pilote EFA est installé préallouent 5 128 pages volumineuses de 2 Mo, que vous pouvez demander comme ressources à utiliser dans le cadre de vos spécifications de travail.

Créer un groupe de nœuds

La procédure suivante vous aide à créer un groupe de nœuds avec un groupe de nœuds p4d.24xlarge sauvegardé avec des interfaces EFA et GPUDirect RDMA, et à exécuter un exemple de test NVIDIA Collective Communications Library (NCCL) pour les performances NCCL multi-nœuds à l'aide de. EFAs L'exemple peut être utilisé comme modèle de formation en profondeur distribuée sur Amazon EKS à l'aide de EFAs.

Déterminez quels types d' EC2 instances Amazon prenant en charge l'EFA sont disponibles dans la AWS région dans laquelle vous souhaitez déployer des nœuds. region-codeRemplacez-le par la AWS région dans laquelle vous souhaitez déployer votre groupe de nœuds.
```
aws ec2 describe-instance-types --region region-code \
    --filters Name=network-info.efa-supported,Values=true \
    --query "InstanceTypes[*].[InstanceType]" --output text
```
Lorsque vous déployez des nœuds, le type d'instance que vous souhaitez déployer doit être disponible dans la AWS région dans laquelle se trouve votre cluster.
Déterminez dans quelles zones de disponibilité le type d'instance que vous souhaitez déployer est disponible. Dans ce didacticiel, le type d'p5.48xlargeinstance est utilisé et doit être renvoyé dans la sortie pour la AWS région que vous avez spécifiée à l'étape précédente. Lorsque vous déployez des nœuds dans un cluster de production, remplacez-les p5.48xlarge par n'importe quel type d'instance renvoyé à l'étape précédente.
```
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
```
L'exemple qui suit illustre un résultat.
```
us-west-2a    us-west-2c    us-west-2b
```
Notez les zones de disponibilité renvoyées pour une utilisation ultérieure. Lorsque vous déployez des nœuds sur un cluster, votre VPC doit disposer de sous-réseaux avec des adresses IP disponibles dans l'une des zones de disponibilité renvoyées dans la sortie.
Créez un groupe de nœuds à l'aide deeksctl. Vous avez besoin d'0.199.0une version ou d'une version ultérieure de l'outil de ligne de eksctl commande installée sur votre appareil ou AWS CloudShell. Pour installer ou mettre à jour eksctl, veuillez consulter Installation dans la documentation de eksctl.
1. Copiez le contenu suivant dans un fichier nommé efa-cluster.yaml. Remplacez les example values par vos propres valeurs. Vous pouvez remplacer p5.48xlarge par une instance différente. Dans ce cas, assurez-vous que les valeurs de availabilityZones sont des zones de disponibilité renvoyées pour le type d'instance à l'étape 1.
```
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. Créez un groupe de nœuds gérés dans un cluster existant.
```
eksctl create nodegroup -f efa-cluster.yaml
```
  Si vous n'avez pas de cluster existant, vous pouvez exécuter la commande suivante pour créer un cluster et le groupe de nœuds.
```
eksctl create cluster -f efa-cluster.yaml
```
  Note
  Comme le type d'instance utilisé dans cet exemple l'est GPUs, le plug-in de périphérique NVIDIA Kubernetes est eksctl automatiquement installé pour vous sur chaque instance.
Déployez le plugin de l'appareil EFA Kubernetes.

Le plugin de l'appareil EFA Kubernetes détecte et annonce les interfaces EFA comme ressources allouables à Kubernetes. Une application peut consommer le type de ressource étendu vpc.amazonaws.com/efa dans un Pod spécification de demande, tout comme le processeur et la mémoire. Pour plus d'informations, consultez la section Consommation de ressources étendues dans le Kubernetes . Une fois demandé, le plugin assigne et monte automatiquement une interface EFA au Pod. L'utilisation du plug-in de l'appareil simplifie la configuration de l'EFA et ne nécessite pas de Pod pour fonctionner en mode privilégié.
```
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
```

(Facultatif) Testez les performances de l'EFA

Nous vous recommandons de tester la configuration EFA. Vous pouvez utiliser les tests NCCL dans le aws-samples/awsome-distributed-training référentiel sur. GitHub Les tests NCCL évaluent les performances du réseau à l'aide de la bibliothèque de communication collective Nvidia. Les étapes suivantes soumettent les tests NCCL sur Amazon EKS.

Déployez l'opérateur MPI Kubeflow :

Pour les tests NCCL, vous pouvez appliquer l'opérateur MPI Kubeflow. L'opérateur MPI facilite l'exécution d'un entraînement distribué de style AllReduce sur Kubernetes. Pour plus d'informations, voir MPI Operator sur GitHub.

Exécutez le test de performance NCCL multi-nœuds pour vérifier le RDMA/EFA : GPUDirect

Pour vérifier les performances du NCCL avec GPUDirectRDMA sur EFA, exécutez le test de performance NCCL standard. Pour plus d'informations, consultez le dépôt officiel des tests NCCL sur GitHub.

Procédez comme suit pour exécuter un nœud à deux nœuds NCCL Performance Test. Dans l'exemple NCCL tâche de test, chaque travailleur demande huit GPUs, 5210 Mo hugepages-2Mi EFAs, quatre et 8 000 Mo de mémoire, ce qui signifie que chaque travailleur consomme toutes les ressources d'une instance. p5.48xlarge

Créez le MPIJob manifeste :

Copiez ce qui suit dans un fichier nommé nccl-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

Appliquez les tests NCCL : MPIJob

MPIJobSoumettez-les en appliquant le manifeste. Cela créera deux EC2 instances p5.48xlarge Amazon.
```
kubectl apply -f nccl-tests.yaml
```
L'exemple qui suit illustre un résultat.
```
mpijob.kubeflow.org/nccl-tests created
```

Vérifiez que le job a démarré :

Visualisez votre course Pods.


kubectl get pods

L'exemple qui suit illustre un résultat.


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

L'opérateur MPI crée un lanceur Pod et 2 travailleurs Pods (un sur chaque nœud).

Vérifiez que la tâche s'exécute correctement avec les journaux :

Consultez le journal du nccl-tests-launcher Pod. Remplacez nbql9 par la valeur de votre sortie.
```
kubectl logs -f nccl-tests-launcher-nbql9
```

Si le test est réussi, vous pouvez déployer vos applications qui utilisent le Nvidia Collective Communication Library.

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Nœuds GPU souillés

Préparer des clusters Inferentia