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

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.](https://github.com/ai-dynamo/nixl)

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

**Topics**

## Schritt 1: Vorbereiten einer EFA-aktivierten Sicherheitsgruppe
<a name="nixl-start-base-setup"></a>

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 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](security-group-rules-reference.md).

**So erstellen Sie eine EFA-fähige Sicherheitsgruppe:**

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

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

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

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

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

   1. Wählen Sie **Sicherheitsgruppe erstellen** aus.

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

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

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

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

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

   1. Wählen Sie unter **Typ** die Option **SSH** aus.

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

   1. Wählen Sie **Regeln speichern** aus.

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

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

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

   1. Wählen Sie **Regeln speichern** aus.

## Schritt 2: Starten einer temporären Instance
<a name="nixl-start-base-temp"></a>

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/](https://console.aws.amazon.com/ec2/).

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

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

1. 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](https://docs.aws.amazon.com/dlami/latest/devguide/appendix-ami-release-notes) finden.

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

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

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

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

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

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

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

## Schritt 3: Installieren der Nvidia-GPU-Treiber, des Nvidia-CUDA-Toolkits und cuDNN
<a name="nixl-start-base-drivers"></a>

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

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

1. 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)
      ```

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

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

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

   1. Erstellen Sie die neue Grub-Konfiguration.

      ```
      $ sudo update-grub
      ```

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

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

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

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

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

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

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

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

## Schritt 4: Installieren GDRCopy
<a name="nixl-start-base-gdrcopy"></a>

Installieren Sie GDRCopy , um die Leistung von Libfabric auf GPU-basierten Plattformen zu verbessern. [Weitere Informationen zu finden Sie im GDRCopy Repository. GDRCopy ](https://github.com/NVIDIA/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
   ```

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

1. Erstellen Sie die GDRCopy DEB-Pakete.

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

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

## Schritt 5: Installieren der EFA-Software
<a name="nixl-start-base-enable"></a>

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](connect-to-linux-instance.md).

1. 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.48.0.tar.gz
   ```

1. 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.48.0.tar.gz && rm -rf aws-efa-installer-1.48.0.tar.gz && cd aws-efa-installer
   ```

1. (*Optional*) Überprüfen Sie die einzelnen Paketsignaturen während der Installation.

   Ab dem EFA-Installationsprogramm 1.48.0 enthält das Installationsprogramm GPG-signierte einzelne RPM- und DEB-Pakete. Verwenden Sie das Flag, um die Authentizität und Integrität jedes einzelnen Pakets während der Installation zu überprüfen. `--check-signatures` Wenn Sie dieses Flag aktivieren, überprüft das Installationsprogramm zuerst alle Paketsignaturen und setzt die Installation nur fort, wenn jedes Paket die Überprüfung bestanden hat. Wenn die Überprüfung eines Pakets fehlschlägt, wird das Installationsprogramm sofort beendet, ohne dass etwas installiert wird.

   1. Laden Sie den öffentlichen GPG-Schlüssel herunter.

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

   1. Exportieren Sie den Schlüsselpfad. Fügen Sie dann im nächsten Schritt den Installationsbefehl `--check-signatures` hinzu und verwenden Sie `sudo -E` statt dessen, `sudo` um die Umgebungsvariable beizubehalten.

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

   Auf RPM-basierten Systemen (Amazon Linux, RHEL, Rocky Linux und SUSE) verifiziert das Installationsprogramm jedes RPM mithilfe von. `rpm --checksig` Auf DEB-basierten Systemen (Ubuntu, Debian) verifiziert das Installationsprogramm jedes DEB mithilfe der GPG-Signaturüberprüfung.

   Wenn die Überprüfung eines Pakets fehlschlägt, wird die Installation sofort abgebrochen, wodurch Ihr System vor kaputten oder bösartigen Paketen geschützt wird.
**Anmerkung**  
Die `--check-signatures` Markierung ist optional. Ohne sie führt das Installationsprogramm keine individuelle Signaturüberprüfung durch.

