Commencez à utiliser EFA et NIXL pour les charges de travail d'inférence sur Amazon EC2 - Amazon Elastic Compute Cloud

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

Commencez à utiliser EFA et NIXL pour les charges de travail d'inférence sur Amazon EC2

La bibliothèque NVIDIA Inference Xfer (NIXL) est une bibliothèque de communication à haut débit et à faible latence conçue spécifiquement pour les charges de travail d'inférence désagrégées. NIXL peut être utilisé avec EFA et Libfabric pour prendre en charge le transfert de cache KV entre les nœuds de préremplissage et de décodage, et il permet un déplacement efficace du cache KV entre les différentes couches de stockage. Pour plus d'informations, consultez le site Web de NIXL.

Exigences

  • Seuls Ubuntu 24.04 et Ubuntu 22.04 base AMIs sont pris en charge.

  • EFA prend uniquement en charge NIXL 1.0.0 et versions ultérieures.

Étapes

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

    Important

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

    Pour d’autres scénarios, consultez Règles de groupe de sécurité pour différents cas d’utilisation.

    Pour créer un groupe de sécurité activé pour EFA

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

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

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

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

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

      3. Pour VPC, sélectionnez le VPC dans lequel vous prévoyez de lancer vos instances activées pour EFA.

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

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

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

      1. Choisissez Ajouter une règle.

      2. Pour Type, sélectionnez Tout le trafic.

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

      4. Choisissez Ajouter une règle.

      5. Pour Type, choisissez SSH.

      6. Pour Type de source, choisissez N'importe où- IPv4.

      7. Sélectionnez Enregistrer les règles.

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

      1. Choisissez Ajouter une règle.

      2. Pour Type, sélectionnez Tout le trafic.

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

      4. Sélectionnez Enregistrer les règles.

    Lancez une instance temporaire que vous pouvez utiliser pour installer et configurer les composants logiciels EFA. Vous utilisez cette instance pour créer une AMI activée pour EFA depuis laquelle vous pouvez lancer vos instances activées pour EFA.

    Pour lancer une instance temporaire

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

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

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

    4. Dans la section Images d’applications et de systèmes d’exploitation, sélectionnez une AMI pour l’un des systèmes d’exploitation pris en charge. Vous pouvez également sélectionner un DLAMI compatible sur la page des notes de mise à jour du DLAMI.

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

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

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

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

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

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

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

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

    8. Dans la section Storage (Stockage), configurez les volumes selon vos besoins.

      Note

      Vous devez provisionner un stockage supplémentaire de 10 à 20 GiB pour le Nvidia CUDA Toolkit. Si vous ne disposez pas d’un espace de stockage suffisant, le message d’erreur insufficient disk space s’affichera lors de la tentative d’installation des pilotes Nvidia et de la boîte à outils CUDA.

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

    Important

    Ignorez l'étape 3 si votre AMI inclut déjà les pilotes GPU Nvidia, le kit d'outils CUDA et cuDNN, ou si vous utilisez une instance autre que le GPU.

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

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

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

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

      $ sudo apt-get install build-essential -y

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

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

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

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

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

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

        GRUB_CMDLINE_LINUX="rdblacklist=nouveau"

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

        $ sudo update-grub

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

    5. Ajoutez le référentiel CUDA et installez les pilotes de GPU Nvidia, la boîte à outils NVIDIA CUDA et 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. Redémarrez l’instance et reconnectez-vous à celle-ci.

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

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

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

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

        Voici un exemple de sortie.

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

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

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

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

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

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

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

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

    8. Assurez-vous que les chemins d’accès CUDA sont définis chaque fois que l’instance démarre.

      • Pour les shells bash , ajoutez les instructions suivantes à /home/username/.bashrc et /home/username/.bash_profile.

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

      • Pour les shells tcsh , ajoutez les instructions suivantes à /home/username/.cshrc.

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

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

      $ nvidia-smi -q | head

      La commande doit renvoyer des informations sur Nvidia GPUs, les pilotes GPU Nvidia et le kit d'outils Nvidia CUDA.

    Important

    Ignorez l'étape 4 si votre AMI inclut GDRCopy déjà une instance sans GPU ou si vous utilisez une instance autre que le GPU.

    Installez GDRCopy pour améliorer les performances de Libfabric sur les plateformes basées sur des GPU. Pour plus d'informations à ce sujetGDRCopy, consultez le GDRCopy référentiel.

    Pour installer GDRCopy

    1. Installez les dépendances obligatoires.

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

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

      $ 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. Construisez les packages GDRCopy DEB.

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

    4. Installez les packages GDRCopy DEB.

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

    Ignorez l'étape 5 si votre AMI inclut déjà le dernier programme d'installation d'EFA.

    Installez le noyau compatible EFA, les pilotes EFA et la pile Libfabric nécessaires pour prendre en charge EFA sur votre instance.

    Pour installer le logiciel EFA

    1. Connectez-vous à l’instance que vous avez lancée. Pour de plus amples informations, veuillez consulter Se connecter à votre instance Linux à l’aide de SSH.

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

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

    3. Extrayez les fichiers du .tar.gz fichier compressé, supprimez l'archive tar et naviguez dans le répertoire extrait.

      $ 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. Exécutez le script d’installation du logicielEFA.

      $ sudo ./efa_installer.sh -y

      Libfabric est installé dans le répertoire /opt/amazon/efa.

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

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

      $ fi_info -p efa -t FI_EP_RDM

      La commande doit renvoyer des informations sur les interfaces EFA Libfabric. L’exemple suivant illustre la sortie de la commande.

      • p3dn.24xlarge avec interface réseau unique

        provider: efa
