Erste Schritte mit EFA und NIXL für Inferenz-Workloads auf Amazon EC2 - Amazon Elastic Compute Cloud

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Erste Schritte mit EFA und NIXL für Inferenz-Workloads auf Amazon EC2

Die NVIDIA Inference Xfer Library (NIXL) ist eine Kommunikationsbibliothek mit hohem Durchsatz und niedriger Latenz, die speziell für disaggregierte Inferenz-Workloads entwickelt wurde. NIXL kann zusammen mit EFA und Libfabric verwendet werden, um die KV-Cache-Übertragung zwischen Prefill- und Decodierungsknoten zu unterstützen und ermöglicht eine effiziente KV-Cache-Bewegung zwischen verschiedenen Speicherebenen. Weitere Informationen finden Sie auf der NIXL-Website.

Voraussetzungen

  • Nur Ubuntu 24.04 und Ubuntu 22.04 Base werden unterstützt. AMIs

  • EFA unterstützt nur NIXL 1.0.0 und höher.

Schritte

    Ein EFA erfordert eine Sicherheitsgruppe, die allen ein- und ausgehenden Datenverkehr von und zur Sicherheitsgruppe zulässt. Mit dem folgenden Verfahren wird eine Sicherheitsgruppe erstellt, die allen eingehenden und ausgehenden Datenverkehr zu und von sich selbst zulässt und die eingehenden SSH-Verkehr von jeder Adresse für die SSH-Konnektivität zulässt. IPv4

    Wichtig

    Diese Sicherheitsgruppe dient nur zu Testzwecken. Für Produktionsumgebungen sollten Sie eine Regel für eingehenden SSH-Datenverkehr erstellen, die Datenverkehr nur von der IP-Adresse zulässt, von der aus Sie eine Verbindung herstellen, z. B. die IP-Adresse Ihres Computers oder einen Bereich von IP-Adressen im lokalen Netzwerk.

    Weitere Szenarien finden Sie unter Sicherheitsgruppenregeln für verschiedene Anwendungsfälle.

    So erstellen Sie eine EFA-fähige Sicherheitsgruppe:

    1. Öffnen Sie die Amazon-EC2-Konsole unter https://console.aws.amazon.com/ec2/.

    2. Wählen Sie im Navigationsbereich Security Groups (Sicherheitsgruppen) und anschließend Create Security Group (Sicherheitsgruppe erstellen) aus.

    3. Führen Sie im Fenster Create Security Group Folgendes aus:

      1. Geben Sie für Security group name (Name der Sicherheitsgruppe) einen beschreibenden Namen für die Sicherheitsgruppe ein, wie etwa EFA-enabled security group.

      2. (Optional:) Geben Sie unter Description (Beschreibung) eine kurze Beschreibung der Sicherheitsgruppe ein.

      3. Wählen Sie bei VPC die VPC aus, in der Sie Ihre EFA-fähigen Instances starten möchten.

      4. Wählen Sie Sicherheitsgruppe erstellen aus.

    4. Wählen Sie die von Ihnen erstellte Sicherheitsgruppe aus und kopieren Sie dann auf der Registerkarte Details die Security group ID (Sicherheitsgruppen-ID).

    5. Bei noch ausgewählter Sicherheitsgruppe wählen Sie Actions (Aktionen), Edit inbound rules (Eingangsregeln bearbeiten) aus und gehen dann folgendermaßen vor:

      1. Wählen Sie Regel hinzufügen aus.

      2. Wählen Sie für Type (Typ) die Option All traffic (Gesamter Datenverkehr) aus.

      3. Wählen Sie bei Source type (Quellentyp) Custom (Benutzerdefiniert) aus und fügen Sie die Sicherheitsgruppen-ID, die Sie kopiert hatten, ins Feld ein.

      4. Wählen Sie Regel hinzufügen aus.

      5. Wählen Sie unter Typ die Option SSH aus.

      6. Wählen Sie als Quelltyp die Option Anywhere- aus. IPv4

      7. Wählen Sie Regeln speichern aus.

    6. Bei noch ausgewählter Sicherheitsgruppe wählen Sie Actions (Aktionen), Edit outbound rules (Ausgangsregeln bearbeiten) aus und gehen dann folgendermaßen vor:

      1. Wählen Sie Regel hinzufügen aus.

      2. Wählen Sie für Type (Typ) die Option All traffic (Gesamter Datenverkehr) aus.

      3. Wählen Sie bei Destination type (Zieltyp) Custom (Benutzerdefiniert) aus und fügen Sie die Sicherheitsgruppen-ID, die Sie kopiert hatten, ins Feld ein.

      4. Wählen Sie Regeln speichern aus.

    Starten Sie eine temporäre Instance, die Sie verwenden können, um die EFA-Softwarekomponenten zu installieren und zu konfigurieren. Sie können mit dieser Instance ein EFA-aktiviertes AMI erstellen, von dem Sie Ihre EFA-aktivierten Instances starten können.

    So starten Sie eine temporäre Instance

    1. Öffnen Sie die Amazon-EC2-Konsole unter https://console.aws.amazon.com/ec2/.

    2. Wählen Sie im Navigationsbereich Instances und dann Instances starten aus, um den Launch Instance Wizard zu öffnen.

    3. (Optional) Geben Sie im Bereich Name and tags (Name und Tags) einen Namen für die Instance an, z. B. EFA-instance. Der Name wird der Instance als Ressourcen-Tag (Name=EFA-instance) zugewiesen.

    4. Wählen Sie im Bereich Anwendungs- und Betriebssystem-Images ein AMI für eines der unterstützten Betriebssysteme aus. Sie können auch ein unterstütztes DLAMI auswählen, das Sie auf der Seite mit den DLAMI-Versionshinweisen finden.

    5. Wählen Sie im Bereich Instance-Typ einen unterstützten Instance-Typ aus.

    6. Wählen Sie im Bereich Key pair (Schlüsselpaar) das Schlüsselpaar aus, das für die Instance verwendet werden soll.

    7. Wählen Sie im Bereich Network settings (Netzwerkeinstellungen) Edit (Bearbeiten) aus und führen Sie dann Folgendes aus:

      1. Wählen Sie unter Subnetz das Subnetz aus, in dem die Instance gestartet werden soll. Wenn Sie kein Subnetz auswählen, können Sie die Instance nicht für EFA aktivieren.

      2. Wählen Sie bei Firewall (security groups) Firewall (Sicherheitsgruppen) Select existing security group (Vorhandene Sicherheitsgruppe auswählen) und dann die Sicherheitsgruppe aus, die Sie im vorherigen Schritt erstellt haben.

      3. Erweitern Sie den Abschnitt Erweiterte Netzwerkkonfiguration.

        Wählen Sie für Netzwerkschnittstelle 1 Netzwerkkartenindex = 0, Geräteindex = 0 und Schnittstellentyp = EFA mit ENA aus.

        (Optional) Wenn Sie einen Instance-Typ mit mehreren Karten verwenden, z. B. p4d.24xlarge oder p5.48xlarge, wählen Sie für jede weitere erforderliche Netzwerkschnittstelle die Option Netzwerkschnittstelle hinzufügen, wählen Sie für Netzwerkkartenindex den nächsten ungenutzten Index aus und wählen Sie dann Geräteindex = 1 und Schnittstellentyp = EFA mit ENA oder Nur-EFA aus.

    8. Konfigurieren Sie im Bereich Storage (Speicher) die Volumes nach Bedarf.

      Anmerkung

      Sie müssen zusätzliche 10 bis 20 GiB Speicher für das Nvidia CUDA Toolkit bereitstellen. Wenn Sie nicht genügend Speicherplatz bereitstellen, erhalten Sie einen insufficient disk space-Fehler beim Versuch, die Nvidia-Treiber und das CUDA-Toolkit zu installieren.

    9. Wählen Sie im Bereich Summary (Zusammenfassung) rechts Launch instance (Instance starten) aus.

    Wichtig

    Überspringen Sie Schritt 3, wenn Ihr AMI bereits Nvidia-GPU-Treiber, das CUDA-Toolkit und cuDNN enthält oder wenn Sie eine Nicht-GPU-Instance verwenden.

    Installieren der Nvidia GPU-Treiber, des Nvidia-CUDA-Toolkits und cuDNN

    1. Um sicherzustellen, dass alle Ihre Softwarepakete aktuell sind, führen Sie ein schnelles Softwareupdate auf Ihrer Instance aus.

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

    2. Installieren Sie die Dienstprogramme, die zum Installieren der Nvidia GPU-Treiber und des Nvidia CUDA-Toolkits benötigt werden.

      $ sudo apt-get install build-essential -y

    3. Um den Nvidia GPU-Treiber verwenden zu können, müssen Sie zunächst die nouveau-Open-Source-Treiber deaktivieren.

      1. Installieren Sie die erforderlichen Dienstprogramme und das Kernel-Header-Paket für Ihre derzeit ausgeführte Kernel-Version.

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

      2. Fügen Sie nouveau der Verweigerungsliste /etc/modprobe.d/blacklist.conf hinzu.

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

      3. Öffnen Sie /etc/default/grub mit dem bevorzugten Texteditor und fügen Sie Folgendes hinzu.

        GRUB_CMDLINE_LINUX="rdblacklist=nouveau"

      4. Erstellen Sie die neue Grub-Konfiguration.

        $ sudo update-grub

    4. Starten Sie die Instance neu und stellen Sie die Verbindung zur Instance wieder her.

    5. Fügen Sie das CUDA-Repository hinzu und installieren Sie die Nvidia-GPU-Treiber, das NVIDIA-CUDA-Toolkit und 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. Starten Sie die Instance neu und stellen Sie die Verbindung zur Instance wieder her.

    7. (Nur p4d.24xlarge und p5.48xlarge) Installieren Sie den NVIDIA Fabric Manager.

      1. Sie müssen die Version von Nvidia Fabric Manager installieren, die mit der Version des Nvidia-Kernelmoduls übereinstimmt, die Sie im vorherigen Schritt installiert haben.

        Führen Sie den folgenden Befehl aus, um die Version des Nvidia Kernelmoduls zu bestimmen.

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

        Es folgt eine Beispielausgabe.

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

        Im obigen Beispiel wurde die Hauptversion 450 des Kernel-Moduls installiert. Dies bedeutet, dass Sie die Nvidia Fabric Manager-Version 450 installieren müssen.

      2. Installieren Sie den Nvidia Fabric Manager. Führen Sie den folgenden Befehl aus, und geben Sie die im vorherigen Schritt angegebene Hauptversion an.

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

        Zum Beispiel, wenn die Hauptversion 450 des Kernelmoduls installiert wurde, verwenden Sie den folgenden Befehl, um die passende Version von Nvidia Fabric Manager zu installieren.

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

      3. Starten Sie den Dienst und stellen Sie sicher, dass er beim Start der Instance automatisch gestartet wird. Nvidia Fabric Manager ist für das NV Switch Management erforderlich.

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

    8. Stellen Sie sicher, dass die CUDA-Pfade bei jedem Start der Instance festgelegt werden.

      • Fügen Sie für Bash-Shells die folgenden Anweisungen zu /home/username/.bashrc und /home/username/.bash_profile hinzu.

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

      • Fügen Sie für tcsh-Shells die folgenden Anweisungen zu /home/username/.cshrc hinzu.

        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. Führen Sie den folgenden Befehl aus, um zu bestätigen, dass die Nvidia GPU-Treiber funktionieren.

      $ nvidia-smi -q | head

      Der Befehl sollte Informationen über die Nvidia- GPUs, Nvidia-GPU-Treiber und das Nvidia-CUDA-Toolkit zurückgeben.

    Wichtig

    Überspringen Sie Schritt 4 GDRCopy, wenn Ihr AMI bereits eine Instance enthält oder wenn Sie eine Nicht-GPU-Instance verwenden.

    Installieren Sie GDRCopy , um die Leistung von Libfabric auf GPU-basierten Plattformen zu verbessern. Weitere Informationen zu finden Sie im GDRCopy Repository. GDRCopy

    Um zu installieren GDRCopy

    1. Installieren Sie die erforderlichen Abhängigkeiten.

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

    2. Laden Sie das Paket herunter und GDRCopy entpacken Sie es.

      $ 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. Erstellen Sie die GDRCopy DEB-Pakete.

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

    4. Installieren Sie die GDRCopy DEB-Pakete.

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

    Überspringen Sie Schritt 5, wenn Ihr AMI bereits das neueste EFA-Installationsprogramm enthält.

    Installieren Sie den EFA-fähigen Kernel, die EFA-Treiber und den Libfabric-Stack, die für die Unterstützung von EFA auf Ihrer Instance erforderlich sind.

    So installieren Sie die EFA-Software

    1. Stellen Sie eine Verbindung zu der Instance her, die Sie gestartet haben. Weitere Informationen finden Sie unter Herstellen einer Verbindung zu Ihrer Linux-Instance mit SSH.

    2. Laden Sie die EFA-Software-Installationsdateien herunter. Die Software-Installationsdateien sind in einer komprimierten Tarball-Datei (.tar.gz) verpackt. Laden Sie die neueste stabile Version mit dem folgenden Befehl herunter.

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

    3. Extrahieren Sie die Dateien aus der komprimierten .tar.gz Datei, löschen Sie den Tarball und navigieren Sie in das entpackte Verzeichnis.

      $ 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. Führen Sie das EFA-Software-Installationsskript aus.

      $ sudo ./efa_installer.sh -y

      Libfabric ist im /opt/amazon/efa-Verzeichnis installiert.

    5. Wenn das EFA-Installationsprogramm Sie auffordert, die Instance neu zu starten, tun Sie dies und stellen Sie dann erneut eine Verbindung mit der Instance her. Melden Sie sich andernfalls von der Instance ab und wieder an, um die Installation abzuschließen.

    6. Überprüfen Sie, ob die EFA-Softwarekomponenten erfolgreich installiert wurden.

      $ fi_info -p efa -t FI_EP_RDM

      Der Befehl muss Informationen zu den Libfabric-EFA-Schnittstellen zurückgeben. Das folgende Beispiel zeigt die Befehlsausgabe.

      • p3dn.24xlarge mit einer einzigen Netzwerkschnittstelle

        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 und p5.48xlarge mit mehreren Netzwerkschnittstellen

        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

    Installieren Sie NIXL. Weitere Informationen zu NIXL finden Sie im NIXL-Repository.

    Pre-built distributions
    Um NIXL mit PyPI zu installieren

    1. Installieren Sie die erforderlichen Abhängigkeiten.

      $ sudo apt install pip

    2. Installieren Sie NIXL.

      $ pip install nixl
    Build from source
    Um NIXL aus dem Quellcode zu erstellen und zu installieren

    1. Installieren Sie die erforderlichen Abhängigkeiten.

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

    2. Navigieren Sie zum Stammverzeichnis.

      $ cd $HOME

    3. Klonen Sie das offizielle NIXL-Repository auf die Instanz und navigieren Sie zum lokalen geklonten Repository.

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

    4. Erstellen und installieren Sie NIXL und geben Sie den Pfad zum Libfabric-Installationsverzeichnis an.

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

    Installieren Sie den NIXL-Benchmark und führen Sie einen Test durch, um sicherzustellen, dass Ihre temporäre Instance ordnungsgemäß für EFA und NIXL konfiguriert ist. Mit dem NIXL-Benchmark können Sie überprüfen, ob NIXL ordnungsgemäß installiert ist und wie erwartet funktioniert. Weitere Informationen finden Sie im Nixlbench-Repository.

    NIXL Benchmark (nixlbench) benötigt ETCD für die Koordination zwischen Client und Server. Um ETCD mit NIXL zu verwenden, sind ETCD-Server und -Client sowie die ETCD CPP-API erforderlich.

    Build from Docker
    Um NIXL Benchmark mit Docker zu installieren und zu testen

    1. Klonen Sie das offizielle NIXL-Repository auf die Instanz und navigieren Sie zum Nixlbench-Build-Verzeichnis.

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

    2. Erstellen Sie den Container.

      $ ./build.sh

      Weitere Informationen zu den Docker-Build-Optionen finden Sie im Nixlbench-Repository.

    3. Docker-Installation.

      $ sudo apt install docker.io -y

    4. Starten Sie den ETCD-Server für die Koordination.

      $ 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. Stellen Sie sicher, dass der ETCD-Server läuft.

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

      Erwartete Ausgabe:

      {"health":"true"}

    6. Öffnen Sie zwei Terminals für die Instanz. Führen Sie auf beiden Terminals den folgenden Befehl aus, um die Installation zu überprüfen. Der Befehl verwendet den ETCD-Server auf derselben Instance, verwendet Libfabric als Backend und arbeitet mit GPU-Speicher.

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

      Verwenden Sie den Wert DRAM anstelle von VRAM für Nicht-GPU-Instanzen.

    Build from source
    Wichtig

    Folgen Sie dieser Registerkarte nur, wenn Sie in Schritt 6 Aus Quelle erstellen ausgewählt haben.

    Um NIXL Benchmark zu installieren

    1. Installieren Sie die erforderlichen Systemabhängigkeiten.

      $ sudo apt install libgflags-dev

    2. Installieren Sie den ETCD-Server und -Client.

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

    3. Installieren Sie die ETCD CPP API.

      1. Installieren Sie die erforderlichen Abhängigkeiten für die ETCD CPP-API.

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

      2. Klonen und installieren Sie die ETCD CPP API.

        $ 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. Erstellen und installieren Sie Nixlbench.

      $ sudo meson setup . $HOME/nixl/benchmark/nixlbench -Dnixl_path=/usr/local/nixl/
