Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Inizia a usare EFA e NIXL per carichi di lavoro di inferenza su Amazon EC2
<a name="efa-start-nixl"></a>

La libreria NVIDIA Inference Xfer (NIXL) è una libreria di comunicazione ad alta velocità e bassa latenza progettata specificamente per carichi di lavoro di inferenza disaggregati. NIXL può essere utilizzato insieme a EFA e Libfabric per supportare il trasferimento KV-cache tra nodi di preriempimento e decodifica e consente lo spostamento efficiente della cache KV tra vari livelli di storage. [Per ulteriori informazioni, consulta il sito Web NIXL.](https://github.com/ai-dynamo/nixl)

**Requisiti**
+ Sono supportati solo Ubuntu 24.04 e Ubuntu 22.04 base AMIs .
+ EFA supporta solo NIXL 1.0.0 e versioni successive.

**Topics**

## Fase 1: preparare un gruppo di sicurezza abilitato per EFA
<a name="nixl-start-base-setup"></a>

Un EFA richiede un gruppo di sicurezza in cui sia consentito tutto il traffico in entrata e in uscita dal gruppo stesso. La procedura seguente crea un gruppo di sicurezza che consente tutto il traffico in entrata e in uscita da e verso se stesso e che consente il traffico SSH in entrata da qualsiasi indirizzo per la connettività SSH. IPv4 

**Importante**  
Questo gruppo di sicurezza è destinato esclusivamente a scopi di test. Per i tuoi ambienti di produzione, consigliamo di creare una regola SSH in entrata che consenta il traffico solo dall'indirizzo IP da cui ti connetti, ad esempio l'indirizzo IP del tuo computer o un intervallo di indirizzi IP nella tua rete locale.

Per altri scenari, consulta [Regole del gruppo di sicurezza per diversi casi d'uso](security-group-rules-reference.md).

**Per creare un gruppo di sicurezza abilitato per EFA**

1. Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. Nel riquadro di navigazione, scegliere **Security Groups (Gruppi di sicurezza)** e quindi **Create Security Group (Crea gruppo di sicurezza)**.

1. Nella finestra **Create Security Group (Crea gruppo di sicurezza)** effettuare le operazioni seguenti:

   1. In **Nome gruppo di sicurezza**, immettere un nome descrittivo per il gruppo di sicurezza, ad esempio `EFA-enabled security group`.

   1. (Facoltativo) In **Description (Descrizione)**, inserire una breve descrizione del gruppo di sicurezza.

   1. In **VPC**, selezionare il VPC in cui avviare le istanze abilitate per EFA.

   1. Scegliere **Create Security Group** (Crea gruppo di sicurezza).

1. Seleziona il gruppo di sicurezza creato e nella scheda **Details** (Dettagli) copia il valore **Security group ID** (ID gruppo di sicurezza).

1. Dopo aver selezionato il gruppo di sicurezza, scegli **Actions** (Operazioni), **Edit inbound rules** (Modifica le regole in entrata) ed esegui le operazioni di seguito:

   1. Scegliere **Add rule** (Aggiungi regola).

   1. In **Type (Tipo)**, selezionare **All traffic (Tutto il traffico)**.

   1. Per **Source type** (Tipo di origine), scegli **Custom** (Personalizzata) e incolla nel campo l'ID del gruppo di sicurezza copiato in precedenza.

   1. Scegli **Aggiungi regola**.

   1. Per **Type** (Tipo) scegli **SSH**.

   1. **Per **Tipo di origine**, scegliete Anywhere-. IPv4**

   1. Scegliere **Salva regole**.

1. Dopo aver selezionato il gruppo di sicurezza, scegli **Actions** (Operazioni), **Edit outbound rules** (Modifica le regole in uscita) ed esegui le operazioni di seguito:

   1. Scegliere **Add rule** (Aggiungi regola).

   1. In **Type (Tipo)**, selezionare **All traffic (Tutto il traffico)**.

   1. Per **Destination type** (Tipo di destinazione), scegli **Custom** (Personalizzata) e incolla nel campo l'ID del gruppo di sicurezza copiato in precedenza.

   1. Scegliere **Salva regole**.

## Fase 2: avviare un'istanza temporanea
<a name="nixl-start-base-temp"></a>

Avvia un'istanza temporanea da utilizzare per installare e configurare i componenti software EFA. L'istanza serve anche per creare un'AMI abilitata per EFA da cui avviare le istanze abilitate per EFA.

**Per avviare un'istanza temporanea**

1. Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. Nel pannello di navigazione, scegli **Instances** (Istanze) e quindi scegli **Launch instances** (Avvia istanze) per aprire la nuova procedura guidata di avvio dell'istanza.

1. (*Opzionale*) Nella sezione **Name and tags** (Nome e tag), fornisci un nome per l'istanza, ad esempio `EFA-instance`. Il nome viene assegnato all'istanza come tag di risorsa (`Name=EFA-instance`).

1. Nella sezione **Immagini di applicazioni e sistema operativo**, seleziona un’AMI per uno dei sistemi operativi supportati. È inoltre possibile selezionare un DLAMI supportato disponibile nella pagina delle note di rilascio [DLAMI](https://docs.aws.amazon.com/dlami/latest/devguide/appendix-ami-release-notes).

1. Nella sezione **Tipo di istanza**, seleziona un tipo di istanza supportato.

1. Nella sezione **Key pair** (Coppia di chiavi), seleziona la coppia di chiavi da utilizzare per l'istanza.

1. Nella sezione **Network settings** (Impostazioni di rete), scegli **Edit** (Modifica) e quindi esegui le operazioni qui descritte:

   1. Per **Subnet** (Sottorete) seleziona la subnet in cui avviare l'istanza. Se non selezioni una sottorete, non puoi abilitare l'istanza per l'EFA.

   1. Per **Firewall (security groups)** (Firewall [gruppi di sicurezza]), scegli **Select existing security group** (Seleziona gruppo di sicurezza esistente) e quindi seleziona il gruppo di sicurezza creato nella fase precedente.

   1. Espandi la sezione **Configurazione avanzata**.

      Come **Interfaccia di rete 1**, seleziona **Indice della scheda di rete = 0**, **Indice dispositivo = 0** e **Tipo di interfaccia = EFA con ENA**.

      (*Facoltativo*) Se utilizzi un'istanza multi-scheda, come `p4d.24xlarge` o `p5.48xlarge`, per ogni interfaccia di rete aggiuntiva richiesta scegli **Aggiungi interfaccia di rete**, seleziona l'indice successivo inutilizzato come **Indice della scheda di rete** e poi seleziona **Indice dispositivo = 1** e **Tipo di interfaccia = EFA con ENA** o **solo EFA**.

1. Nella sezione **Storage** (Archiviazione), configura i volumi secondo necessità.
**Nota**  
Devi effettuare un provisioning aggiuntivo di 10-20 GiB di spazio di archiviazione per Nvidia CUDA Toolkit. Se non effettui il provisioning di uno spazio di archiviazione sufficiente, riceverai un errore `insufficient disk space` durante il tentativo di installare i driver Nvidia e il toolkit CUDA.

1. Nel pannello **Summary** (Riepilogo) a destra, scegli **Launch instance** (Avvia istanza).

**Importante**  
Salta il passaggio 3 se l'AMI include già i driver GPU Nvidia, il toolkit CUDA e cuDNN o se stai usando un'istanza non GPU.

## Fase 3: installare driver GPU Nvidia, il kit di strumenti Nvidia CUDA e cuDNN
<a name="nixl-start-base-drivers"></a>

**Per installare driver GPU Nvidia, il kit di strumenti Nvidia CUDA e cuDNN**

1. Per verificare che tutti i pacchetti software siano aggiornati, eseguire un aggiornamento rapido del software sull'istanza.

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

1. Installare le utilità che sono richieste per installare i driver GPU Nvidia e il toolkit CUDA Nvidia.

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

1. Per utilizzare il driver GPU Nvidia, è necessario prima disabilitare i driver open source `nouveau`.

   1. Installare le utility richieste e il pacchetto delle intestazioni kernel per la versione del kernel attualmente in esecuzione.

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

   1. Aggiungere `nouveau` al file dell'elenco dei `/etc/modprobe.d/blacklist.conf `negati.

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

   1. Aprire il file `/etc/default/grub` utilizzando qualsiasi editor di testo e aggiungere il seguente script.

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

   1. Ricompilare il file di configurazione di Grub.

      ```
      $ sudo update-grub
      ```

1. Riavviare l'istanza e riconnettersi a essa.

1. Aggiungere il repository CUDA e installare i driver GPU Nvidia, il toolkit NVIDIA CUDA e 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. Riavviare l'istanza e riconnettersi a essa.

1. (Solo `p4d.24xlarge` e `p5.48xlarge`) Installare Nvidia Fabric Manager.

   1. È necessario installare la versione di Nvidia Fabric Manager che corrisponde alla versione del modulo del kernel Nvidia installata al passaggio precedente.

      Eseguire questo comando per determinare la versione del modulo del kernel Nvidia.

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

      Di seguito è riportato un output di esempio.

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

      Nell'esempio precedente, è stata installata la versione principale `450` del modulo del kernel. Ciò significa che è necessario installare la versione `450` di Nvidia Fabric Manager.

   1. Installare Nvidia Fabric Manager. Eseguire questo comando e specificare la versione principale identificata nella fase precedente.

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

      Ad esempio, se è stata installata la versione principale `450` del modulo del kernel, utilizzare il seguente comando per installare la versione corrispondente di Nvidia Fabric Manager.

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

   1. Avviare il servizio e assicurarsi che venga avviato automaticamente all'avvio dell'istanza. Nvidia Fabric Manager è necessario per la gestione degli switch NV.

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

1. Assicurarsi che i percorsi CUDA siano impostati ogni volta che viene avviata l'istanza.
   + Per le shell *bash*, aggiungere le seguenti istruzioni a `/home/username/.bashrc` e `/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
     ```
   + Per le shell *tcsh*, aggiungere le seguenti istruzioni a `/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. Per confermare che i driver GPU di Nvidia GPU siano funzionanti, eseguire questo comando.

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

   Il comando dovrebbe restituire informazioni su Nvidia, i driver GPU Nvidia e il toolkit Nvidia GPUs CUDA.

**Importante**  
Salta il passaggio 4 se l'AMI lo include GDRCopy già o se stai usando un'istanza non GPU.

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

 GDRCopy Installa per migliorare le prestazioni di Libfabric su piattaforme basate su GPU. [Per ulteriori informazioni in meritoGDRCopy, consulta il repository. GDRCopy ](https://github.com/NVIDIA/gdrcopy)

**Per installare GDRCopy**

1. Installare le dipendenze richieste.

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

1. Scarica ed estrai il GDRCopy pacchetto.

   ```
   $ 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. Compila i pacchetti GDRCopy DEB.

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

1. Installa i pacchetti 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
   ```

**Importante**  
Salta il passaggio 5 se l'AMI include già l'ultimo programma di installazione EFA.

## Fase 5: installazione del software EFA
<a name="nixl-start-base-enable"></a>

Installa il kernel compatibile con EFA, i driver EFA e lo stack Libfabric necessari per supportare EFA sulla tua istanza.

**Per installare il software EFA**

1. Connettersi all'istanza avviata. Per ulteriori informazioni, consulta [Connessione a un’istanza Linux tramite SSH](connect-to-linux-instance.md).

1. Scarica i file di installazione del software. I file di installazione del software sono riuniti in un file (`.tar.gz`) tarball compresso. Per scaricare l'ultima versione *stabile*, utilizzare il comando seguente.

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

1. Estrai i file dal file compresso, elimina l'`.tar.gz`archivio tar e naviga nella directory estratta.

   ```
   $ 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. (*Facoltativo*) Verifica le firme dei singoli pacchetti durante l'installazione.

   A partire dal programma di installazione EFA 1.48.0, il programma di installazione include singoli pacchetti RPM e DEB firmati da GPG. Per verificare l'autenticità e l'integrità di ogni singolo pacchetto durante l'installazione, utilizzate il flag. `--check-signatures` Quando abiliti questo flag, il programma di installazione verifica innanzitutto tutte le firme dei pacchetti e procede con l'installazione solo se ogni pacchetto supera la verifica. Se un pacchetto non supera la verifica, il programma di installazione esce immediatamente senza installare nulla.

   1. Scarica la chiave pubblica GPG.

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

   1. Esporta il percorso chiave. Quindi, nel passaggio successivo, aggiungilo `--check-signatures` al comando di installazione e usa `sudo -E` invece di `sudo` conservare la variabile di ambiente.

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

   Sui sistemi basati su RPM (Amazon Linux, RHEL, Rocky Linux e SUSE), il programma di installazione verifica ogni RPM utilizzato. `rpm --checksig` Sui sistemi basati su DEB (Ubuntu, Debian), l'installatore verifica ogni DEB utilizzando la verifica della firma GPG.

   Se la verifica di un pacchetto fallisce, l'installazione si interrompe immediatamente, proteggendo il sistema da pacchetti danneggiati o dannosi.
**Nota**  
La `--check-signatures` bandiera è facoltativa. Senza di esso, il programma di installazione non esegue la verifica della firma individuale.

1. Eseguire lo script di installazione del software EFA.
**Nota**  
Se avete completato il precedente passaggio facoltativo per configurare la verifica della firma dei pacchetti, aggiungetelo `--check-signatures` al comando di installazione e utilizzate `sudo -E` invece di. `sudo` Ad esempio: `sudo -E ./efa_installer.sh -y --check-signatures`.

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

   **Libfabric** è installato nella directory `/opt/amazon/efa`.

1. Se il programma di installazione di EFA richiede il riavvio dell'istanza, eseguire questa operazione e riconnettersi all'istanza. In caso contrario, disconnettersi dall'istanza e quindi accedere di nuovo per completare l'installazione.

1. Verificare la corretta installazione dei componenti software EFA.

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

   Il comando deve restituire informazioni sulle interfacce EFA Libfabric. L'esempio seguente mostra l'output del comando.
   + `p3dn.24xlarge` con interfaccia di rete singola

     ```
     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` e `p5.48xlarge` con più interfacce di rete

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

## Passaggio 6: installa NIXL
<a name="nixl-start-base-nixl"></a>

Installa NIXL. Per ulteriori informazioni su NIXL, consulta il repository [NIXL](https://github.com/ai-dynamo/nixl).

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

**Per installare NIXL usando PyPI**

1. Installare le dipendenze richieste.

   ```
   $ sudo apt install pip
   ```

1. Installa NIXL.

   ```
   $ pip install nixl
   ```

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

**Per compilare e installare NIXL dal codice sorgente**

1. Installare le dipendenze richieste.

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

1. Passare alla home directory.

   ```
   $ cd $HOME
   ```

1. Clona il repository NIXL ufficiale sull'istanza e accedi al repository clonato locale.

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

1. Compila e installa NIXL e specifica il percorso della directory di installazione di Libfabric.

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

------

## Passo 7: Installa NIXL Benchmark e testa la tua configurazione EFA e NIXL
<a name="nixl-start-base-tests"></a>

Installa NIXL Benchmark ed esegui un test per assicurarti che l'istanza temporanea sia configurata correttamente per EFA e NIXL. Il benchmark NIXL consente di confermare che NIXL è installato correttamente e che funziona come previsto. [Per ulteriori informazioni, consulta il repository nixlbench.](https://github.com/ai-dynamo/nixl/tree/main/benchmark/nixlbench)

NIXL Benchmark (nixlbench) richiede ETCD per il coordinamento tra client e server. Per utilizzare ETCD con NIXL sono necessari il server e il client ETCD e l'API CPP ETCD.

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

**Per installare e testare NIXL Benchmark utilizzando Docker**

1. Clona il repository NIXL ufficiale sull'istanza e vai alla directory di build di nixlbench.

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

1. Compila il container.

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

   [Per ulteriori informazioni sulle opzioni di build di Docker, consulta il repository nixlbench.](https://github.com/ai-dynamo/nixl/tree/main/benchmark/nixlbench)

1. Installazione di Docker.

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

1. Avvia il server ETCD per il coordinamento.

   ```
   $ 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. Verifica che il server ETCD sia in esecuzione.

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

   Output previsto:

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

1. Apri due terminali per l'istanza. Su entrambi i terminali, esegui il comando seguente per verificare l'installazione. Il comando utilizza il server ETCD sulla stessa istanza, utilizza Libfabric come backend e funziona utilizzando la memoria 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
   ```
**Nota**  
Utilizza il valore `DRAM` anziché per le istanze non GPU. `VRAM`

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

**Importante**  
Segui questa scheda solo se hai scelto **Crea dal sorgente** nel passaggio 6.

**Per installare NIXL Benchmark**

1. Installa le dipendenze di sistema richieste.

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

1. Installa il server e il client ETCD.

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

1. Installa l'API ETCD CPP.

   1. Installa le dipendenze richieste per l'API ETCD CPP.

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

   1. Clona e installa l'API ETCD CPP.

      ```
      $ cd $HOME
      $ git clone https://github.com/etcd-cpp-apiv3/etcd-cpp-apiv3.git
      $ cd etcd-cpp-apiv3
      $ mkdir build && cd build
      $ cmake ..
      $ sudo make -j$(nproc) && sudo make install
      ```

1. Compila e installa nixlbench.

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

**Per testare la tua configurazione EFA e NIXL**

1. Avvia il server ETCD sull'istanza.

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

1. Verifica che il server ETCD sia in esecuzione.

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

   Output previsto:

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

1. Apri due terminali per l'istanza. Su entrambi i terminali, completa i seguenti passaggi per eseguire nixlbench.

   1. Vai alla directory in cui è installato nixlbench.

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

   1. Esegui il test e specifica il backend, l'indirizzo del server ETCD e il tipo di segmento dell'iniziatore. Il comando seguente utilizza il server ETCD sulla stessa istanza, utilizza Libfabric come backend e funziona utilizzando la memoria GPU. Le variabili di ambiente configurano quanto segue:
      + `NIXL_LOG_LEVEL=INFO`— Abilita un output di debug dettagliato. È inoltre possibile specificare di `WARN` ricevere solo messaggi di errore.
      + `LD_LIBRARY_PATH`— Imposta il percorso per la libreria NIXL.

      Per ulteriori informazioni sugli argomenti del benchmark NIXL, consultate il [NIXLbenchREADME](https://github.com/ai-dynamo/nixl/blob/main/benchmark/nixlbench/README.md) nel repository ufficiale nixlbench.

      ```
      $ export NIXL_LOG_LEVEL=INFO
      $ export LD_LIBRARY_PATH=/usr/local/nixl/lib/$(gcc -dumpmachine):$LD_LIBRARY_PATH
      
      $ nixlbench --etcd-endpoints 'http://localhost:2379' \
          --backend 'LIBFABRIC' \
          --initiator_seg_type 'VRAM' \
          --target_seg_type 'VRAM'
      ```
**Nota**  
Usa il valore anziché per le istanze non GPU. `DRAM` `VRAM`

------

## Fase 8: Installa le tue applicazioni di machine learning
<a name="nixl-start-base-app"></a>

Installa le applicazioni di machine learning sull'istanza temporanea. La procedura di installazione varia in base alla specifica applicazione di machine learning.

**Nota**  
Consulta la documentazione dell'applicazione di machine learning per le istruzioni di installazione.

## Fase 9: Creare un'AMI compatibile con EFA e NIXL
<a name="nixl-start-base-ami"></a>

Dopo aver installato i componenti software necessari, procedi con la creazione di un'AMI che puoi riutilizzare per avviare le istanze abilitate per EFA.

**Per creare un'AMI dall'istanza temporanea**

1. Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. Nel riquadro di navigazione, scegliere **Instances (Istanze)**.

1. Seleziona l'istanza temporanea creata e seleziona **Actions** (Operazioni), **Image** (Immagine), **Create Image** (Crea immagine).

1. Per **Create image (Crea immagine)**, effettua le seguenti operazioni:

   1. In **Image name (Nome immagine)**, immettere un nome descrittivo per l'AMI.

   1. (Facoltativo) In **Image description (Descrizione immagine**), inserire una breve descrizione dell'AMI.

   1. Scegliere **Create Image (Crea immagine)**.

1. Nel pannello di navigazione, scegli **AMIs**.

1. Individuare nell'elenco l'AMI creata. Prima di procedere con la fase seguente, attendi che lo stato passi da `pending` a `available`.

## Fase 10: terminazione dell'istanza temporanea
<a name="nixl-start-base-terminate"></a>

A questo punto l'istanza temporanea avviata non è più necessaria. È possibile terminare l'istanza per evitare di incorrere in costi aggiuntivi.

**Per terminare l'istanza temporanea**

1. Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. Nel riquadro di navigazione, scegliere **Instances (Istanze)**.

1. Selezionare l'istanza temporanea creata, quindi scegliere **Actions (Operazioni)**, **Instance state (Stato istanza)**, **Terminate instance (Termina istanza)**.

1. Quando viene richiesta la conferma, seleziona **Termina**.

## Fase 11: Avvio di istanze compatibili con EFA e NIXL
<a name="nixl-start-base-cluster"></a>

**Avvia le tue istanze compatibili con EFA e NIXL utilizzando l'AMI abilitata per EFA che hai creato nella **fase 9** e il gruppo di sicurezza abilitato per EFA creato nella fase 1.**

**Per avviare istanze compatibili con EFA e NIXL**

1. Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. Nel pannello di navigazione, scegli **Instances** (Istanze) e quindi scegli **Launch instances** (Avvia istanze) per aprire la nuova procedura guidata di avvio dell'istanza.

1. (*Opzionale*) Nella sezione **Name and tags** (Nome e tag), fornisci un nome per l'istanza, ad esempio `EFA-instance`. Il nome viene assegnato all'istanza come tag di risorsa (`Name=EFA-instance`).

1. Nella sezione **Immagini dell'applicazione e del sistema operativo**AMIs, scegli **Mio**, quindi seleziona l'AMI che hai creato nel passaggio precedente.

1. Nella sezione **Tipo di istanza**, seleziona un tipo di istanza supportato.

1. Nella sezione **Key pair** (Coppia di chiavi), seleziona la coppia di chiavi da utilizzare per l'istanza.

1. Nella sezione **Network settings** (Impostazioni di rete), scegli **Edit** (Modifica) e quindi esegui le operazioni qui descritte:

   1. Per **Subnet** (Sottorete) seleziona la subnet in cui avviare l'istanza. Se non selezioni una sottorete, non puoi abilitare l'istanza per l'EFA.

   1. Per **Firewall (gruppi di sicurezza)**, scegli **Seleziona gruppo di sicurezza esistente**, quindi seleziona il gruppo di sicurezza creato nel **passaggio 1**.

   1. Espandi la sezione **Configurazione avanzata**.

      Come **Interfaccia di rete 1**, seleziona **Indice della scheda di rete = 0**, **Indice dispositivo = 0** e **Tipo di interfaccia = EFA con ENA**.

      (*Facoltativo*) Se utilizzi un'istanza multi-scheda, come `p4d.24xlarge` o `p5.48xlarge`, per ogni interfaccia di rete aggiuntiva richiesta scegli **Aggiungi interfaccia di rete**, seleziona l'indice successivo inutilizzato come **Indice della scheda di rete** e poi seleziona **Indice dispositivo = 1** e **Tipo di interfaccia = EFA con ENA** o **solo EFA**.

1. (*Opzionale*) Nella sezione **Storage** (Archiviazione), configura i volumi secondo necessità.

1. Nel pannello **Summary** (Riepilogo) a destra, per **Number of instances** (Numero di istanze), inserisci il numero di istanze abilitate per EFA che desideri avviare, quindi seleziona **Launch instance** (Avvia istanza).

## Fase 12: abilitazione di SSH senza password
<a name="nixl-start-base-passwordless"></a>

Per consentire l'esecuzione delle applicazioni in tutte le istanze del cluster, è necessario abilitare l'accesso SSH senza password dal nodo leader ai nodi membro. Il nodo principale è l'istanza da cui vengono eseguite le applicazioni. Le restanti istanze del cluster sono i nodi membro.

**Per abilitare SSH senza password tra le istanze del cluster**

1. Selezionare un'istanza nel cluster come nodo principale e connettersi a essa.

1. Disabilita `strictHostKeyChecking` e abilita `ForwardAgent` sul nodo principale. Aprire il file `~/.ssh/config` utilizzando qualsiasi editor di testo e aggiungere il seguente script.

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

1. Generare una coppia di chiavi RSA.

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

   La coppia di chiavi viene creata nella directory `$HOME/.ssh/`.

1. Modifica le autorizzazioni della chiave privata sul nodo principale.

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

1. Aprire `~/.ssh/id_rsa.pub` utilizzando l'editor di testo preferito e copiare la chiave.

1. Per ogni nodo membro nel cluster, procedere nel modo seguente:

   1. Collegarsi all'istanza.

   1. Aprire `~/.ssh/authorized_keys` utilizzando qualsiasi editor di testo e aggiungere la chiave pubblica copiata in precedenza.

1. Per verificare che SSH senza password funzioni come previsto, connettersi al nodo leader ed eseguire il seguente comando.

   ```
   $ ssh member_node_private_ip
   ```

   La connessione al nodo membro non dovrebbe richiedere una chiave o una password.

**Importante**  
Segui il passaggio 13 solo se hai seguito il passaggio 7.

## Passaggio 13: verifica la configurazione EFA e NIXL su più istanze
<a name="nixl-start-base-test-multi"></a>

Esegui un test per assicurarti che le tue istanze siano configurate correttamente per EFA e NIXL.

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

**Per testare la configurazione EFA e NIXL su più istanze utilizzando Docker**

1. Seleziona due host per eseguire il benchmark nixlbench. Utilizzate l'indirizzo IP del primo host come IP del server ETCD per lo scambio di metadati.

1. Avviare il server ETCD sull'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. Verificare che il server ETCD sia in esecuzione.

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

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

1. Esegui il benchmark nixlbench sull'host 1.

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

1. Esegui il benchmark nixlbench sull'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 ]

**Importante**  
Segui questa scheda solo se hai scelto **Compila dal sorgente** nel passaggio 6.

**Per testare la configurazione EFA e NIXL su più istanze**

1. Seleziona due host per eseguire il benchmark nixlbench. Utilizzate l'indirizzo IP del primo host come IP del server ETCD per lo scambio di metadati.

1. Avvia il server ETCD sull'host 1.

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

1. Verifica che il server ETCD sia in esecuzione.

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

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

1. Esegui il benchmark nixlbench sull'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. Esegui il benchmark nixlbench sull'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
   ```

------

## *Fase 14: Testare l'inferenza disaggregata servendo su vLLM (opzionale)*
<a name="nixl-start-base-serve"></a>

Dopo l'installazione di NIXL, è possibile utilizzare NIXL tramite inferenza LLM e framework di servizio come vLLM e Tensorrt-LLM. SGLang

**Per gestire il carico di lavoro di inferenza utilizzando vLLM**

1. Installa VLLm.

   ```
   $ pip install vllm
   ```

1. Avvia il server VLLm con NIXL. I seguenti comandi di esempio creano un'istanza prefill (producer) e un'istanza di decode (consumer) per la connessione handshake NIXL, il connettore KV, il ruolo KV e il backend di trasporto. [Per esempi e script dettagliati, consulta la Guida all'uso. NIXLConnector](https://github.com/vllm-project/vllm/blob/2d977a7a9ead3179fde9ed55d69393ef7b6cec47/docs/features/nixl_connector_usage.md)

   Per utilizzare NIXL con EFA, imposta le variabili di ambiente in base alla configurazione e al caso d'uso.
   + Configurazione Producer (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"]}}'
     ```
   + Configurazione del consumatore (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"]}}'
     ```

   La configurazione di esempio precedente imposta quanto segue:
   + `kv_role`to`kv_both`, che abilita una funzionalità simmetrica in cui il connettore può fungere sia da produttore che da consumatore. Ciò offre flessibilità per configurazioni e scenari sperimentali in cui la distinzione dei ruoli non è predeterminata.
   + `kv_buffer_device`to`cuda`, che consente l'utilizzo della memoria GPU.
   + backend NIXL to`LIBFABRIC`, che consente al traffico NIXL di passare attraverso EFA.