fabric: EFA-fe80::94:3dff:fe89:1b70
domain: efa_0-rdm
version: 2.0
type: FI_EP_RDM
protocol: FI_PROTO_EFA

      • p4d.24xlarge et p5.48xlarge avec plusieurs interfaces réseau

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

    Installez NIXL. Pour plus d'informations sur NIXL, consultez le référentiel NIXL.

    Pre-built distributions
    Pour installer NIXL à l'aide de PyPI

    1. Installez les dépendances obligatoires.

      $ sudo apt install pip

    2. Installez NIXL.

      $ pip install nixl
    Build from source
    Pour compiler et installer NIXL à partir des sources

    1. Installez les dépendances obligatoires.

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

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

      $ cd $HOME

    3. Clonez le référentiel NIXL officiel sur l'instance et accédez au référentiel cloné local.

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

    4. Compilez et installez NIXL et spécifiez le chemin d'accès au répertoire d'installation de Libfabric.

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

    Installez le NIXL Benchmark et effectuez un test pour vous assurer que votre instance temporaire est correctement configurée pour EFA et NIXL. Le NIXL Benchmark vous permet de confirmer que NIXL est correctement installé et qu'il fonctionne comme prévu. Pour plus d'informations, consultez le référentiel nixlbench.

    NIXL Benchmark (nixlbench) nécessite ETCD pour la coordination entre le client et le serveur. L'utilisation d'ETCD avec NIXL nécessite le serveur et le client ETCD, ainsi que l'API ETCD CPP.

    Build from Docker
    Pour installer et tester NIXL Benchmark à l'aide de Docker

    1. Clonez le référentiel NIXL officiel sur l'instance et accédez au répertoire de construction nixlbench.

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

    2. Générez le conteneur.

      $ ./build.sh

      Pour plus d'informations sur les options de compilation de Docker, consultez le référentiel nixlbench.

    3. Installez Docker.

      $ sudo apt install docker.io -y

    4. Démarrez le serveur ETCD pour la coordination.

      $ 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. Vérifiez que le serveur ETCD est en cours d'exécution.

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

      Sortie attendue :

      {"health":"true"}

    6. Ouvrez deux terminaux pour l'instance. Sur les deux terminaux, exécutez la commande suivante pour vérifier l'installation. La commande utilise le serveur ETCD sur la même instance, utilise Libfabric comme backend et fonctionne à l'aide de la mémoire du 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
      Note

      Utilisez la valeur DRAM plutôt que VRAM pour les instances autres que le GPU.

    Build from source
    Important

    Suivez cet onglet uniquement si vous avez choisi Créer à partir du code source à l'étape 6.

    Pour installer NIXL Benchmark

    1. Installez les dépendances système requises.

      $ sudo apt install libgflags-dev

    2. Installez le serveur et le client ETCD.

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

    3. Installez l'API ETCD CPP.

      1. Installez les dépendances requises pour l'API ETCD CPP.

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

      2. Clonez et installez l'API ETCD CPP.

        $ 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. Construisez et installez nixlbench.

      $ sudo meson setup . $HOME/nixl/benchmark/nixlbench -Dnixl_path=/usr/local/nixl/