1. Führen Sie das EFA-Software-Installationsskript aus.
**Anmerkung**  
Wenn Sie den vorherigen optionalen Schritt zur Einrichtung der Paketsignaturüberprüfung abgeschlossen haben, fügen Sie ihn `--check-signatures` an den Installationsbefehl an und verwenden Sie `sudo -E` stattdessen. `sudo` Beispiel: `sudo -E ./efa_installer.sh -y --check-signatures`.

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

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

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

1. Ü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
     ```

## Schritt 6: Installieren Sie NIXL
<a name="nixl-start-base-nixl"></a>

Installieren Sie NIXL. Weitere Informationen zu NIXL finden Sie im [NIXL-Repository](https://github.com/ai-dynamo/nixl).

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

**Um NIXL mit PyPI zu installieren**

1. Installieren Sie die erforderlichen Abhängigkeiten.

   ```
   $ sudo apt install pip
   ```

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

1. Navigieren Sie zum Stammverzeichnis.

   ```
   $ cd $HOME
   ```

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

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

------

## Schritt 7: Installieren Sie NIXL Benchmark und testen Sie Ihre EFA- und NIXL-Konfiguration
<a name="nixl-start-base-tests"></a>

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](https://github.com/ai-dynamo/nixl/tree/main/benchmark/nixlbench).

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

1. Erstellen Sie den Container.

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

   [Weitere Informationen zu den Docker-Build-Optionen finden Sie im Nixlbench-Repository.](https://github.com/ai-dynamo/nixl/tree/main/benchmark/nixlbench)

1. Docker-Installation.

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

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

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

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

   Erwartete Ausgabe:

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

1. Ö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
   ```

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

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

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

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

1. 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" &
   ```

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

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

   Erwartete Ausgabe:

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

1. Ö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/
      ```

   1. 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 angeben`WARN`, 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](https://github.com/ai-dynamo/nixl/blob/main/benchmark/nixlbench/README.md) 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.

------

## Schritt 8: Installieren Sie Ihre Anwendungen für maschinelles Lernen
<a name="nixl-start-base-app"></a>

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 Machine-Learning-Anwendung.

## Schritt 9: Erstellen Sie ein EFA- und NIXL-fähiges AMI
<a name="nixl-start-base-ami"></a>

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/](https://console.aws.amazon.com/ec2/).

1. Wählen Sie im Navigationsbereich **Instances** aus.

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

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

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

   1. Wählen Sie **Create Image (Image erstellen)** aus.

1. Wählen Sie im Navigationsbereich **AMIs** aus.

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

## Schritt 10: Beenden der temporären Instance
<a name="nixl-start-base-terminate"></a>

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/](https://console.aws.amazon.com/ec2/).

1. Wählen Sie im Navigationsbereich **Instances** aus.

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

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

## Schritt 11: Starten Sie EFA- und NIXL-fähige Instances
<a name="nixl-start-base-cluster"></a>

**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/](https://console.aws.amazon.com/ec2/).

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

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

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

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

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

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

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

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

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

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

## Schritt 12: Passwortloses SSH aktivieren
<a name="nixl-start-base-passwordless"></a>

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.

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

1. Generieren Sie ein RSA-Schlüsselpaar.

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

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

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

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

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

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

   1. Stellen Sie eine Verbindung mit der Instance her.

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

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

## Schritt 13: Testen Sie Ihre EFA- und NIXL-Konfiguration instanzübergreifend
<a name="nixl-start-base-test-multi"></a>

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

------

## *Schritt 14: Testen Sie die disaggregierte Inferenzbereitstellung über vLLM (optional)*
<a name="nixl-start-base-serve"></a>

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

1. 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](https://github.com/vllm-project/vllm/blob/2d977a7a9ead3179fde9ed55d69393ef7b6cec47/docs/features/nixl_connector_usage.md)

   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_role`to`kv_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_device`to`cuda`, was die Verwendung von GPU-Speicher ermöglicht.
   + NIXL-Backend zu`LIBFABRIC`, wodurch der NIXL-Verkehr über EFA übertragen werden kann.