$ sudo ninja && sudo ninja install
    Um Ihre EFA- und NIXL-Konfiguration zu testen

    1. Starten Sie den ETCD-Server auf der Instanz.

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

    2. Stellen Sie sicher, dass der ETCD-Server läuft.

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

      Erwartete Ausgabe:

      {"health":"true"}

    3. Öffnen Sie zwei Terminals für die Instanz. Führen Sie auf beiden Terminals die folgenden Schritte aus, um nixlbench auszuführen.

      1. Navigieren Sie zu dem Verzeichnis, in dem Nixlbench installiert ist.

        $ cd /usr/local/nixlbench/bin/

      2. Führen Sie den Test aus und geben Sie das Backend, die Adresse des ETCD-Servers und den Initiatorsegmenttyp an. Der folgende Befehl verwendet den ETCD-Server auf derselben Instanz, verwendet Libfabric als Backend und arbeitet mit GPU-Speicher. Die Umgebungsvariablen konfigurieren Folgendes:

        • NIXL_LOG_LEVEL=INFO— Ermöglicht eine detaillierte Debugging-Ausgabe. Sie können auch angebenWARN, dass nur Fehlermeldungen empfangen werden sollen.

        • LD_LIBRARY_PATH— Legt den Pfad für die NIXL-Bibliothek fest.

        Weitere Informationen zu den NIXL-Benchmark-Argumenten finden Sie in der NIXLbenchREADME-Datei im offiziellen Nixlbench-Repository.

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

        Verwenden Sie den Wert DRAM anstelle von VRAM für Nicht-GPU-Instanzen.

    Installieren Sie die Machine-Learning-Anwendungen auf der temporären Instance. Der Installationsvorgang variiert je nach Machine-Learning-Anwendung.

    Anmerkung

    Installationsanweisungen finden Sie in der Dokumentation Ihrer Anwendung für maschinelles Lernen.

    Nachdem Sie die erforderlichen Softwarekomponenten installiert haben, erstellen Sie ein AMI, das Sie erneut verwenden können, um Ihre EFA-fähigen Instances zu starten.

    So erstellen Sie ein AMI aus Ihrer temporären Instance:

    1. Öffnen Sie die Amazon-EC2-Konsole unter https://console.aws.amazon.com/ec2/.

    2. Wählen Sie im Navigationsbereich Instances aus.

    3. Wählen Sie die temporäre Instance aus, die Sie erstellt haben, und wählen Sie anschließend Actions (Aktionen), Image und Create Image (Image erstellen) aus.

    4. Gehen Sie bei Create Image (Image erstellen) wie folgt vor:

      1. Geben Sie unter Image name (Image-Name) einen beschreibenden Namen für das AMI ein.

      2. (Optional:) Geben Sie bei Image description (Image-Beschreibung) eine kurze Beschreibung des Zwecks des AMI ein.

      3. Wählen Sie Create Image (Image erstellen) aus.

    5. Wählen Sie im Navigationsbereich AMIs aus.

    6. Suchen Sie das AMI, das Sie erstellt haben, in der Liste. Warten Sie, bis der Status von pending zu available wechselt, bevor Sie mit dem nächsten Schritt fortfahren.

    An diesem Punkt benötigen Sie die temporäre Instance, die Sie gestartet haben, nicht mehr. Sie können die Instance beenden, damit keine weiteren Kosten dafür anfallen.

    So beenden Sie die temporäre Instance:

    1. Öffnen Sie die Amazon-EC2-Konsole unter https://console.aws.amazon.com/ec2/.

    2. Wählen Sie im Navigationsbereich Instances aus.

    3. Wählen Sie die temporäre instance aus, die Sie erstellt haben, und wählen Sie anschließend Actions (Aktionen), Instance state (Instance-Zustand) und Terminate instance (Instance beenden) aus.

    4. Wählen Sie Terminate (Kündigen) aus, wenn Sie zur Bestätigung aufgefordert werden.

    Starten Sie Ihre EFA- und NIXL-fähigen Instances mit dem EFA-fähigen AMI, das Sie in Schritt 9 erstellt haben, und der EFA-fähigen Sicherheitsgruppe, die Sie in Schritt 1 erstellt haben.

    Um EFA- und NIXL-fähige Instances zu starten

    1. Öffnen Sie die Amazon-EC2-Konsole unter https://console.aws.amazon.com/ec2/.

    2. Wählen Sie im Navigationsbereich Instances und dann Instances starten aus, um den Launch Instance Wizard zu öffnen.

    3. (Optional) Geben Sie im Bereich Name and tags (Name und Tags) einen Namen für die Instance an, z. B. EFA-instance. Der Name wird der Instance als Ressourcen-Tag (Name=EFA-instance) zugewiesen.

    4. Wählen Sie im Abschnitt Anwendungs- und Betriebssystemimages die Option My AMIs und dann das AMI aus, das Sie im vorherigen Schritt erstellt haben.

    5. Wählen Sie im Bereich Instance-Typ einen unterstützten Instance-Typ aus.

    6. Wählen Sie im Bereich Key pair (Schlüsselpaar) das Schlüsselpaar aus, das für die Instance verwendet werden soll.

    7. Wählen Sie im Bereich Network settings (Netzwerkeinstellungen) Edit (Bearbeiten) aus und führen Sie dann Folgendes aus:

      1. Wählen Sie unter Subnetz das Subnetz aus, in dem die Instance gestartet werden soll. Wenn Sie kein Subnetz auswählen, können Sie die Instance nicht für EFA aktivieren.

      2. Wählen Sie für Firewall (Sicherheitsgruppen) die Option Bestehende Sicherheitsgruppe auswählen und wählen Sie dann die Sicherheitsgruppe aus, die Sie in Schritt 1 erstellt haben.

      3. Erweitern Sie den Abschnitt Erweiterte Netzwerkkonfiguration.

        Wählen Sie für Netzwerkschnittstelle 1 Netzwerkkartenindex = 0, Geräteindex = 0 und Schnittstellentyp = EFA mit ENA aus.

        (Optional) Wenn Sie einen Instance-Typ mit mehreren Karten verwenden, z. B. p4d.24xlarge oder p5.48xlarge, wählen Sie für jede weitere erforderliche Netzwerkschnittstelle die Option Netzwerkschnittstelle hinzufügen, wählen Sie für Netzwerkkartenindex den nächsten ungenutzten Index aus und wählen Sie dann Geräteindex = 1 und Schnittstellentyp = EFA mit ENA oder Nur-EFA aus.

    8. (Optional) Konfigurieren Sie im Bereich Storage (Speicher) die Volumes nach Bedarf.

    9. Geben Sie im Bereich Summary (Zusammenfassung) rechts bei Number of instances (Anzahl der Instances) die Anzahl EFA-fähiger Instances ein, die Sie starten möchten, und wählen Sie dann Launch instance (Instance starten).

    Damit Ihre Anwendungen auf allen Instances in Ihrem Cluster ausgeführt werden können, müssen Sie passwortlosen SSH-Zugriff vom Führungsknoten auf die Mitgliedsknoten aktivieren. Der Führungsknoten ist die Instance, von der aus Sie die Anwendungen ausführen. Die verbleibenden Instances im Cluster sind die Mitgliedsknoten.

    So aktivieren Sie passwortloses SSH zwischen den Instances im Cluster:

    1. Wählen Sie eine Instance im Cluster als Führungsknoten aus und stellen Sie eine Verbindung zu ihr her.

    2. Deaktivieren Sie strictHostKeyChecking und aktivieren Sie ForwardAgent für den Führungsknoten. Öffnen Sie ~/.ssh/config mit dem bevorzugten Texteditor und fügen Sie Folgendes hinzu.

      Host *
    ForwardAgent yes
