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.

# Démarrez avec EFA et NCCL pour les charges de travail EFA et ML sur Amazon EC2
<a name="efa-start-nccl"></a>

La NVIDIA Collective Communications Library (NCCL) est une bibliothèque de routines de communication collectives standard pour plusieurs GPU sur un nœud ou plusieurs nœuds. La NCCL peut être utilisée conjointement avec EFA, Libfabric et MPI pour prendre en charge différentes charges de travail de Machine Learning. Pour plus d’informations, consultez le site web [NCCL](https://developer.nvidia.com/nccl).

**Exigences**
+ Seuls les types d’instances de calcul accéléré de la série P sont pris en charge. Pour plus d’informations, consultez la section [Instances de calcul accéléré Amazon EC2](https://docs.aws.amazon.com/ec2/latest/instancetypes/ac.html#ac-sizes).
+ Seules les AMI de référence Amazon Linux 2023, Amazon Linux 2, Ubuntu 24.04 et Ubuntu 22.04 sont prises en charge.
+ Seule NCCL 2.4.2 et les versions ultérieures sont prises en charge avec EFA.

*Pour plus d'informations sur l'exécution de charges de travail d'apprentissage automatique avec EFA et NCCL à l'aide d'un AWS Apprentissage profond (deep learning) AMIs, consultez la section [Utilisation d'EFA sur le DLAMI dans le manuel du développeur](https://docs.aws.amazon.com/dlami/latest/devguide/tutorial-efa-using.html).AWS Apprentissage profond (deep learning) AMIs *

**Topics**
+ [Étape 1 : préparer un groupe EFA-enabled de sécurité](#nccl-start-base-setup)
+ [Étape 2 : Lancer une instance temporaire](#nccl-start-base-temp)
+ [Étape 3 : Installer les pilotes GPU Nvidia, le Nvidia CUDA Toolkit et cuDNN](#nccl-start-base-drivers)
+ [Étape 4 : Installer GDRCopy](#nccl-start-base-gdrcopy)
+ [Étape 5 : Installer le logiciel EFA](#nccl-start-base-enable)
+ [Étape 6 : Installer NCCL](#nccl-start-base-nccl)
+ [Étape 7 : Installer les tests NCCL](#nccl-start-base-tests)
+ [Étape 8 : Tester votre configuration EFA et NCCL](#nccl-start-base-test)
+ [Étape 9 : Installer vos applications de Machine Learning](#nccl-start-base-app)
+ [Étape 10 : Création d'un EFA et d'un NCCL-enabled AMI](#nccl-start-base-ami)
+ [Étape 11 : Résilier l'instance temporaire](#nccl-start-base-terminate)
+ [Étape 12 : Lancer EFA et les NCCL-enabled instances dans un groupe de placement de clusters](#nccl-start-base-cluster)
+ [Étape 13 : Activer SSH sans mot de passe](#nccl-start-base-passwordless)

## Étape 1 : préparer un groupe EFA-enabled de sécurité
<a name="nccl-start-base-setup"></a>

Un EFA a besoin d’un groupe de sécurité qui autorise tout le trafic entrant et sortant vers et depuis le groupe de sécurité proprement dit. La procédure suivante crée un groupe de sécurité qui autorise tout le trafic entrant et sortant à destination et en provenance de lui-même, et qui autorise le trafic SSH entrant depuis n’importe quelle adresse IPv4 pour la connectivité SSH.

**Important**  
Ce groupe de sécurité n’est destiné qu’à des fins de test. Pour vos environnements de production, nous vous recommandons de créer une règle SSH entrante qui autorise le trafic uniquement à partir de l’adresse IP à partir de laquelle vous vous connectez, telle que l’adresse IP de votre ordinateur ou une plage d’adresses IP de votre réseau local.

Pour d’autres scénarios, consultez [Règles de groupe de sécurité pour différents cas d’utilisation](security-group-rules-reference.md).

**Pour créer un groupe EFA-enabled de sécurité**

1. Ouvrez la console Amazon EC2 à l’adresse [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. Dans le panneau de navigation, choisissez **Security Groups (Groupes de sécurité)**, puis **Create security group (Créer un groupe de sécurité)**.

1. Dans la fenêtre **Create security group (Créer un groupe de sécurité)**, procédez comme suit :

   1. Pour **Nom du groupe de sécurité**, saisissez un nom descriptif pour le groupe de sécurité, tel que `EFA-enabled security group`.

   1. (Facultatif) Pour **Description**, saisissez une brève description du groupe de sécurité.

   1. Pour le **VPC**, sélectionnez le VPC dans lequel vous souhaitez lancer vos instances. EFA-enabled 

   1. Sélectionnez **Create security group** (Créer un groupe de sécurité).

1. Sélectionnez le groupe de sécurité que vous avez créé et dans l’onglet **Details** (Détails), copiez le **Security group ID** (ID du groupe de sécurité).

1. En conservant la sélection du groupe de sécurité, choisissez **Actions**, **Edit inbound rules** (Modifier les règles entrantes), puis procédez comme suit :

   1. Choisissez **Ajouter une règle**.

   1. Pour **Type**, sélectionnez **Tout le trafic**.

   1. Pour **Source type** (Type de source), choisissez **Custom** (Personnalisée) et collez l’ID du groupe de sécurité que vous avez copié dans le champ.

   1. Choisissez **Ajouter une règle**.

   1. Pour **Type**, choisissez **SSH**.

   1. Pour **Type de source**, choisissez **Anywhere-IPv4**.

   1. Sélectionnez **Enregistrer les règles**.

1. En conservant la sélection du groupe de sécurité, choisissez **Actions**, **Edit outbound rules** (Modifier les règles sortantes), puis procédez comme suit :

   1. Choisissez **Ajouter une règle**.

   1. Pour **Type**, sélectionnez **Tout le trafic**.

   1. Pour **Destination type** (Type de destination), choisissez **Custom** (Personnalisée) et collez l’ID du groupe de sécurité que vous avez copié dans le champ.

   1. Sélectionnez **Enregistrer les règles**.

## Étape 2 : Lancer une instance temporaire
<a name="nccl-start-base-temp"></a>

Lancez une instance temporaire que vous pouvez utiliser pour installer et configurer les composants logiciels EFA. Vous utilisez cette instance pour créer une EFA-enabled AMI à partir de laquelle vous pouvez lancer vos EFA-enabled instances.

**Pour lancer une instance temporaire**

1. Ouvrez la console Amazon EC2 à l’adresse [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. Dans le volet de navigation, choisissez **Instances**, puis **Launch Instances** (Lancer des instances) pour ouvrir le nouvel assistant de lancement d’instance.

1. (*Facultatif*) Dans la section **Name and tags** (Noms et identifications), fournissez un nom pour l’instance, tel que `EFA-instance`. Le nom est attribué à l’instance en tant qu’identification de ressource (`Name={{EFA-instance}}`).

1. Dans la section **Images d’applications et de systèmes d’exploitation**, sélectionnez une AMI pour l’un des systèmes d’exploitation pris en charge.

1. Dans la section **Type d’instance**, sélectionnez un type d’instance pris en charge.

1. Dans la section **Key pair** (Paire de clés), sélectionnez la paire de clés à utiliser pour l’instance.

1. Dans la section **Network settings** (Paramètres réseau), choisissez **Edit** (Modifier), puis procédez comme suit :

   1. Pour **Sous-réseau**, choisissez le sous-réseau dans lequel lancer l’instance.
**Important**  
Vous devez sélectionner un sous-réseau. Si vous ne sélectionnez pas de sous-réseau, vous ne pouvez pas activer l’instance pour EFA.

   1. Pour **Firewall (security groups)** (Pare-feu (groupes de sécurité)), choisissez **Sélectionner un groupe de sécurité existant** (Select existing security group), puis sélectionnez le groupe de sécurité que vous avez créé à l’étape précédente.

   1. Développez la section **Configuration du réseau avancée**.

      Pour **l’interface réseau 1**, sélectionnez **Index de la carte réseau = 0**, **Index du périphérique = 0** et **Type d’interface = EFA avec ENA**.

      (*Facultatif*) Si vous utilisez un type d'instance multicarte, tel que `p4d.24xlarge` ou`p5.48xlarge`, pour chaque interface réseau supplémentaire requise, choisissez **Ajouter une interface réseau**, pour **Index de carte réseau**, sélectionnez le prochain index non utilisé, puis sélectionnez **Index du périphérique = 1** et **Type d'interface = EFA avec ENA** ou **EFA-only**.

1. Dans la section **Storage** (Stockage), configurez les volumes selon vos besoins.
**Note**  
Vous devez provisionner un stockage supplémentaire de 10 à 20 GiB pour le Nvidia CUDA Toolkit. Si vous ne disposez pas d’un espace de stockage suffisant, le message d’erreur `insufficient disk space` s’affichera lors de la tentative d’installation des pilotes Nvidia et de la boîte à outils CUDA.

1. Dans le panneau **Summary** (Récapitulatif) à droite, choisissez **Launch instance** (Lancer l’instance).

## Étape 3 : Installer les pilotes GPU Nvidia, le Nvidia CUDA Toolkit et cuDNN
<a name="nccl-start-base-drivers"></a>

------
#### [ Amazon Linux 2023 and Amazon Linux 2 ]

**Pour installer les pilotes GPU Nvidia, le Nvidia CUDA Toolkit et cuDNN**

1. Pour vous assurer que tous vos packages logiciels sont mis à jour, effectuez une mise à jour logicielle rapide sur votre instance.

   ```
   $ sudo yum upgrade -y && sudo reboot
   ```

   Reconnectez-vous à votre instance après son redémarrage.

1. Installez les utilitaires nécessaires pour l’installation des pilotes GPU Nvidia et du Nvidia CUDA toolkit.

   ```
   $ sudo yum groupinstall 'Development Tools' -y
   ```

1. Désactiver le`nouveau`pilotes Open Source.

   1. Installez les utilitaires requis et le package d’en-têtes de noyau correspondant à la version du noyau que vous exécutez actuellement.

      ```
      $ sudo yum install -y wget kernel-devel-$(uname -r) kernel-headers-$(uname -r)
      ```

   1. Ajoutez `nouveau` au fichier de liste de refus `/etc/modprobe.d/blacklist.conf `.

      ```
      $ cat << EOF | sudo tee --append /etc/modprobe.d/blacklist.conf
      blacklist vga16fb
      blacklist nouveau
      blacklist rivafb
      blacklist nvidiafb
      blacklist rivatv
      EOF
      ```

   1. Ajouter`GRUB_CMDLINE_LINUX="rdblacklist=nouveau"`vers le`grub` fichier et générez à nouveau la configuration Grub.

      ```
      $ echo 'GRUB_CMDLINE_LINUX="rdblacklist=nouveau"' | sudo tee -a /etc/default/grub \
      && sudo grub2-mkconfig -o /boot/grub2/grub.cfg
      ```

1. Redémarrez l’instance et reconnectez-vous à celle-ci.

1. Préparer les référentiels requis

   1. Activez le référentiel EPEL et définissez la distribution sur `rhel7`.

      ```
      $ sudo amazon-linux-extras install epel \
      && distribution='rhel7'
      ```

   1. Configurez le référentiel réseau CUDA et mettez à jour le cache du référentiel.

      ```
      $ ARCH=$( /bin/arch ) \
      && sudo yum-config-manager --add-repo http://developer.download.nvidia.com/compute/cuda/repos/$distribution/${ARCH}/cuda-$distribution.repo \
      && sudo yum clean expire-cache
      ```

   1. (*Noyau version 5.10 uniquement*) Effectuez ces étapes uniquement si vous utilisez Amazon Linux 2 avec le noyau version 5.10. Si vous utilisez Amazon Linux 2 avec le noyau version 4.12, ignorez ces étapes. Pour vérifier la version de votre noyau, exécutez**uname -r**.

      1. Créez le fichier de configuration du pilote Nvidia nommé`/etc/dkms/nvidia.conf`.

         ```
         $ sudo mkdir -p /etc/dkms \
         && echo "MAKE[0]=\"'make' -j2 module SYSSRC=\${kernel_source_dir} IGNORE_XEN_PRESENCE=1 IGNORE_PREEMPT_RT_PRESENCE=1 IGNORE_CC_MISMATCH=1 CC=/usr/bin/gcc10-gcc\"" | sudo tee /etc/dkms/nvidia.conf
         ```

      1. (`p4d.24xlarge` et `p5.48xlarge` uniquement) Copiez le fichier de configuration du pilote Nvidia.

         ```
         $ sudo cp /etc/dkms/nvidia.conf /etc/dkms/nvidia-open.conf
         ```

1. Installer les pilotes GPU Nvidia, la boîte à outils NVIDIA CUDA et cuDNN.

   ```
   $ sudo yum clean all \
   && sudo yum -y install nvidia-driver-latest-dkms \
   && sudo yum -y install cuda-drivers-fabricmanager cuda libcudnn8-devel
   ```

1. Redémarrez l’instance et reconnectez-vous à celle-ci.

1. (`p4d.24xlarge` et `p5.48xlarge` uniquement) Démarrez le service Nvidia Fabric Manager et assurez-vous qu’il démarre automatiquement au démarrage de l’instance. Nvidia Fabric Manager est requis pour la gestion des commutateurs NV.

   ```
   $ sudo systemctl enable nvidia-fabricmanager && sudo systemctl start nvidia-fabricmanager
   ```

1. Assurez-vous que les chemins d’accès CUDA sont définis chaque fois que l’instance démarre.
   + Pour les shells *bash* , ajoutez les instructions suivantes à `/home/{{username}}/.bashrc` et `/home/{{username}}/.bash_profile`. 

     ```
     export PATH=/usr/local/cuda/bin:$PATH
     export LD_LIBRARY_PATH=/usr/local/cuda/lib64:/usr/local/cuda/extras/CUPTI/lib64:$LD_LIBRARY_PATH
     ```
   + Pour les shells *tcsh* , ajoutez les instructions suivantes à `/home/{{username}}/.cshrc`.

     ```
     setenv PATH=/usr/local/cuda/bin:$PATH
     setenv LD_LIBRARY_PATH=/usr/local/cuda/lib64:/usr/local/cuda/extras/CUPTI/lib64:$LD_LIBRARY_PATH
     ```

1. Pour vérifier que les pilotes GPU Nvidia sont fonctionnels, exécutez la commande suivante.

   ```
   $ nvidia-smi -q | head
   ```

   La commande doit renvoyer des informations sur les GPU Nvidia, les pilotes GPU Nvidia et le Nvidia CUDA Toolkit.

------
#### [ Ubuntu 24.04 and Ubuntu 22.04 ]

**Pour installer les pilotes GPU Nvidia, le Nvidia CUDA Toolkit et cuDNN**

1. Pour vous assurer que tous vos packages logiciels sont mis à jour, effectuez une mise à jour logicielle rapide sur votre instance.

   ```
   $ sudo apt-get update && sudo apt-get upgrade -y
   ```

1. Installez les utilitaires nécessaires pour l’installation des pilotes GPU Nvidia et du Nvidia CUDA toolkit.

   ```
   $ sudo apt-get update && sudo apt-get install build-essential -y
   ```

1. Pour utiliser le pilote GPU Nvidia, vous devez d’abord désactiver les pilotes open source `nouveau`.

   1. Installez les utilitaires requis et le package d’en-têtes de noyau correspondant à la version du noyau que vous exécutez actuellement.

      ```
      $ sudo apt-get install -y gcc make linux-headers-$(uname -r)
      ```

   1. Ajoutez `nouveau` au fichier de liste de refus `/etc/modprobe.d/blacklist.conf `.

      ```
      $ cat << EOF | sudo tee --append /etc/modprobe.d/blacklist.conf
      blacklist vga16fb
      blacklist nouveau
      blacklist rivafb
      blacklist nvidiafb
      blacklist rivatv
      EOF
      ```

   1. Ouvrez le fichier `/etc/default/grub` à l’aide de l’éditeur de texte de votre choix et ajoutez ce qui suit. 

      ```
      GRUB_CMDLINE_LINUX="rdblacklist=nouveau"
      ```

   1. Générez à nouveau la configuration Grub.

      ```
      $ sudo update-grub
      ```

1. Redémarrez l’instance et reconnectez-vous à celle-ci.

1. Ajoutez le référentiel CUDA et installez les pilotes de GPU Nvidia, la boîte à outils NVIDIA CUDA et cuDNN.
   + `p3dn.24xlarge`

     ```
     $ sudo apt-key adv --fetch-keys http://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu2004/x86_64/7fa2af80.pub \
     && wget -O /tmp/deeplearning.deb http://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu2004/x86_64/nvidia-machine-learning-repo-ubuntu2004_1.0.0-1_amd64.deb \
     && sudo dpkg -i /tmp/deeplearning.deb \
     && wget -O /tmp/cuda.pin https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2004/x86_64/cuda-ubuntu2004.pin \
     && sudo mv /tmp/cuda.pin /etc/apt/preferences.d/cuda-repository-pin-600 \
     && sudo apt-key adv --fetch-keys https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2004/x86_64/3bf863cc.pub \
     && sudo add-apt-repository 'deb http://developer.download.nvidia.com/compute/cuda/repos/ubuntu2004/x86_64/ /' \
     && sudo apt update \
     && sudo apt install nvidia-dkms-535 \
     && sudo apt install -o Dpkg::Options::='--force-overwrite' cuda-drivers-535 cuda-toolkit-12-3 libcudnn8 libcudnn8-dev -y
     ```
   + `p4d.24xlarge` et `p5.48xlarge`

     ```
     $ sudo apt-key adv --fetch-keys http://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu2004/x86_64/7fa2af80.pub \
     && wget -O /tmp/deeplearning.deb http://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu2004/x86_64/nvidia-machine-learning-repo-ubuntu2004_1.0.0-1_amd64.deb \
     && sudo dpkg -i /tmp/deeplearning.deb \
     && wget -O /tmp/cuda.pin https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2004/x86_64/cuda-ubuntu2004.pin \
     && sudo mv /tmp/cuda.pin /etc/apt/preferences.d/cuda-repository-pin-600 \
     && sudo apt-key adv --fetch-keys https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2004/x86_64/3bf863cc.pub \
     && sudo add-apt-repository 'deb http://developer.download.nvidia.com/compute/cuda/repos/ubuntu2004/x86_64/ /' \
     && sudo apt update \
     && sudo apt install nvidia-kernel-open-535 \
     && sudo apt install -o Dpkg::Options::='--force-overwrite' cuda-drivers-535 cuda-toolkit-12-3 libcudnn8 libcudnn8-dev -y
     ```

1. Redémarrez l’instance et reconnectez-vous à celle-ci.

1. (`p4d.24xlarge` et `p5.48xlarge` uniquement) Installez Nvidia Fabric Manager.

   1. Vous devez installer la version de Nvidia Fabric Manager qui correspond à la version du module de noyau Nvidia que vous avez installée à l’étape précédente.

      Exécutez la commande suivante pour déterminer la version du module de noyau Nvidia.

      ```
      $ cat /proc/driver/nvidia/version | grep "Kernel Module"
      ```

      Voici un exemple de sortie.

      ```
      NVRM version: NVIDIA UNIX x86_64 Kernel Module  450.42.01  Tue Jun 15 21:26:37 UTC 2021
      ```

      Dans l’exemple ci-dessus, la version principale `450` du module de noyau a été installée. Cela signifie que vous devez installer la version `450` de Nvidia Fabric Manager.

   1. Installez Nvidia Fabric Manager. Exécutez la commande suivante et spécifiez la version principale identifiée à l’étape précédente.

      ```
      $ sudo apt install -o Dpkg::Options::='--force-overwrite' nvidia-fabricmanager-{{major_version_number}}
      ```

      Par exemple, si la version majeure `450` du module de noyau a été installée, utilisez la commande suivante pour installer la version correspondante de Nvidia Fabric Manager.

      ```
      $ sudo apt install -o Dpkg::Options::='--force-overwrite' nvidia-fabricmanager-450
      ```

   1. Démarrez le service et assurez-vous qu’il démarre automatiquement au démarrage de l’instance. Nvidia Fabric Manager est requis pour la gestion des commutateurs NV.

      ```
      $ sudo systemctl start nvidia-fabricmanager && sudo systemctl enable nvidia-fabricmanager
      ```

1. Assurez-vous que les chemins d’accès CUDA sont définis chaque fois que l’instance démarre.
   + Pour les shells *bash* , ajoutez les instructions suivantes à `/home/{{username}}/.bashrc` et `/home/{{username}}/.bash_profile`. 

     ```
     export PATH=/usr/local/cuda/bin:$PATH
     export LD_LIBRARY_PATH=/usr/local/cuda/lib64:/usr/local/cuda/extras/CUPTI/lib64:$LD_LIBRARY_PATH
     ```
   + Pour les shells *tcsh* , ajoutez les instructions suivantes à `/home/{{username}}/.cshrc`.

     ```
     setenv PATH=/usr/local/cuda/bin:$PATH
     setenv LD_LIBRARY_PATH=/usr/local/cuda/lib64:/usr/local/cuda/extras/CUPTI/lib64:$LD_LIBRARY_PATH
     ```

1. Pour vérifier que les pilotes GPU Nvidia sont fonctionnels, exécutez la commande suivante.

   ```
   $ nvidia-smi -q | head
   ```

   La commande doit renvoyer des informations sur les GPU Nvidia, les pilotes GPU Nvidia et le Nvidia CUDA Toolkit.

------

## Étape 4 : Installer GDRCopy
<a name="nccl-start-base-gdrcopy"></a>

Installez GDRCopy pour améliorer les performances de Libfabric. Pour plus d’informations sur GDRCopy, consultez le [référentiel GDRCopy](https://github.com/NVIDIA/gdrcopy) (français non disponible).

------
#### [ Amazon Linux 2023 and Amazon Linux 2 ]

**Pour installer GDRCopy**

1. Installez les dépendances obligatoires.

   ```
   $ sudo yum -y install dkms rpm-build make check check-devel subunit subunit-devel
   ```

1. Téléchargez et extrayez le package GDRCopy.

   ```
   $ wget https://github.com/NVIDIA/gdrcopy/archive/refs/tags/v2.4.tar.gz \
   && tar xf v2.4.tar.gz ; cd gdrcopy-2.4/packages
   ```

1. Créez (build) le package RPM GDRCopy.

   ```
   $ CUDA=/usr/local/cuda ./build-rpm-packages.sh
   ```

1. Installez le package RPM GDRCopy.

   ```
   $ sudo rpm -Uvh gdrcopy-kmod-2.4-1dkms.noarch*.rpm \
   && sudo rpm -Uvh gdrcopy-2.4-1.x86_64*.rpm \
   && sudo rpm -Uvh gdrcopy-devel-2.4-1.noarch*.rpm
   ```

------
#### [ Ubuntu 24.04 and Ubuntu 22.04 ]

**Pour installer GDRCopy**

1. Installez les dépendances obligatoires.

   ```
   $ sudo apt -y install build-essential devscripts debhelper check libsubunit-dev fakeroot pkg-config dkms
   ```

1. Téléchargez et extrayez le package GDRCopy.

   ```
   $ wget https://github.com/NVIDIA/gdrcopy/archive/refs/tags/v2.4.tar.gz \
   && tar xf v2.4.tar.gz \
   && cd gdrcopy-2.4/packages
   ```

1. Créez (build) le package RPM GDRCopy.

   ```
   $ CUDA=/usr/local/cuda ./build-deb-packages.sh
   ```

1. Installez le package RPM GDRCopy.

   ```
   $ sudo dpkg -i gdrdrv-dkms_2.4-1_amd64.*.deb \
   && sudo dpkg -i libgdrapi_2.4-1_amd64.*.deb \
   && sudo dpkg -i gdrcopy-tests_2.4-1_amd64.*.deb \
   && sudo dpkg -i gdrcopy_2.4-1_amd64.*.deb
   ```

------

## Étape 5 : Installer le logiciel EFA
<a name="nccl-start-base-enable"></a>

Installez le EFA-enabled noyau, les pilotes EFA, Libfabric, le plugin aws-ofi-nccl et la pile Open MPI nécessaires pour prendre en charge EFA sur votre instance.

**Pour installer le logiciel EFA**

1. Connectez-vous à l’instance que vous avez lancée. Pour de plus amples informations, veuillez consulter [Se connecter à votre instance Linux à l’aide de SSH](connect-to-linux-instance.md).

1. Téléchargez les fichiers d’installation du logiciel EFA. Les fichiers d’installation du logiciel sont packagés dans un fichier d’archive compressé (`.tar.gz`). Pour télécharger la version *stable* la plus récente, utilisez la commande suivante.

   Vous pouvez aussi obtenir la dernière version en remplaçant le numéro de version par `latest` dans la commande ci-dessus.

   ```
   $ curl -O https://efa-installer.amazonaws.com/aws-efa-installer-1.48.0.tar.gz
   ```

1. (*Facultatif*) Vérifiez l’authenticité et l’intégrité du fichier tarball EFA (`.tar.gz`).

   Nous vous recommandons de le faire pour vérifier l’identité de l’éditeur du logiciel et pour vérifier que le fichier n’a pas été modifié ou endommagé depuis sa publication. Si vous ne souhaitez pas vérifier le fichier d’archive, ignorez cette étape.
**Note**  
Sinon, si vous préférez vérifier le fichier d’archive à l’aide d’un total de contrôle MD5 ou SHA256 à la place, consultez [Vérification du programme d’installation EFA à l’aide d’un total de contrôle](efa-verify.md).

   1. Téléchargez la clé publique GPG et importez-la dans votre porte-clés.

      ```
      $ wget https://efa-installer.amazonaws.com/aws-efa-installer.key && gpg --import aws-efa-installer.key
      ```

      La commande doit renvoyer une valeur clé. Notez la valeur clé, car vous en aurez besoin lors de l’étape suivante.

   1. Vérifiez l’empreinte digitale de la clé GPG. Exécutez la commande suivante et spécifiez la valeur clé que vous avez obtenue à l’étape précédente.

      ```
      $ gpg --fingerprint {{key_value}}
      ```

      La commande doit renvoyer une empreinte digitale identique à `4E90 91BC BB97 A96B 26B1 5E59 A054 80B1 DD2D 3CCC`. Si l’empreinte digitale ne correspond pas, n’exécutez pas le script d’installation EFA et contactez Support.

   1. Téléchargez le fichier SIGNATURE et vérifiez la signature du fichier d’archive EFA.

      ```
      $ wget https://efa-installer.amazonaws.com/aws-efa-installer-1.48.0.tar.gz.sig && gpg --verify ./aws-efa-installer-1.48.0.tar.gz.sig
      ```

      Voici un exemple de sortie.

      ```
      gpg: Signature made Wed 29 Jul 2020 12:50:13 AM UTC using RSA key ID DD2D3CCC
      gpg: Good signature from "Amazon EC2 EFA <ec2-efa-maintainers@amazon.com>"
      gpg: WARNING: This key is not certified with a trusted signature!
      gpg:          There is no indication that the signature belongs to the owner.
      Primary key fingerprint: 4E90 91BC BB97 A96B 26B1  5E59 A054 80B1 DD2D 3CCC
      ```

      Si le résultat inclut `Good signature` et que l’empreinte digitale correspond à l’empreinte digitale renvoyée à l’étape précédente, passez à l’étape suivante. Si ce n’est pas le cas, n’exécutez pas le script d’installation EFA et contactez Support.

1. Procédez à l’extraction des fichiers à partir du fichier compressé `.tar.gz` et accédez au répertoire extrait.

   ```
   $ tar -xf aws-efa-installer-1.48.0.tar.gz && cd aws-efa-installer
   ```

1. (*Facultatif*) Vérifiez les signatures de chaque package lors de l'installation.

   À partir du programme d'installation EFA 1.48.0, le programme d'installation inclut des packages RPM et DEB GPG-signed individuels. Pour vérifier l'authenticité et l'intégrité de chaque package lors de l'installation, utilisez le `--check-signatures` drapeau. Lorsque vous activez cet indicateur, le programme d'installation vérifie d'abord toutes les signatures de package et ne procède à l'installation que si chaque package réussit la vérification. Si la vérification d'un package échoue, le programme d'installation se ferme immédiatement sans rien installer.

   1. Téléchargez la clé publique GPG.

      ```
      $ wget https://efa-installer.amazonaws.com/aws-efa-installer.key
      ```

   1. Exportez le chemin clé. Ensuite, à l'étape suivante, ajoutez `--check-signatures` à la commande d'installation et utilisez-la à la `sudo -E` place de `sudo` pour conserver la variable d'environnement.

      ```
      $ export EFA_INSTALLER_KEY=$(pwd)/aws-efa-installer.key
      ```

   Sur RPM-based les systèmes (Amazon Linux, RHEL, Rocky Linux et SUSE), le programme d'installation vérifie chaque RPM utilisé. `rpm --checksig` Sur DEB-based les systèmes (Ubuntu, Debian), l'installateur vérifie chaque DEB à l'aide de la vérification de signature GPG.

   Si la vérification d'un package échoue, l'installation est immédiatement interrompue, protégeant ainsi votre système contre les packages défectueux ou malveillants.
**Note**  
Le `--check-signatures` drapeau est facultatif. Sans cela, le programme d'installation n'effectue pas de vérification individuelle des signatures.

1. Exécutez le script d’installation du logicielEFA.
**Note**  
Si vous avez effectué l'étape facultative précédente pour configurer la vérification de la signature du package, ajoutez-le `--check-signatures` à la commande d'installation et utilisez-le à la `sudo -E` place de`sudo`. Par exemple : `sudo -E ./efa_installer.sh -y --mpi=openmpi4 --check-signatures`.
**Note**  
Depuis EFA 1.30.0, Open MPI 4.1 et Open MPI 5 sont installés par défaut. À moins que vous n'ayez besoin d'Open MPI 5, nous vous recommandons de n'installer qu'Open MPI 4.1. La commande suivante installe Open MPI 4.1 uniquement. Si vous souhaitez installer Open MPI 4.1 et Open MPI 5, supprimez-les. `--mpi=openmpi4`

   ```
   $ sudo ./efa_installer.sh -y --mpi=openmpi4
   ```

   **Libfabric** est installé dans le répertoire `/opt/amazon/efa`. Le **plug-in aws-ofi-nccl** est installé dans le répertoire `/opt/amazon/ofi-nccl`. **Open MPI** est installé dans le répertoire `/opt/amazon/openmpi`.

1. Si le programme d’installation d’EFA vous invite à redémarrer l’instance, faites-le et reconnectez-vous à l’instance. Sinon, déconnectez-vous de l’instance, puis reconnectez-vous pour terminer l’installation.

1. Vérifiez que les composants logiciels EFA ont été installés avec succès.

   ```
   $ fi_info -p efa -t FI_EP_RDM
   ```

   La commande doit renvoyer des informations sur les interfaces EFA Libfabric. L’exemple suivant illustre la sortie de la commande.
   + `p3dn.24xlarge` avec interface réseau unique

     ```
     provider: efa
     fabric: EFA-fe80::94:3dff:fe89:1b70
     domain: efa_0-rdm
     version: 2.0
     type: FI_EP_RDM
     protocol: FI_PROTO_EFA
     ```
   + `p4d.24xlarge` et `p5.48xlarge` avec plusieurs interfaces réseau

     ```
     provider: efa
     fabric: EFA-fe80::c6e:8fff:fef6:e7ff
     domain: efa_0-rdm
     version: 111.0
     type: FI_EP_RDM
     protocol: FI_PROTO_EFA
     provider: efa
     fabric: EFA-fe80::c34:3eff:feb2:3c35
     domain: efa_1-rdm
     version: 111.0
     type: FI_EP_RDM
     protocol: FI_PROTO_EFA
     provider: efa
     fabric: EFA-fe80::c0f:7bff:fe68:a775
     domain: efa_2-rdm
     version: 111.0
     type: FI_EP_RDM
     protocol: FI_PROTO_EFA
     provider: efa
     fabric: EFA-fe80::ca7:b0ff:fea6:5e99
     domain: efa_3-rdm
     version: 111.0
     type: FI_EP_RDM
     protocol: FI_PROTO_EFA
     ```

## Étape 6 : Installer NCCL
<a name="nccl-start-base-nccl"></a>

Installez la NCCL. Pour plus d’informations sur la NCCL, consultez le [référentiel NCCL](https://github.com/NVIDIA/nccl).

**Pour installer la NCCL.**

1. Accédez au répertoire `/opt`.

   ```
   $ cd /opt
   ```

1. Clonez le référentiel officiel de la NCCL dans l’instance et accédez au référentiel cloné local.

   ```
   $ sudo git clone https://github.com/NVIDIA/nccl.git -b v2.23.4-1 && cd nccl
   ```

1. Créez et installez la NCCL et spécifiez le répertoire d’installation CUDA.

   ```
   $ sudo make -j src.build CUDA_HOME=/usr/local/cuda
   ```

## Étape 7 : Installer les tests NCCL
<a name="nccl-start-base-tests"></a>

Installez les tests NCCL. Les tests NCCL vous permettent de vous assurer que NCCL a été installée correctement et qu’elle fonctionne normalement. Pour plus d’informations sur les tests NCCL, consultez le [référentiel nccl-tests](https://github.com/NVIDIA/nccl-tests).

**Pour installer les tests NCCL**

1. Accédez à votre répertoire de base.

   ```
   $ cd $HOME
   ```

1. Clonez le référentiel officiel nccl-tests dans l’instance et accédez au référentiel cloné local.

   ```
   $ git clone https://github.com/NVIDIA/nccl-tests.git && cd nccl-tests
   ```

1. Ajoutez le répertoire Libfabric à la variable `LD_LIBRARY_PATH`. 
   + Amazon Linux 2023 et Amazon Linux 2

     ```
     $ export LD_LIBRARY_PATH={{/opt/amazon/efa/lib64}}:$LD_LIBRARY_PATH
     ```
   + Ubuntu 24.04 et Ubuntu 22.04

     ```
     $ export LD_LIBRARY_PATH={{/opt/amazon/efa/lib}}:$LD_LIBRARY_PATH
     ```

1. Installez les tests NCCL et spécifiez les répertoires d'installation MPI, NCCL et CUDA.

   ```
   $ make MPI=1 MPI_HOME={{/opt/amazon/openmpi}} NCCL_HOME={{/opt/nccl/build}} CUDA_HOME={{/usr/local/cuda}}
   ```

## Étape 8 : Tester votre configuration EFA et NCCL
<a name="nccl-start-base-test"></a>

Exécutez un test afin de vous assurer que votre instance temporaire est configurée correctement pour EFA et NCCL. 

**Pour tester votre configuration EFA et NCCL**

1. Créez un fichier hôte qui spécifie les hôtes sur lesquels les tests doivent être exécutés. La commande suivante crée un fichier hôte nommé `my-hosts` qui inclut une référence à l’instance elle-même.

------
#### [ IMDSv2 ]

   ```
   [ec2-user ~]$ TOKEN=`curl -X PUT "http://169.254.169.254/latest/api/token" -H "X-aws-ec2-metadata-token-ttl-seconds: 21600"` \
   && curl -H "X-aws-ec2-metadata-token: $TOKEN" -v http://169.254.169.254/latest/meta-data/local-ipv4 >> my-hosts
   ```

------
#### [ IMDSv1 ]

   ```
   [ec2-user ~]$ curl http://169.254.169.254/latest/meta-data/local-ipv4 >> my-hosts
   ```

------

1. Exécutez le test et spécifiez le fichier hôte (`--hostfile`) et le nombre de GPU à utiliser (`-n`). La commande suivante exécute le test `all_reduce_perf` sur 8 GPU sur l’instance elle-même et spécifie les variables d’environnement suivantes.
   + `FI_EFA_USE_DEVICE_RDMA=1` : (`p4d.24xlarge` uniquement) utilise la fonctionnalité RDMA du périphérique pour le transfert unilatéral et bilatéral.
   + `NCCL_DEBUG=INFO` : permet des sorties de débogage détaillées. Vous pouvez également spécifier `VERSION` pour imprimer uniquement la version NCCL au début du test ou `WARN` pour recevoir uniquement des messages d’erreur.

   Pour plus d’informations sur les arguments de test NCCL, consultez le [LISEZ-MOI sur les tests NCCL](https://github.com/NVIDIA/nccl-tests/blob/master/README.md) dans le référentiel nccl-tests officiel.
   + `p3dn.24xlarge`

     ```
     $ /opt/amazon/openmpi/bin/mpirun \
     -x LD_LIBRARY_PATH=/opt/nccl/build/lib:/usr/local/cuda/lib64:/opt/amazon/efa/lib:/opt/amazon/openmpi/lib:/opt/amazon/ofi-nccl/lib:$LD_LIBRARY_PATH \
     -x NCCL_DEBUG=INFO \
     --hostfile my-hosts -n 8 -N 8 \
     --mca pml ^cm --mca btl tcp,self --mca btl_tcp_if_exclude lo,docker0 --bind-to none \
     $HOME/nccl-tests/build/all_reduce_perf -b 8 -e 1G -f 2 -g 1 -c 1 -n 100
     ```
   + `p4d.24xlarge` et `p5.48xlarge`

     ```
     $ /opt/amazon/openmpi/bin/mpirun \
     -x FI_EFA_USE_DEVICE_RDMA=1 \
     -x LD_LIBRARY_PATH=/opt/nccl/build/lib:/usr/local/cuda/lib64:/opt/amazon/efa/lib:/opt/amazon/openmpi/lib:/opt/amazon/ofi-nccl/lib:$LD_LIBRARY_PATH \
     -x NCCL_DEBUG=INFO \
     --hostfile my-hosts -n 8 -N 8 \
     --mca pml ^cm --mca btl tcp,self --mca btl_tcp_if_exclude lo,docker0 --bind-to none \
     $HOME/nccl-tests/build/all_reduce_perf -b 8 -e 1G -f 2 -g 1 -c 1 -n 100
     ```

1. Vous pouvez confirmer que EFA est actif en tant que fournisseur sous-jacent pour NCCL lorsque le journal `NCCL_DEBUG` est imprimé.

   ```
   ip-192-168-2-54:14:14 [0] NCCL INFO NET/OFI Selected Provider is efa*
   ```

   Les informations supplémentaires suivantes s'affichent lors de l'utilisation d'une instance `p4d.24xlarge`.

   ```
   ip-192-168-2-54:14:14 [0] NCCL INFO NET/OFI Running on P4d platform, Setting NCCL_TOPO_FILE environment variable to /home/ec2-user/install/plugin/share/aws-ofi-nccl/xml/p4d-24xl-topo.xml
   ```

## Étape 9 : Installer vos applications de Machine Learning
<a name="nccl-start-base-app"></a>

Installez les applications de machine learning sur l'instance temporaire. La procédure d’installation varie selon l’application de machine learning spécifique. Pour plus d’informations sur l’installation de logiciels sur votre instance Linux, consultez [Gérer les logiciels sur votre instance Amazon Linux 2](https://docs.aws.amazon.com/linux/al2/ug/managing-software.html).

**Note**  
Reportez-vous à la documentation de votre application de machine learning pour obtenir des instructions d’installation.

## Étape 10 : Création d'un EFA et d'un NCCL-enabled AMI
<a name="nccl-start-base-ami"></a>

Après avoir installé les composants logiciels requis, vous créez une AMI que vous pouvez réutiliser pour lancer vos EFA-enabled instances.

**Pour créer une AMI à partir de votre instance temporaire**

1. Ouvrez la console Amazon EC2 à l’adresse [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. Dans le panneau de navigation, choisissez **Instances**.

1. Sélectionnez l’instance temporaire que vous avez créée et choisissez **Actions**, **Image**, **Créer une image**.

1. Pour **Créer une image**, procédez comme suit :

   1. Pour **Nom de l’image**, entrez un nom descriptif pour l’AMI.

   1. (Facultatif) Pour **Description de l’image**, saisissez une brève description de l’objectif de l’AMI.

   1. Choisissez **Create image (Créer une image)**.

1. Dans le panneau de navigation, sélectionnez **AMI**.

1. Recherchez l’AMI que vous avez créée dans la liste. Attendez que le statut passe de `pending` à `available` avant de poursuivre avec l'étape suivante.

## Étape 11 : Résilier l'instance temporaire
<a name="nccl-start-base-terminate"></a>

À ce stade, vous n'avez plus besoin de l'instance temporaire que vous avez lancée. Vous pouvez résilier l’instance pour arrêter d’être facturé pour celle-ci.

**Pour résilier l’instance temporaire**

1. Ouvrez la console Amazon EC2 à l’adresse [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. Dans le panneau de navigation, choisissez **Instances**.

1. Sélectionnez l’instance temporaire que vous avez créée puis choisissez **Actions**, **État de l’instance**, **Résilier l’instance**.

1. Lorsque vous êtes invité à confirmer, choisissez **Terminate (Mettre fin)**.

## Étape 12 : Lancer EFA et les NCCL-enabled instances dans un groupe de placement de clusters
<a name="nccl-start-base-cluster"></a>

Lancez votre EFA et vos NCCL-enabled instances dans un groupe de placement de clusters à l'aide de l' EFA-enabledAMI et du groupe EFA-enabled de sécurité que vous avez créés précédemment.

**Note**  
Il n'est pas obligatoire de lancer vos EFA-enabled instances dans un groupe de placement de clusters. Toutefois, nous vous recommandons d'exécuter vos EFA-enabled instances dans un groupe de placement de clusters, car cela les lance dans un groupe à faible latence dans une seule zone de disponibilité.
Pour vous assurer que la capacité est disponible lorsque vous mettez à l’échelle les instances de votre cluster, vous pouvez créer une réserve de capacité pour votre groupe de placement du cluster. Pour plus d’informations, consultez [Utilisation des réserves de capacité avec les groupes de placement du cluster](cr-cpg.md).

------
#### [ New console ]

**Pour lancer une instance temporaire**

1. Ouvrez la console Amazon EC2 à l’adresse [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. Dans le volet de navigation, choisissez **Instances**, puis **Launch Instances** (Lancer des instances) pour ouvrir le nouvel assistant de lancement d’instance.

1. (*Facultatif*) Dans la section **Name and tags** (Noms et identifications), fournissez un nom pour l’instance, tel que `EFA-instance`. Le nom est attribué à l’instance en tant qu’identification de ressource (`Name={{EFA-instance}}`).

1. Dans la section **Application and OS Images** (Images d’applications et de systèmes d’exploitation), choisissez **My AMIs** (Mes AMI), puis sélectionnez l’AMI que vous avez créée à l’étape précédente.

1. Dans la section **Instance type** (Type d’instance), sélectionnez `p3dn.24xlarge` ou `p4d.24xlarge`.

1. Dans la section **Key pair** (Paire de clés), sélectionnez la paire de clés à utiliser pour l’instance.

1. Dans la section **Network settings** (Paramètres réseau), choisissez **Edit** (Modifier), puis procédez comme suit :

   1. Pour **Sous-réseau**, choisissez le sous-réseau dans lequel lancer l’instance. Si vous ne sélectionnez pas de sous-réseau, vous ne pouvez pas activer l’instance pour EFA.

   1. Pour **Firewall (security groups)** (Pare-feu (groupes de sécurité)), choisissez **Sélectionner un groupe de sécurité existant** (Select existing security group), puis sélectionnez le groupe de sécurité que vous avez créé à l’étape précédente.

   1. Développez la section **Configuration du réseau avancée**.

      Pour **l’interface réseau 1**, sélectionnez **Index de la carte réseau = 0**, **Index du périphérique = 0** et **Type d’interface = EFA avec ENA**.

      (Facultatif) Si vous utilisez un type d'instance multicarte, tel que `p4d.24xlarge` ou`p5.48xlarge`, pour chaque interface réseau supplémentaire requise, choisissez **Ajouter une interface réseau**, pour **Index de carte réseau**, sélectionnez le prochain index non utilisé, puis sélectionnez **Index du périphérique = 1** et **Type d'interface = EFA avec ENA** ou **EFA-only**.

1. (*Facultatif*) Dans la section **Storage** (Stockage), configurez les volumes selon vos besoins.

1. Dans la section **Advanced details** (Détails avancés), pour **Placement group name** (Nom du groupe de placement), sélectionnez le groupe de placement du cluster dans lequel lancer l’instance. Si vous avez besoin de créer un groupe de placement du cluster, choisissez **Create new placement group** (Créer un groupe de placement).

1. Dans le panneau **Résumé** sur la droite, pour **Nombre d'instances**, entrez le nombre d' EFA-enabled instances que vous souhaitez lancer, puis choisissez **Launch instance**.

------
#### [ Old console ]

**Pour lancer votre EFA et vos NCCL-enabled instances dans un groupe de placement en cluster**

1. Ouvrez la console Amazon EC2 à l’adresse [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. Choisissez **Launch Instances**.

1. Sur la page **Choisir une AMI**, choisissez **Mes AMI**, recherchez l’AMI que vous avez créée précédemment, puis choisissez **Sélectionner**.

1. Sur la page **Choisir un type d’instance**, sélectionnez **p3dn.24xlarge**, puis choisissez **Suivant : configurer les détails d’instance**.

1. Sur la page **Configurer les détails de l’instance**, procédez de la façon suivante :

   1. Dans **Nombre d'instances**, entrez le nombre d'EFA et d'NCCL-enabled instances que vous souhaitez lancer.

   1. Pour **Réseau** et **Sous-réseau**, sélectionnez le VPC et le sous-réseau dans lesquels lancer les instances.

   1. Pour le **Groupe de placement**, sélectionnez **Ajoutez une instance au groupe de placement**.

   1. Pour **Nom du groupe de placement**, sélectionnez **Ajouter à un nouveau groupe de placement**, puis saisissez un nom descriptif pour le groupe de placement. Ensuite, pour **Stratégie du groupe de placement**, sélectionnez **Cluster**.

   1. Pour **EFA**, choisissez **Enable (Activer)**.

   1. Dans la section **Interfaces réseau**, pour l’appareil **eth0**, choisissez **Nouvelle interface réseau**. Vous pouvez éventuellement entrer une adresse IPv4 principale et une ou plusieurs adresses IPv4 secondaires. Si vous lancez l’instance dans un sous-réseau auquel un bloc d’adresse CIDR IPv6 est associé, vous pouvez éventuellement spécifier une adresse IPv6 principale et une ou plusieurs adresses IPv6 secondaires.

   1. Choisissez **Suivant : Ajouter un stockage**.

1. Sur la page **Ajouter un stockage**, spécifiez les volumes à attacher aux instances, outre ceux spécifiés par l’AMI (par exemple, le volume du périphérique racine). Choisissez ensuite **Suivant : Ajouter des balises**.

1. Sur la page **Ajouter des balises**, spécifiez des balises pour l’instance, par exemple un nom évocateur, puis sélectionnez **Suivant : Configurer le groupe de sécurité**.

1. Sur la page **Configurer le groupe de sécurité**, cliquez sur **Attribuer un groupe de sécurité**, choisissez **Sélectionner un groupe de sécurité existant**, puis le groupe de sécurité que vous avez créé précédemment.

1. Choisissez **Vérifier et lancer**.

1. Sur la page **Examiner le lancement de l'instance**, vérifiez les paramètres, puis choisissez **Lancer** pour sélectionner une paire de clés et lancer votre instance.

------

## Étape 13 : Activer SSH sans mot de passe
<a name="nccl-start-base-passwordless"></a>

Pour permettre à vos applications de s'exécuter sur toutes les instances de votre cluster, vous devez activer l'accès SSH sans mot de passe du nœud principal aux nœuds membres. Le nœud principal est l’instance à partir de laquelle vous exécutez vos applications. Les instances restantes du cluster sont les nœuds membres.

**Pour activer SSH sans mot de passe entre les instances du cluster**

1. Sélectionnez une instance dans le cluster en tant que nœud principal et connectez-vous à celle-ci.

1. Désactivez `strictHostKeyChecking` et activez `ForwardAgent` sur le nœud principal. Ouvrez le fichier `~/.ssh/config` à l’aide de l’éditeur de texte de votre choix et ajoutez ce qui suit.

   ```
   Host *
       ForwardAgent yes
   Host *
       StrictHostKeyChecking no
   ```

1. Générez une paire de clés RSA

   ```
   $ ssh-keygen -t rsa -N "" -f ~/.ssh/id_rsa
   ```

   La paire de clés est créée dans le répertoire `$HOME/.ssh/`.

1. Modifiez les autorisations de la clé privée sur le nœud principal.

   ```
   $ chmod 600 ~/.ssh/id_rsa
   chmod 600 ~/.ssh/config
   ```

1. Ouvrez `~/.ssh/id_rsa.pub` à l’aide de l’éditeur de texte de votre choix et copiez la clé.

1. Pour chaque nœud membre du cluster, procédez comme suit :

   1. Connectez-vous à l’instance.

   1. Ouvrez `~/.ssh/authorized_keys` à l’aide de l’éditeur de texte de votre choix et ajoutez la clé publique que vous avez copiée plus tôt.

1. Pour tester que le SSH sans mot de passe fonctionne comme prévu, connectez-vous à votre nœud principal et exécutez la commande suivante.

   ```
   $ ssh {{member_node_private_ip}}
   ```

   Vous devez vous connecter au nœud membre sans être invité à entrer une clé ou un mot de passe.