Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Memulai EFA dan NIXL untuk beban kerja inferensi di Amazon EC2
<a name="efa-start-nixl"></a>

NVIDIA Inference Xfer Library (NIXL) adalah pustaka komunikasi latensi rendah throughput tinggi yang dirancang khusus untuk beban kerja inferensi terpilah. NIXL dapat digunakan bersama dengan EFA dan Libfabric untuk mendukung transfer KV-cache antara prefill dan decode node, dan memungkinkan pergerakan KV-cache yang efisien antara berbagai lapisan penyimpanan. Untuk informasi lebih lanjut, lihat situs web [NIXL](https://github.com/ai-dynamo/nixl).

**Persyaratan**
+ Hanya basis Ubuntu 24.04 dan Ubuntu 22.04 AMIs yang didukung.
+ EFA hanya mendukung NIXL 1.0.0 dan yang lebih baru.

**Topics**

## Langkah 1: Siapkan grup keamanan yang diaktifkan EFA
<a name="nixl-start-base-setup"></a>

EFA memerlukan grup keamanan yang memungkinkan semua lalu lintas masuk dan keluar ke dan dari grup keamanan itu sendiri. Prosedur berikut membuat grup keamanan yang memungkinkan semua lalu lintas masuk dan keluar ke dan dari dirinya sendiri, dan yang memungkinkan lalu lintas SSH masuk dari IPv4 alamat apa pun untuk konektivitas SSH.

**penting**  
Grup keamanan ini ditujukan untuk tujuan pengujian saja. Untuk lingkungan produksi Anda, kami sarankan Anda membuat aturan SSH masuk yang memungkinkan lalu lintas hanya dari alamat IP dari mana Anda terhubung, seperti alamat IP komputer Anda, atau berbagai alamat IP di jaringan lokal Anda.

Untuk skenario lainnya, lihat [Aturan-aturan grup keamanan untuk kasus penggunaan yang berbeda](security-group-rules-reference.md).

**Untuk membuat grup keamanan yang diaktifkan EFA**

1. Buka konsol Amazon EC2 di. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)

1. Dalam panel navigasi, pilih **Grup Keamanan**, lalu pilih **Buat grup keamanan**.

1. Di jendela **Buat Grup Keamanan**, lakukan hal berikut:

   1. Untuk **Nama grup keamanan**, masukkan nama deskriptif untuk grup keamanan, seperti `EFA-enabled security group`.

   1. (Opsional) Untuk **Deskripsi**, masukkan deskripsi singkat grup keamanan.

   1. Untuk **VPC**, pilih VPC untuk tujuan peluncuran instans Anda yang didukung EFA.

   1. Pilih **Buat grup keamanan**.

1. Pilih grup keamanan yang Anda buat, dan pada tab **Detail**, salin **ID grup keamanan**.

1. Dengan grup keamanan yang masih dipilih, pilih **Tindakan**, **Edit aturan masuk**, lalu lakukan hal berikut:

   1. Pilih **Tambahkan aturan**.

   1. Untuk **Tipe**, pilih **Semua lalu lintas**.

   1. Untuk **Tipe sumber**, pilih **Kustom** dan tempelkan ID grup keamanan yang Anda salin ke dalam bidang.

   1. Pilih **Tambahkan aturan**.

   1. Untuk **Tipe**, pilih **SSH**.

   1. Untuk **jenis Sumber**, pilih **Anywhere- IPv4**.

   1. Pilih **Simpan aturan**.

1. Dengan grup keamanan yang masih dipilih, pilih **Tindakan**, **Edit aturan keluar**, lalu lakukan hal berikut:

   1. Pilih **Tambahkan aturan**.

   1. Untuk **Tipe**, pilih **Semua lalu lintas**.

   1. Untuk **Tipe tujuan**, pilih **Kustom** dan tempelkan ID grup keamanan yang Anda salin ke dalam bidang.

   1. Pilih **Simpan aturan**.

## Langkah 2: Luncurkan instans sementara
<a name="nixl-start-base-temp"></a>

Luncurkan instans sementara yang dapat Anda gunakan untuk menginstal dan mengonfigurasi komponen perangkat lunak EFA. Anda menggunakan instans ini untuk membuat AMI yang diaktifkan EFA sebagai tempat untuk meluncurkan instans Anda yang diaktifkan EFA.

