# Introducción a EFA y NCCL para cargas de trabajo de ML en Amazon EC2
<a name="efa-start-nccl"></a>

La Biblioteca de comunicación colectiva de NVIDIA (NCCL) es una biblioteca de rutinas de comunicación colectiva estándar para múltiples GPU en un solo nodo o múltiples nodos. NCCL se puede usar junto con EFA, Libfabric y MPI para admitir varias cargas de trabajo de machine learning. Para obtener más información, consulte el sitio web de [NCCL](https://developer.nvidia.com/nccl).

**Requisitos**
+ Solo se admiten los tipos de instancia de la serie P de computación acelerada. Para obtener más información, consulte [ instancia de computación acelerada de Amazon EC2](https://docs.aws.amazon.com/ec2/latest/instancetypes/ac.html#ac-sizes).
+ Solo se admiten las AMI base Amazon Linux 2023 Amazon Linux 2, Ubuntu 24.04 y Ubuntu 22.04.
+ Con EFA solo se admite NCCL 2.4.2 y versiones posteriores.

Para obtener más información sobre cómo ejecutar cargas de trabajo de machine learning con EFA y NCCL mediante un AWS Deep Learning AMIs, consulte [Uso de EFA en la DLAMI](https://docs.aws.amazon.com/dlami/latest/devguide/tutorial-efa-using.html) en la *Guía para desarrolladores AWS Deep Learning AMIs*.

**Topics**
+ [Paso 1: preparar un grupo de seguridad habilitado para EFA](#nccl-start-base-setup)
+ [Paso 2: iniciar una instancia temporal](#nccl-start-base-temp)
+ [Paso 3: instalar los controladores de GPU Nvidia, el kit de herramientas Nvidia CUDA y la cuDNN](#nccl-start-base-drivers)
+ [Paso 4: instalación de GDRCopy](#nccl-start-base-gdrcopy)
+ [Paso 5: instalación del software EFA](#nccl-start-base-enable)
+ [Paso 6: instalar NCCL](#nccl-start-base-nccl)
+ [Paso 7: Instalar las pruebas de NCCL](#nccl-start-base-tests)
+ [Paso 8: Probar la configuración de EFA y NCCL](#nccl-start-base-test)
+ [Paso 9: Instalar las aplicaciones de machine learning](#nccl-start-base-app)
+ [Paso 10: Crear una AMI habilitada para EFA y NCCL](#nccl-start-base-ami)
+ [Paso 11: Terminar la instancia temporal](#nccl-start-base-terminate)
+ [Paso 12: Lanzar instancias habilitadas para EFA en un grupo de colocación de clústeres](#nccl-start-base-cluster)
+ [Paso 13: Habilitar SSH sin contraseña](#nccl-start-base-passwordless)

## Paso 1: preparar un grupo de seguridad habilitado para EFA
<a name="nccl-start-base-setup"></a>

Un EFA requiere un grupo de seguridad que permita todo el tráfico entrante y saliente hacia y desde el propio grupo de seguridad. En el siguiente procedimiento, se crea un grupo de seguridad que permite todo el tráfico entrante y saliente de sí mismo, y que permite el tráfico SSH entrante desde cualquier dirección IPv4 para la conectividad SSH.

**importante**  
Este grupo de seguridad está pensado solo con fines de prueba. Para sus entornos de producción, le recomendamos que cree una regla SSH entrante que permita el tráfico únicamente desde la dirección IP desde la que se conecta, como la dirección IP de su equipo o un rango de direcciones IP en la red local.

Para ver otros escenarios, consulte [Reglas de grupo de seguridad para diferentes casos de uso](security-group-rules-reference.md).

**Para crear un grupo de seguridad habilitado para EFA**

1. Abra la consola de Amazon EC2 en [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. En el panel de navegación, elija **Grupos de seguridad** y, a continuación, elija **Crear grupo de seguridad**.

1. En la ventana **Crear grupo de seguridad**, haga lo siguiente:

   1. En **Nombre del grupo de seguridad**, ingrese un nombre descriptivo para el grupo de seguridad, como, por ejemplo, `EFA-enabled security group`.

   1. (Opcional) En **Descripción**, ingrese una breve descripción del grupo de seguridad.

   1. En **VPC**, seleccione la VPC en la que desea iniciar sus instancias habilitadas para EFA.

   1. Elija **Creación de grupo de seguridad**.

1. Seleccione el grupo de seguridad que creó y, en la pestaña **Detalles**, copie el **ID del grupo de seguridad**.

1. Con el grupo de seguridad todavía seleccionado, elija **Acciones**, **Editar reglas de entrada** y, luego, haga lo siguiente:

   1. Seleccione **Agregar regla**.

   1. En **Tipo**, seleccione **Todo el tráfico**.

   1. En **Tipo de origen**, elija **Personalizar** y pegue el ID del grupo de seguridad que copió en el campo.

   1. Seleccione **Agregar regla**.

   1. En **Tipo**, seleccione **SSH**.

   1. En **Tipo de origen**, elija **Cualquiera de IPv4**.

   1. Seleccione **Guardar reglas**.

1. Con el grupo de seguridad todavía seleccionado, elija **Acciones**, **Editar reglas de salida** y, luego, haga lo siguiente:

   1. Seleccione **Agregar regla**.

   1. En **Tipo**, seleccione **Todo el tráfico**.

   1. En **Tipo de destino**, elija **Personalizar** y pegue el ID del grupo de seguridad que copió en el campo.

   1. Seleccione **Guardar reglas**.

## Paso 2: iniciar una instancia temporal
<a name="nccl-start-base-temp"></a>

Lance una instancia temporal que puede utilizar para instalar y configurar los componentes de software de EFA. Puede utilizar esta instancia para crear una AMI habilitada para EFA desde la que puede iniciar sus instancias habilitadas para EFA.

**Para iniciar una instancia temporal**

1. Abra la consola de Amazon EC2 en [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. En el panel de navegación, elija **Instancias** y, a continuación, **Iniciar instancias** para abrir el nuevo asistente de inicialización de instancias.

1. (*Opcional*) En la sección **Nombre y etiquetas**, proporcione un nombre para la instancia, como `EFA-instance`. El nombre se asigna a la instancia como etiqueta de recurso (`Name={{EFA-instance}}`).

1. En la sección **Imágenes de aplicaciones y sistema operativo**, seleccione una AMI para uno de los sistemas operativos compatibles.

1. En la sección **Tipo de instancia**, seleccione un tipo de instancia compatible.

1. En la sección **Par de claves**, seleccione el par de claves que desea utilizar en la instancia.

1. En la sección **Configuración de red**, elija **Editar** y realice lo siguiente:

   1. En **Subred**, elija la subred en la que desea iniciar la instancia.
**importante**  
Debe seleccionar una subred. Si no selecciona una subred, no puede habilitar la instancia para EFA.

   1. En **Firewall (grupos de seguridad)**, elija **Seleccionar grupo de seguridad existente** y, a continuación, seleccione el grupo de seguridad que creó en el paso anterior.

   1. Amplíe la sección **Configuración de red avanzada**.

      Para **la interfaz de red 1**, seleccione **Índice de tarjeta de red = 0**, **Índice de dispositivo = 0** y **Tipo de interfaz = EFA con ENA**.

      (*Opcional*) Si utiliza un tipo de instancia con varias tarjetas, por ejemplo, `p4d.24xlarge` o `p5.48xlarge`, para cada interfaz de red adicional necesaria, elija **Agregar interfaz de red**; en **Índice de tarjetas de red**, seleccione el siguiente índice no utilizado y, a continuación, seleccione **Índice de dispositivo = 1** y **Tipo de interfaz = EFA con ENA** o **solo EFA**.

1. En la sección **Storage** (Almacenamiento), configure los volúmenes según sea necesario.
**nota**  
Debe aprovisionar 10 a 20 GiB adicionales de almacenamiento para el conjunto de herramientas CUDA de Nvidia. Si no aprovisiona suficiente almacenamiento, recibirá un error de `insufficient disk space` cuando intente instalar los controladores de Nvidia y el kit de herramientas CUDA.

1. En el panel **Resumen** que se encuentra a la derecha, elija **Iniciar instancia**.

## Paso 3: instalar los controladores de GPU Nvidia, el kit de herramientas Nvidia CUDA y la cuDNN
<a name="nccl-start-base-drivers"></a>

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

**Para instalar los controladores de GPU Nvidia, el kit de herramientas Nvidia CUDA y la cuDNN, haga lo siguiente:**

1. Para asegurarse de que todos los paquetes de software están actualizados, realice una actualización rápida del software en la instancia.

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

   Una vez que se haya reiniciado, vuelva a conectarse a la instancia.

1. Instale las utilidades necesarias para instalar los controladores de la GPU Nvidia y el kit de herramientas Nvidia CUDA.

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

1. Desactive los controladores de código abierto de `nouveau`.

   1. Instale las utilidades y el paquete de encabezados del kernel necesarios para la versión del kernel que está ejecutando actualmente.

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

   1. Agregue `nouveau` al archivo de lista de denegaciones `/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. Anexe `GRUB_CMDLINE_LINUX="rdblacklist=nouveau"` al archivo `grub` y vuelva a generar la configuración de Grub.

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

1. Reinicie la instancia y vuelva a conectarse a ella.

1. Preparar los repositorios necesarios

   1. Habilite el repositorio EPEL y configure la distribución en `rhel7`.

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

   1. Configure el repositorio de red CUDA y actualice la caché del repositorio.

      ```
      $ 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. (*Solo versión 5.10 del kernel*) Siga estos pasos solo si está utilizando Amazon Linux 2 con la versión 5.10 del kernel. Si utiliza Amazon Linux 2 con la versión 4.12 del kernel, omita estos pasos. Para comprobar la versión del kernel, ejecute **uname -r**.

      1. Cree el archivo de configuración del controlador de Nvidia denominado `/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. (Solo para `p4d.24xlarge` y `p5.48xlarge`) Copie el archivo de configuración del controlador de Nvidia.

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

1. Instale los controladores de GPU de Nvidia, el conjunto de herramientas NVIDIA CUDA y la cuDNN.

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

1. Reinicie la instancia y vuelva a conectarse a ella.

1. (Solo para `p4d.24xlarge` y `p5.48xlarge`) Inicie el servicio de Nvidia Fabric Manager y asegúrese de que se inicie de forma automática cuando se inicia la instancia. Nvidia Fabric Manager es necesario para la administración de NV Switch.

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

1. Asegúrese de que las rutas CUDA se establecen cada vez que se inicia la instancia.
   + Para intérpretes de comandos *bash*, agregue las siguientes instrucciones a `/home/{{username}}/.bashrc` y `/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
     ```
   + Para intérpretes de comandos *tcsh*, agregue las siguientes instrucciones a `/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. Para confirmar que los controladores de la GPU Nvidia son funcionales, ejecute el siguiente comando.

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

   El comando debe devolver información sobre las GPU de Nvidia, los controladores de GPU de Nvidia y el kit de herramientas Nvidia CUDA.

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

**Para instalar los controladores de GPU Nvidia, el kit de herramientas Nvidia CUDA y la cuDNN, haga lo siguiente:**

1. Para asegurarse de que todos los paquetes de software están actualizados, realice una actualización rápida del software en la instancia.

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

1. Instale las utilidades necesarias para instalar los controladores de la GPU Nvidia y el kit de herramientas Nvidia CUDA.

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

1. Para usar el controlador de GPU Nvidia, primero debe deshabilitar los controladores de código abierto `nouveau`.

   1. Instale las utilidades y el paquete de encabezados del kernel necesarios para la versión del kernel que está ejecutando actualmente.

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

   1. Agregue `nouveau` al archivo de lista de denegaciones `/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. Abra `/etc/default/grub` con su editor de texto preferido y agregue lo siguiente. 

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

   1. Reconstruya la configuración de Grub.

      ```
      $ sudo update-grub
      ```

1. Reinicie la instancia y vuelva a conectarse a ella.

1. Agregue el repositorio de CUD e instale los controladores de GPU de Nvidia, el conjunto de herramientas NVIDIA CUDA y la 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` y `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. Reinicie la instancia y vuelva a conectarse a ella.

1. (Solo para `p4d.24xlarge` y `p5.48xlarge`) Instale Nvidia Fabric Manager.

   1. Debe instalar la versión de Nvidia Fabric Manager que coincida con la versión del módulo del kernel de Nvidia que instaló en el paso anterior.

      Ejecute el siguiente comando para determinar la versión del módulo del kernel de Nvidia.

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

      A continuación, se muestra un ejemplo del resultado.

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

      En el ejemplo anterior, la versión principal `450` del módulo del kernel. Esto significa que necesita instalar la versión de Nvidia Fabric Manager `450`.

   1. Instale Nvidia Fabric Manager. Ejecute el siguiente comando y especifique la versión principal identificada en el paso anterior.

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

      Por ejemplo, si se instaló la versión principal `450` del módulo de kernel, utilice el siguiente comando para instalar la versión correspondiente de Nvidia Fabric Manager.

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

   1. Inicie el servicio y asegúrese de que se inicie de forma automática cuando se inicia la instancia. Nvidia Fabric Manager es necesario para la administración de NV Switch.

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

1. Asegúrese de que las rutas CUDA se establecen cada vez que se inicia la instancia.
   + Para intérpretes de comandos *bash*, agregue las siguientes instrucciones a `/home/{{username}}/.bashrc` y `/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
     ```
   + Para intérpretes de comandos *tcsh*, agregue las siguientes instrucciones a `/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. Para confirmar que los controladores de la GPU Nvidia son funcionales, ejecute el siguiente comando.

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

   El comando debe devolver información sobre las GPU de Nvidia, los controladores de GPU de Nvidia y el kit de herramientas Nvidia CUDA.

------

## Paso 4: instalación de GDRCopy
<a name="nccl-start-base-gdrcopy"></a>

Instale GDRCopy para mejorar el rendimiento de Libfabric. Para obtener más información sobre GDRCopy, consulte el [repositorio de GDRCopy](https://github.com/NVIDIA/gdrcopy).

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

**Para instalar GDRCopy**

1. Instale las dependencias requeridas.

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

1. Descargue y extraiga el paquete de 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. Compile el paquete RPM de GDRCopy.

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

1. Instale el paquete RPM de 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 ]

**Para instalar GDRCopy**

1. Instale las dependencias requeridas.

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

1. Descargue y extraiga el paquete de 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. Compile el paquete RPM de GDRCopy.

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

1. Instale el paquete RPM de 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
   ```

------

## Paso 5: instalación del software EFA
<a name="nccl-start-base-enable"></a>

Instale el kernel habilitado para EFA, los controladores de EFA, Libfabric, el complemento aws-ofi-nccl y la pila Open MPI necesarios para admitir EFA en la instancia.

**Para instalar el software EFA**

1. Conéctese a la instancia que lanzó. Para obtener más información, consulte [Conexión a la instancia de Linux con SSH](connect-to-linux-instance.md).

1. Descargue los archivos de instalación de software de EFA. Los archivos de instalación de software están empaquetados en un archivo tarball comprimido (`.tar.gz`). Para descargar la última versión *estable*, utilice el comando siguiente.

   También puede obtener la última versión reemplazando el número de versión por `latest` en el comando anterior.

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

1. (*Opcional*) Verifique la autenticidad y la integridad del archivo tarball (`.tar.gz`) de EFA.

   Le recomendamos que lo haga para verificar la identidad del editor de software y para verificar que el archivo no se haya modificado ni dañado desde que se publicó. Si no desea verificar el archivo tarball, omita este paso.
**nota**  
De forma alternativa, si prefiere verificar el archivo tarball con una suma de comprobación MD5 o SHA256, consulte [Verificar el instalador de EFA mediante una suma de comprobación](efa-verify.md).

   1. Descargue la clave pública de GPG e impórtela a su conjunto de claves.

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

      El comando debe devolver un valor de clave. Anote el valor de clave, ya que lo necesitará en el siguiente paso.

   1. Verifique la huella digital de la clave de GPG. Ejecute el siguiente comando y especifique el valor de clave del paso anterior.

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

      El comando debe devolver una huella digital idéntica a `4E90 91BC BB97 A96B 26B1 5E59 A054 80B1 DD2D 3CCC`. Si la huella digital no coincide, no ejecute el script de instalación de EFA y contáctese con Soporte.

   1. Descargue el archivo de firma y verifique la firma del archivo tarball de 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
      ```

      A continuación se muestra un ejemplo de salida.

      ```
      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 el resultado incluye `Good signature` y la huella digital coincide con la huella digital del paso anterior, avance al siguiente paso. Si no es así, no ejecute el script de instalación de EFA y contáctese con Soporte.

1. Extraiga los archivos desde el archivo `.tar.gz` comprimido y acceda al directorio extraído.

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

1. (*Opcional*) Verifique las firmas de los paquetes individuales durante la instalación.

   A partir del instalador EFA 1.48.0, el instalador incluye paquetes RPM y DEB individuales con firma GPG. Para verificar la autenticidad e integridad de cada paquete individual durante la instalación, use el indicador `--check-signatures`. Cuando se activa este indicador, el instalador verifica primero todas las firmas de los paquetes y solo continúa con la instalación si todos los paquetes pasan la verificación. Si algún paquete no pasa la verificación, el instalador se cierra inmediatamente sin instalar nada.

   1. Descargue la clave GPG pública.

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

   1. Exporte la ruta clave. A continuación, en el siguiente paso, añada `--check-signatures` al comando de instalación y use `sudo -E` en lugar de `sudo` para conservar la variable de entorno.

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

   En los sistemas basados en RPM (Amazon Linux, RHEL, Rocky Linux y SUSE), el instalador usa `rpm --checksig` para verificar cada RPM. En los sistemas basados en DEB (Ubuntu, Debian), el instalador usa la verificación de firmas GPG para verificar cada DEB.

   Si la verificación de algún paquete falla, la instalación se interrumpe inmediatamente para proteger el sistema contra paquetes dañados o maliciosos.
**nota**  
La etiqueta `--check-signatures` es opcional. Sin el indicador, el instalador no realiza una verificación de las firmas individuales.

1. Ejecute el script de instalación de software de EFA.
**nota**  
Si completó el paso opcional anterior para configurar la verificación de la firma del paquete, añada `--check-signatures` al comando de instalación y use `sudo -E` en lugar de `sudo`. Por ejemplo: `sudo -E ./efa_installer.sh -y --mpi=openmpi4 --check-signatures`.
**nota**  
A partir de la versión 1.30.0 de EFA, tanto Open MPI 4.1 como Open MPI 5 se instalan de forma predeterminada. A menos que necesite Open MPI 5, le recomendamos que instale únicamente Open MPI 4.1. El siguiente comando solo instala Open MPI 4.1. Si desea instalar Open MPI 4.1 y Open MPI 5, quite `--mpi=openmpi4`.

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

   **Libfabric** está instalado en el directorio `/opt/amazon/efa`. El **complemento aws-ofi-nccl** está instalado en el directorio `/opt/amazon/ofi-nccl`. **Open MPI** está instalado en el directorio `/opt/amazon/openmpi`.

1. Si el instalador de EFA le pide que reinicie la instancia, hágalo y vuelva a conectarse a la instancia. De lo contrario, cierre la sesión de la instancia y vuelva a iniciar sesión para completar la instalación.

1. Confirme que los componentes de software de EFA se han instalado correctamente.

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

   El comando debe devolver información acerca de las interfaces de EFA de Libfabric. En el siguiente ejemplo, se muestra el comando de salida.
   + `p3dn.24xlarge` con interfaz de red única

     ```
     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` y `p5.48xlarge` con múltiples interfaces de red

     ```
     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
     ```

## Paso 6: instalar NCCL
<a name="nccl-start-base-nccl"></a>

Instale NCCL. Para obtener más información sobre NCCL, consulte el [repositorio de NCCL](https://github.com/NVIDIA/nccl).

**Para instalar NCCL**

1. Vaya al directorio `/opt`.

   ```
   $ cd /opt
   ```

1. Clone el repositorio oficial de NCCL en la instancia y vaya al repositorio clonado local.

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

1. Cree e instale NCCL y especifique el directorio de instalación de CUDA.

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

## Paso 7: Instalar las pruebas de NCCL
<a name="nccl-start-base-tests"></a>

Instale las pruebas de NCCL. Las pruebas de NCCL le permiten confirmar que NCCL está instalado correctamente y que está funcionando como se esperaba. Para obtener más información sobre las pruebas de NCCL, consulte el [repositorio nccl-tests](https://github.com/NVIDIA/nccl-tests).

**Para instalar las pruebas de NCCL**

1. Vaya al directorio de inicio.

   ```
   $ cd $HOME
   ```

1. Clone el repositorio oficial nccl-tests en la instancia y vaya al repositorio clonado local.

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

1. Añada el directorio Libfabric a la variable `LD_LIBRARY_PATH`. 
   + Amazon Linux 2023 y Amazon Linux 2

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

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

1. Instale las pruebas NCCL y especifique los directorios de instalación MPI, NCCL y CUDA.

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

## Paso 8: Probar la configuración de EFA y NCCL
<a name="nccl-start-base-test"></a>

Ejecute una prueba para asegurarse de que su instancia temporal esté configurada correctamente para EFA y NCCL. 

**Para probar la configuración de EFA y NCCL**

1. Cree un archivo de hosts que especifique los hosts en los que desea ejecutar las pruebas. El siguiente comando crea un archivo de hosts con el nombre `my-hosts` que incluye una referencia a la propia instancia.

------
#### [ 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. Ejecute la prueba y especifique el archivo de hosts (`--hostfile`) y el número de GPUs que desea usar (`-n`). El siguiente comando ejecuta la prueba `all_reduce_perf` en 8 GPUs de la propia instancia y especifica las siguientes variables de entorno.
   + `FI_EFA_USE_DEVICE_RDMA=1`: (solo `p4d.24xlarge`) utiliza la funcionalidad de RDMA del dispositivo para la transferencia de un solo lado y de dos lados.
   + `NCCL_DEBUG=INFO`: habilita la salida de depuración detallada. También puede especificar `VERSION` para imprimir solo la versión de NCCL al inicio de la prueba o `WARN` para recibir solo mensajes de error.

   Para obtener más información sobre los argumentos de prueba de NCCL, consulte el archivo [README de pruebas de NCCL](https://github.com/NVIDIA/nccl-tests/blob/master/README.md) en el repositorio nccl-tests oficial.
   + `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` y `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. Puede confirmar que EFA está activo como proveedor subyacente de NCCL cuando se imprime el registro `NCCL_DEBUG`.

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

   La siguiente información adicional se muestra cuando se utiliza una instancia `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
   ```

## Paso 9: Instalar las aplicaciones de machine learning
<a name="nccl-start-base-app"></a>

Instale la aplicación de machine learning en la instancia temporal. El procedimiento de instalación varía en función de la aplicación de machine learning específica. Para obtener más información sobre la instalación de software en la instancia de Linux, consulte [Manage software on your Amazon Linux 2 instance](https://docs.aws.amazon.com/linux/al2/ug/managing-software.html).

**nota**  
Consulte la documentación de su aplicación de machine learning para ver las instrucciones de instalación.

## Paso 10: Crear una AMI habilitada para EFA y NCCL
<a name="nccl-start-base-ami"></a>

Después de haber instalado los componentes de software requeridos, crea una AMI que puede reutilizar para lanzar las instancias habilitadas para EFA.

**Para crear una AMI desde la instancia temporal**

1. Abra la consola de Amazon EC2 en [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. En el panel de navegación, seleccione **Instances (Instancias)**.

1. Seleccione la instancia temporal que creó y elija **Acciones**, **Imagen**, **Crear imagen**.

1. En **Crear imagen**, realice lo siguiente:

   1. En **Nombre de imagen**, ingrese un nombre descriptivo para la AMI.

   1. (Opcional) En **Descripción de imagen**, ingrese una breve descripción del propósito la AMI.

   1. Elija **Crear imagen**.

1. En el panel de navegación, elija **AMI**.

1. Localice la AMI que creó en la lista. Espere a que el estado pase de `pending` a `available` antes de continuar con el paso siguiente.

## Paso 11: Terminar la instancia temporal
<a name="nccl-start-base-terminate"></a>

En este punto, ya no necesita la instancia temporal que lanzó. Puede finalizar la instancia para dejar de incurrir en cargos debido a esta.

**Para finalizar la instancia temporal**

1. Abra la consola de Amazon EC2 en [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. En el panel de navegación, seleccione **Instances (Instancias)**.

1. Seleccione la instancia temporal que creó y, a continuación, elija **Acciones**, **Estado de instancia**, **Finalizar instancia**.

1. Cuando se le indique que confirme, elija **Terminate (Rescindir)**.

## Paso 12: Lanzar instancias habilitadas para EFA en un grupo de colocación de clústeres
<a name="nccl-start-base-cluster"></a>

Lance las instancias habilitadas para EFA y NCCL en un grupo con ubicación en clúster utilizando la AMI habilitada para EFA y el grupo de seguridad habilitado para EFA que creó anteriormente.

**nota**  
No es un requisito absoluto lanzar las instancias habilitadas con un EFA a un grupo de colocación de clústeres. Sin embargo, le recomendamos ejecutar sus instancias habilitadas para EFA en un grupo con ubicación en clúster a medida que inicia las instancias en un grupo de baja latencia en una única zona de disponibilidad.
Para garantizar que la capacidad esté disponible a medida que escala las instancias del clúster, puede crear una reserva de capacidad para su grupo con ubicación en clúster. Para obtener más información, consulte [Utilización de reservas de capacidad con grupos con ubicación en clúster](cr-cpg.md).

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

**Para iniciar una instancia temporal**

1. Abra la consola de Amazon EC2 en [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. En el panel de navegación, elija **Instancias** y, a continuación, **Iniciar instancias** para abrir el nuevo asistente de inicialización de instancias.

1. (*Opcional*) En la sección **Nombre y etiquetas**, proporcione un nombre para la instancia, como `EFA-instance`. El nombre se asigna a la instancia como etiqueta de recurso (`Name={{EFA-instance}}`).

1. En la sección **Imágenes de aplicaciones y sistema operativo**, elija **Mi AMI** y, a continuación, seleccione la AMI que creó en el paso anterior.

1. En la sección **Tipo de instancia**, seleccione `p3dn.24xlarge` o `p4d.24xlarge`.

1. En la sección **Par de claves**, seleccione el par de claves que desea utilizar en la instancia.

1. En la sección **Configuración de red**, elija **Editar** y realice lo siguiente:

   1. En **Subred**, elija la subred en la que desea iniciar la instancia. Si no selecciona una subred, no puede habilitar la instancia para EFA.

   1. En **Firewall (grupos de seguridad)**, elija **Seleccionar grupo de seguridad existente** y, a continuación, seleccione el grupo de seguridad que creó en el paso anterior.

   1. Amplíe la sección **Configuración de red avanzada**.

      Para **la interfaz de red 1**, seleccione **Índice de tarjeta de red = 0**, **Índice de dispositivo = 0** y **Tipo de interfaz = EFA con ENA**.

      (Opcional) Si utiliza un tipo de instancia con varias tarjetas, por ejemplo, `p4d.24xlarge` o `p5.48xlarge`, para cada interfaz de red adicional necesaria, elija **Agregar interfaz de red**; en **Índice de tarjetas de red**, seleccione el siguiente índice no utilizado y, a continuación, seleccione **Índice de dispositivo = 1** y **Tipo de interfaz = EFA con ENA** o **solo EFA**.

1. (*Opcional*) En la sección **Storage** (Almacenamiento), configure los volúmenes según sea necesario.

1. En la sección **Detalles avanzados**, para **Nombre del grupo de ubicación**, seleccione el grupo con ubicación en clúster en el que se iniciará la instancia. Si necesita crear un nuevo grupo con ubicación en clúster, elija **Create new placement group** (Crear nuevo grupo de ubicación).

1. En el panel **Summary** (Resumen) que se encuentra a la derecha, en **Number of instances** (Cantidad de instancias), ingrese la cantidad de instancias habilitadas para EFA que desea lanzar y, a continuación, elija **Launch instance** (Lanzar instancia).

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

**Para iniciar las instancias habilitadas para EFA y NCCL en un grupo con ubicación en clúster**

1. Abra la consola de Amazon EC2 en [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. Elija **Iniciar instancia**.

1. En la página **Elegir una AMI**, elija **Mi AMI**, encuentre la AMI que creó anteriormente y, a continuación, elija **Seleccionar**.

1. En la página **Elegir un tipo de instancia**, seleccione **p3dn.24xlarge** y, a continuación, elija **Siguiente: Configurar detalles de instancia**.

1. En la página **Configurar detalles de instancia**, haga lo siguiente:

   1. En **Número de instancias**, ingrese el número de instancias habilitadas para EFA y NCCL que desea iniciar.

   1. En **Red** y **Subred**, seleccione la VPC y la subred en la que iniciar las instancias.

   1. En **Grupo de ubicación**, seleccione **Añadir instancia a grupo de ubicación**.

   1. En **Nombre de grupo de ubicación**, seleccione **Agregar a un nuevo grupo de ubicación** y, a continuación, ingrese un nombre descriptivo para el grupo de ubicación. Luego, en **Estrategia de grupo de ubicación**, seleccione **clúster**.

   1. En **EFA**, elija **Habilitar**.

   1. En la sección **Interfaces de red**, para el dispositivo **eth0**, elija **Nueva interfaz de red**. Como opción, puede especificar una dirección IPv4 principal y una o varias direcciones IPv4 secundarias. Si está iniciando la instancia en una subred que tiene un bloque de CIDR de IPv6 asociado, como opción puede especificar una dirección IPv6 principal y una o varias direcciones IPv6 secundarias.

   1. Elija **Siguiente: Añadir almacenamiento**.

1. En la página **Agregar almacenamiento**, especifique los volúmenes que desea adjuntar a las instancias además de los volúmenes especificados por la AMI (como el volumen de dispositivo raíz). A continuación, elija **Siguiente: Agregar etiquetas**.

1. En la página **Añadir etiquetas**, especifique etiquetas para las instancias, por ejemplo, un nombre fácil de recordar, y, a continuación, elija **Siguiente: Configurar grupo de seguridad**.

1. En la página **Configurar grupo de seguridad**, en **Asignar un grupo de seguridad**, seleccione **Seleccionar un grupo de seguridad existente** y, a continuación, seleccione el grupo de seguridad que creó anteriormente.

1. Elija **Review and Launch (Revisar y lanzar)**.

1. En la página **Review Instance Launch (Revisar lanzamiento de instancia)**, revise la configuración y, a continuación, elija **Launch (Lanzar)** para elegir un par de claves y lanzar las instancias.

------

## Paso 13: Habilitar SSH sin contraseña
<a name="nccl-start-base-passwordless"></a>

Para permitir que las aplicaciones se ejecuten en todas las instancias del clúster, debe habilitar el acceso mediante SSH sin contraseña desde el nodo principal hasta los nodos miembro. El nodo principal es la instancia desde la que se ejecutan las aplicaciones. Las instancias restantes del clúster son los nodos miembros.

**Para habilitar SSH sin contraseña entre las instancias del clúster**

1. Seleccione una instancia del clúster como nodo principal y conéctese a ella.

1. Desactive `strictHostKeyChecking` y habilite `ForwardAgent` en el nodo principal. Abra `~/.ssh/config` con su editor de texto preferido y agregue lo siguiente.

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

1. Genere un par de claves de RSA.

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

   El par de claves se crea en el directorio `$HOME/.ssh/`.

1. Cambie los permisos de la clave privada en el nodo principal.

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

1. Abra `~/.ssh/id_rsa.pub` con su editor de texto preferido y copie la clave.

1. Para cada nodo miembro del clúster, realice lo siguiente:

   1. Conéctese a la instancia.

   1. Abra `~/.ssh/authorized_keys` con su editor de texto preferido y agregue la clave pública que copió anteriormente.

1. Para probar que SSH sin contraseña funciona como se esperaba, conecte al nodo principal y ejecute el siguiente comando.

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

   Debe conectarse al nodo miembro sin que se le pida una clave o una contraseña.