Introducción a EFA y NIXL para cargas de trabajo de inferencia en Amazon EC2 - Amazon Elastic Compute Cloud

Introducción a EFA y NIXL para cargas de trabajo de inferencia en Amazon EC2

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.

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.

Steps

    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.

    Para crear un grupo de seguridad habilitado para EFA

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

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

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

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

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

      4. Elija Crear grupo de seguridad.

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

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

      1. Seleccione Agregar regla.

      2. En Tipo, seleccione Todo el tráfico.

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

      4. Seleccione Agregar regla.

      5. En Tipo, seleccione SSH.

      6. En Tipo de origen, elija Cualquiera de IPv4.

      7. Seleccione Guardar reglas.

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

      1. Seleccione Agregar regla.

      2. En Tipo, seleccione Todo el tráfico.

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

      4. Seleccione Guardar reglas.

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

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

    3. (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).

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

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

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

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

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

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

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

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

    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

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

    3. 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)

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

      3. Abra /etc/default/grub con su editor de texto preferido y agregue lo siguiente.

        GRUB_CMDLINE_LINUX="rdblacklist=nouveau"

      4. Reconstruya la configuración de Grub.

        $ sudo update-grub

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

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

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

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

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

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

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

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

    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.

    Para instalar GDRCopy

    1. Instale las dependencias requeridas.

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

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

    3. Compile los paquetes DEB de GDRCopy.

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

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

    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.

    2. 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.47.0.tar.gz

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

      $ tar -xf aws-efa-installer-1.47.0.tar.gz && rm -rf aws-efa-installer-1.47.0.tar.gz && cd aws-efa-installer

    4. Ejecute el script de instalación de software de EFA.

      $ sudo ./efa_installer.sh -y

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

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

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

    Instale NIXL. Para obtener más información sobre NIXL, consulte el repositorio de NIXL.

    Pre-built distributions
    Para instalar NIXL mediante PyPI

    1. Instale las dependencias requeridas.

      $ sudo apt install pip

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

    2. Vaya al directorio de inicio.

      $ cd $HOME

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

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

    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.

    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

    2. Cree el contenedor.

      $ ./build.sh

      Para obtener más información sobre las opciones de compilación de Docker, consulte el repositorio de nixlbench.

    3. Instale Docker.

      $ sudo apt install docker.io -y

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

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

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

      Resultado previsto:

      {"health":"true"}

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

    2. Instale el servidor y el cliente de ETCD.

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

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

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

    4. 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" &

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

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

      Resultado previsto:

      {"health":"true"}

    3. 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/

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

    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.

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

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

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

    4. En Crear imagen, realice lo siguiente:

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

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

      3. Elija Crear imagen.

    5. En el panel de navegación, elija AMI.

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

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

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

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

    4. Cuando se le indique que confirme, elija Finalizar.

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

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

    3. (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).

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

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

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

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

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

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

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

    9. En el panel Resumenque 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.

    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.

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

    3. 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/.

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

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

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

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

      1. Conéctese a la instancia.

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

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

    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.

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

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

      $ curl -L http://localhost:2379/health
      {"health":"true"}

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

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

    2. Lance el servidor ETCD en el host 1.

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

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

      $ curl -L http://localhost:2379/health
      {"health":"true"}

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

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

    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

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

      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.