# Introducción a EFA y NIXL para cargas de trabajo de inferencia en Amazon EC2
<a name="efa-start-nixl"></a>

La NVIDIA Inference Xfer Library (NIXL) es una biblioteca de comunicaciones de alto rendimiento y baja latencia diseñada de forma específica para cargas de trabajo de inferencia desagregadas. NIXL se puede utilizar junto con EFA y Libfabric para permitir la transferencia de caché KV entre los nodos de prellenado y decodificación, y permite un movimiento eficiente de la caché KV entre varias capas de almacenamiento. Para obtener más información, consulte el sitio web de [NIXL](https://github.com/ai-dynamo/nixl).

**Requisitos**
+ Solo se admiten AMI base de Ubuntu 24.04 y Ubuntu 22.04.
+ EFA solo es compatible con NIXL 1.0.0 y posterior.

**Topics**

## Paso 1: preparar un grupo de seguridad habilitado para EFA
<a name="nixl-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 **Crear 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="nixl-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. También puede seleccionar una DLAMI compatible de las que aparecen en la [página de notas de la versión de DLAMI](https://docs.aws.amazon.com/dlami/latest/devguide/appendix-ami-release-notes)

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. 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**.

**importante**  
Omita el paso 3 si su AMI ya incluye los controladores de GPU de Nvidia, el kit de herramientas CUDA y cuDNN, o si utiliza una instancia que no es de GPU.

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

**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 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.

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

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.

**importante**  
Omita el paso 4 si su AMI ya incluye GDRCopy o si utiliza una instancia que no es de GPU.

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

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

**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 los paquetes DEB de GDRCopy.

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

1. Instale los paquetes DEB 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
   ```

**importante**  
Omita el paso 5 si su AMI ya incluye el último instalador de EFA.

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

Instale el kernel habilitado para EFA, los controladores de EFA, y la pila de Libfabric necesarios para admitir EFA en su 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.

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

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

   ```
   $ tar -xf aws-efa-installer-1.48.0.tar.gz && rm -rf 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 --check-signatures`.

   ```
   $ sudo ./efa_installer.sh -y
   ```

   **Libfabric** está instalado en el directorio `/opt/amazon/efa`.

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 NIXL
<a name="nixl-start-base-nixl"></a>

Instale NIXL. Para obtener más información sobre NIXL, consulte el [repositorio de NIXL](https://github.com/ai-dynamo/nixl).

------
#### [ Pre-built distributions ]

**Para instalar NIXL mediante PyPI**

1. Instale las dependencias requeridas.

   ```
   $ sudo apt install pip
   ```

1. Instale NIXL.

   ```
   $ pip install nixl
   ```

------
#### [ Build from source ]

**Compilar e instalar NIXL desde el origen**

1. Instale las dependencias requeridas.

   ```
   $ sudo apt install cmake pkg-config meson pybind11-dev libaio-dev nvidia-cuda-toolkit pip libhwloc-dev \
   && pip install meson ninja pybind11
   ```

1. Vaya al directorio de inicio.

   ```
   $ cd $HOME
   ```

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

   ```
   $ sudo git clone https://github.com/ai-dynamo/nixl.git && cd nixl
   ```

1. Cree e instale NIXL y especifique la ruta al directorio de instalación de Libfabric.

   ```
   $ sudo meson setup . nixl --prefix=/usr/local/nixl -Dlibfabric_path=/opt/amazon/efa
   $ cd nixl && sudo ninja && sudo ninja install
   ```

------

## Paso 7: instale NIXL Benchmark y pruebe la configuración de EFA y NIXL
<a name="nixl-start-base-tests"></a>

Instale NIXL Benchmark y ejecute una prueba para asegurarse de que su instancia temporal esté configurada correctamente para EFA y NIXL. NIXL Benchmark le permite confirmar que NIXL está instalado correctamente y que está funcionando como se esperaba. Para más información, consulte el [repositorio de nixlbench](https://github.com/ai-dynamo/nixl/tree/main/benchmark/nixlbench).

NIXL Benchmark (nixlbench) requiere ETCD para la coordinación entre el cliente y el servidor. Para usar ETCD con NIXL se requieren el servidor y el cliente de ETCD y la API CPP de ETCD.

------
#### [ Build from Docker ]

**Instalar y probar NIXL Benchmark mediante Docker**

1. Clone el repositorio oficial de NIXL en la instancia y vaya al directorio de compilación de nixlbench.

   ```
   $ git clone https://github.com/ai-dynamo/nixl.git
   $ cd nixl/benchmark/nixlbench/contrib
   ```

1. Cree el contenedor.

   ```
   $ ./build.sh
   ```

   Para obtener más información sobre las opciones de compilación de Docker, consulte el [repositorio de nixlbench](https://github.com/ai-dynamo/nixl/tree/main/benchmark/nixlbench).

1. Instale Docker.

   ```
   $ sudo apt install docker.io -y
   ```

1. Inicie el servidor ETCD para la coordinación.

   ```
   $ docker run -d --name etcd-server \
       -p 2379:2379 -p 2380:2380 \
       quay.io/coreos/etcd:v3.5.18 \
       /usr/local/bin/etcd \
       --data-dir=/etcd-data \
       --listen-client-urls=http://0.0.0.0:2379 \
       --advertise-client-urls=http://0.0.0.0:2379 \
       --listen-peer-urls=http://0.0.0.0:2380 \
       --initial-advertise-peer-urls=http://0.0.0.0:2380 \
       --initial-cluster=default=http://0.0.0.0:2380
   ```

1. Valide que el servidor ETCD esté ejecutándose.

   ```
   $ curl -L http://localhost:2379/health
   ```

   Resultado previsto:

   ```
   {"health":"true"}
   ```

1. Abra dos terminales para la instancia. En ambos terminales, ejecute el siguiente comando para verificar la instalación. El comando usa el servidor ETCD en la misma instancia, utiliza Libfabric como backend y funciona con la memoria de la GPU.

   ```
   $ docker run -it --gpus all --network host nixlbench:latest \
       nixlbench --etcd_endpoints http://localhost:2379 \
       --backend LIBFABRIC \
       --initiator_seg_type VRAM \
       --target_seg_type VRAM
   ```
**nota**  
Use el valor `DRAM` en lugar de `VRAM` para instancias que no sean de GPU.

------
#### [ Build from source ]

**importante**  
Siga esta pestaña solo si eligió **Compilar desde el origen** en el Paso 6.

**Instalar NIXL Benchmark**

1. Instale las dependencias de sistema requeridas.

   ```
   $ sudo apt install libgflags-dev
   ```

1. Instale el servidor y el cliente de ETCD.

   ```
   $ sudo apt install -y etcd-server etcd-client
   ```

1. Instale la API CPP de ETCD.

   1. Instale las dependencias requeridas para la API CPP de ETCD.

      ```
      $ sudo apt install libboost-all-dev libssl-dev libgrpc-dev libgrpc++-dev libprotobuf-dev protobuf-compiler-grpc libcpprest-dev
      ```

   1. Clone e instale la API CPP de ETCD.

      ```
      $ cd $HOME
      $ git clone https://github.com/etcd-cpp-apiv3/etcd-cpp-apiv3.git
      $ cd etcd-cpp-apiv3
      $ mkdir build && cd build
      $ cmake ..
      $ sudo make -j$(nproc) && sudo make install
      ```

1. Compile e instale nixlbench.

   ```
   $ sudo meson setup . $HOME/nixl/benchmark/nixlbench -Dnixl_path=/usr/local/nixl/
   $ sudo ninja && sudo ninja install
   ```

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

1. Inicie el servidor ETCD en la instancia.

   ```
   $ etcd --listen-client-urls "http://0.0.0.0:2379" \
       --advertise-client-urls "http://localhost:2379" &
   ```

1. Valide que el servidor ETCD esté ejecutándose.

   ```
   $ curl -L http://localhost:2379/health
   ```

   Resultado previsto:

   ```
   {"health":"true"}
   ```

1. Abra dos terminales para la instancia. En ambos terminales, complete los siguientes pasos para ejecutar nixlbench.

   1. Navegue hasta el directorio en el que está instalado nixlbench.

      ```
      $ cd /usr/local/nixlbench/bin/
      ```

   1. Ejecute la prueba y especifique el backend, la dirección del servidor ETCD y el tipo de segmento del iniciador. El siguiente comando usa el servidor ETCD en la misma instancia, utiliza Libfabric como backend y funciona con la memoria de la GPU. Las variables de entorno configuran lo siguiente:
      + `NIXL_LOG_LEVEL=INFO`: activa la salida de depuración detallada. También puede especificar `WARN` para recibir solamente mensajes de error.
      + `LD_LIBRARY_PATH`: establece la ruta de la biblioteca NIXL.

      Para obtener más información sobre los argumentos de prueba de NIXL, consulte el archivo [README de NIXLbench](https://github.com/ai-dynamo/nixl/blob/main/benchmark/nixlbench/README.md) en el reposorio nixlbench oficial.

      ```
      $ export NIXL_LOG_LEVEL=INFO
      $ export LD_LIBRARY_PATH=/usr/local/nixl/lib/$(gcc -dumpmachine):$LD_LIBRARY_PATH
      
      $ nixlbench --etcd-endpoints 'http://localhost:2379' \
          --backend 'LIBFABRIC' \
          --initiator_seg_type 'VRAM' \
          --target_seg_type 'VRAM'
      ```
**nota**  
Use el valor `DRAM` en lugar de `VRAM` para instancias que no sean de GPU.

------

## Paso 8: Instalar las aplicaciones de machine learning
<a name="nixl-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.

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

## Paso 9: cree una AMI habilitada para EFA y NIXL
<a name="nixl-start-base-ami"></a>

Después de haber instalado los componentes de software requeridos, crea una AMI que puede reutilizar para iniciar 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 10: Termine la instancia temporal
<a name="nixl-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 **Finalizar**.

## Paso 11: lance instancias habilitadas para EFA y NIXL
<a name="nixl-start-base-cluster"></a>

Lance las instancias habilitadas para EFA y NIXL mediante la AMI habilitada para EFA que creó en el **Paso 9** y el grupo de seguridad habilitado para EFA que creó en el **Paso 1**.

**Lanzar instancias habilitadas para EFA y NIXL**

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 **Mis AMI** y, a continuación, seleccione la AMI que creó en el paso anterior.

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. 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 1**.

   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 **Almacenamiento**, configure los volúmenes según sea necesario.

1. En el panel **Resumen**que se encuentra a la derecha, en **Cantidad de instancias**, ingrese la cantidad de instancias habilitadas para EFA que desea iniciar y, a continuación, elija **Iniciar instancias**.

## Paso 12: habilitar SSH sin contraseña
<a name="nixl-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.

**importante**  
Siga el Paso 13 solo si siguió el Paso 7.

## Paso 13: pruebe la configuración de EFA y NIXL en todas las instancias
<a name="nixl-start-base-test-multi"></a>

Ejecute una prueba para asegurarse de que sus instancias estén configuradas correctamente para EFA y NIXL.

------
#### [ Build from Docker ]

**Probar la configuración de EFA y NIXL en todas las instancias a través de Docker**

1. Seleccione dos hosts para ejecutar nixlbench benchmark. Utilice la dirección IP del primer host como IP del servidor ETCD para el intercambio de metadatos.

1. Inicie el servidor ETCD en el host 1.

   ```
   $ docker run -d --name etcd-server \
       -p 2379:2379 -p 2380:2380 \
       quay.io/coreos/etcd:v3.5.18 \
       /usr/local/bin/etcd \
       --data-dir=/etcd-data \
       --listen-client-urls=http://0.0.0.0:2379 \
       --advertise-client-urls=http://0.0.0.0:2379 \
       --listen-peer-urls=http://0.0.0.0:2380 \
       --initial-advertise-peer-urls=http://0.0.0.0:2380 \
       --initial-cluster=default=http://0.0.0.0:2380
   ```

1. Valide que el servidor ETCD esté ejecutándose.

   ```
   $ curl -L http://localhost:2379/health
   ```

   ```
   {"health":"true"}
   ```

1. Ejecute el punto de referencia nixlbench en el host 1.

   ```
   $ docker run -it --gpus all --network host nixlbench:latest \
       nixlbench --etcd_endpoints http://localhost:2379 \
       --backend LIBFABRIC \
       --initiator_seg_type VRAM
   ```

1. Ejecute el punto de referencia nixlbench en el host 2.

   ```
   $ docker run -it --gpus all --network host nixlbench:latest \
       nixlbench --etcd_endpoints http://{{ETCD_SERVER_IP}}:2379 \
       --backend LIBFABRIC \
       --initiator_seg_type VRAM
   ```

------
#### [ Build from source ]

**importante**  
Siga esta pestaña solo si eligió **Compilar desde el origen** en el Paso 6.

**Probar la configuración de EFA y NIXL en todas las instancias**

1. Seleccione dos hosts para ejecutar nixlbench benchmark. Utilice la dirección IP del primer host como IP del servidor ETCD para el intercambio de metadatos.

1. Lance el servidor ETCD en el host 1.

   ```
   $ etcd --listen-client-urls "http://0.0.0.0:2379" \
       --advertise-client-urls "http://localhost:2379" &
   ```

1. Valide que el servidor ETCD esté ejecutándose.

   ```
   $ curl -L http://localhost:2379/health
   ```

   ```
   {"health":"true"}
   ```

1. Ejecute el punto de referencia nixlbench en el host 1.

   ```
   $ export NIXL_LOG_LEVEL=INFO
   $ export LD_LIBRARY_PATH=$HOME/nixl/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH
   
   $ nixlbench \
       --etcd-endpoints http://localhost:2379 \
       --backend LIBFABRIC \
       --initiator_seg_type VRAM
   ```

1. Ejecute el punto de referencia nixlbench en el host 2.

   ```
   $ export NIXL_LOG_LEVEL=INFO
   $ export LD_LIBRARY_PATH=$HOME/nixl/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH
   
   $ nixlbench \
       --etcd-endpoints http://{{ETCD_SERVER_IP}}:2379 \
       --backend LIBFABRIC \
       --initiator_seg_type VRAM
   ```

------

## Paso 14: pruebe el servicio de inferencia desagregada a través de vLLM (*opcional*)
<a name="nixl-start-base-serve"></a>

Una vez instalado NIXL, puede usar NIXL a través de marcos de inferencia y servicio de LLM, como vLLM, SGLang y TensorRT-LLM.

**Para atender su carga de trabajo de inferencias mediante vLLM**

1. Instale vLLM.

   ```
   $ pip install vllm
   ```

1. Inicie el servidor vLLM con NIXL. Los siguientes comandos de ejemplo crean una instancia de prellenado (productor) y una de decodificación (consumidor) para el establecimiento de comunicación NIXL, el conector KV, la función KV y el backend de transporte. Para ver ejemplos y scripts detallados, consulte la [Guía de uso de NIXLConnector](https://github.com/vllm-project/vllm/blob/2d977a7a9ead3179fde9ed55d69393ef7b6cec47/docs/features/nixl_connector_usage.md).

   Para usar NIXL con EFA, establezca las variables de entorno en función de su configuración y caso de uso.
   + Configuración de productor (prerellenar)

     ```
     $ vllm serve {{your-application}} \
         --port 8200 \
         --enforce-eager \
         --kv-transfer-config '{"kv_connector":"NixlConnector","kv_role":"kv_both","kv_buffer_device":"cuda","kv_connector_extra_config":{"backends":["LIBFABRIC"]}}'
     ```
   + Configuración de consumidor (decodificador)

     ```
     $ vllm serve {{your-application}} \
         --port 8200 \
         --enforce-eager \
         --kv-transfer-config '{"kv_connector":"NixlConnector","kv_role":"kv_both","kv_buffer_device":"cuda","kv_connector_extra_config":{"backends":["LIBFABRIC"]}}'
     ```

   El ejemplo de configuración anterior establece lo siguiente:
   + `kv_role` a `kv_both`, que permite una funcionalidad simétrica en la que el conector puede actuar como productor y consumidor. Esto proporciona flexibilidad para configuraciones y escenarios experimentales en los que la distinción de roles no está predeterminada.
   + `kv_buffer_device` a `cuda`, que permite utilizar la memoria de la GPU.
   + Backend de NIXL a `LIBFABRIC`, que permite que el tráfico de NIXL pase por EFA.