**Untuk meluncurkan instans sementara**

1. Buka konsol Amazon EC2 di. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)

1. Di panel navigasi, pilih **Instans**, lalu pilih **Luncurkan Instans** untuk membuka wizard peluncuran instans baru.

1. (*Opsional*) Di bagian **Nama dan tanda**, berikan nama untuk instans, seperti `EFA-instance`. Nama ditetapkan ke instans sebagai tanda sumber daya (`Name={{EFA-instance}}`).

1. Di bagian **Application and OS Images**, pilih AMI untuk salah satu sistem operasi yang didukung. Anda juga dapat memilih DLAMI yang didukung yang ditemukan di Halaman Catatan Rilis [DLAMI](https://docs.aws.amazon.com/dlami/latest/devguide/appendix-ami-release-notes).

1. Di bagian **Jenis instans**, pilih jenis instans yang didukung.

1. Pada bagian **Pasangan kunci**, pilih pasangan kunci yang akan digunakan untuk instans.

1. Di bagian **Pengaturan jaringan**, pilih **Edit**, lalu lakukan hal berikut:

   1. Untuk **Subnet**, pilih subnet untuk meluncurkan instans. Jika Anda tidak memilih subnet, Anda tidak dapat mengaktifkan instans untuk EFA.

   1. Untuk **Firewall (grup keamanan)**, pilih **Pilih grup keamanan yang ada**, lalu pilih grup keamanan yang Anda buat di langkah sebelumnya.

   1. Perluas bagian **Konfigurasi jaringan lanjutan**.

      Untuk **antarmuka Jaringan 1**, pilih **Indeks kartu jaringan = 0**, **Indeks perangkat = 0**, dan **Jenis antarmuka = EFA dengan ENA**.

      **(*Opsional*) Jika Anda menggunakan jenis instans multi-kartu, seperti `p4d.24xlarge` atau`p5.48xlarge`, untuk setiap antarmuka jaringan tambahan yang diperlukan, pilih **Tambahkan antarmuka jaringan**, untuk **indeks kartu jaringan pilih indeks** berikutnya yang tidak digunakan, lalu pilih **Indeks perangkat = 1 dan Jenis antarmuka =** **EFA dengan ENA atau EFA** saja.**

1. Di bagian **Penyimpanan**, konfigurasikan volume sesuai kebutuhan.
**catatan**  
Anda harus menyediakan penyimpanan tambahan 10 hingga 20 GiB untuk Nvidia CUDA. Jika Anda tidak menyediakan penyimpanan yang cukup, Anda akan menerima kesalahan `insufficient disk space` saat mencoba menginstal driver Nvidia dan toolkit CUDA.

1. Di panel **Ringkasan** di sebelah kanan, pilih **Luncurkan instans**.

**penting**  
Lewati Langkah 3 jika AMI Anda sudah menyertakan driver GPU Nvidia, toolkit CUDA, dan cuDNN, atau jika Anda menggunakan instance non-GPU.

## Langkah 3: Instal driver Nvidia GPU, kit alat CUDA Nvidia, dan cuDNN
<a name="nixl-start-base-drivers"></a>

**Untuk menginstal driver Nvidia GPU, kit alat CUDA Nvidia, dan cuDNN**

1. Untuk memastikan bahwa semua paket perangkat lunak Anda telah diperbarui, lakukan pembaruan perangkat lunak cepat di instans Anda.

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

1. Pasang utilitas yang diperlukan untuk memasang driver GPU Nvidia dan toolkit Nvidia CUDA.

   ```
   $ sudo apt-get install build-essential -y
   ```

1. Untuk menggunakan driver GPU Nvidia, Anda harus menonaktifkan driver sumber terbuka `nouveau` terlebih dahulu.

   1. Instal utilitas yang diperlukan dan paket header kernel untuk versi kernel yang sedang Anda jalankan.

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

   1. Tambahkan `nouveau` ke file daftar penolakan `/etc/modprobe.d/blacklist.conf `.

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

   1. Buka `/etc/default/grub` menggunakan editor teks pilihan Anda dan tambahkan berikut ini.

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

   1. Buat kembali konfigurasi Grub.

      ```
      $ sudo update-grub
      ```

1. Boot ulang dan terhubung kembali ke instans Anda.

1. Tambahkan repositori CUDA dan instal driver Nvidia GPU, toolkit CUDA NVIDIA, dan 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. Boot ulang dan terhubung kembali ke instans Anda.

1. (`p4d.24xlarge` dan `p5.48xlarge` saja) Instal Nvidia Fabric Manager.

   1. Anda harus menginstal versi Nvidia Fabric Manager yang cocok dengan versi modul kernel Nvidia yang Anda instal pada langkah sebelumnya.

      Jalankan perintah berikut untuk menentukan versi modul kernel Nvidia.

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

      Berikut ini adalah output contoh.

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

      Pada contoh di atas, versi utama `450` dari modul kernel diinstal. Ini berarti Anda perlu menginstal versi Nvidia Fabric Manager `450`.

   1. Instal Nvidia Fabric Manager. Jalankan perintah berikut dan tentukan versi utama yang diidentifikasi pada langkah sebelumnya.

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

      Misalnya, jika versi `450` utama modul kernel diinstal, gunakan perintah berikut untuk menginstal versi Nvidia Fabric Manager yang cocok.

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

   1. Mulai layanan, dan pastikan bahwa layanan tersebut dimulai secara otomatis ketika instans dimulai. Nvidia Fabric Manager diperlukan untuk NV Switch Management.

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

1. Pastikan bahwa jalur CUDA diatur setiap kali instans dimulai.
   + Untuk shell *bash*, tambahkan pernyataan berikut ke `/home/{{username}}/.bashrc` dan `/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
     ```
   + Untuk shell *tcsh*, tambahkan pernyataan berikut ke `/home/{{username}}/.cshrc`.

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

1. Untuk mengonfirmasi bahwa driver Nvidia GPU berfungsi, jalankan perintah berikut.

   ```
   $ nvidia-smi -q | head
   ```

   Perintah tersebut harus mengembalikan informasi tentang Nvidia GPUs, driver GPU Nvidia, dan toolkit Nvidia CUDA.

**penting**  
Lewati Langkah 4 jika AMI Anda sudah termasuk GDRCopy, atau jika Anda menggunakan instans non-GPU.

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

Instal GDRCopy untuk meningkatkan kinerja Libfabric pada platform berbasis GPU. Untuk informasi selengkapnyaGDRCopy, lihat [GDRCopy repositori](https://github.com/NVIDIA/gdrcopy).

**Untuk menginstal GDRCopy**

1. Instal dependensi yang diperlukan.

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

1. Unduh dan ekstrak GDRCopy paketnya.

   ```
   $ 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. Bangun paket GDRCopy DEB.

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

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

**penting**  
Lewati Langkah 5 jika AMI Anda sudah menyertakan penginstal EFA terbaru.

## Langkah 5: Instal perangkat lunak EFA
<a name="nixl-start-base-enable"></a>

Instal kernel berkemampuan EFA, driver EFA, dan tumpukan Libfabric yang diperlukan untuk mendukung EFA pada instans Anda.

**Untuk menginstal perangkat lunak EFA**

1. Hubungkan ke instans yang Anda luncurkan. Untuk informasi selengkapnya, lihat [Hubungkan ke instans Linux Anda, menggunakan SSH.](connect-to-linux-instance.md).

1. Unduh file penginstalan perangkat lunak EFA. File penginstalan perangkat lunak dikemas menjadi file tarball (`.tar.gz`) yang dikompresi. Untuk mengunduh versi *stabil* terbaru, gunakan perintah berikut.

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

1. Ekstrak file dari file terkompresi`.tar.gz`, hapus tarball, dan navigasikan ke direktori yang diekstraksi.

   ```
   $ 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. (*Opsional*) Verifikasi tanda tangan paket individual selama instalasi.

   Dimulai dengan installer EFA 1.48.0, installer menyertakan paket RPM dan DEB individual yang ditandatangani GPG. Untuk memverifikasi keaslian dan integritas setiap paket individu selama instalasi, gunakan `--check-signatures` bendera. Saat Anda mengaktifkan tanda ini, penginstal memverifikasi semua tanda tangan paket terlebih dahulu, dan hanya melanjutkan penginstalan jika setiap paket melewati verifikasi. Jika ada paket yang gagal verifikasi, penginstal segera keluar tanpa menginstal apa pun.

   1. Unduh kunci publik GPG.

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

   1. Ekspor jalur kunci. Kemudian, pada langkah berikutnya, tambahkan `--check-signatures` ke perintah instalasi dan gunakan `sudo -E` alih-alih `sudo` untuk melestarikan variabel lingkungan.

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

   Pada sistem berbasis RPM (Amazon Linux, RHEL, Rocky Linux, dan SUSE), installer memverifikasi setiap RPM menggunakan. `rpm --checksig` Pada sistem berbasis DEB (Ubuntu, Debian), installer memverifikasi setiap DEB menggunakan verifikasi tanda tangan GPG.

   Jika verifikasi paket apa pun gagal, instalasi segera dibatalkan, melindungi sistem Anda dari paket yang rusak atau berbahaya.
**catatan**  
`--check-signatures`Bendera adalah opsional. Tanpa itu, penginstal tidak melakukan verifikasi tanda tangan individu.

1. Unduh skrip penginstalan perangkat lunak EFA.
**catatan**  
Jika Anda menyelesaikan langkah opsional sebelumnya untuk mengatur verifikasi tanda tangan paket, tambahkan `--check-signatures` ke perintah instalasi dan gunakan `sudo -E` sebagai gantinya. `sudo` Sebagai contoh: `sudo -E ./efa_installer.sh -y --check-signatures`.

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

   **Libfabric** diinstal di `/opt/amazon/efa` direktori.

1. Jika penginstal EFA meminta Anda untuk me-reboot instans, lakukanlah dan kemudian sambungkan kembali ke instans. Jika tidak, log out dari instans lalu log kembali untuk menyelesaikan penginstalan.

1. Pastikan bahwa komponen perangkat lunak EFA telah berhasil diinstal.

   ```
   $ fi_info -p efa -t FI_EP_RDM
   ```

   Perintah tersebut harus mengembalikan informasi tentang antarmuka Libfabric EFA. Contoh berikut menunjukkan output perintah.
   + `p3dn.24xlarge` dengan satu antarmuka jaringan

     ```
     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` dan `p5.48xlarge` dengan berbagai antarmuka jaringan

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

## Langkah 6: Instal NIXL
<a name="nixl-start-base-nixl"></a>

Instal NIXL. Untuk informasi selengkapnya tentang NIXL, lihat repositori [NIXL](https://github.com/ai-dynamo/nixl).

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

**Untuk menginstal NIXL menggunakan PyPI**

1. Instal dependensi yang diperlukan.

   ```
   $ sudo apt install pip
   ```

1. Instal NIXL.

   ```
   $ pip install nixl
   ```

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

**Untuk membangun dan menginstal NIXL dari sumber**

1. Instal dependensi yang diperlukan.

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

1. Navigasi ke direktori beranda Anda.

   ```
   $ cd $HOME
   ```

1. Kloning repositori NIXL resmi ke instance dan navigasikan ke repositori kloning lokal.

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

1. Bangun dan instal NIXL dan tentukan jalur ke direktori instalasi Libfabric.

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

------

## Langkah 7: Instal NIXL Benchmark dan uji konfigurasi EFA dan NIXL Anda
<a name="nixl-start-base-tests"></a>

Instal Benchmark NIXL dan jalankan pengujian untuk memastikan bahwa instans sementara Anda dikonfigurasi dengan benar untuk EFA dan NIXL. Benchmark NIXL memungkinkan Anda untuk mengonfirmasi bahwa NIXL diinstal dengan benar dan beroperasi seperti yang diharapkan. Untuk informasi selengkapnya, lihat repositori [nixlbench](https://github.com/ai-dynamo/nixl/tree/main/benchmark/nixlbench).

NIXL Benchmark (nixlbench) membutuhkan ETCD untuk koordinasi antara klien dan server. Untuk menggunakan ETCD dengan NIXL memerlukan ETCD Server dan Klien, dan ETCD CPP API.

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

**Untuk menginstal dan menguji NIXL Benchmark menggunakan Docker**

1. Kloning repositori NIXL resmi ke instance dan navigasikan ke direktori build nixlbench.

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

1. Bangun wadahnya.

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

   Untuk informasi selengkapnya tentang opsi build Docker, lihat repositori [nixlbench](https://github.com/ai-dynamo/nixl/tree/main/benchmark/nixlbench).

1. Pasang Docker.

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

1. Mulai server ETCD untuk koordinasi.

   ```
   $ 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. Validasi bahwa server ETCD sedang berjalan.

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

   Keluaran yang diharapkan

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

1. Buka dua terminal untuk contoh. Di kedua terminal, jalankan perintah berikut untuk memverifikasi instalasi. Perintah menggunakan server ETCD pada instance yang sama, menggunakan Libfabric sebagai backend, dan beroperasi menggunakan memori 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
   ```
**catatan**  
Gunakan nilai `DRAM` alih-alih `VRAM` untuk instance non-GPU.

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

**penting**  
Ikuti tab ini hanya jika Anda memilih **Build from source** di Langkah 6.

**Untuk menginstal NIXL Benchmark**

1. Instal dependensi sistem yang diperlukan.

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

1. Instal ETCD Server dan Klien.

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

1. Instal ETCD CPP API.

   1. Instal dependensi yang diperlukan untuk ETCD CPP API.

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

   1. Kloning dan instal 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. Bangun dan instal nixlbench.

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

**Untuk menguji konfigurasi EFA dan NIXL Anda**

1. Mulai server ETCD pada instance.

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

1. Validasi bahwa server ETCD sedang berjalan.

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

   Keluaran yang diharapkan

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

1. Buka dua terminal untuk contoh. Di kedua terminal, selesaikan langkah-langkah berikut untuk menjalankan nixlbench.

   1. Arahkan ke direktori tempat nixlbench diinstal.

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

   1. Jalankan pengujian dan tentukan backend, alamat server ETCD, dan tipe segmen inisiator. Perintah berikut menggunakan server ETCD pada contoh yang sama, menggunakan Libfabric sebagai backend, dan beroperasi menggunakan memori GPU. Variabel lingkungan mengkonfigurasi berikut ini:
      + `NIXL_LOG_LEVEL=INFO`- Mengaktifkan output debugging rinci. Anda juga dapat menentukan `WARN` untuk hanya menerima pesan kesalahan.
      + `LD_LIBRARY_PATH`— Menetapkan jalur untuk perpustakaan NIXL.

      Untuk informasi lebih lanjut tentang argumen Benchmark NIXL, lihat [NIXLbenchREADME](https://github.com/ai-dynamo/nixl/blob/main/benchmark/nixlbench/README.md) di repositori nixlbench resmi.

      ```
      $ 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'
      ```
**catatan**  
Gunakan nilai `DRAM` alih-alih `VRAM` untuk instance non-GPU.

------

## Langkah 8: Instal aplikasi pembelajaran mesin Anda
<a name="nixl-start-base-app"></a>

Instal aplikasi machine learning di instans sementara. Prosedur penginstalan bervariasi tergantung pada aplikasi machine learning tertentu.

**catatan**  
Lihat dokumentasi aplikasi pembelajaran mesin Anda untuk petunjuk pemasangan.

## Langkah 9: Buat AMI yang mendukung EFA dan NIXL
<a name="nixl-start-base-ami"></a>

Setelah menginstal komponen perangkat lunak yang diperlukan, Anda membuat AMI yang dapat digunakan kembali untuk meluncurkan instans Anda dengan EFA yang diaktifkan.

**Untuk membuat AMI dari instans sementara Anda**

1. Buka konsol Amazon EC2 di. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)

1. Di panel navigasi, pilih **Instans**.

1. Pilih instans sementara yang Anda buat dan pilih **Tindakan**, **Gambar**, **Buat gambar**.

1. Untuk **Buat gambar**, lakukan hal berikut:

   1. Untuk **Nama gambar**, masukkan nama deskriptif untuk AMI.

   1. (Opsional) Untuk **Deskripsi gambar**, masukkan deskripsi singkat tentang tujuan AMI.

   1. Pilih **Buat gambar**.

1. Di panel navigasi, pilih **AMIs**.

1. Temukan AMI yang Anda buat dalam daftar. Tunggu hingga status berubah dari `pending` menjadi `available` sebelum melanjutkan ke langkah berikutnya.

## Langkah 10: Mengakhiri instans sementara
<a name="nixl-start-base-terminate"></a>

Pada titik ini, Anda tidak memerlukan lagi instans sementara yang Anda luncurkan. Anda dapat mengakhiri instans agar biaya tidak dibebankan lagi padanya.

**Untuk mengakhiri instans sementara**

1. Buka konsol Amazon EC2 di. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)

1. Di panel navigasi, pilih **Instans**.

1. Pilih instans sementara yang Anda buat dan pilih **Tindakan**, **Status instans**, **Akhiri instans**.

1. Saat diminta konfirmasi, pilih **Akhiri**.

## Langkah 11: Luncurkan instans yang mendukung EFA dan NIXL
<a name="nixl-start-base-cluster"></a>

**Luncurkan instans berkemampuan EFA dan NIXL Anda menggunakan AMI berkemampuan EFA yang Anda buat di **Langkah 9**, dan grup keamanan berkemampuan EFA yang Anda buat di Langkah 1.**

**Untuk meluncurkan instans berkemampuan EFA dan NIXL**

1. Buka konsol Amazon EC2 di. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)

1. Di panel navigasi, pilih **Instans**, lalu pilih **Luncurkan Instans** untuk membuka wizard peluncuran instans baru.

1. (*Opsional*) Di bagian **Nama dan tanda**, berikan nama untuk instans, seperti `EFA-instance`. Nama ditetapkan ke instans sebagai tanda sumber daya (`Name={{EFA-instance}}`).

1. Di bagian **Application and OS Images**AMIs, pilih **My**, lalu pilih AMI yang Anda buat pada langkah sebelumnya.

1. Di bagian **Jenis instans**, pilih jenis instans yang didukung.

1. Pada bagian **Pasangan kunci**, pilih pasangan kunci yang akan digunakan untuk instans.

1. Di bagian **Pengaturan jaringan**, pilih **Edit**, lalu lakukan hal berikut:

   1. Untuk **Subnet**, pilih subnet untuk meluncurkan instans. Jika Anda tidak memilih subnet, Anda tidak dapat mengaktifkan instans untuk EFA.

   1. Untuk **Firewall (grup keamanan)**, **pilih Pilih grup keamanan yang ada**, lalu pilih grup keamanan yang Anda buat di **Langkah 1**.

   1. Perluas bagian **Konfigurasi jaringan lanjutan**.

      Untuk **antarmuka Jaringan 1**, pilih **Indeks kartu jaringan = 0**, **Indeks perangkat = 0**, dan **Jenis antarmuka = EFA dengan ENA**.

      **(*Opsional*) Jika Anda menggunakan jenis instans multi-kartu, seperti `p4d.24xlarge` atau`p5.48xlarge`, untuk setiap antarmuka jaringan tambahan yang diperlukan, pilih **Tambahkan antarmuka jaringan**, untuk **indeks kartu jaringan pilih indeks** berikutnya yang tidak digunakan, lalu pilih **Indeks perangkat = 1 dan Jenis antarmuka =** **EFA dengan ENA atau EFA** saja.**

1. (*Opsional*) Di bagian **Penyimpanan**, konfigurasikan volume sesuai kebutuhan.

1. Di panel **Ringkasan** di sebelah kanan, untuk **Jumlah instans**, masukkan jumlah instans yang diaktifkan EFA yang ingin Anda luncurkan, lalu pilih **Luncurkan instans**.

## Langkah 12: Mengaktifkan SSH tanpa kata sandi
<a name="nixl-start-base-passwordless"></a>

Agar aplikasi Anda dapat berjalan di semua instans dalam klaster, Anda harus mengaktifkan akses SSH tanpa kata sandi dari simpul pemimpin ke simpul anggota. Simpul pemimpin adalah instans dari mana Anda menjalankan aplikasi Anda. Instans yang tersisa di klaster adalah simpul anggota.

**Untuk mengaktifkan SSH tanpa kata sandi antar instans dalam klaster**

1. Pilih satu instans dalam klaster sebagai simpul pemimpin, dan hubungkan ke instans tersebut.

1. Nonaktifkan `strictHostKeyChecking` dan aktifkan `ForwardAgent` pada simpul pemimpin. Buka `~/.ssh/config` menggunakan editor teks pilihan Anda dan tambahkan berikut ini.

   ```
   Host *
       ForwardAgent yes
   Host *
       StrictHostKeyChecking no
   ```

1. Membuat pasangan kunci RSA.

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

   Pasangan kunci dibuat dalam direktori `$HOME/.ssh/`.

1. Ubah izin kunci privat pada simpul pemimpin.

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

1. Buka `~/.ssh/id_rsa.pub` menggunakan editor teks pilihan Anda dan salin kunci.

1. Untuk setiap simpul anggota di klaster, lakukan hal berikut:

   1. Hubungkan dengan instans.

   1. Buka `~/.ssh/authorized_keys` menggunakan editor teks pilihan Anda tambahkan kunci publik yang Anda salin sebelumnya.

1. Untuk menguji apakah SSH tanpa kata sandi berfungsi seperti yang diharapkan, hubungkan ke simpul pemimpin Anda dan jalankan perintah berikut.

   ```
   $ ssh {{member_node_private_ip}}
   ```

   Anda harus terhubung ke simpul anggota tanpa diminta untuk memasukkan kunci atau kata sandi.

**penting**  
Ikuti Langkah 13 hanya jika Anda mengikuti Langkah 7.

## Langkah 13: Uji konfigurasi EFA dan NIXL Anda di seluruh instance
<a name="nixl-start-base-test-multi"></a>

Jalankan pengujian untuk memastikan bahwa instans Anda dikonfigurasi dengan benar untuk EFA dan NIXL.

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

**Untuk menguji konfigurasi EFA dan NIXL Anda di seluruh instance menggunakan Docker**

1. Pilih dua host untuk menjalankan benchmark nixlbench. Gunakan alamat IP host pertama sebagai IP server ETCD untuk pertukaran metadata.

1. Mulai server ETCD di 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. Validasi bahwa server ETCD sedang berjalan.

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

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

1. Jalankan benchmark nixlbench pada host 1.

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

1. Jalankan benchmark nixlbench pada host 2.

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

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

**penting**  
Ikuti tab ini hanya jika Anda memilih **Build from source** di Langkah 6.

**Untuk menguji konfigurasi EFA dan NIXL Anda di seluruh instance**

1. Pilih dua host untuk menjalankan benchmark nixlbench. Gunakan alamat IP host pertama sebagai IP server ETCD untuk pertukaran metadata.

1. Luncurkan server ETCD di host 1.

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

1. Validasi bahwa server ETCD sedang berjalan.

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

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

1. Jalankan benchmark nixlbench pada host 1.

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

1. Jalankan benchmark nixlbench pada host 2.

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

------

## *Langkah 14: Uji penyajian inferensi terpilah melalui VllM (Opsional)*
<a name="nixl-start-base-serve"></a>

Setelah NIXL diinstal, Anda dapat menggunakan NIXL melalui inferensi LLM dan kerangka kerja penyajian seperti VllM,, dan TensorRT-LLM. SGLang

**Untuk melayani beban kerja inferensi Anda menggunakan VllM**

1. Instal Vllm.

   ```
   $ pip install vllm
   ```

1. Mulai server Vllm dengan NIXL. Contoh perintah berikut membuat satu prefill (producer) dan satu decode (consumer) instance untuk koneksi handshake NIXL, konektor KV, peran KV, dan backend transport. Untuk contoh dan skrip terperinci, lihat [Panduan NIXLConnector Penggunaan](https://github.com/vllm-project/vllm/blob/2d977a7a9ead3179fde9ed55d69393ef7b6cec47/docs/features/nixl_connector_usage.md).

   Untuk menggunakan NIXL dengan EFA, atur variabel lingkungan berdasarkan kasus penyiapan dan penggunaan Anda.
   + Konfigurasi Produser (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"]}}'
     ```
   + Konfigurasi konsumen (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"]}}'
     ```

   Konfigurasi sampel sebelumnya menetapkan hal berikut:
   + `kv_role`untuk`kv_both`, yang memungkinkan fungsionalitas simetris di mana konektor dapat bertindak sebagai produsen dan konsumen. Ini memberikan fleksibilitas untuk pengaturan eksperimental dan skenario di mana perbedaan peran tidak ditentukan sebelumnya.
   + `kv_buffer_device`untuk`cuda`, yang memungkinkan menggunakan memori GPU.
   + NIXL backend ke`LIBFABRIC`, yang memungkinkan lalu lintas NIXL melewati EFA.