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

# Nozioni di base su EFA e NCCL per i carichi di lavoro ML su Amazon EC2
<a name="efa-start-nccl"></a>

La NVIDIA Collective Communications Library (NCCL) è una libreria di routine di comunicazione collettiva standard per più utenti GPUs su uno o più nodi. NCCL può essere utilizzato con EFA, Libfabric e MPI per supportare diversi carichi di lavoro di machine learning. Per ulteriori informazioni, consulta il sito Web [NCCL](https://developer.nvidia.com/nccl).

**Requisiti**
+ Sono supportati solo i tipi di istanza della serie P con elaborazione accelerata. Per ulteriori informazioni, consulta [ Istanze a calcolo accelerato Amazon EC2](https://docs.aws.amazon.com/ec2/latest/instancetypes/ac.html#ac-sizes).
+ Sono supportati solo Amazon Linux 2023, Amazon Linux 2, Ubuntu 24.04 e Ubuntu 22.04 base AMIs .
+ Solo NCCL 2.4.2 e versione successiva è supportata da EFA.

*Per ulteriori informazioni sull'esecuzione di carichi di lavoro di machine learning con EFA e NCCL utilizzando un AWS Deep Learning AMIs, consulta Using EFA [on the DLAMI](https://docs.aws.amazon.com/dlami/latest/devguide/tutorial-efa-using.html) nella Developer Guide.AWS Deep Learning AMIs *

**Topics**
+ [Fase 1: preparare un gruppo di sicurezza abilitato per EFA](#nccl-start-base-setup)
+ [Fase 2: avviare un'istanza temporanea](#nccl-start-base-temp)
+ [Fase 3: installare driver GPU Nvidia, il kit di strumenti Nvidia CUDA e cuDNN](#nccl-start-base-drivers)
+ [Fase 4: Installazione GDRCopy](#nccl-start-base-gdrcopy)
+ [Fase 5: installazione del software EFA](#nccl-start-base-enable)
+ [Fase 6: installare NCCL](#nccl-start-base-nccl)
+ [Fase 7: installare i test NCCL](#nccl-start-base-tests)
+ [Fase 8: testare la configurazione EFA e NCCL](#nccl-start-base-test)
+ [Fase 9: installare applicazioni di machine learning](#nccl-start-base-app)
+ [Fase 10: creare un EFA e un'AMI abilitata NCCL](#nccl-start-base-ami)
+ [Fase 11: terminare l'istanza temporanea](#nccl-start-base-terminate)
+ [Fase 12: avviare le istanze EFA e abilitate NCCL in un gruppo di collocazione cluster](#nccl-start-base-cluster)
+ [Fase 13: abilitare SSH senza password](#nccl-start-base-passwordless)

## Fase 1: preparare un gruppo di sicurezza abilitato per EFA
<a name="nccl-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**, scegli 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="nccl-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.

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.
**Importante**  
È necessario selezionare una sottorete. 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).

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

------
#### [ Amazon Linux 2023 and Amazon Linux 2 ]

**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 yum upgrade -y && sudo reboot
   ```

   Dopo il riavvio, riconnettersi all'istanza.

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

   ```
   $ sudo yum groupinstall 'Development Tools' -y
   ```

1. 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 yum install -y wget kernel-devel-$(uname -r) kernel-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. Aggiungere `GRUB_CMDLINE_LINUX="rdblacklist=nouveau"` al file `grub` e ricompilare il file di configurazione di Grub.

      ```
      $ echo 'GRUB_CMDLINE_LINUX="rdblacklist=nouveau"' | sudo tee -a /etc/default/grub \
      && sudo grub2-mkconfig -o /boot/grub2/grub.cfg
      ```

1. Riavviare l'istanza e riconnettersi a essa.

1. Preparare i repository richiesti

   1. Abilita l’archivio EPEL e imposta la distribuzione su `rhel7`.

      ```
      $ sudo amazon-linux-extras install epel \
      && distribution='rhel7'
      ```

   1. Impostare il repository di rete CUDA e aggiornare la cache del repository.

      ```
      $ ARCH=$( /bin/arch ) \
      && sudo yum-config-manager --add-repo http://developer.download.nvidia.com/compute/cuda/repos/$distribution/${ARCH}/cuda-$distribution.repo \
      && sudo yum clean expire-cache
      ```

   1. (*Solo kernel versione 5.10*) Eseguire questi passaggi solo se si utilizza Amazon Linux 2 con kernel versione 5.10. Se si utilizza Amazon Linux 2 con kernel versione 4.12, saltare questi passaggi. Per controllare la versione del kernel, eseguire **uname -r**.

      1. Creare il file di configurazione del driver Nvidia denominato `/etc/dkms/nvidia.conf`.

         ```
         $ sudo mkdir -p /etc/dkms \
         && echo "MAKE[0]=\"'make' -j2 module SYSSRC=\${kernel_source_dir} IGNORE_XEN_PRESENCE=1 IGNORE_PREEMPT_RT_PRESENCE=1 IGNORE_CC_MISMATCH=1 CC=/usr/bin/gcc10-gcc\"" | sudo tee /etc/dkms/nvidia.conf
         ```

      1. (Solo `p4d.24xlarge` e `p5.48xlarge`) Copia il file di configurazione del driver Nvidia.

         ```
         $ sudo cp /etc/dkms/nvidia.conf /etc/dkms/nvidia-open.conf
         ```

1. Installare i driver GPU Nvidia, il toolkit NVIDIA CUDA e cuDNN.

   ```
   $ sudo yum clean all \
   && sudo yum -y install nvidia-driver-latest-dkms \
   && sudo yum -y install cuda-drivers-fabricmanager cuda libcudnn8-devel
   ```

1. Riavviare l'istanza e riconnettersi a essa.

1. (Solo `p4d.24xlarge` e `p5.48xlarge`) Avviare il servizio Nvidia Fabric Manager e assicurarsi che venga avviato automaticamente all'avvio dell'istanza. Nvidia Fabric Manager è necessario per la gestione degli switch NV.

   ```
   $ sudo systemctl enable nvidia-fabricmanager && sudo systemctl start 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 GPUs, i driver GPU Nvidia e il toolkit Nvidia CUDA.

------
#### [ Ubuntu 24.04 and Ubuntu 22.04 ]

**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 update && 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.
   + `p3dn.24xlarge`

     ```
     $ 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
     ```
   + `p4d.24xlarge` e `p5.48xlarge`

     ```
     $ 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-kernel-open-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 GPUs, i driver GPU Nvidia e il toolkit Nvidia CUDA.

------

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

 GDRCopy Installa per migliorare le prestazioni di Libfabric. Per ulteriori informazioni suGDRCopy, consulta il [GDRCopy repository](https://github.com/NVIDIA/gdrcopy).

------
#### [ Amazon Linux 2023 and Amazon Linux 2 ]

**Per installare GDRCopy**

1. Installare le dipendenze richieste.

   ```
   $ sudo yum -y install dkms rpm-build make check check-devel subunit subunit-devel
   ```

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 il pacchetto GDRCopy RPM.

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

1. Installa il pacchetto GDRCopy RPM.

   ```
   $ sudo rpm -Uvh gdrcopy-kmod-2.4-1dkms.noarch*.rpm \
   && sudo rpm -Uvh gdrcopy-2.4-1.x86_64*.rpm \
   && sudo rpm -Uvh gdrcopy-devel-2.4-1.noarch*.rpm
   ```

------
#### [ Ubuntu 24.04 and Ubuntu 22.04 ]

**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 il pacchetto GDRCopy RPM.

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

1. Installa il pacchetto GDRCopy RPM.

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

------

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

Installa il kernel compatibile con EFA, i driver EFA, Libfabric, il aws-ofi-nccl plugin e lo stack Open MPI 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.

   È inoltre possibile ottenere l'ultima versione sostituendo il numero della versione con `latest` nel comando qui sopra.

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

1. (*Opzionale*) Verifica l'autenticità e l'integrità del file tarball EFA (`.tar.gz`).

   È consigliabile eseguire questa operazione per verificare l'identità dell'autore del software e che il file non sia stato alterato o danneggiato dopo la pubblicazione. Se non desideri verificare il file tarball, ignora questo passaggio.
**Nota**  
In alternativa, se preferisci verificare il file tarball utilizzando invece un checksum or, consulta. MD5 SHA256 [Verifica del programma di installazione EFA utilizzando un checksum](efa-verify.md)

   1. Scarica la chiave pubblica GPG e importala nel tuo keyring.

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

      Il comando dovrebbe restituire un valore di chiave. Prendere nota del valore della chiave poiché sarà necessario nella fase successiva.

   1. Verifica l'impronta digitale della chiave GPG. Esegui questo comando e specifica la chiave valore creata nella fase precedente.

      ```
      $ gpg --fingerprint key_value
      ```

      Il comando dovrebbe restituire un'impronta digitale identica a `4E90 91BC BB97 A96B 26B1 5E59 A054 80B1 DD2D 3CCC`. Se l'impronta digitale non corrisponde, non eseguire lo script di installazione EFA e contatta Supporto.

   1. Scarica il file di firma e verifica la firma del file tarball EFA.

      ```
      $ wget https://efa-installer.amazonaws.com/aws-efa-installer-1.48.0.tar.gz.sig && gpg --verify ./aws-efa-installer-1.48.0.tar.gz.sig
      ```

      Di seguito viene mostrato l'output di esempio.

      ```
      gpg: Signature made Wed 29 Jul 2020 12:50:13 AM UTC using RSA key ID DD2D3CCC
      gpg: Good signature from "Amazon EC2 EFA <ec2-efa-maintainers@amazon.com>"
      gpg: WARNING: This key is not certified with a trusted signature!
      gpg:          There is no indication that the signature belongs to the owner.
      Primary key fingerprint: 4E90 91BC BB97 A96B 26B1  5E59 A054 80B1 DD2D 3CCC
      ```

      Se il risultato include `Good signature` e se l'impronta digitale corrisponde a quella restituita nel passaggio precedente, procedi alla fase successiva. In caso contrario, non eseguire lo script di installazione EFA e contatta Supporto.

1. Estrarre i file dal file `.tar.gz` compresso e andare alla directory estratta.

   ```
   $ tar -xf 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 --mpi=openmpi4 --check-signatures`.
**Nota**  
A partire da EFA 1.30.0, per impostazione predefinita vengono installati sia Open MPI 4.1 che Open MPI 5. A meno che non sia necessario Open MPI 5, si consiglia di installare solo Open MPI 4.1. Il comando seguente installa solo Open MPI 4.1. Se si desidera installare Open MPI 4.1 e Open MPI 5, rimuovere. `--mpi=openmpi4`

   ```
   $ sudo ./efa_installer.sh -y --mpi=openmpi4
   ```

   **Libfabric** è installato nella directory `/opt/amazon/efa`. Il **aws-ofi-nccl plugin** è installato nella directory. `/opt/amazon/ofi-nccl` **Open MPI** è installato nella directory `/opt/amazon/openmpi`.

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

## Fase 6: installare NCCL
<a name="nccl-start-base-nccl"></a>

Installare NCCL. Per ulteriori informazioni su NCCL, consulta il [repository NCCL](https://github.com/NVIDIA/nccl).

**Per installare NCCL**

1. Passa alla directory `/opt`.

   ```
   $ cd /opt
   ```

1. Clonare il repository NCCL ufficiale sull'istanza e navigare nel repository clonato locale.

   ```
   $ sudo git clone https://github.com/NVIDIA/nccl.git -b v2.23.4-1 && cd nccl
   ```

1. Creare e installare NCCL e specificare la directory di installazione CUDA.

   ```
   $ sudo make -j src.build CUDA_HOME=/usr/local/cuda
   ```

## Fase 7: installare i test NCCL
<a name="nccl-start-base-tests"></a>

Installare i test NCCL. I test NCCL consentono di confermare che NCCL sia installato correttamente e che funzioni come previsto. Per ulteriori informazioni sui test NCCL, consulta il [repository nccl-tests](https://github.com/NVIDIA/nccl-tests).

**Per installare i test NCCL**

1. Passare alla home directory.

   ```
   $ cd $HOME
   ```

1. Clonare il repository nccl-tests ufficiale sull'istanza e navigare nel repository clonato locale.

   ```
   $ git clone https://github.com/NVIDIA/nccl-tests.git && cd nccl-tests
   ```

1. Aggiungere la directory Libfabric alla variabile `LD_LIBRARY_PATH`. 
   + Amazon Linux 2023 e Amazon Linux 2

     ```
     $ export LD_LIBRARY_PATH=/opt/amazon/efa/lib64:$LD_LIBRARY_PATH
     ```
   + Ubuntu 24.04 e Ubuntu 22.04

     ```
     $ export LD_LIBRARY_PATH=/opt/amazon/efa/lib:$LD_LIBRARY_PATH
     ```

1. Installare i test NCCL e specificare le directory di installazione MPI, NCCL e CUDA.

   ```
   $ make MPI=1 MPI_HOME=/opt/amazon/openmpi NCCL_HOME=/opt/nccl/build CUDA_HOME=/usr/local/cuda
   ```

## Fase 8: testare la configurazione EFA e NCCL
<a name="nccl-start-base-test"></a>

Eseguire un test per accertare che l'istanza temporanea sia configurata adeguatamente per EFA e NCCL. 

**Per testare la configurazione EFA ed NCCL**

1. Creare un file host che specifichi gli host su cui eseguire i test. Il comando seguente crea un file di host denominato `my-hosts` che include un riferimento all'istanza stessa.

------
#### [ IMDSv2 ]

   ```
   [ec2-user ~]$ TOKEN=`curl -X PUT "http://169.254.169.254/latest/api/token" -H "X-aws-ec2-metadata-token-ttl-seconds: 21600"` \
   && curl -H "X-aws-ec2-metadata-token: $TOKEN" -v http://169.254.169.254/latest/meta-data/local-ipv4 >> my-hosts
   ```

------
#### [ IMDSv1 ]

   ```
   [ec2-user ~]$ curl http://169.254.169.254/latest/meta-data/local-ipv4 >> my-hosts
   ```

------

1. Esegui il test e specifica il file host (`--hostfile`) e il numero di GPUs da utilizzare (`-n`). Il comando seguente esegue il `all_reduce_perf` test su 8 GPUs sull'istanza stessa e specifica le seguenti variabili di ambiente.
   + `FI_EFA_USE_DEVICE_RDMA=1`: (solo `p4d.24xlarge`) utilizza la funzionalità RDMA del dispositivo per il trasferimento unilaterale e bilaterale.
   + `NCCL_DEBUG=INFO`: consente un output di debug dettagliato. È possibile inoltre specificare `VERSION` per stampare solo la versione NCCL all'inizio del test o `WARN` per ricevere solo i messaggi di errore.

   Per ulteriori informazioni sugli argomenti di test NCCL, consulta [README Test NCCL](https://github.com/NVIDIA/nccl-tests/blob/master/README.md) nel repository ufficiale nccl-tests.
   + `p3dn.24xlarge`

     ```
     $ /opt/amazon/openmpi/bin/mpirun \
     -x LD_LIBRARY_PATH=/opt/nccl/build/lib:/usr/local/cuda/lib64:/opt/amazon/efa/lib:/opt/amazon/openmpi/lib:/opt/amazon/ofi-nccl/lib:$LD_LIBRARY_PATH \
     -x NCCL_DEBUG=INFO \
     --hostfile my-hosts -n 8 -N 8 \
     --mca pml ^cm --mca btl tcp,self --mca btl_tcp_if_exclude lo,docker0 --bind-to none \
     $HOME/nccl-tests/build/all_reduce_perf -b 8 -e 1G -f 2 -g 1 -c 1 -n 100
     ```
   + `p4d.24xlarge` e `p5.48xlarge`

     ```
     $ /opt/amazon/openmpi/bin/mpirun \
     -x FI_EFA_USE_DEVICE_RDMA=1 \
     -x LD_LIBRARY_PATH=/opt/nccl/build/lib:/usr/local/cuda/lib64:/opt/amazon/efa/lib:/opt/amazon/openmpi/lib:/opt/amazon/ofi-nccl/lib:$LD_LIBRARY_PATH \
     -x NCCL_DEBUG=INFO \
     --hostfile my-hosts -n 8 -N 8 \
     --mca pml ^cm --mca btl tcp,self --mca btl_tcp_if_exclude lo,docker0 --bind-to none \
     $HOME/nccl-tests/build/all_reduce_perf -b 8 -e 1G -f 2 -g 1 -c 1 -n 100
     ```

1. È possibile confermare che EFA sia attivo come provider sottostante per NCCL quando viene stampato il log `NCCL_DEBUG`.

   ```
   ip-192-168-2-54:14:14 [0] NCCL INFO NET/OFI Selected Provider is efa*
   ```

   Le seguenti informazioni aggiuntive vengono visualizzate quando si utilizza un'istanza `p4d.24xlarge`.

   ```
   ip-192-168-2-54:14:14 [0] NCCL INFO NET/OFI Running on P4d platform, Setting NCCL_TOPO_FILE environment variable to /home/ec2-user/install/plugin/share/aws-ofi-nccl/xml/p4d-24xl-topo.xml
   ```

## Fase 9: installare applicazioni di machine learning
<a name="nccl-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. Per ulteriori informazioni sull'installazione di software sull'istanza Linux, consulta [Gestione del software nell'istanza Amazon Linux 2](https://docs.aws.amazon.com/linux/al2/ug/managing-software.html).

**Nota**  
Per le istruzioni di installazione, consulta la documentazione dell'applicazione di machine learning.

## Fase 10: creare un EFA e un'AMI abilitata NCCL
<a name="nccl-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, attendere che lo stato passi da `pending` a `available`.

## Fase 11: terminare l'istanza temporanea
<a name="nccl-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 12: avviare le istanze EFA e abilitate NCCL in un gruppo di collocazione cluster
<a name="nccl-start-base-cluster"></a>

Avvia le istanze abilitate per EFA e NCCL in un gruppo di collocazione cluster tramite l'AMI abilitata per EFA e il gruppo di sicurezza abilitato per EFA creati in precedenza.

**Nota**  
Avviare le istanze abilitate per l'EFA in un gruppo di collocazione cluster non è un requisito in assoluto. È tuttavia consigliabile eseguire le istanze abilitate per EFA in un gruppo di collocazione cluster perché le istanze vengono così avviate in gruppo a bassa latenza in un'unica zona di disponibilità.
Per garantire che la capacità sia disponibile durante il dimensionamento delle istanze del cluster, è possibile creare una prenotazione della capacità per il gruppo di collocazione cluster. Per ulteriori informazioni, consulta [Utilizza la prenotazione della capacità con i gruppi di posizionamento cluster](cr-cpg.md).

------
#### [ New console ]

**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 dell'applicazione e del sistema operativo**AMIs, scegli **Mio**, quindi seleziona l'AMI che hai creato nel passaggio precedente.

1. Nella sezione **Instance type** (Tipo di istanza), seleziona `p3dn.24xlarge` o `p4d.24xlarge`.

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. (*Opzionale*) Nella sezione **Storage** (Archiviazione), configura i volumi secondo necessità.

1. Nella sezione **Advanced details** (Dettagli avanzati), per **Placement group name** (Nome del gruppo di collocazione), seleziona il gruppo di collocazione cluster in cui avviare l'istanza. Se occorre creare un nuovo gruppo di collocazione cluster, scegli **Create new placement group** (Crea nuovo gruppo di collocazione).

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

------
#### [ Old console ]

**Per avviare le istanze abilitate per EFA e NCCL in un gruppo di collocazione cluster**

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

1. Scegliere **Launch Instance (Avvia istanza)**.

1. Nella pagina **Scegli un AMI**, scegli **Mio AMIs**, trova l'AMI che hai creato in precedenza, quindi scegli **Seleziona**.

1. Nella pagina **Choose an Instance Type (Scegli il tipo di istanza)**, seleziona **p3dn.24xlarge** e scegli **Next: Configure Instance Details (Fase successiva: configurazione dei dettagli dell'istanza)**.

1. Nella pagina **Configure Instance Details (Configura i dettagli dell'istanza)**, procedere come segue:

   1. In **Number of instances (Numero di istanze)**, immettere il numero di istanze abilitate per EFA e NCCL che si desidera avviare.

   1. In **Network (Rete)** e **Subnet (Sottorete)**, selezionare il VPC e la sottorete in cui avviare le istanze.

   1. In **Placement group (Gruppo di posizionamento)**, selezionare la casella **Add instance to placement group (Aggiungi istanza a gruppo di posizionamento)**.

   1. In **Placement group name (Nome del gruppo di posizionamento)**, selezionare **Add to a new placement group (Aggiungi a un nuovo gruppo di posizionamento)** e immettere un nome descrittivo per il gruppo di posizionamento. Quindi, in **Placement group strategy (Strategia gruppo di posizionamento)**, selezionare **Cluster**.

   1. In **EFA**, scegliere **Enable (Abilita)**.

   1. Nella sezione **Network Interfaces (Interfacce di rete)**, per il dispositivo **eth0** scegliere **New network interface (Nuova interfaccia di rete)**. Facoltativamente, puoi specificare un IPv4 indirizzo principale e uno o più IPv4 indirizzi secondari. Se si avvia l'istanza in una sottorete a cui è associato un blocco IPv6 CIDR, è possibile specificare facoltativamente un IPv6 indirizzo primario e uno o più indirizzi secondari. IPv6 

   1. Scegliere **Next: Add Storage (Successivo: aggiungi storage)**.

1. Nella pagina **Add archiviazione (Aggiungi archiviazione)**, specificare i volumi da collegare all'istanza, oltre a quelli specificati dall'AMI (ad esempio il volume del dispositivo di root). Quindi selezionare **Next: Add Tags (Fase successiva: aggiungere tag)**.

1. Nella pagina **Add Tags (Aggiungi tag)** specificare i tag per l'istanza, ad esempio un nome intuitivo, quindi selezionare **Next: Configure Security Group (Successivo: configurazione del gruppo di sicurezza)**.

1. Nella pagina **Configure Security Group (Configura gruppo di sicurezza)**, scegliere **Assign a security group (Assegna un gruppo di sicurezza)**, selezionare **Select an existing security group (Seleziona un gruppo di sicurezza esistente)** e quindi selezionare il gruppo di sicurezza creato in precedenza.

1. Scegliere **Review and Launch (Analizza e avvia)**.

1. Nella pagina **Review Instance Launch (Verifica avvio istanza)** controllare le impostazioni e selezionare **Launch (Avvia)** per scegliere una coppia di chiavi e avviare l'istanza.

------

## Fase 13: abilitare SSH senza password
<a name="nccl-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.