本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。

# 開始使用適用於 Amazon EC2 上推論工作負載的 EFA 和 NIXL
<a name="efa-start-nixl"></a>

NVIDIA Inference Xfer Library (NIXL) 是一種高輸送量、低延遲的通訊程式庫，專為分解的推論工作負載而設計。NIXL 可以與 EFA 和 Libfabric 搭配使用，以支援預先填充和解碼節點之間的 KV-cache 傳輸，並可在各種儲存層之間實現高效的 KV-cache 移動。如需詳細資訊，請參閱 [NIXL](https://github.com/ai-dynamo/nixl) 網站。

**要求**
+ 僅支援 Ubuntu 24.04 和 Ubuntu 22.04 基本 AMIs。
+ EFA 僅支援 NIXL 1.0.0 及更新版本。

**Topics**

## 步驟 1：準備具備 EFA 功能的安全群組
<a name="nixl-start-base-setup"></a>

EFA 需要有安全群組來允許往返安全群組自身的所有傳入和傳出流量。下列程序會建立一個安全群組，該安全群組允許所有傳入和傳出流量，並允許來自任何 IPv4 地址的傳入 SSH 流量以進行 SSH 連線。

**重要**  
此安全群組僅供測試之用。對於生產環境，我們建議您建立傳入 SSH 規則，該規則僅允許來自連線 IP 位址的流量，例如電腦的 IP 位址或區域網路中的一系列 IP 位址。

如需其他案例，請參閱[不同使用案例的安全群組規則](security-group-rules-reference.md)。

**建立具備 EFA 功能的安全群組**

1. 在 [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/) 開啟 Amazon EC2 主控台。

1. 在導覽窗格中，選擇 **Security Groups** (安全群組)，然後選擇 **Create Security Group** (建立安全群組)。

1. 在 **Create Security Group** (建立安全群組) 視窗中，執行下列動作：

   1. 對於 **Security group name** (安全群組名稱)，輸入安全群組的描述性名稱，例如 `EFA-enabled security group`。

   1. (選用) 對於 **Description** (描述)，輸入安全群組的簡短描述。

   1. 對於 **VPC**，選取您打算讓具備 EFA 功能的執行個體在其中啟動的 VPC。

   1. 選擇 **Create Security Group** (建立安全群組)。

1. 選取您建立的安全群組，在 **Details** (詳細資料) 索引標籤上，複製 **Security group ID** (安全群組 ID)。

1. 在仍然選取安全群組的情況下，依序選取 **Actions** (動作) 和 **Edit inbound rules** (編輯傳入規則)，然後執行下列動作。

   1. 選擇**新增規則**。

   1. 針對**類型**，選擇**所有流量**。

   1. 若為 **Source type** (來源類型)，選擇 **Custom** (自訂)，然後將您複製的安全群組 ID 貼到欄位中。

   1. 選擇**新增規則**。

   1. 針對 **Type** (類型)，選擇 **SSH**。

   1. 針對 **Source type** (來源類別)，選擇 **Anywhere-IPv4**(隨處 - IPv4)。

   1. 選擇**儲存規則**。

1. 在仍然選取安全群組的情況下，依序選取 **Actions** (動作) 和 **Edit outbound rules** (編輯傳出規則)，然後執行下列動作。

   1. 選擇**新增規則**。

   1. 針對**類型**，選擇**所有流量**。

   1. 若為 **Destination type** (目的地類型)，選擇 **Custom** (自訂)，然後將您複製的安全群組 ID 貼到欄位中。

   1. 選擇**儲存規則**。

## 步驟 2：啟動暫時執行個體
<a name="nixl-start-base-temp"></a>

啟動暫時執行個體，以用來安裝和設定 EFA 軟體元件。您可以使用此執行個體來建立具備 EFA 功能的 AMI，再從中啟動具備 EFA 功能的執行個體。

**啟動暫時執行個體**

1. 前往 [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/) 開啟 Amazon EC2 主控台。

1. 在導覽窗格中，選擇 **Instances** (執行個體)，接著選擇 **Launch Instances** (啟動執行個體) 來開啟新的啟動執行個體精靈。

1. (*選用*) 在 **Name and tags** (名稱和標籤) 區段中，為執行個體命名，例如，`EFA-instance`。該名稱將指派作為執行個體的資源標籤 (`Name={{EFA-instance}}`)。

1. 在**應用程式和作業系統映像**區段中，為其中一個支援的作業系統選取 AMI。您也可以在 DLAMI [版本備註頁面上選取支援的 DLAMI](https://docs.aws.amazon.com/dlami/latest/devguide/appendix-ami-release-notes)。

1. 在**執行個體類型**區段中，選取支援的執行個體類型。

1. 在 **Key pair** (金鑰對) 區段中，選取要用於執行個體的金鑰對。

1. 在 **Network settings** (網路設定) 區段，選擇 **Edit** (編輯)，接著執行下列動作：

   1. 對於 **Subnet (子網路)**，請選擇要在其中啟動執行個體的子網路。若您未選取子網路，便無法啟用 EFA 的執行個體。

   1. 針對 **Firewall (security groups)** (防火牆 (安全群組))，選取 **Select existing security group** (選取現有的安全群組)，接著選取您在前一個步驟中建立的安全群組。

   1. 展開**進階設定**區段。

      針對**網路介面 1**，選取**網路卡索引 = 0**、**裝置索引 = 0**，以及**介面類型 = EFA 搭配 ENA**。

      (*選用*) 如果您使用的是多卡執行個體類型，例如 `p4d.24xlarge` 或 `p5.48xlarge`，則針對所需的每個額外網路介面，選擇**新增網路介面**，針對**網路卡索引**，選擇下一個未使用的索引，然後選擇**裝置索引 = 1**，**介面類型 = EFA 搭配 ENA** **或僅限 EFA**。

1. 在**儲存**區段中，根據需求設定磁碟區。
**注意**  
您必須為 Nvidia CUDA 工具組佈建額外的 10 到 20 GitB 儲存空間。如果您沒有佈建足夠的儲存空間，您會在嘗試安裝 Nvidia 驅動程式和 CUDA 工具組時，收到 `insufficient disk space` 錯誤。

1. 在右邊的 **Summary** (摘要) 面板中，選擇 **Launch instance** (啟動執行個體)。

**重要**  
如果您的 AMI 已包含 Nvidia GPU 驅動程式、CUDA 工具組和 cuDNN，或者您使用非 GPU 執行個體，請略過步驟 3。

## 步驟 3：安裝 Nvidia GPU 驅動程式、Nvidia CUDA 工具組和 cuDNN
<a name="nixl-start-base-drivers"></a>

**安裝 Nvidia GPU 驅動程式、Nvidia CUDA 工具組和 cuDNN**

1. 為確保所有軟體套件皆為最新版本，請對您的執行個體執行快速軟體更新。

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

1. 請安裝 Nvidia GPU 驅動程式和 Nvidia CUDA 工具組需要的公用程式。

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

1. 若要使用 Nvidia GPU 驅動程式，您必須先停用 `nouveau` 開源驅動程式。

   1. 針對您目前執行的核心版本，安裝需要的公用程式和核心標頭套件。

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

   1. 新增 `nouveau` 至 `/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. 使用您偏好的文字編輯器開啟 `/etc/default/grub`，然後新增下列命令。

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

   1. 重建 Grub 組態。

      ```
      $ sudo update-grub
      ```

1. 重新啟動執行個體並重新連線至其中。

1. 新增 CUDA 儲存庫並安裝 Nvidia GPU 驅動程式、NVIDIA CUDA 工具組和 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. 重新啟動執行個體並重新連線至其中。

1. (僅限 `p4d.24xlarge` 和 `p5.48xlarge`) 安裝 Nvidia Fabric Manager。

   1. 您安裝的 Nvidia Fabric Manager 版本必須與您在上一個步驟中安裝的 Nvidia 核心模組版本一致。

      執行以下命令來判斷 Nvidia 核心模組的版本。

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

      以下為範例輸出。

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

      在上述範例中，已安裝核心模組主要版本 `450`。這表示您需要安裝 Nvidia Fabric Manager 版本 `450`。

   1. 安裝 Nvidia Fabric Manager。執行以下命令，並指定在上一步驟中使用的主要版本。

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

      例如，如果已安裝核心模組的主要版本 `450`，請使用下列命令來安裝同樣版本的 Nvidia Fabric Manager。

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

   1. 啟動服務，並確保服務會在執行個體啟動時自動啟動。NV Switch Management 需要使用 Nvidia Fabric Manager。

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

1. 確認每次執行個體啟動時都已設定 CUDA 路徑。
   + 針對 *bash* shell，新增以下陳述式到 `/home/{{username}}/.bashrc` 和 `/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
     ```
   + 針對 *tcsh* shell，新增以下陳述式到 `/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. 若要確認 Nvidia GPU 驅動程式正確運作，請執行下列命令。

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

   命令應該回傳 Nvidia GPU、Nvidia GPU 驅動程式和 Nvidia CUDA 工具組的資訊。

**重要**  
如果您的 AMI 已包含 GDRCopy，或者您使用非 GPU 執行個體，請略過步驟 4。

## 步驟 4：安裝 GDRY
<a name="nixl-start-base-gdrcopy"></a>

安裝 GDRCopy 以改善 GPU 型平台上 Libfabric 的效能。如需更多關於 GDRCopy 的詳細資訊，請參閱 [GDRCopy 儲存庫](https://github.com/NVIDIA/gdrcopy)。

**若要安裝 GDRCopy**

1. 安裝所需的依存項目。

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

1. 下載並解壓縮 GDRCopy 套件。

   ```
   $ wget https://github.com/NVIDIA/gdrcopy/archive/refs/tags/v2.4.tar.gz \
   && tar xf v2.4.tar.gz \
   && cd gdrcopy-2.4/packages
   ```

1. 建置 GDRCopy DEB 套件。

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

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

**重要**  
如果您的 AMI 已包含最新的 EFA 安裝程式，請略過步驟 5。

## 步驟 5：安裝 EFA 軟體
<a name="nixl-start-base-enable"></a>

安裝執行個體上支援 EFA 所需的啟用 EFA 的核心、EFA 驅動程式和 Libfabric 堆疊。

**安裝 EFA 軟體**

1. 連接至您啟動的執行個體。如需詳細資訊，請參閱[使用 SSH 連線至您的 Linux 執行個體](connect-to-linux-instance.md)。

1. 下載 EFA 軟體安裝檔案。軟體安裝檔案已封裝成壓縮 tarball (`.tar.gz`) 檔案。若要下載最新*穩定*版本，請使用下列命令：

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

1. 從壓縮`.tar.gz`檔案解壓縮檔案，刪除 tarball，然後導覽至解壓縮的目錄。

   ```
   $ 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. (*選用*) 在安裝期間驗證個別套件簽章。

   從 EFA 安裝程式 1.48.0 開始，安裝程式包含 GPG 簽署的個別 RPM 和 DEB 套件。若要在安裝期間驗證每個個別套件的真實性和完整性，請使用 `--check-signatures`旗標。當您啟用此旗標時，安裝程式會先驗證所有套件簽章，而且只有在每個套件通過驗證時才會繼續安裝。如果任何套件驗證失敗，安裝程式會立即結束，而無需安裝任何項目。

   1. 下載 GPG 公有金鑰。

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

   1. 匯出金鑰路徑。然後，在下一個步驟中，將 附加`--check-signatures`到安裝命令，並使用 `sudo -E`而不是 `sudo` 來保留環境變數。

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

   在 RPM 型系統上 (Amazon Linux、RHEL、Rocky Linux 和 SUSE)，安裝程式會使用 驗證每個 RPM`rpm --checksig`。在 DEB 型系統 (Ubuntu、Debian) 上，安裝程式會使用 GPG 簽章驗證來驗證每個 DEB。

   如果任何套件的驗證失敗，安裝會立即中止，保護您的系統免於損壞或惡意的套件。
**注意**  
`--check-signatures` 旗標為選用。如果沒有，安裝程式不會執行個別簽章驗證。

1. 執行 EFA 軟體安裝指令碼。
**注意**  
如果您已完成上一個設定套件簽章驗證的選用步驟，請附加`--check-signatures`至安裝命令並使用 `sudo -E`，而非 `sudo`。例如：`sudo -E ./efa_installer.sh -y --check-signatures`。

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

   **Libfabric** 安裝在 `/opt/amazon/efa` 目錄中。

1. 如果 EFA 安裝程式提示您重新啟動執行個體，請執行這項操作，然後重新連線至執行個體。否則，請登出執行個體，然後重新登入以完成安裝。

1. 確認已成功安裝 EFA 軟體元件。

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

   此命令應該會傳回 Libfabric EFA 介面的相關資訊。以下範例顯示命令輸出。
   + `p3dn.24xlarge` 具有單一網路介面

     ```
     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` 和 `p5.48xlarge`

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

## 步驟 6：安裝 NIXL
<a name="nixl-start-base-nixl"></a>

安裝 NIXL。如需 NIXL 的詳細資訊，請參閱 [NIXL 儲存庫](https://github.com/ai-dynamo/nixl)。

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

**使用 PyPI 安裝 NIXL**

1. 安裝所需的依存項目。

   ```
   $ sudo apt install pip
   ```

1. 安裝 NIXL。

   ```
   $ pip install nixl
   ```

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

**從來源建置和安裝 NIXL**

1. 安裝所需的依存項目。

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

1. 導覽至您的主目錄。

   ```
   $ cd $HOME
   ```

1. 將官方 NIXL 儲存庫複製到執行個體，然後導覽至本機複製的儲存庫。

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

1. 建置並安裝 NIXL，並指定 Libfabric 安裝目錄的路徑。

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

------

## 步驟 7：安裝 NIXL 基準並測試您的 EFA 和 NIXL 組態
<a name="nixl-start-base-tests"></a>

安裝 NIXL Benchmark 並執行測試，以確保您的暫時執行個體已針對 EFA 和 NIXL 正確設定。NIXL Benchmark 可讓您確認 NIXL 已正確安裝，並正常運作。如需詳細資訊，請參閱 [nixlbench 儲存庫](https://github.com/ai-dynamo/nixl/tree/main/benchmark/nixlbench)。

NIXL Benchmark (nixlbench) 需要 ETCD 才能協調用戶端和伺服器。若要搭配 NIXL 使用 ETCD，需要 ETCD 伺服器和用戶端，以及 ETCD CPP API。

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

**使用 Docker 安裝和測試 NIXL 基準**

1. 將官方 NIXL 儲存庫複製到執行個體，然後導覽至 nixlbench 建置目錄。

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

1. 建置容器。

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

   如需 Docker 建置選項的詳細資訊，請參閱 [nixlbench 儲存庫](https://github.com/ai-dynamo/nixl/tree/main/benchmark/nixlbench)。

1. 安裝 Docker.

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

1. 啟動 ETCD 伺服器以進行協調。

   ```
   $ 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. 驗證 ETCD 伺服器是否正在執行。

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

   預期的輸出結果：

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

1. 開啟執行個體的兩個終端機。在兩個終端機上執行下列命令來驗證安裝。命令在相同的執行個體上使用 ETCD 伺服器、使用 Libfabric 做為後端，並使用 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
   ```
**注意**  
對於非 GPU 執行個體，請使用 值`DRAM`，而非 `VRAM` 。

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

**重要**  
只有在您在步驟 6 中選擇**從來源建置**時，才遵循此索引標籤。

**安裝 NIXL 基準**

1. 安裝所需的系統相依性。

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

1. 安裝 ETCD 伺服器和用戶端。

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

1. 安裝 ETCD CPP API。

   1. 安裝 ETCD CPP API 所需的相依性。

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

   1. 複製並安裝 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. 建置並安裝 nixlbench。

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

**測試 EFA 和 NIXL 組態**

1. 在執行個體上啟動 ETCD 伺服器。

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

1. 驗證 ETCD 伺服器是否正在執行。

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

   預期的輸出結果：

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

1. 開啟執行個體的兩個終端機。在兩個終端機上，完成下列步驟以執行 nixlbench。

   1. 導覽至安裝 nixlbench 的目錄。

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

   1. 執行測試並指定後端、ETCD 伺服器的地址和啟動器區段類型。下列命令在相同的執行個體上使用 ETCD 伺服器、使用 Libfabric 做為後端，並使用 GPU 記憶體操作。環境變數會設定下列項目：
      + `NIXL_LOG_LEVEL=INFO` — 啟用詳細的偵錯輸出。您也可以指定 僅`WARN`接收錯誤訊息。
      + `LD_LIBRARY_PATH` — 設定 NIXL 程式庫的路徑。

      如需 NIXL Benchmark 引數的詳細資訊，請參閱官方 [nixlbench 儲存庫中的 NIXLbench README](https://github.com/ai-dynamo/nixl/blob/main/benchmark/nixlbench/README.md)。

      ```
      $ 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'
      ```
**注意**  
對於非 GPU 執行個體，請使用 值`DRAM`，而非 `VRAM` 。

------

## 步驟 8：安裝您的機器學習應用程式
<a name="nixl-start-base-app"></a>

在暫時執行個體上安裝機器學習應用程式。安裝程序依特定的機器學習應用程式而異。

**注意**  
如需安裝說明，請參閱機器學習應用程式的文件。

## 步驟 9：建立啟用 EFA 和 NIXL 的 AMI
<a name="nixl-start-base-ami"></a>

安裝所需的軟體元件之後，您需要建立 AMI，以重複用來啟動具備 EFA 功能的執行個體。

**從暫時執行個體建立 AMI**

1. 在 [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/) 開啟 Amazon EC2 主控台。

1. 在導覽窗格中，選擇 **Instances** (執行個體)。

1. 選取您建立的暫時執行個體，然後選取 **Actions** (動作)、**Image** (映像)、**Create image** (建立映像)。

1. 對於 **Create image** (建立映像)，執行下列動作：

   1. 對於 **Image name** (映像名稱)，輸入 AMI 的描述性名稱。

   1. (選用) 對於 **Image description** (映像描述)，輸入 AMI 的簡短描述。

   1. 選擇**建立映像**。

1. 在導覽窗格中，選擇 **AMIs**。

1. 在清單中找出您建立的 AMI。等待狀態從`pending`變為`available`，再繼續進行下一個步驟。

## 步驟 10：終止暫時執行個體
<a name="nixl-start-base-terminate"></a>

此時，您不再需要您啟動的暫時執行個體。您可以終止執行個體，以停止產生費用。

**終止暫時執行個體**

1. 在 [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/) 開啟 Amazon EC2 主控台。

1. 在導覽窗格中，選擇 **Instances** (執行個體)。

1. 選取您建立的暫時執行個體，然後選取**動作**、**執行個體狀態**、**終止執行個體**。

1. 出現確認提示時，請選擇**終止**。

## 步驟 11：啟動啟用 EFA 和 NIXL 的執行個體
<a name="nixl-start-base-cluster"></a>

使用您在**步驟 9** 中建立的已啟用 EFA 的 AMI，以及您在**步驟 1** 中建立的已啟用 EFA 的安全群組，來啟動已啟用 EFA 和 NIXL 的執行個體。

**啟動啟用 EFA 和 NIXL 的執行個體**

1. 前往 [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/) 開啟 Amazon EC2 主控台。

1. 在導覽窗格中，選擇 **Instances** (執行個體)，接著選擇 **Launch Instances** (啟動執行個體) 來開啟新的啟動執行個體精靈。

1. (*選用*) 在 **Name and tags** (名稱和標籤) 區段中，為執行個體命名，例如，`EFA-instance`。該名稱將指派作為執行個體的資源標籤 (`Name={{EFA-instance}}`)。

1. 在 **Application and OS Images** (應用程式和作業系統映像) 區段中，選取 **My AMIs (我的 AMI)**，接著選取您在前一個步驟中建立的 AMI。

1. 在**執行個體類型**區段中，選取支援的執行個體類型。

1. 在 **Key pair** (金鑰對) 區段中，選取要用於執行個體的金鑰對。

1. 在 **Network settings** (網路設定) 區段，選擇 **Edit** (編輯)，接著執行下列動作：

   1. 對於 **Subnet (子網路)**，請選擇要在其中啟動執行個體的子網路。若您未選取子網路，便無法啟用 EFA 的執行個體。

   1. 針對**防火牆 （安全群組）**，選擇**選取現有的安全群組**，然後選取您在**步驟 1 **中建立的安全群組。

   1. 展開**進階設定**區段。

      針對**網路介面 1**，選取**網路卡索引 = 0**、**裝置索引 = 0**，以及**介面類型 = EFA 搭配 ENA**。

      (*選用*) 如果您使用的是多卡執行個體類型，例如 `p4d.24xlarge` 或 `p5.48xlarge`，則針對所需的每個額外網路介面，選擇**新增網路介面**，針對**網路卡索引**，選擇下一個未使用的索引，然後選擇**裝置索引 = 1**，**介面類型 = EFA 搭配 ENA** **或僅限 EFA**。

1. (*選用*) 在**儲存**區段中，根據需求設定磁碟區。

1. 在右邊的**摘要**面板，針對**執行個體的數目**，輸入要啟動的具備 EFA 功能的執行個體數量，接著選擇**啟動執行個體**。

## 步驟 12：啟用無密碼 SSH
<a name="nixl-start-base-passwordless"></a>

若要讓您的應用程式能夠跨越叢集中的所有執行個體執行，您必須啟用從領導節點到成員節點的無密碼 SSH 存取。領導節點是您在其中執行應用程式的執行個體。叢集中的其餘執行個體為成員節點。

**在叢集的執行個體之間啟用無密碼 SSH**

1. 選取叢集中的一個執行個體作為領導節點，並與它連線。

1. 在領導節點上停用 `strictHostKeyChecking` 並啟用 `ForwardAgent`。使用您偏好的文字編輯器開啟 `~/.ssh/config`，然後新增下列命令。

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

1. 產生 RSA 金鑰對。

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

   在 `$HOME/.ssh/` 目錄中建立金鑰對。

1. 變更領導節點上私有金鑰的許可。

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

1. 使用您偏好的文字編輯器開啟 `~/.ssh/id_rsa.pub` 並複製該金鑰。

1. 對於叢集中的每個成員節點，執行以下操作：

   1. 連線到執行個體。

   1. 使用您偏好的文字編輯器開啟 `~/.ssh/authorized_keys`，然後新增您先前複製的公有金鑰。

1. 若要測試無密碼的 SSH 是否如預期運作，請連線至領導節點並執行下列命令。

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

   您應該連線至成員節點，而不會提示您輸入金鑰或密碼。

**重要**  
只有在遵循步驟 7 時，才遵循步驟 13。

## 步驟 13：跨執行個體測試 EFA 和 NIXL 組態
<a name="nixl-start-base-test-multi"></a>

執行測試，以確保您的執行個體已針對 EFA 和 NIXL 正確設定。

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

**使用 Docker 跨執行個體測試 EFA 和 NIXL 組態**

1. 選取兩個主機來執行 nixlbench 基準測試。使用第一個主機的 IP 地址做為中繼資料交換的 ETCD 伺服器 IP。

1. 在主機 1 上啟動 ETCD 伺服器。

   ```
   $ 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. 驗證 ETCD 伺服器是否正在執行。

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

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

1. 在主機 1 上執行 nixlbench 基準測試。

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

1. 在主機 2 上執行 nixlbench 基準測試。

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

**重要**  
只有在您在步驟 6 中選擇**從來源建置**時，才遵循此索引標籤。

**跨執行個體測試 EFA 和 NIXL 組態**

1. 選取兩個主機來執行 nixlbench 基準測試。使用第一個主機的 IP 地址做為中繼資料交換的 ETCD 伺服器 IP。

1. 在主機 1 上啟動 ETCD 伺服器。

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

1. 驗證 ETCD 伺服器是否正在執行。

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

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

1. 在主機 1 上執行 nixlbench 基準測試。

   ```
   $ 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. 在主機 2 上執行 nixlbench 基準測試。

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

------

## 步驟 14：測試透過 vLLM 提供的分解推論 (*選用*)
<a name="nixl-start-base-serve"></a>

安裝 NIXL 之後，您可以透過 LLM 推論使用 NIXL，並提供 vLLM、SGLang 和 TensorRT-LLM 等架構。

**使用 vLLM 為您的推論工作負載提供服務**

1. 安裝 vLLM。

   ```
   $ pip install vllm
   ```

1. 使用 NIXL 啟動 vLLM 伺服器。下列範例命令會為 NIXL 交握連線、KV 連接器、KV 角色和傳輸後端建立一個預填充 （生產者） 和一個解碼 （消費者） 執行個體。如需詳細範例和指令碼，請參閱 [NIXLConnector 使用者指南](https://github.com/vllm-project/vllm/blob/2d977a7a9ead3179fde9ed55d69393ef7b6cec47/docs/features/nixl_connector_usage.md)。

   若要搭配 EFA 使用 NIXL，請根據您的設定和使用案例設定環境變數。
   + 生產者 （預填器） 組態

     ```
     $ 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"]}}'
     ```
   + 取用者 （解碼器） 組態

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

   上述範例組態會設定下列項目：
   + `kv_role` 到 `kv_both`，這會啟用對稱功能，其中連接器可以同時做為生產者和消費者。這可為未預先決定角色差異的實驗設定和案例提供靈活性。
   + `kv_buffer_device` 到 `cuda`，這可讓您使用 GPU 記憶體。
   + NIXL 後端至 `LIBFABRIC`，可讓 NIXL 流量通過 EFA。