# Conceitos básicos do EFA e NCCL para workloads de ML no Amazon EC2
<a name="efa-start-nccl"></a>

A Nvidia Collective Communications Library (NCCL) é uma biblioteca de rotinas de comunicação coletiva padrão para várias GPUs em um único nó ou em vários nós. A NCCL pode ser usada com o EFA, o Libfabric e a MPI para oferecer suporte a várias workloads de machine learning. Para obter mais informações, consulte o site da [NCCL](https://developer.nvidia.com/nccl).

**Requisitos**
+ Somente os tipos de instância da série P são compatíveis. Para obter mais informações, consulte [ Instâncias com computação acelerada do Amazon EC2](https://docs.aws.amazon.com/ec2/latest/instancetypes/ac.html#ac-sizes).
+ Apenas as AMIs básicas do Amazon Linux 2023, Amazon Linux 2, Ubuntu 24.04 e Ubuntu 22.04 são compatíveis.
+ Somente a NCCL 2.4.2 e posterior são compatíveis com EFA.

Para obter mais informações sobre como executar workloads de machine learning com EFA e NCCL usando um AMIs de deep learning da AWS, consulte [Usando o EFA no DLAMI](https://docs.aws.amazon.com/dlami/latest/devguide/tutorial-efa-using.html) no *Guia do desenvolvedor do AMIs de deep learning da AWS*.

**Topics**
+ [Etapa 1: Preparar um grupo de segurança habilitado para EFA](#nccl-start-base-setup)
+ [Etapa 2: Iniciar uma instância temporária](#nccl-start-base-temp)
+ [Etapa 3: Instalar drivers de GPU Nvidia, o toolkit Nvidia CUDA e o cuDNN](#nccl-start-base-drivers)
+ [Etapa 4: instalar o GDRCopy](#nccl-start-base-gdrcopy)
+ [Etapa 5: instalar o software EFA](#nccl-start-base-enable)
+ [Etapa 6: instalar NCCL](#nccl-start-base-nccl)
+ [Etapa 7: Instalar os testes da NCCL](#nccl-start-base-tests)
+ [Etapa 8: Testar a configuração do EFA e da NCCL](#nccl-start-base-test)
+ [Etapa 9: Instalar as aplicações de machine learning](#nccl-start-base-app)
+ [Etapa 10: Criar um EFA e uma AMI habilitada para NCCL](#nccl-start-base-ami)
+ [Etapa 11: Encerrar a instância temporária](#nccl-start-base-terminate)
+ [Etapa 12: Iniciar instâncias habilitadas para EFA e para NCCL em um grupo de posicionamento de cluster](#nccl-start-base-cluster)
+ [Etapa 13: Habilitar SSH sem senha](#nccl-start-base-passwordless)

## Etapa 1: Preparar um grupo de segurança habilitado para EFA
<a name="nccl-start-base-setup"></a>

Um EFA requer um grupo de segurança que permita todo o tráfego de entrada e saída do grupo de segurança e para ele próprio. O procedimento a seguir cria um grupo de segurança que permite todo o tráfego de entrada e saída de e para si mesmo e que permite tráfego SSH de entrada de qualquer endereço IPv4 para conectividade SSH.

**Importante**  
Esse grupo de segurança deve ser usado apenas para fins de teste. Para seus ambientes de produção, recomendamos que você crie uma regra SSH de entrada que permita o tráfego somente do endereço IP do qual você está se conectando, como o endereço IP do seu computador ou uma variedade de endereços IP na sua rede local.

Para outros cenários, consulte [Regras de grupo de segurança para diferentes casos de uso](security-group-rules-reference.md).

**Para criar um grupo de segurança habilitado para EFA**

1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. No painel de navegação, escolha **Security Groups** (Grupos de segurança) e, em seguida, **Create Security Group** (Criar grupo de segurança).

1. Na janela **Security group** (Grupo de segurança), faça o seguinte:

   1. Em **Security group name** (Nome do grupo de segurança), insira um nome descritivo para o grupo de segurança, como `EFA-enabled security group`.

   1. (Opcional) Em **Description** (Descrição), insira uma breve descrição do grupo de segurança.

   1. Em **VPC**, selecione a VPC na qual você pretende executar suas instâncias habilitadas para EFA.

   1. Escolha **Criar grupo de segurança**.

1. Selecione o grupo de segurança que você criou e, na guia **Details** (Detalhes), copie o **Security group** (Grupo de segurança).

1. Com o grupo de segurança ainda selecionado, escolha **Actions** (Ações), **Edit inbound rules** (Editar regras de entrada), e faça o seguinte:

   1. Escolha **Adicionar regra**.

   1. Para **Tipo**, escolha **Todo o tráfego**.

   1. Para **Source type** (Tipo de origem), escolha **Custom** (Personalizado) e cole o ID do grupo de segurança que você copiou no campo.

   1. Escolha **Adicionar regra**.

   1. Para **Tipo**, escolha **SSH**.

   1. Para **Source type** (Tipo de origem), escolha **Anywhere-IPv4** (IPv4 em qualquer lugar).

   1. Selecione **Salvar regras**.

1. Na lista, selecione o grupo de segurança e escolha **Actions** (Ações), **Edit outbound rules** (Editar regras de saída), e faça o seguinte:

   1. Escolha **Adicionar regra**.

   1. Para **Tipo**, escolha **Todo o tráfego**.

   1. Para **Destination** (Destino), escolha **Custom** (Personalizado) e cole o ID do grupo de segurança que você copiou no campo.

   1. Selecione **Salvar regras**.

## Etapa 2: Iniciar uma instância temporária
<a name="nccl-start-base-temp"></a>

Execute uma instância temporária que é possível usar para instalar e configurar os componentes do software EFA. Você usa essa instância para criar um AMI habilitado para EFA a partir do qual é possível executar suas instâncias habilitadas para EFA.

**Para executar uma instância temporária**

1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. No painel de navegação, selecione **Instances** (Instâncias) e, depois, escolha **Launch Instances** (Iniciar instâncias) para abrir o novo assistente de inicialização de instância.

1. (*Opcional*) Na seção **Name and tags** (Nome e etiquetas), forneça um nome para a instância, como `EFA-instance`. O nome é atribuído à instância como uma etiqueta de recurso (`Name={{EFA-instance}}`).

1. Na seção **Application and OS Images** (Imagens de aplicação e sistema operacional), selecione uma AMI para um dos sistemas operacionais compatíveis.

1. Na seção **Instance type** (Tipo de instância), selecione um tipo de instância compatível.

1. Na seção **Key pair** (Par de chaves), selecione o par de chaves a ser usado na instância.

1. Na seção **Network settings** (Configurações da rede), escolha **Edit** (Editar) e faça o seguinte:

   1. Em **Subnet (Sub-rede)**, escolha a sub-rede na qual deseja iniciar a instância.
**Importante**  
Você deve selecionar uma sub-rede. Se você não selecionar uma sub-rede, não será possível habilitar a instância para o EFA.

   1. Para **Firewall (security groups)** (Firewall/grupos de segurança), escolha **Select existing security group** (Selecione grupo de segurança existente) e, em seguida, selecione o grupo de segurança que você criou na etapa anterior.

   1. Expanda a seção **Configuração de rede avançada**.

      Para **Interface de rede 1**, selecione **Índice da placa de rede = 0**, **Índice do dispositivo = 0** e **Tipo de interface = EFA com ENA**.

      **(*Opcional*) Se você estiver usando um tipo de instância com várias placas, como `p4d.24xlarge` ou`p5.48xlarge`, para cada interface de rede adicional necessária, escolha **Adicionar interface de rede**, em **Índice da placa de rede, selecione o próximo índice** não utilizado e, em seguida, selecione **Índice do dispositivo = 1** e **Tipo de interface = EFA com ENA** ou somente EFA.**.

1. Na seção **Storage** (Armazenamento), configure os volumes conforme necessário.
**nota**  
É necessário provisionar um armazenamento adicional de 10 a 20 GiB para o Toolkit Nvidia CUDA. Se você não provisionar armazenamento suficiente, você receberá uma mensagem de erro `insufficient disk space` ao tentar instalar os drivers Nvidia e o Toolkit CUDA.

1. No painel **Summary** (Resumo) painel, escolha **Launch instance** (Iniciar instância).

## Etapa 3: Instalar drivers de GPU Nvidia, o toolkit Nvidia CUDA e o cuDNN
<a name="nccl-start-base-drivers"></a>

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

**Para instalar os drivers de GPU Nvidia, o toolkit Nvidia CUDA e o cuDNN**

1. Para garantir que todos os pacotes de software estejam atualizados, execute uma atualização rápida de software em sua instância.

   ```
   $ sudo yum upgrade -y && sudo reboot
   ```

   Reconecte-se à sua instância depois de reinicializá-la.

1. Instale os utilitários necessários para instalar os drivers de GPU Nvidia e o toolkit Nvidia CUDA.

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

1. Desabilite os drivers de código aberto `nouveau`.

   1. Instale os utilitários necessários e o pacote de cabeçalhos kernel para a versão do kernel que está sendo executada.

      ```
      $ sudo yum install -y wget kernel-devel-$(uname -r) kernel-headers-$(uname -r)
      ```

   1. Adicione `nouveau` ao arquivo de lista de negação `/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. Anexe `GRUB_CMDLINE_LINUX="rdblacklist=nouveau"` ao arquivo `grub` e recompile a configuração do Grub.

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

1. Reinicialize a instância e reconecte-se a ela.

1. Prepare os repositórios necessários

   1. Ative o repositório EPEL e defina a distribuição como `rhel7`.

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

   1. Configure o repositório de rede CUDA e atualize o cache do repositório.

      ```
      $ 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. (*Somente kernel versão 5.10*) Execute estas etapas somente se você estiver usando o Amazon Linux 2 com o kernel versão 5.10. Se você estiver usando o Amazon Linux 2 com o kernel versão 4.12, ignore estas etapas. Para verificar a versão do kernel, execute **uname -r**.

      1. Crie o arquivo de configuração do driver Nvidia chamado `/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. (`p4d.24xlarge` e `p5.48xlarge` somente) Copie o arquivo de configuração do driver NVIDIA.

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

1. Instale os drivers de GPU Nvidia, o toolkit Nvidia CUDA e o cuDNN.

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

1. Reinicialize a instância e reconecte-se a ela.

1. (`p4d.24xlarge` e `p5.48xlarge` somente) Inicie o serviço NVIDIA Fabric Manager e verifique se ele será iniciado automaticamente quando a instância for iniciada. O Nvidia Fabric Manager é necessário para o gerenciamento do NV Switch.

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

1. Certifique-se de que os caminhos do CUDA sejam definidos cada vez que a instância for executada.
   + Em shells *bash*, adicione as seguintes instruções 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
     ```
   + Em shells *tcsh*, adicione as seguintes instruções 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. Para verificar se os drivers de GPU Nvidia estão funcionando, execute o comando a seguir.

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

   O comando deve retornar informações sobre os as GPUs Nvidia, sobre os drivers de GPU Nvidia e sobre o toolkit Nvidia CUDA.

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

**Para instalar os drivers de GPU Nvidia, o toolkit Nvidia CUDA e o cuDNN**

1. Para garantir que todos os pacotes de software estejam atualizados, execute uma atualização rápida de software em sua instância.

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

1. Instale os utilitários necessários para instalar os drivers de GPU Nvidia e o toolkit Nvidia CUDA.

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

1. Para usar o driver de GPU Nvidia, é necessário primeiro desabilitar os drivers de código aberto `nouveau`.

   1. Instale os utilitários necessários e o pacote de cabeçalhos kernel para a versão do kernel que está sendo executada.

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

   1. Adicione `nouveau` ao arquivo de lista de negação `/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. Abra o `/etc/default/grub` usando o editor de texto de sua preferência e adicione o seguinte. 

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

   1. Recompile a configuração do Grub.

      ```
      $ sudo update-grub
      ```

1. Reinicialize a instância e reconecte-se a ela.

1. Adicione o repositório CUDA e instale os drivers de GPU Nvidia, o toolkit Nvidia CUDA e o 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 da `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. Reinicialize a instância e reconecte-se a ela.

1. (Somente `p4d.24xlarge` e `p5.48xlarge`) Instale o Nvidia Fabric Manager.

   1. É necessário instalar a versão do Nvidia Fabric Manager que corresponde à versão do módulo do kernel Nvidia que você instalou na etapa anterior.

      Execute o seguinte comando para determinar a versão do módulo do kernel Nvidia.

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

      A seguir está um exemplo de saída.

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

      No exemplo acima, a versão principal`450`do módulo do kernel foi instalado. Isso significa que você precisa instalar a versão do Nvidia Fabric Manager `450`.

   1. Instale o Nvidia Fabric Manager. Execute o seguinte comando e especifique a versão principal identificada na etapa anterior.

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

      Por exemplo, se a versão principal`450`do módulo do kernel foi instalado, use o seguinte comando para instalar a versão correspondente do Nvidia Fabric Manager.

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

   1. Inicie o serviço e certifique-se de que ele seja iniciado automaticamente quando a instância for executada. O Nvidia Fabric Manager é necessário para o gerenciamento do NV Switch.

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

1. Certifique-se de que os caminhos do CUDA sejam definidos cada vez que a instância for executada.
   + Em shells *bash*, adicione as seguintes instruções 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
     ```
   + Em shells *tcsh*, adicione as seguintes instruções 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. Para verificar se os drivers de GPU Nvidia estão funcionando, execute o comando a seguir.

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

   O comando deve retornar informações sobre os as GPUs Nvidia, sobre os drivers de GPU Nvidia e sobre o toolkit Nvidia CUDA.

------

## Etapa 4: instalar o GDRCopy
<a name="nccl-start-base-gdrcopy"></a>

Instale o GDRCopy para melhorar a performance do Libfabric. Para obter mais informações sobre a GDRCopy, consulte o [repositório do GDRCopy](https://github.com/NVIDIA/gdrcopy).

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

**Para instalar o GDRCopy**

1. Instale as dependências necessárias.

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

1. Baixe e extraia o pacote do 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. Crie o pacote RPM do GDRCopy.

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

1. Instale o pacote RPM do GDRCopy.

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

**Para instalar o GDRCopy**

1. Instale as dependências necessárias.

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

1. Baixe e extraia o pacote do 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. Crie o pacote RPM do GDRCopy.

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

1. Instale o pacote RPM do GDRCopy.

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

------

## Etapa 5: instalar o software EFA
<a name="nccl-start-base-enable"></a>

Instale o kernel habilitado para EFA, drivers EFA, Libfabric, plugin aws-ofi-nccl e pilha Open MPI, que são necessários para oferecer compatibilidade com EFA em sua instância.

**Como instalar o software EFA**

1. Conecte à instância que você iniciou. Para obter mais informações, consulte [Conectar-se à instância do Linux usando SSH](connect-to-linux-instance.md).

1. Faça download dos arquivos de instalação do software do EFA. Os arquivos de instalação do software são empacotados em um arquivo compactado tarball (`.tar.gz`). Para fazer download da última versão *estável*, use o seguinte comando:

   Também é possível obter a versão mais recente substituindo o número da versão por `latest` no comando acima.

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

1. (*Opcional*) Verifique a autenticidade e a integridade do arquivo do EFA tarball (`.tar.gz`).

   Recomendamos que você faça isso para verificar a identidade do fornecedor do software e para verificar se a aplicação não foi alterada ou corrompida desde que foi publicada. Se você não deseja verificar o arquivo tarball, ignore esta etapa.
**nota**  
Como alternativa, se você preferir verificar o arquivo tarball usando uma soma de verificação MD5 ou SHA256, consulte [Verificar o instalador EFA usando uma soma de verificação](efa-verify.md).

   1. Faça download da chave GPG pública e importe-a para seu pen-drive.

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

      O comando deve retornar um valor de chave. Anote o valor da chave, pois ele será necessário na próxima etapa.

   1. Verifique a impressão digital da chave GPG. Execute o seguinte comando e especifique o valor de chave da etapa anterior.

      ```
      $ gpg --fingerprint {{key_value}}
      ```

      O comando deve retornar uma impressão digital idêntica a `4E90 91BC BB97 A96B 26B1 5E59 A054 80B1 DD2D 3CCC`. Se a impressão digital não corresponder, não execute o script de instalação do EFA e entre em contato com o Suporte.

   1. Faça download do arquivo de assinatura e verifique a assinatura do arquivo 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
      ```

      Veja a seguir um exemplo de saída.

      ```
      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 o resultado incluir `Good signature` e a impressão digital corresponder à impressão digital retornada na etapa anterior, passe para a próxima etapa. Caso contrário, não execute o script de instalação do EFA e entre em contato com o Suporte.

1. Extraia os arquivos do arquivo compactado `.tar.gz` e navegue para o diretório extraído.

   ```
   $ tar -xf aws-efa-installer-1.48.0.tar.gz && cd aws-efa-installer
   ```

1. (*Opcional*) Verifique as assinaturas de pacotes individuais durante a instalação.

   A partir do EFA 1.48.0, o instalador inclui pacotes individuais RPM e DEB assinados com GPG. Para verificar a autenticidade e a integridade de cada pacote individual durante a instalação, use o sinalizador `--check-signatures`. Quando você habilita esse sinalizador, o instalador verifica primeiro todas as assinaturas de pacotes e prossegue com a instalação somente se cada pacote for aprovado na verificação. Se algum pacote não for aprovado na verificação, o instalador sairá imediatamente sem instalar nada.

   1. Baixe a chave pública.

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

   1. Exporte o caminho principal. Em seguida, na próxima etapa, anexe `--check-signatures` ao comando de instalação e use `sudo -E` em vez de `sudo` para preservar a variável de ambiente.

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

   Em sistemas baseados em RPM (Amazon Linux, RHEL, Rocky Linux e SUSE), o instalador verifica cada RPM usando `rpm --checksig`. Em sistemas baseados em DEB (Ubuntu, Debian), o instalador verifica cada DEB usando a verificação de assinatura GPG.

   Se houver falha na verificação de algum pacote, a instalação será interrompida imediatamente, protegendo seu sistema contra pacotes danificados ou maliciosos.
**nota**  
O sinalizador `--check-signatures` é opcional. Sem isso, o instalador não realiza a verificação de assinaturas individuais.

1. Execute o script de instalação do software EFA.
**nota**  
Se você concluiu a etapa opcional anterior para configurar a verificação de assinaturas de pacotes, acrescente `--check-signatures` ao comando de instalação e use `sudo -E` em vez de `sudo`. Por exemplo: `sudo -E ./efa_installer.sh -y --mpi=openmpi4 --check-signatures`.
**nota**  
A partir do EFA 1.30.0, tanto a Open MPI 4.1 quanto a Open MPI 5 são instaladas por padrão. A menos que você precise da Open MPI 5, recomendamos que instale apenas a Open MPI 4.1. O comando a seguir instala apenas a Open MPI 4.1. Se quiser instalar a Open MPI 4.1 e a Open MPI 5, remova `--mpi=openmpi4`.

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

   O **Libfabric** está instalado no diretório `/opt/amazon/efa`. O **plugin aws-ofi-nccl** está instalado no diretório `/opt/amazon/ofi-nccl`. O **Open MPI** está instalado no diretório `/opt/amazon/openmpi`.

1. Se o instalador do EFA solicitar que você reinicialize a instância, faça-o e, em seguida, reconecte-se à instância. Caso contrário, faça logout da instância e faça login novamente para concluir a instalação.

1. Confirme se os componentes do software EFA foram instalados com sucesso.

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

   O comando deve retornar informações sobre as interfaces EFA Libfabric. O exemplo a seguir mostra a saída do comando.
   + `p3dn.24xlarge` com interface de rede única

     ```
     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` com várias interfaces de rede

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

## Etapa 6: instalar NCCL
<a name="nccl-start-base-nccl"></a>

Instale a NCCL. Para obter mais informações sobre a NCCL, consulte o [Repositório da NCCL](https://github.com/NVIDIA/nccl).

**Como instalar a NCCL**

1. Navegue até o diretório `/opt`.

   ```
   $ cd /opt
   ```

1. Clone o repositório oficial da NCCL para a instância e navegue até o repositório local clonado.

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

1. Compile e instale a NCCL e especifique o diretório de instalação do CUDA.

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

## Etapa 7: Instalar os testes da NCCL
<a name="nccl-start-base-tests"></a>

Instale os testes da NCCL. Os testes da NCCL permitem confirmar se a NCCL está instalada adequadamente se ela está funcionando conforme esperado. Para obter mais informações sobre os testes da NCCL, consulte o [Repositório nccl-tests](https://github.com/NVIDIA/nccl-tests).

**Como instalar os testes da NCCL**

1. Navegue até o diretório inicial.

   ```
   $ cd $HOME
   ```

1. Clone o repositório oficial de nccl-tests para a instância e navegue até o repositório local clonado.

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

1. Adicione o diretório do Libfabric à variável `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. Instale os testes da NCCL e especifique os diretórios de instalação da MPI da NCCL e do CUDA.

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

## Etapa 8: Testar a configuração do EFA e da NCCL
<a name="nccl-start-base-test"></a>

Execute um teste para verificar se a instância temporária está configurada adequadamente para o EFA e para a NCCL. 

**Como testar a configuração do EFA e da NCCL**

1. Crie um arquivo de host que especifique os hosts nos quais executar os testes. O comando a seguir cria um arquivo de host chamado `my-hosts` que inclui uma referência à própria instância.

------
#### [ 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. Execute o teste e especifique o arquivo de host (`--hostfile`) e o número de GPUs a serem usadas (`-n`). O comando a seguir executa o teste `all_reduce_perf` em 8 GPUs na própria instância e especifica as variáveis de ambiente a seguir.
   + `FI_EFA_USE_DEVICE_RDMA=1`: (somente `p4d.24xlarge`) usa a funcionalidade RDMA do dispositivo para transferência unilateral e bilateral.
   + `NCCL_DEBUG=INFO` habilita a saída de depuração detalhada. Também é possível especificar `VERSION` para imprimir somente a versão da NCCL no início do teste ou `WARN` para receber somente mensagens de erro.

   Para obter mais informações sobre os argumentos de teste da NCCL, consulte o [README NCCL Tests](https://github.com/NVIDIA/nccl-tests/blob/master/README.md) no repositório oficial de 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 da `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. É possível confirmar se EFA está ativo como o provedor subjacente para NCCL quando o log `NCCL_DEBUG` é impresso.

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

   As seguintes informações adicionais são exibidas ao usar uma instância `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
   ```

## Etapa 9: Instalar as aplicações de machine learning
<a name="nccl-start-base-app"></a>

Instale as aplicações de machine learning na instância temporária. O procedimento de instalação varia dependendo da aplicação de machine learning específica. Para obter mais informações sobre instalação de software em sua instância do Linux, consulte [Manage software on your Amazon Linux 2 instance](https://docs.aws.amazon.com/linux/al2/ug/managing-software.html).

**nota**  
Pode ser necessário consultar a documentação da aplicação de machine learning para obter instruções de instalação.

## Etapa 10: Criar um EFA e uma AMI habilitada para NCCL
<a name="nccl-start-base-ami"></a>

Depois de instalar os componentes de software necessários, crie uma AMI que possa ser reutilizada para executar suas instâncias habilitadas para o EFA.

**Para criar uma AMI a partir de sua instância temporária**

1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. No painel de navegação, escolha **Instances (Instâncias)**.

1. Selecione a instância, escolha **Actions** (Ações), **Image** (Imagem), **Create image** (Criar imagem).

1. Em **Create image (Criar imagem)**, faça o seguinte:

   1. Em **Image name (Nome da imagem)**, insira um nome descritivo para a AMI.

   1. (Opcional) Em **Image description (Descrição da imagem)**, informe a descrição do propósito da AMI.

   1. Escolha **Create Image (Criar imagem)**.

1. No painel de navegação, selecione **AMIs**.

1. Encontre a AMI que você criou na lista. Aguarde até que o status mude de `pending` para `available` antes de continuar para a próxima etapa.

## Etapa 11: Encerrar a instância temporária
<a name="nccl-start-base-terminate"></a>

Neste ponto, você não precisa mais da instância temporária que você executou. É possível encerrar a instância para não incorrer mais em cobranças desnecessárias.

**Para encerrar a instância temporária**

1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. No painel de navegação, escolha **Instances (Instâncias)**.

1. Selecione a instância temporária, escolha **Actions (Ações)**, selecione **Instance state (Estado da instância)**, **Terminate instance (Encerrar instance)**.

1. Quando a confirmação for solicitada, escolha **Terminate (Encerrar)**.

## Etapa 12: Iniciar instâncias habilitadas para EFA e para NCCL em um grupo de posicionamento de cluster
<a name="nccl-start-base-cluster"></a>

Execute as instâncias habilitadas para EFA em um grupo de posicionamento de cluster usando a AMI habilitada para EFA criada e o grupo de segurança habilitado para EFA criado anteriormente.

**nota**  
Não é um requisito absoluto executar suas instâncias habilitadas para EFA em um placement group de cluster. No entanto, recomendamos a execução de suas instâncias habilitadas para EFA em um grupo de posicionamento de cluster ao executar as instâncias em um grupo de baixa latência em uma única zona de disponibilidade.
Para garantir que a capacidade esteja disponível à medida que escala as instâncias do cluster, é possível criar uma reserva de capacidade para o grupo de posicionamento de cluster. Para obter mais informações, consulte [Usar reservas de capacidade em grupos de posicionamento de cluster](cr-cpg.md).

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

**Para executar uma instância temporária**

1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. No painel de navegação, selecione **Instances** (Instâncias) e, depois, escolha **Launch Instances** (Iniciar instâncias) para abrir o novo assistente de inicialização de instância.

1. (*Opcional*) Na seção **Name and tags** (Nome e etiquetas), forneça um nome para a instância, como `EFA-instance`. O nome é atribuído à instância como uma etiqueta de recurso (`Name={{EFA-instance}}`).

1. Na seção **Application and OS Images** (Imagens de aplicações e SO), selecione **My AMIs** (Minhas AMIs) e, em seguida, selecione a AMI que você criou na etapa anterior.

1. Na seção **Instance type** (Tipo de instância), selecione `p3dn.24xlarge` ou `p4d.24xlarge`.

1. Na seção **Key pair** (Par de chaves), selecione o par de chaves a ser usado na instância.

1. Na seção **Network settings** (Configurações da rede), escolha **Edit** (Editar) e faça o seguinte:

   1. Em **Subnet (Sub-rede)**, escolha a sub-rede na qual deseja iniciar a instância. Se você não selecionar uma sub-rede, não será possível habilitar a instância para o EFA.

   1. Para **Firewall (security groups)** (Firewall/grupos de segurança), escolha **Select existing security group** (Selecione grupo de segurança existente) e, em seguida, selecione o grupo de segurança que você criou na etapa anterior.

   1. Expanda a seção **Configuração de rede avançada**.

      Para **Interface de rede 1**, selecione **Índice da placa de rede = 0**, **Índice do dispositivo = 0** e **Tipo de interface = EFA com ENA**.

      (Opcional) Caso esteja usando um tipo de instância com várias placas, como `p4d.24xlarge` ou`p5.48xlarge`, para cada interface de rede adicional necessária, selecione **Adicionar interface de rede**, em **Índice da placa de rede**, selecione o próximo índice não utilizado e, em seguida, selecione **Índice do dispositivo = 1** e **Tipo de interface = EFA com ENA** ou **exclusivamente EFA**.

1. (*Opcional*) Na seção **Storage** (Armazenamento), configure os volumes conforme necessário.

1. Na seção **Advanced details** (Detalhes avançados), para **Placement group name** (Nome do grupo de posicionamento), selecione o grupo de posicionamento de cluster no qual iniciar a instância. Caso precise criar um novo grupo de posicionamento de cluster, escolha **Create new placement group** (Criar novo grupo de posicionamento).

1. No painel **Summary** (Resumo) à direita, em **Number of instances** (Número de instâncias), insira o número de instâncias habilitadas para EFA que você deseja iniciar e escolha **Launch instance** (Iniciar instância).

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

**Para executar as instâncias habilitadas para EFA e NCCL em um grupo de posicionamento de cluster.**

1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. Escolha **Launch Instance (Executar instância)**.

1. Na página **Choose an AMI (Escolher uma AMI)**, selecione **My AMIs (Minhas AMIs)**, localize a AMI criada anteriormente e escolha **Select (Selecionar)**.

1. Na página **Choose an Instance Type (Escolher um tipo de instância)**, escolha **p3dn.24xlarge** e selecione **Next: Configure Instance Details (Próximo: configurar detalhes da instância)**.

1. Na página **Configure Instance Details (Configurar detalhes da instância)**, faça o seguinte:

   1. Em **Number of instances (Número de instâncias)**, insira o número de instâncias habilitadas para EFA e NCCL que você deseja executar.

   1. Em **Network (Rede)** e **Subnet (Sub-rede)**, selecione a VPC e a sub-rede na qual executar as instâncias.

   1. Em **Placement group**, selecione **Add instance to placement group (Adicionar instância ao placement group)**.

   1. Em **Placement group name** (Nome do grupo de posicionamento), selecione **Add to a new placement group** (Adicionar a um novo grupo de posicionamento) e, em seguida, insira um nome descritivo para o grupo de posicionamento. Em seguida, em **Placement group strategy** (Estratégia do grupo de posicionamento), selecione **cluster**.

   1. Para **EFA**, escolha **Enable (Habilitar)**.

   1. Na seção **Network Interfaces (Interfaces de rede)**, para dispositivo **eth0**, escolha **New network interface (Nova interface de rede)**. Como opção, é possível especificar um endereço IPv4 principal e um ou mais endereços IPv4 secundários. Se estiver executando a instância em uma sub-rede que tenha um bloco CIDR IPv6 associado, será possível especificar opcionalmente um endereço IPv6 principal e um ou mais endereços IPv6 secundários.

   1. Escolha **Next: Add Storage**.

1. Na página **Add Storage (Adicionar armazenamento)**, especifique os volumes para anexar às instâncias, além dos volumes especificados pela AMI (como o volume raiz). Depois, selecione **Next: Add Tags (Próximo: adicionar tags)**.

1. Na página **Add Tags (Adicionar tags)**, especifique tags para as instâncias, como nome amigável, e selecione **Next: Configure Security Group (Próximo: Configurar grupo de segurança)**.

1. Na página **Configure Security Group** (Configurar grupo de segurança), para **Assign a security group** (Atribuir um grupo de segurança), selecione **Select an existing security group** (Selecionar um grupo de segurança existente) e selecione o grupo de segurança que você criou anteriormente.

1. Escolha **Review and Launch**.

1. Na página **Review Instance Launch (Revisar execução da instância)**, reveja as configurações, e escolha **Launch (Executar)** para escolher um par de chaves e executar a instâncias.

------

## Etapa 13: Habilitar SSH sem senha
<a name="nccl-start-base-passwordless"></a>

Para permitir que suas aplicações sejam executadas em todas as instâncias do cluster, é necessário habilitar o acesso SSH sem senha do nó líder para os nós membros. O nó líder é a instância a partir da qual você executa suas aplicações. As instâncias restantes no cluster são os nós membros.

**Para habilitar SSH sem senha entre as instâncias no cluster**

1. Selecione uma instância no cluster como o nó líder e conecte-se a ela.

1. Desabilite `strictHostKeyChecking` e habilite `ForwardAgent` no nó líder. Abra o `~/.ssh/config` usando o editor de texto de sua preferência e adicione o seguinte.

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

1. Gere um par de chaves RSA.

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

   O par de chaves é criado no diretório do `$HOME/.ssh/`.

1. Altere as permissões da chave privada no nó líder.

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

1. Abra `~/.ssh/id_rsa.pub` usando seu editor de texto preferido e copie a chave.

1. Para cada nó de membro no cluster, faça o seguinte:

   1. Conecte-se à instância.

   1. Abra `~/.ssh/authorized_keys` usando o editor de texto de sua preferência e adicione a chave pública que você copiou anteriormente.

1. Para testar se o SSH sem senha está funcionando como esperado, conecte-se ao seu nó líder e execute o comando a seguir.

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

   É necessário se conectar ao nó membro sem receber uma solicitação para inserir uma chave ou senha.