$ sudo ninja && sudo ninja install
    Pour tester votre configuration EFA et NIXL

    1. Démarrez le serveur ETCD sur l'instance.

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

    2. Vérifiez que le serveur ETCD est en cours d'exécution.

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

      Sortie attendue :

      {"health":"true"}

    3. Ouvrez deux terminaux pour l'instance. Sur les deux terminaux, effectuez les étapes suivantes pour exécuter nixlbench.

      1. Accédez au répertoire dans lequel nixlbench est installé.

        $ cd /usr/local/nixlbench/bin/

      2. Exécutez le test et spécifiez le backend, l'adresse du serveur ETCD et le type de segment initiateur. La commande suivante utilise le serveur ETCD sur la même instance, utilise Libfabric comme backend et utilise la mémoire du GPU. Les variables d'environnement configurent les éléments suivants :

        • NIXL_LOG_LEVEL=INFO— Permet une sortie de débogage détaillée. Vous pouvez également spécifier WARN de ne recevoir que les messages d'erreur.

        • LD_LIBRARY_PATH— Définit le chemin de la bibliothèque NIXL.

        Pour plus d'informations sur les arguments du NIXL Benchmark, consultez le NIXLbenchfichier README dans le référentiel officiel de nixlbench.

        $ 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'
        Note

        Utilisez la valeur DRAM plutôt que VRAM pour les instances autres que le GPU.

    Installez les applications de machine learning sur l’instance temporaire. La procédure d’installation varie selon l’application de machine learning spécifique.

    Note

    Reportez-vous à la documentation de votre application d'apprentissage automatique pour obtenir des instructions d'installation.

    Une fois que vous avez installé les composants logiciels requis, vous devez créer une AMI que vous pouvez réutiliser pour lancer vos instances activées pour EFA.

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

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

    2. Dans le panneau de navigation, choisissez Instances.

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

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

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

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

      3. Choisissez Create image (Créer une image).

    5. Dans le panneau de navigation, sélectionnez AMIs.

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

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

    Pour résilier l’instance temporaire

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

    2. Dans le panneau de navigation, choisissez Instances.

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

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

    Lancez vos instances compatibles EFA et Nixl à l'aide de l'AMI compatible EFA que vous avez créée à l'étape 9 et du groupe de sécurité compatible EFA que vous avez créé à l'étape 1.

    Pour lancer des instances compatibles EFA et Nixl

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

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

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

    4. Dans la section Images de l'application et du système d'exploitationAMIs, choisissez My, puis sélectionnez l'AMI que vous avez créée à l'étape précédente.

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

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

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

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

      2. Pour Firewall (groupes de sécurité), choisissez Sélectionner le groupe de sécurité existant, puis sélectionnez le groupe de sécurité que vous avez créé à l'étape 1.

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

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

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

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

    9. Dans le panneau Summary (Récapitulatif) à droite, pour Number of instances (Nombre d’instances), saisissez le nombre d’instances activées pour EFA que vous souhaitez lancer, puis choisissez Launch instance (Lancer l’instance).

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

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

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

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

      Host *
    ForwardAgent yes
Host *
    StrictHostKeyChecking no

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

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

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

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

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

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

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

      1. Connectez-vous à l’instance.

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

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

      $ ssh member_node_private_ip

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

    Important

    Suivez l'étape 13 uniquement si vous avez suivi l'étape 7.

    Effectuez un test pour vous assurer que vos instances sont correctement configurées pour EFA et NIXL.

    Build from Docker
    Pour tester votre configuration EFA et NIXL sur plusieurs instances à l'aide de Docker

    1. Sélectionnez deux hôtes pour exécuter le benchmark nixlbench. Utilisez l'adresse IP du premier hôte comme adresse IP du serveur ETCD pour l'échange de métadonnées.

    2. Démarrez le serveur ETCD sur l'hôte 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. Vérifiez que le serveur ETCD est en cours d'exécution.

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

    4. Exécutez le benchmark nixlbench sur l'hôte 1.

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

    5. Exécutez le benchmark nixlbench sur l'hôte 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
    Important

    Suivez cet onglet uniquement si vous avez choisi Créer à partir du code source à l'étape 6.

    Pour tester votre configuration EFA et NIXL sur plusieurs instances

    1. Sélectionnez deux hôtes pour exécuter le benchmark nixlbench. Utilisez l'adresse IP du premier hôte comme adresse IP du serveur ETCD pour l'échange de métadonnées.

    2. Lancez le serveur ETCD sur l'hôte 1.

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

    3. Vérifiez que le serveur ETCD est en cours d'exécution.

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

    4. Exécutez le benchmark nixlbench sur l'hôte 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. Exécutez le benchmark nixlbench sur l'hôte 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

    Une fois NIXL installé, vous pouvez utiliser NIXL via l'inférence LLM et des frameworks de service tels que vLLM et TensorRT-LLM. SGLang

    Pour répondre à votre charge de travail d'inférence à l'aide de vLLM

    1. Installez vLLM.

      $ pip install vllm

    2. Démarrez le serveur vLLM avec NIXL. Les exemples de commandes suivants créent une instance de préremplissage (producteur) et une instance de décodage (consommateur) pour la connexion NIXL Handshake, le connecteur KV, le rôle KV et le backend de transport. Pour des exemples détaillés et des scripts, consultez le guide NIXLConnector d'utilisation.

      Pour utiliser NIXL avec EFA, définissez les variables d'environnement en fonction de votre configuration et de votre cas d'utilisation.

      • Configuration du producteur (préremplisseur)

        $ 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"]}}'

      • Configuration du consommateur (décodeur)

        $ 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"]}}'

      L'exemple de configuration précédent définit les paramètres suivants :

      • kv_roleàkv_both, qui permet une fonctionnalité symétrique dans laquelle le connecteur peut agir à la fois en tant que producteur et en tant que consommateur. Cela offre de la flexibilité pour les configurations expérimentales et les scénarios dans lesquels la distinction des rôles n'est pas prédéterminée.

      • kv_buffer_deviceàcuda, qui permet d'utiliser la mémoire du GPU.

      • Backend NIXL versLIBFABRIC, qui permet au trafic NIXL de passer par EFA.