Host *
    StrictHostKeyChecking no

    3. Generieren Sie ein RSA-Schlüsselpaar.

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

      Das Schlüsselpaar wird im $HOME/.ssh/-Verzeichnis erstellt.

    4. Ändern Sie die Berechtigungen des privaten Schlüssels auf dem Führungsknoten.

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

    5. Öffnen Sie ~/.ssh/id_rsa.pub mit Ihrem bevorzugten Texteditor und kopieren Sie den Schlüssel.

    6. Gehen Sie für jeden Mitgliedsknoten im Cluster wie folgt vor:

      1. Stellen Sie eine Verbindung mit der Instance her.

      2. Öffnen Sie ~/.ssh/authorized_keys mit Ihrem bevorzugten Texteditor und fügen Sie den öffentlichen Schlüssel hinzu, den Sie zuvor kopiert haben.

    7. Um zu testen, ob das passwortlose SSH wie erwartet funktioniert, stellen Sie eine Verbindung zum Leaderknoten her und führen Sie den folgenden Befehl aus.

      $ ssh member_node_private_ip

      Sie sollten eine Verbindung zum Mitgliedsknoten herstellen können, ohne zur Eingabe eines Schlüssels oder Passworts aufgefordert zu werden.

    Wichtig

    Folgen Sie Schritt 13 nur, wenn Sie Schritt 7 befolgt haben.

    Führen Sie einen Test durch, um sicherzustellen, dass Ihre Instances ordnungsgemäß für EFA und NIXL konfiguriert sind.

    Build from Docker
    Um Ihre EFA- und NIXL-Konfiguration instanzübergreifend mit Docker zu testen

    1. Wählen Sie zwei Hosts aus, um den Nixlbench-Benchmark auszuführen. Verwenden Sie die IP-Adresse des ersten Hosts als ETCD-Server-IP für den Metadatenaustausch.

    2. Starten Sie den ETCD-Server auf 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. Stellen Sie sicher, dass der ETCD-Server läuft.

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

    4. Führen Sie den Nixlbench-Benchmark auf Host 1 aus.

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

    5. Führen Sie den Nixlbench-Benchmark auf Host 2 aus.

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

    Folgen Sie dieser Registerkarte nur, wenn Sie in Schritt 6 Aus Quelle erstellen ausgewählt haben.

    Um Ihre EFA- und NIXL-Konfiguration instanzübergreifend zu testen

    1. Wählen Sie zwei Hosts aus, um den Nixlbench-Benchmark auszuführen. Verwenden Sie die IP-Adresse des ersten Hosts als ETCD-Server-IP für den Metadatenaustausch.

    2. Starten Sie den ETCD-Server auf Host 1.

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

    3. Stellen Sie sicher, dass der ETCD-Server läuft.

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

    4. Führen Sie den Nixlbench-Benchmark auf Host 1 aus.

      $ 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. Führen Sie den Nixlbench-Benchmark auf Host 2 aus.

      $ 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

    Nach der Installation von NIXL können Sie NIXL über LLM-Inferenz- und Serving-Frameworks wie vLLM und Tensorrt-LLM verwenden. SGLang

    Um Ihren Inferenz-Workload mit vLLM zu bedienen

    1. Installieren Sie vLLM.

      $ pip install vllm

    2. Starten Sie den vLLM-Server mit NIXL. Die folgenden Beispielbefehle erstellen eine Prefill- (Producer) und eine Decodierungsinstanz (Consumer) für die NIXL-Handshake-Verbindung, den KV-Connector, die KV-Rolle und das Transport-Backend. Ausführliche Beispiele und Skripts finden Sie im Nutzungshandbuch. NIXLConnector

      Um NIXL mit EFA zu verwenden, legen Sie die Umgebungsvariablen entsprechend Ihrem Setup und Anwendungsfall fest.

      • Konfiguration des Herstellers (Prefiller)

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

      • Konfiguration für Verbraucher (Decoder)

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

      Die vorherige Beispielkonfiguration legt Folgendes fest:

      • kv_roletokv_both, was eine symmetrische Funktionalität ermöglicht, bei der der Konnektor sowohl als Produzent als auch als Verbraucher agieren kann. Dies bietet Flexibilität für Versuchsaufbauten und Szenarien, in denen die Rollenverteilung nicht im Voraus festgelegt ist.

      • kv_buffer_devicetocuda, was die Verwendung von GPU-Speicher ermöglicht.

      • NIXL-Backend zuLIBFABRIC, wodurch der NIXL-Verkehr über EFA übertragen werden kann.