# Redes aperfeiçoadas para instâncias do Amazon EC2
A rede avançada usa virtualização de E/S raiz (SR-IOV) para fornecer recursos de rede de alta performance em tipos de instâncias com suporte. A SR-IOV é um método de virtualização de dispositivos que fornece performance de E/S mais elevado e menor utilização de CPU em comparação com interfaces de redes virtualizadas tradicionais. A rede avançada fornece uma largura de banda maior, uma performance melhor de pacotes por segundo (PPS) e latências consistentemente menores entre instâncias. Não há nenhuma cobrança adicional pelo uso da rede avançada.
Para obter mais informações sobre a velocidade de rede compatível com cada tipo de instância, consulte [Tipos de instância do Amazon EC2](https://aws.amazon.com/ec2/instance-types/).
É possível habilitar redes avançadas usando um dos seguintes mecanismos:
**Elastic Network Adapter (ENA)**
O Elastic Network Adapter (ENA) oferece suporte a velocidades de rede de até 100 Gbps para tipos de instâncias compatíveis.
Todas as [instâncias baseadas em Nitro](instance-types.md#instance-hypervisor-type) usam o ENA para obter uma rede aprimorada. Além disso, as seguintes instâncias baseadas em Xen usam ENA: H1, I3, G3, `m4.16xlarge`, P2, P3, P3dn e R4.
Para obter mais informações, consulte [Habilitar redes aperfeiçoadas com o ENA em instâncias do EC2](enhanced-networking-ena.md).
**Interface Intel 82599 Virtual Function (VF)**
A interface Intel 82599 Virtual Function oferece suporte a velocidades de rede de até 10 Gbps para tipos de instâncias compatíveis.
Os seguintes tipos de instância usam a interface Intel 82599 VF para redes aprimoradas: C3, C4, D2, I2, M4 (excluindo o m4.16xlarge) e R3.
Para obter mais informações, consulte [Habilitar redes aperfeiçoadas com a interface Intel 82599 VF](sriov-networking.md).
**Topics**
+ [Elastic Network Adapter (ENA)](enhanced-networking-ena.md)
+ [ENA Express](ena-express.md)
+ [Intel 82599 VF](sriov-networking.md)
+ [Melhor desempenho de rede](monitoring-network-performance-ena.md)
+ [Aprimorar a latência de rede no Linux](ena-improve-network-latency-linux.md)
+ [Considerações sobre a performance do Nitro](ena-nitro-perf.md)
+ [Otimizar a performance da rede no Windows](enhanced-networking-os.md)
# Habilitar redes aperfeiçoadas com o ENA em instâncias do EC2
O Amazon EC2 oferece recursos de rede avançada pelo Elastic Network Adapter (ENA). Para usar a rede aperfeiçoada, é necessário usar uma AMI que inclua o driver do ENA necessário ou instalá-lo manualmente. Em seguida, habilite o suporte do ENA na instância.
Para revisar as notas de versão ou as instruções de instalação de um driver do ENA, consulte a guia que corresponde à plataforma do sistema operacional da instância.
------
#### [ Linux ]
É possível consultar a seguinte documentação no GitHub:
+ Analise as [notas de lançamento do driver do kernel do ENA do Linux](https://github.com/amzn/amzn-drivers/blob/master/kernel/linux/ena/RELEASENOTES.md) no GitHub.
+ Para ter uma visão geral do driver do kernel do ENA do Linux que inclui instruções de instalação, consulte [Linux kernel driver for Elastic Network Adapter (ENA) family](https://github.com/amzn/amzn-drivers/blob/master/kernel/linux/ena/README.rst) no GitHub.
------
#### [ Windows ]
É possível revisar a seguinte documentação na seção **Gerenciar drivers de dispositivo** deste guia:
+ [Rastrear os lançamentos da versão do driver do ENA do Windows](ena-driver-releases-windows.md).
+ [Instalar o driver do ENA em instâncias do Windows do EC2](ena-adapter-driver-install-upgrade-win.md).
------
Para instâncias baseadas em Nitro, os recursos da rede aperfeiçoada variam de acordo com a versão do Nitro que o tipo de instância implementa.
Para analisar as especificações de rede da instância, escolha o link da família de instâncias para seu tipo de instância. Se você não tiver certeza quanto a qual família de instâncias é aplicável, consulte [Convenções de nomenclatura](https://docs.aws.amazon.com/ec2/latest/instancetypes/instance-type-names.html) no guia *Tipos de instância do Amazon EC2*.
+ [Network specifications for accelerated computing instances](https://docs.aws.amazon.com/ec2/latest/instancetypes/ac.html#ac_network)
+ [Network specifications for compute optimized instances](https://docs.aws.amazon.com/ec2/latest/instancetypes/co.html#co_network)
+ [Network specifications for general purpose instances](https://docs.aws.amazon.com/ec2/latest/instancetypes/gp.html#gp_network)
+ [Network specifications for high-performance computing instances](https://docs.aws.amazon.com/ec2/latest/instancetypes/hpc.html#hpc_network)
+ [Network specifications for memory optimized instances](https://docs.aws.amazon.com/ec2/latest/instancetypes/mo.html#mo_network)
+ [Network specifications for storage optimized instances](https://docs.aws.amazon.com/ec2/latest/instancetypes/so.html#so_network)
**Topics**
+ [Pré-requisitos para redes aperfeiçoadas com o ENA](#ena-requirements)
+ [Testar se a rede avançada está habilitada](test-enhanced-networking-ena.md)
+ [Habilitar redes avançadas na instância](enabling_enhanced_networking.md)
+ [Filas do ENA](ena-queues.md)
+ [Solucionar problemas do driver do kernel do ENA no Linux](troubleshooting-ena.md)
+ [Solução de problemas do driver do Adaptador de Rede Elástica do Windows](troubleshoot-ena-driver.md)
## Pré-requisitos para redes aperfeiçoadas com o ENA
Para se preparar para a rede avançada com o ENA, configure a instância da seguinte forma:
+ Execute uma [instância baseada em Nitro](instance-types.md#instance-hypervisor-type).
+ Verifique se a instância tem conectividade com a Internet.
+ Se houver dados importantes na instância que deseja preservar, você deverá fazer backup desses dados agora criando uma AMI na instância. A atualização do driver do kernel do ENA e a habilitação do atributo `enaSupport` podem renderizar instâncias incompatíveis ou sistemas operacionais inacessíveis. Se você tiver um backup recente, seus dados ainda serão retidos, caso isso ocorra.
+ **Instâncias do Linux**: inicie a instância usando uma versão compatível do kernel do Linux e uma distribuição com suporte, para que as redes aperfeiçoadas do ENA sejam habilitadas automaticamente para a instância. Para obter mais informações, consulte [Notas de release do driver ENA do kernel do Linux](https://github.com/amzn/amzn-drivers/blob/master/kernel/linux/ena/RELEASENOTES.md).
+ **Instâncias do Windows**: se a instância estiver executando o Windows Server 2008 R2 SP1, verifique se ela tem a [atualização de suporte à assinatura de código SHA-2](https://support.microsoft.com/en-us/help/4474419/sha-2-code-signing-support-update).
+ Use o [AWS CloudShell](https://console.aws.amazon.com/cloudshell) no Console de gerenciamento da AWS ou instale e configure a [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) ou o [AWS Tools for Windows PowerShell](https://docs.aws.amazon.com/powershell/latest/userguide/) em qualquer computador de sua escolha, de preferência em seu desktop local ou notebook. Para obter mais informações sobre o ACM, consulte [Acessar o Amazon EC2](concepts.md#access-ec2) ou o [Guia do usuário do AWS CloudShell](https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html). A rede avançada não pode ser gerenciada no console do Amazon EC2.
# Testar se a rede avançada está habilitada
É possível testar se as redes aperfeiçoadas estão habilitadas nas instâncias ou nas AMIs.
**Atributo de instância**
Verifique o valor do atributo de instância `enaSupport`.
------
#### [ AWS CLI ]
Use o comando [https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-instances.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-instances.html).
```
aws ec2 describe-instances \
--instance-ids i-1234567890abcdef0 \
--query "Reservations[].Instances[].EnaSupport"
```
Se a rede aprimorada estiver habilitada, a saída será a seguinte.
```
[
true
]
```
------
#### [ PowerShell ]
Use o cmdlet [https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2Instance.html](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2Instance.html).
```
(Get-EC2Instance -InstanceId i-1234567890abcdef0).Instances.EnaSupport
```
Se a rede aprimorada estiver habilitada, a saída será a seguinte.
```
True
```
------
**Atributo de imagem**
Verifique o valor do atributo de imagem `enaSupport`.
------
#### [ AWS CLI ]
Use o comando [https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-images.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-images.html).
```
aws ec2 describe-images \
--image-id ami-0abcdef1234567890 \
--query "Images[].EnaSupport"
```
Se a rede aprimorada estiver habilitada, a saída será a seguinte.
```
[
true
]
```
------
#### [ PowerShell ]
Use o cmdlet [https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2Image.html](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2Image.html).
```
(Get-EC2Image -ImageId ami-0abcdef1234567890).EnaSupport
```
Se a rede aprimorada estiver habilitada, a saída será a seguinte.
```
True
```
------
**Driver da interface de rede do Linux**
Use o comando a seguir para verificar se o driver do kernel do `ena` está sendo usado em uma interface específica, substituindo o nome da interface que você deseja verificar. Se estiver usando uma única interface (padrão), ela será `eth0`. Se sua distribuição Linux oferecer suporte a nomes de rede previsíveis, o nome poderia ser algo como `ens5`. Para obter mais informações, expanda a seção para RHEL, SUSE e CentOS em [Habilitar redes avançadas na instância](enabling_enhanced_networking.md).
No exemplo a seguir, o driver do kernel do `ena` não está carregado porque o driver listado é `vif`.
```
[ec2-user ~]$ ethtool -i eth0
driver: vif
version:
firmware-version:
bus-info: vif-0
supports-statistics: yes
supports-test: no
supports-eeprom-access: no
supports-register-dump: no
supports-priv-flags: no
```
Neste exemplo, o driver do kernel do `ena` está carregado e na versão mínima recomendada. Essa instância configurou a rede avançada corretamente.
```
[ec2-user ~]$ ethtool -i eth0
driver: ena
version: 1.5.0g
firmware-version:
expansion-rom-version:
bus-info: 0000:00:05.0
supports-statistics: yes
supports-test: no
supports-eeprom-access: no
supports-register-dump: no
supports-priv-flags: no
```
# Habilitar redes avançadas na instância
O procedimento usado dependerá do sistema operacional da instância.
## Amazon Linux
As AMIs do Amazon Linux incluem o driver do kernel necessário para redes aperfeiçoadas com o ENA instalado e o suporte para ENA habilitado. Portanto, se você executar uma instância com uma versão HVM do Amazon Linux em um tipo de instância compatível, a rede avançada já estará habilitada para a instância. Para obter mais informações, consulte [Testar se a rede avançada está habilitada](test-enhanced-networking-ena.md).
## Ubuntu
As AMIs HVM mais recentes do Ubuntu incluem o driver do kernel necessário para redes aperfeiçoadas com o ENA instalado e o suporte para ENA habilitado. Portanto, se você executar uma instância com a AMI do HVM do Ubuntu mais recente em um tipo de instância compatível, a rede avançada já estará habilitada para a instância. Para obter mais informações, consulte [Testar se a rede avançada está habilitada](test-enhanced-networking-ena.md).
Se tiver executado a instância usando uma AMI mais antiga e ela ainda não tiver as redes avançadas habilitadas, será possível instalar o pacote do kernel `linux-aws` para obter os drivers de redes avançadas mais recentes e atualizar o atributo necessário.
**Para instalar o pacote do kernel `linux-aws` (Ubuntu 16.04 ou posterior)**
O Ubuntu 16.04 e o 18.04 são fornecidos com o kernel personalizado do Ubuntu (pacote do kernel `linux-aws`). Para usar um kernel diferente, entre em contato com o [Suporte](https://console.aws.amazon.com/support).
**Para instalar o pacote do kernel `linux-aws` (Ubuntu Trusty 14.04)**
1. Conecte-se à sua instância.
1. Atualize o cache de pacotes e os pacotes.
```
ubuntu:~$ sudo apt-get update && sudo apt-get upgrade -y linux-aws
```
**Importante**
Se, durante o processo de atualização, for solicitada a instalação do `grub`, use o `/dev/xvda` para instalar o `grub` e, em seguida, escolha manter a versão atual do `/boot/grub/menu.lst`.
1. [Instância com EBS] A partir do computador local, interrompa a instância usando o console do Amazon EC2 ou um dos seguintes comandos: [https://docs.aws.amazon.com/cli/latest/reference/ec2/stop-instances.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/stop-instances.html) (AWS CLI) ou [https://docs.aws.amazon.com/powershell/latest/reference/items/Stop-EC2Instance.html](https://docs.aws.amazon.com/powershell/latest/reference/items/Stop-EC2Instance.html) (AWS Tools for Windows PowerShell).
[Instância baseada em armazenamento de instâncias] Você não pode parar a instância para modificar o atributo. Em vez disso, siga este procedimento: [Para habilitar a rede avançada no Ubuntu (instâncias com suporte do armazenamento de instâncias)](#enhanced-networking-ena-instance-store-ubuntu).
1. No computador local, ative o atributo de rede avançada usando um dos seguintes comandos:
+ [https://docs.aws.amazon.com/cli/latest/reference/ec2/modify-instance-attribute.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/modify-instance-attribute.html) (AWS CLI)
```
aws ec2 modify-instance-attribute --instance-id i-1234567890abcdef0 --ena-support
```
+ [https://docs.aws.amazon.com/powershell/latest/reference/items/Edit-EC2InstanceAttribute.html](https://docs.aws.amazon.com/powershell/latest/reference/items/Edit-EC2InstanceAttribute.html) (ferramentas para o Windows PowerShell)
```
Edit-EC2InstanceAttribute -InstanceId i-1234567890abcdef0 -EnaSupport $true
```
1. (Opcional) Crie uma AMI na instância, conforme descrito em [Criação de uma AMI baseada no Amazon EBS](creating-an-ami-ebs.md). A AMI herda o atributo de rede avançada `enaSupport` da instância. Portanto, é possível usar essa AMI para executar outra instância com a rede avançada habilitada por padrão.
1. A partir do computador local, inicie a instância usando o console do Amazon EC2 ou um dos seguintes comandos: [https://docs.aws.amazon.com/cli/latest/reference/ec2/start-instances.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/start-instances.html) (AWS CLI) ou [https://docs.aws.amazon.com/powershell/latest/reference/items/Start-EC2Instance.html](https://docs.aws.amazon.com/powershell/latest/reference/items/Start-EC2Instance.html) (AWS Tools for Windows PowerShell).
**Para habilitar a rede avançada no Ubuntu (instâncias com suporte do armazenamento de instâncias)**
Siga o procedimento anterior até a etapa onde você para a instância. Crie uma nova AMI como descrito em [Criação de uma AMI baseada no Amazon S3](creating-an-ami-instance-store.md), habilitando o atributo de rede avançada ao registrar a AMI.
+ [https://docs.aws.amazon.com/cli/latest/reference/ec2/register-image.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/register-image.html) (AWS CLI)
```
aws ec2 register-image --ena-support ...
```
+ [https://docs.aws.amazon.com/powershell/latest/reference/items/Register-EC2Image.html](https://docs.aws.amazon.com/powershell/latest/reference/items/Register-EC2Image.html) (AWS Tools for Windows PowerShell)
```
Register-EC2Image -EnaSupport $true ...
```
## RHEL, SUSE e CentOS
As AMIs mais recentes para Red Hat Enterprise Linux, SUSE Linux Enterprise Server e CentOS incluem o driver do kernel necessário para redes aperfeiçoadas com o ENA e o suporte para ENA habilitado. Portanto, se você executar uma instância com a AMI mais recente em um tipo de instância compatível, a rede aprimorada já estará habilitada para a instância. Para obter mais informações, consulte [Testar se a rede avançada está habilitada](test-enhanced-networking-ena.md).
O procedimento a seguir fornece as etapas gerais para habilitar a rede aprimorada em uma distribuição do Linux diferente do Amazon Linux AMI ou do Ubuntu. Para obter mais informações, como a sintaxe detalhada dos comandos, os locais dos arquivos ou o suporte para o pacote e a ferramenta, consulte a documentação da sua distribuição do Linux.
**Para habilitar a rede avançada no Linux**
1. Conecte-se à sua instância.
1. Clone o código-fonte do driver do kernel do `ena` na instância no GitHub em [https://github.com/amzn/amzn-drivers](https://github.com/amzn/amzn-drivers). (Como o SUSE Linux Enterprise Server 12 SP2 e posterior incluem ENA 2.02 por padrão, não é necessário fazer download e compilar o driver ENA. Para o SUSE Linux Enterprise Server 12 SP2 e posterior, é necessário registrar uma solicitação para adicionar a versão do driver que deseja ao kernel comercial).
```
git clone https://github.com/amzn/amzn-drivers
```
1. Compile e instale o driver do kernel do `ena` na instância. Essas etapas dependem da distribuição Linux. Para obter mais informações sobre a compilação do driver do kernel no Red Hat Enterprise Linux, consulte [How do I install the latest ENS driver for enhanced network support on an Amazon EC2 instance that runs RHEL?](https://repost.aws/knowledge-center/install-ena-driver-rhel-ec2)
1. Execute o comando **sudo depmod** para atualizar as dependências do driver do kernel.
1. Atualize o `initramfs` na instância para garantir que o novo driver do kernel seja carregado no momento da inicialização. Por exemplo, se a distribuição oferecer suporte a **dracut**, será possível usar o comando a seguir.
```
dracut -f -v
```
1. Determine se o sistema usa nomes previsíveis de interface de rede por padrão. Os sistemas que usam as versões 197 ou superiores do **systemd** ou **udev** podem renomear dispositivos de Ethernet e não garantem que uma única interface de rede será nomeada `eth0`. Esse comportamento pode causar problemas para conexão à instância. Para mais informações e ver outras opções de configuração, consulte [Nomes previsíveis de interface de rede](https://www.freedesktop.org/wiki/Software/systemd/PredictableNetworkInterfaceNames/) no site freedesktop.org.
1. É possível verificar as versões do **systemd** ou **udev** em sistemas baseados em RPM com o comando a seguir.
```
rpm -qa | grep -e '^systemd-[0-9]\+\|^udev-[0-9]\+'
systemd-208-11.el7_0.2.x86_64
```
No exemplo do Red Hat Enterprise Linux 7 acima, a versão do **systemd** é a 208, portanto, os nomes previsíveis de interface de rede devem ser desativados.
1. Desabilite nomes previsíveis de interface de rede adicionando a opção `net.ifnames=0` à linha `GRUB_CMDLINE_LINUX` no `/etc/default/grub`.
```
sudo sed -i '/^GRUB\_CMDLINE\_LINUX/s/\"$/\ net\.ifnames\=0\"/' /etc/default/grub
```
1. Recompile o arquivo de configuração do grub.
```
sudo grub2-mkconfig -o /boot/grub2/grub.cfg
```
1. [Instância com EBS] No computador local, interrompa a instância usando o console do Amazon EC2 ou um dos seguintes comandos: [https://docs.aws.amazon.com/cli/latest/reference/ec2/stop-instances.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/stop-instances.html) (AWS CLI), [https://docs.aws.amazon.com/powershell/latest/reference/items/Stop-EC2Instance.html](https://docs.aws.amazon.com/powershell/latest/reference/items/Stop-EC2Instance.html) (AWS Tools for Windows PowerShell).
[Instância baseada em armazenamento de instâncias] Você não pode parar a instância para modificar o atributo. Em vez disso, siga este procedimento: [Para habilitar as redes avançadas no Linux (instâncias compatíveis com o armazenamento de instância)](#other-linux-enhanced-networking-ena-instance-store).
1. No computador local, ative o atributo de rede avançada `enaSupport` usando um dos seguintes comandos:
+ [https://docs.aws.amazon.com/cli/latest/reference/ec2/modify-instance-attribute.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/modify-instance-attribute.html) (AWS CLI)
```
aws ec2 modify-instance-attribute --instance-id i-1234567890abcdef0 --ena-support
```
+ [https://docs.aws.amazon.com/powershell/latest/reference/items/Edit-EC2InstanceAttribute.html](https://docs.aws.amazon.com/powershell/latest/reference/items/Edit-EC2InstanceAttribute.html) (ferramentas para o Windows PowerShell)
```
Edit-EC2InstanceAttribute -InstanceId i-1234567890abcdef0 -EnaSupport $true
```
1. (Opcional) Crie uma AMI na instância, conforme descrito em [Criação de uma AMI baseada no Amazon EBS](creating-an-ami-ebs.md). A AMI herda o atributo de rede avançada `enaSupport` da instância. Portanto, é possível usar essa AMI para executar outra instância com a rede avançada habilitada por padrão.
Se o sistema operacional da instância contiver um arquivo `/etc/udev/rules.d/70-persistent-net.rules`, você deverá excluí-lo antes de criar a AMI. Esse arquivo contém o endereço MAC do adaptador de Ethernet da instância original. Se outra instância for iniciada com esse arquivo, o sistema operacional será incapaz de localizar o dispositivo e o `eth0` poderá falhar causando problemas de inicialização. Esse arquivo é gerado novamente no próximo ciclo de inicialização, e todas as instâncias executadas na AMI criam sua própria versão do arquivo.
1. A partir do computador local, inicie a instância usando o console do Amazon EC2 ou um dos seguintes comandos: [https://docs.aws.amazon.com/cli/latest/reference/ec2/start-instances.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/start-instances.html) (AWS CLI) ou [https://docs.aws.amazon.com/powershell/latest/reference/items/Start-EC2Instance.html](https://docs.aws.amazon.com/powershell/latest/reference/items/Start-EC2Instance.html) (AWS Tools for Windows PowerShell).
1. (Opcional) Conecte-se à instância e verifique se o driver do kernel está instalado.
Se não for possível conectar-se à instância depois de habilitar a rede avançada, consulte [Solucionar problemas do driver do kernel do ENA no Linux](troubleshooting-ena.md).
**Para habilitar as redes avançadas no Linux (instâncias compatíveis com o armazenamento de instância)**
Siga o procedimento anterior até a etapa onde você para a instância. Crie uma nova AMI como descrito em [Criação de uma AMI baseada no Amazon S3](creating-an-ami-instance-store.md), habilitando o atributo de rede avançada ao registrar a AMI.
+ [https://docs.aws.amazon.com/cli/latest/reference/ec2/register-image.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/register-image.html) (AWS CLI)
```
aws ec2 register-image --ena-support ...
```
+ [https://docs.aws.amazon.com/powershell/latest/reference/items/Register-EC2Image.html](https://docs.aws.amazon.com/powershell/latest/reference/items/Register-EC2Image.html) (AWS Tools for Windows PowerShell)
```
Register-EC2Image -EnaSupport ...
```
## Ubuntu com DKMS
Esse método é apenas para fins de teste e feedback. Não é destinado ao uso com implantações de produção. Para implantações de produção, consulte [Ubuntu](#enhanced-networking-ena-ubuntu).
**Importante**
O uso do DKMS anula o acordo de suporte da sua assinatura. Ele não deve ser usado para implantações de produção.
**Para habilitar a rede avançada com o ENA no Ubuntu (instâncias com suporte do EBS)**
1. Siga as etapas 1 e 2 em [Ubuntu](#enhanced-networking-ena-ubuntu).
1. Instale os pacotes `build-essential` para compilar o driver do kernel e o pacote `dkms` para que o driver do kernel do `ena` seja recompilado sempre que o kernel for atualizado.
```
ubuntu:~$ sudo apt-get install -y build-essential dkms
```
1. Clone a fonte do driver do kernel do `ena` na instância no GitHub em [https://github.com/amzn/amzn-drivers](https://github.com/amzn/amzn-drivers).
```
ubuntu:~$ git clone https://github.com/amzn/amzn-drivers
```
1. Mova o pacote `amzn-drivers` para o diretório `/usr/src/` para que o DKMS possa localizá-lo e compilá-lo para cada atualização de kernel. Adicione o número da versão (é possível localizar o número da versão atual nas notas de release) do código-fonte ao nome do diretório. Por exemplo, a versão `1.0.0` é mostrada no exemplo a seguir.
```
ubuntu:~$ sudo mv amzn-drivers /usr/src/amzn-drivers-1.0.0
```
1. Crie o arquivo de configuração do DKMS com os valores a seguir substituindo a versão do `ena`.
Criar o arquivo.
```
ubuntu:~$ sudo touch /usr/src/amzn-drivers-1.0.0/dkms.conf
```
Edite o arquivo e adicione os valores a seguir.
```
ubuntu:~$ sudo vim /usr/src/amzn-drivers-1.0.0/dkms.conf
PACKAGE_NAME="ena"
PACKAGE_VERSION="1.0.0"
CLEAN="make -C kernel/linux/ena clean"
MAKE="make -C kernel/linux/ena/ BUILD_KERNEL=${kernelver}"
BUILT_MODULE_NAME[0]="ena"
BUILT_MODULE_LOCATION="kernel/linux/ena"
DEST_MODULE_LOCATION[0]="/updates"
DEST_MODULE_NAME[0]="ena"
AUTOINSTALL="yes"
```
1. Adicione, compile e instale o driver do kernel do `ena` na instância usando o DKMS.
Adicione o driver do kernel ao DKMS.
```
ubuntu:~$ sudo dkms add -m amzn-drivers -v 1.0.0
```
Crie o driver do kernel usando o comando **dkms**.
```
ubuntu:~$ sudo dkms build -m amzn-drivers -v 1.0.0
```
Instale o driver do kernel usando **dkms**.
```
ubuntu:~$ sudo dkms install -m amzn-drivers -v 1.0.0
```
1. Reconstrua `initramfs` para que o driver do kernel correto seja carregado no momento da inicialização.
```
ubuntu:~$ sudo update-initramfs -u -k all
```
1. Verifique se o kernel do driver `ena` está instalado usando o comando modinfo ena em [Testar se a rede avançada está habilitada](test-enhanced-networking-ena.md).
```
ubuntu:~$ modinfo ena
filename: /lib/modules/3.13.0-74-generic/updates/dkms/ena.ko
version: 1.0.0
license: GPL
description: Elastic Network Adapter (ENA)
author: Amazon.com, Inc. or its affiliates
srcversion: 9693C876C54CA64AE48F0CA
alias: pci:v00001D0Fd0000EC21sv*sd*bc*sc*i*
alias: pci:v00001D0Fd0000EC20sv*sd*bc*sc*i*
alias: pci:v00001D0Fd00001EC2sv*sd*bc*sc*i*
alias: pci:v00001D0Fd00000EC2sv*sd*bc*sc*i*
depends:
vermagic: 3.13.0-74-generic SMP mod_unload modversions
parm: debug:Debug level (0=none,...,16=all) (int)
parm: push_mode:Descriptor / header push mode (0=automatic,1=disable,3=enable)
0 - Automatically choose according to device capability (default)
1 - Don't push anything to device memory
3 - Push descriptors and header buffer to device memory (int)
parm: enable_wd:Enable keepalive watchdog (0=disable,1=enable,default=1) (int)
parm: enable_missing_tx_detection:Enable missing Tx completions. (default=1) (int)
parm: numa_node_override_array:Numa node override map
(array of int)
parm: numa_node_override:Enable/Disable numa node override (0=disable)
(int)
```
1. Passe para a etapa 3 em [Ubuntu](#enhanced-networking-ena-ubuntu).
## Habilitar redes avançadas no Windows
Se você executou a instância e ela ainda não tiver a rede avançada habilitada, você deverá fazer download e instalar o driver do adaptador de rede necessário na instância e, em seguida, definir o atributo `enaSupport` da instância para ativar a rede avançada.
**Para habilitar a rede avançada**
1. Conecte-se à instância e faça login como administrador local.
1. [Windows Server 2016 e 2019 apenas] Execute o seguinte script do PowerShell do EC2Launch para configurar a instância depois de instalar o driver.
```
PS C:\> C:\ProgramData\Amazon\EC2-Windows\Launch\Scripts\InitializeInstance.ps1 -Schedule
```
1. Na instância, instale o driver da seguinte forma:
1. [Faça download](https://s3.amazonaws.com/ec2-windows-drivers-downloads/ENA/Latest/AwsEnaNetworkDriver.zip) do driver mais recente para a instância.
1. Extraia o arquivo zip.
1. Instale o driver executando o script `install.ps1` do PowerShell.
**nota**
Se você receber um erro de política de execução, defina a política como `Unrestricted` (por padrão, ela é definida como `Restricted` ou `RemoteSigned`). Em uma linha de comando, execute `Set-ExecutionPolicy -ExecutionPolicy Unrestricted` e, depois, execute o script `install.ps1` do PowerShell novamente.
1. No seu computador local, interrompa a instância usando o console do Amazon EC2 ou um dos comandos a seguir: [https://docs.aws.amazon.com/cli/latest/reference/ec2/stop-instances.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/stop-instances.html) (AWS CLI) ou [https://docs.aws.amazon.com/powershell/latest/reference/items/Stop-EC2Instance.html](https://docs.aws.amazon.com/powershell/latest/reference/items/Stop-EC2Instance.html) (AWS Tools for Windows PowerShell).
1. Ative o suporte ao ENA na instância da seguinte maneira:
1. No computador local, verifique o atributo de suporte ao ENA da instância do EC2 em sua instância executando um dos seguinte comandos. Se o atributo não estiver habilitado, a saída será “[]” ou em branco. `EnaSupport` será definido como `false` por padrão.
+ [https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-instances.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-instances.html) (AWS CLI)
```
aws ec2 describe-instances --instance-ids i-1234567890abcdef0 --query "Reservations[].Instances[].EnaSupport"
```
+ [https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2Instance.html](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2Instance.html) (ferramentas para o Windows PowerShell)
```
(Get-EC2Instance -InstanceId i-1234567890abcdef0).Instances.EnaSupport
```
1. Para ativar o suporte ao ENA, execute um dos seguintes comandos:
+ [https://docs.aws.amazon.com/cli/latest/reference/ec2/modify-instance-attribute.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/modify-instance-attribute.html) (AWS CLI)
```
aws ec2 modify-instance-attribute --instance-id i-1234567890abcdef0 --ena-support
```
+ [https://docs.aws.amazon.com/powershell/latest/reference/items/Edit-EC2InstanceAttribute.html](https://docs.aws.amazon.com/powershell/latest/reference/items/Edit-EC2InstanceAttribute.html) (AWS Tools for Windows PowerShell)
```
Edit-EC2InstanceAttribute -InstanceId i-1234567890abcdef0 -EnaSupport $true
```
Se encontrar problemas ao reiniciar a instância, também é possível desativar o suporte ao ENA com um dos seguintes comandos:
+ [https://docs.aws.amazon.com/cli/latest/reference/ec2/modify-instance-attribute.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/modify-instance-attribute.html) (AWS CLI)
```
aws ec2 modify-instance-attribute --instance-id i-1234567890abcdef0 --no-ena-support
```
+ [https://docs.aws.amazon.com/powershell/latest/reference/items/Edit-EC2InstanceAttribute.html](https://docs.aws.amazon.com/powershell/latest/reference/items/Edit-EC2InstanceAttribute.html) (AWS Tools for Windows PowerShell)
```
Edit-EC2InstanceAttribute -InstanceId i-1234567890abcdef0 -EnaSupport $false
```
1. Verifique se o atributo foi definido como `true` usando **describe-instances** ou **Get-EC2Instance** conforme mostrado anteriormente. Você agora deve ver a seguinte saída:
```
[
true
]
```
1. A partir do computador local, inicie a instância usando o console do Amazon EC2 ou um dos seguintes comandos: [https://docs.aws.amazon.com/cli/latest/reference/ec2/start-instances.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/start-instances.html) (AWS CLI) ou [https://docs.aws.amazon.com/powershell/latest/reference/items/Start-EC2Instance.html](https://docs.aws.amazon.com/powershell/latest/reference/items/Start-EC2Instance.html) (AWS Tools for Windows PowerShell).
1. Na instância, valide se o driver do ENA está instalado e ativado da seguinte maneira:
1. Clique com o botão direito do mouse no ícone de rede e escolha **Abrir Central de Rede e Compartilhamento**.
1. Escolha o adaptador de Ethernet (por exemplo, **Ethernet 2**).
1. Escolha **Detalhes**. Para **Detalhes da conexão de rede**, verifique se a **Descrição** é **Amazon Elastic Network Adapter**.
1. (Opcional) Crie uma AMI na instância. A AMI herda o atributo `enaSupport` da instância. Portanto, é possível usar essa AMI para executar outra instância com ENA ativado por padrão.
# Filas do ENA
As filas do ENA são alocadas para as interfaces de rede com limites estáticos padrão com base no tipo e no tamanho da instância. Nos tipos de instância compatíveis, você pode alocar dinamicamente essas filas nas Interfaces de Rede Elástica (ENIs). Embora o número total de filas por instância dependa do tipo e do tamanho da instância, você pode configurar várias ENIs com filas de ENA até atingir o número máximo de filas da ENI e da instância.
A alocação flexível de filas do ENA otimiza a distribuição de recursos, permitindo a máxima utilização da vCPU. Workloads de alta performance de rede normalmente exigem várias filas do ENA. É possível ajustar a performance de rede e os pacotes por segundo (PPS) ajustando o número de filas de acordo com suas necessidades específicas de workload. Por exemplo, aplicações com uso intensivo de rede podem exigir mais filas em comparação com aplicações com uso intensivo de CPU.
**Topics**
+ [Instâncias compatíveis](#supported-instances)
+ [Modificar o número de filas](#modify)
## Instâncias compatíveis
As instâncias a seguir são compatíveis com a alocação dinâmica de várias filas do ENA.
### Uso geral
| Tipo de instância | Filas ENA padrão por interface | Máximo de filas ENA por interface | Máximo de filas ENA por instância |
| --- | --- | --- | --- |
| M6i |
| m6i.large | 2 | 2 | 6 |
| m6i.xlarge | 4 | 4 | 16 |
| m6i.2xlarge | 8 | 8 | 32 |
| m6i.4xlarge | 8 | 16 | 64 |
| m6i.8xlarge | 8 | 32 | 64 |
| m6i.12xlarge | 8 | 32 | 64 |
| m6i.16xlarge | 8 | 32 | 120 |
| m6i.24xlarge | 8 | 32 | 120 |
| m6i.32xlarge | 8 | 32 | 120 |
| M6id |
| m6id.large | 2 | 2 | 6 |
| m6id.xlarge | 4 | 4 | 16 |
| m6id.2xlarge | 8 | 8 | 32 |
| m6id.4xlarge | 8 | 16 | 64 |
| m6id.8xlarge | 8 | 32 | 64 |
| m6id.12xlarge | 8 | 32 | 64 |
| m6id.16xlarge | 8 | 32 | 120 |
| m6id.24xlarge | 8 | 32 | 120 |
| m6id.32xlarge | 8 | 32 | 120 |
| M6idn |
| m6idn.large | 2 | 2 | 6 |
| m6idn.xlarge | 4 | 4 | 16 |
| m6idn.2xlarge | 8 | 8 | 32 |
| m6idn.4xlarge | 8 | 16 | 64 |
| m6idn.8xlarge | 16 | 32 | 128 |
| m6idn.12xlarge | 16 | 32 | 128 |
| m6idn.16xlarge | 16 | 32 | 240 |
| m6idn.24xlarge | 32 | 32 | 480 |
| m6idn.32xlarge | 32 | 32 | 512 \$1 |
| M6in |
| m6in.large | 2 | 2 | 6 |
| m6in.xlarge | 4 | 4 | 16 |
| m6in.2xlarge | 8 | 8 | 32 |
| m6in.4xlarge | 8 | 16 | 64 |
| m6in.8xlarge | 16 | 32 | 128 |
| m6in.12xlarge | 16 | 32 | 128 |
| m6in.16xlarge | 16 | 32 | 240 |
| m6in.24xlarge | 32 | 32 | 480 |
| m6in.32xlarge | 32 | 32 | 512 \$1 |
| M8a |
| m8a.medium | 1 | 1 | 3 |
| m8a.large | 2 | 2 | 6 |
| m8a.xlarge | 4 | 4 | 16 |
| m8a.2xlarge | 8 | 8 | 32 |
| m8a.4xlarge | 8 | 16 | 64 |
| m8a.8xlarge | 8 | 32 | 128 |
| m8a.12xlarge | 16 | 64 | 192 |
| m8a.16xlarge | 16 | 64 | 256 |
| m8a.24xlarge | 16 | 128 | 384 |
| m8a.48xlarge | 32 | 128 | 768 |
| m8a.metal-24xl | 16 | 128 | 384 |
| m8a.metal-48xl | 32 | 128 | 768 |
| M8azn |
| m8azn.medium | 1 | 1 | 3 |
| m8azn.large | 2 | 2 | 8 |
| m8azn.xlarge | 4 | 4 | 16 |
| m8azn.3xlarge | 4 | 16 | 48 |
| m8azn.6xlarge | 8 | 32 | 96 |
| m8azn.12xlarge | 8 | 64 | 192 |
| m8azn.24xlarge | 16 | 128 | 384 |
| m8azn.metal-12xl | 8 | 64 | 192 |
| m8azn.metal-24xl | 16 | 128 | 384 |
| M8gb |
| m8gb.medium | 1 | 1 | 2 |
| m8gb.large | 2 | 2 | 6 |
| m8gb.xlarge | 4 | 4 | 16 |
| m8gb.2xlarge | 8 | 8 | 32 |
| m8gb.4xlarge | 8 | 16 | 64 |
| m8gb.8xlarge | 8 | 32 | 128 |
| m8gb.12xlarge | 16 | 64 | 192 |
| m8gb.16xlarge | 16 | 64 | 256 |
| m8gb.24xlarge | 16 | 128 | 384 |
| m8gb.48xlarge | 32 | 128 | 768 \$1 |
| m8gb.metal-24xl | 32 | 128 | 768 |
| m8gb.metal-48xl | 32 | 128 | 768 \$1 |
| M8gn |
| m8gn.medium | 1 | 1 | 2 |
| m8gn.large | 2 | 2 | 6 |
| m8gn.xlarge | 4 | 4 | 16 |
| m8gn.2xlarge | 8 | 8 | 32 |
| m8gn.4xlarge | 8 | 16 | 64 |
| m8gn.8xlarge | 8 | 32 | 128 |
| m8gn.12xlarge | 16 | 64 | 192 |
| m8gn.16xlarge | 16 | 64 | 256 |
| m8gn.24xlarge | 16 | 128 | 384 |
| m8gn.48xlarge | 32 | 128 | 768 \$1 |
| m8gn.metal-24xl | 32 | 128 | 768 |
| m8gn.metal-48xl | 32 | 128 | 768 \$1 |
| M8i |
| m8i.large | 2 | 2 | 6 |
| m8i.xlarge | 4 | 4 | 16 |
| m8i.2xlarge | 8 | 8 | 32 |
| m8i.4xlarge | 8 | 16 | 64 |
| m8i.8xlarge | 8 | 32 | 128 |
| m8i.12xlarge | 16 | 64 | 192 |
| m8i.16xlarge | 16 | 64 | 256 |
| m8i.24xlarge | 16 | 128 | 384 |
| m8i.32xlarge | 16 | 128 | 512 |
| m8i.48xlarge | 32 | 128 | 768 |
| m8i.96xlarge | 32 | 128 | 1536 |
| m8i.metal-48xl | 32 | 128 | 768 |
| m8i.metal-96xl | 32 | 128 | 1536 |
| M8id |
| m8id.large | 2 | 2 | 6 |
| m8id.xlarge | 4 | 4 | 16 |
| m8id.2xlarge | 8 | 8 | 32 |
| m8id.4xlarge | 8 | 16 | 64 |
| m8id.8xlarge | 8 | 32 | 128 |
| m8id.12xlarge | 16 | 64 | 192 |
| m8id.16xlarge | 16 | 64 | 256 |
| m8id.24xlarge | 16 | 128 | 384 |
| m8id.32xlarge | 16 | 128 | 512 |
| m8id.48xlarge | 32 | 128 | 768 |
| m8id.96xlarge | 32 | 128 | 1536 |
| m8id.metal-48xl | 32 | 128 | 768 |
| m8id.metal-96xl | 32 | 128 | 1536 |
| M8i-flex |
| m8i-flex.large | 1 | 1 | 3 |
| m8i-flex.xlarge | 2 | 2 | 8 |
| m8i-flex.2xlarge | 4 | 4 | 16 |
| m8i-flex.4xlarge | 4 | 8 | 32 |
| m8i-flex.8xlarge | 4 | 16 | 64 |
| m8i-flex.12xlarge | 8 | 32 | 96 |
| m8i-flex.16xlarge | 8 | 32 | 128 |
**nota**
\$1 Esses tipos de instância contam com várias placas de rede. Outros tipos de instância contam com uma única placa de rede. Para obter mais informações, consulte [Placas de rede](using-eni.md#network-cards).
### Otimizadas para computação
| Tipo de instância | Filas ENA padrão por interface | Máximo de filas ENA por interface | Máximo de filas ENA por instância |
| --- | --- | --- | --- |
| C6i |
| c6i.large | 2 | 2 | 6 |
| c6i.xlarge | 4 | 4 | 16 |
| c6i.2xlarge | 8 | 8 | 32 |
| c6i.4xlarge | 8 | 16 | 64 |
| c6i.8xlarge | 8 | 32 | 64 |
| c6i.12xlarge | 8 | 32 | 64 |
| c6i.16xlarge | 8 | 32 | 120 |
| c6i.24xlarge | 8 | 32 | 120 |
| c6i.32xlarge | 8 | 32 | 120 |
| C6id |
| c6id.large | 2 | 2 | 6 |
| c6id.xlarge | 4 | 4 | 16 |
| c6id.2xlarge | 8 | 8 | 32 |
| c6id.4xlarge | 8 | 16 | 64 |
| c6id.8xlarge | 8 | 32 | 64 |
| c6id.12xlarge | 8 | 32 | 64 |
| c6id.16xlarge | 8 | 32 | 120 |
| c6id.24xlarge | 8 | 32 | 120 |
| c6id.32xlarge | 8 | 32 | 120 |
| C6in |
| c6in.large | 2 | 2 | 6 |
| c6in.xlarge | 4 | 4 | 16 |
| c6in.2xlarge | 8 | 8 | 32 |
| c6in.4xlarge | 8 | 16 | 64 |
| c6in.8xlarge | 16 | 32 | 128 |
| c6in.12xlarge | 16 | 32 | 128 |
| c6in.16xlarge | 16 | 32 | 240 |
| c6in.24xlarge | 32 | 32 | 480 |
| c6in.32xlarge | 32 | 32 | 512 \$1 |
| C8a |
| c8a.medium | 1 | 1 | 3 |
| c8a.large | 2 | 2 | 6 |
| c8a.xlarge | 4 | 4 | 16 |
| c8a.2xlarge | 8 | 8 | 32 |
| c8a.4xlarge | 8 | 16 | 64 |
| c8a.8xlarge | 8 | 32 | 128 |
| c8a.12xlarge | 16 | 64 | 192 |
| c8a.16xlarge | 16 | 64 | 256 |
| c8a.24xlarge | 16 | 128 | 384 |
| c8a.48xlarge | 32 | 128 | 768 |
| c8a.metal-24xl | 16 | 128 | 384 |
| c8a.metal-48xl | 32 | 128 | 768 |
| C8gb |
| c8gb.medium | 1 | 1 | 2 |
| c8gb.large | 2 | 2 | 6 |
| c8gb.xlarge | 4 | 4 | 16 |
| c8gb.2xlarge | 8 | 8 | 32 |
| c8gb.4xlarge | 8 | 16 | 64 |
| c8gb.8xlarge | 8 | 32 | 128 |
| c8gb.12xlarge | 16 | 64 | 192 |
| c8gb.16xlarge | 16 | 64 | 256 |
| c8gb.24xlarge | 16 | 128 | 384 |
| c8gb.48xlarge | 32 | 128 | 768 \$1 |
| c8gb.metal-24xl | 32 | 128 | 768 |
| c8gb.metal-48xl | 32 | 128 | 768 \$1 |
| C8gn |
| c8gn.medium | 1 | 1 | 2 |
| c8gn.large | 2 | 2 | 6 |
| c8gn.xlarge | 4 | 4 | 16 |
| c8gn.2xlarge | 8 | 8 | 32 |
| c8gn.4xlarge | 8 | 16 | 64 |
| c8gn.8xlarge | 8 | 32 | 128 |
| c8gn.12xlarge | 16 | 64 | 192 |
| c8gn.16xlarge | 16 | 64 | 256 |
| c8gn.24xlarge | 16 | 128 | 384 |
| c8gn.48xlarge | 32 | 128 | 768 \$1 |
| c8gn.metal-24xl | 32 | 128 | 768 |
| c8gn.metal-48xl | 32 | 128 | 768 \$1 |
| C8i |
| c8i.large | 2 | 2 | 6 |
| c8i.xlarge | 4 | 4 | 16 |
| c8i.2xlarge | 8 | 8 | 32 |
| c8i.4xlarge | 8 | 16 | 64 |
| c8i.8xlarge | 8 | 32 | 128 |
| c8i.12xlarge | 16 | 64 | 192 |
| c8i.16xlarge | 16 | 64 | 256 |
| c8i.24xlarge | 16 | 128 | 384 |
| c8i.32xlarge | 16 | 128 | 512 |
| c8i.48xlarge | 32 | 128 | 768 |
| c8i.96xlarge | 32 | 128 | 1536 |
| c8i.metal-48xl | 32 | 128 | 768 |
| c8i.metal-96xl | 32 | 128 | 1536 |
| C8id |
| c8id.large | 2 | 2 | 6 |
| c8id.xlarge | 4 | 4 | 16 |
| c8id.2xlarge | 8 | 8 | 32 |
| c8id.4xlarge | 8 | 16 | 64 |
| c8id.8xlarge | 8 | 32 | 128 |
| c8id.12xlarge | 16 | 64 | 192 |
| c8id.16xlarge | 16 | 64 | 256 |
| c8id.24xlarge | 16 | 128 | 384 |
| c8id.32xlarge | 16 | 128 | 512 |
| c8id.48xlarge | 32 | 128 | 768 |
| c8id.96xlarge | 32 | 128 | 1536 |
| c8id.metal-48xl | 32 | 128 | 768 |
| c8id.metal-96xl | 32 | 128 | 1536 |
| C8i-flex |
| c8i-flex.large | 1 | 1 | 3 |
| c8i-flex.xlarge | 2 | 2 | 8 |
| c8i-flex.2xlarge | 4 | 4 | 16 |
| c8i-flex.4xlarge | 4 | 8 | 32 |
| c8i-flex.8xlarge | 4 | 16 | 64 |
| c8i-flex.12xlarge | 8 | 32 | 96 |
| c8i-flex.16xlarge | 8 | 32 | 128 |
**nota**
\$1 Esses tipos de instância contam com várias placas de rede. Outros tipos de instância contam com uma única placa de rede. Para obter mais informações, consulte [Placas de rede](using-eni.md#network-cards).
### Otimizado para memória
| Tipo de instância | Filas ENA padrão por interface | Máximo de filas ENA por interface | Máximo de filas ENA por instância |
| --- | --- | --- | --- |
| R6i |
| r6i.large | 2 | 2 | 6 |
| r6i.xlarge | 4 | 4 | 16 |
| r6i.2xlarge | 8 | 8 | 32 |
| r6i.4xlarge | 8 | 16 | 64 |
| r6i.8xlarge | 8 | 32 | 64 |
| r6i.12xlarge | 8 | 32 | 64 |
| r6i.16xlarge | 8 | 32 | 120 |
| r6i.24xlarge | 8 | 32 | 120 |
| r6i.32xlarge | 8 | 32 | 120 |
| R6id |
| r6id.large | 2 | 2 | 6 |
| r6id.xlarge | 4 | 4 | 16 |
| r6id.2xlarge | 8 | 8 | 32 |
| r6id.4xlarge | 8 | 16 | 64 |
| r6id.8xlarge | 8 | 32 | 64 |
| r6id.12xlarge | 8 | 32 | 64 |
| r6id.16xlarge | 8 | 32 | 120 |
| r6id.24xlarge | 8 | 32 | 120 |
| r6id.32xlarge | 8 | 32 | 120 |
| R6idn |
| r6idn.large | 2 | 2 | 6 |
| r6idn.xlarge | 4 | 4 | 16 |
| r6idn.2xlarge | 8 | 8 | 32 |
| r6idn.4xlarge | 8 | 16 | 64 |
| r6idn.8xlarge | 16 | 32 | 128 |
| r6idn.12xlarge | 16 | 32 | 128 |
| r6idn.16xlarge | 16 | 32 | 240 |
| r6idn.24xlarge | 32 | 32 | 480 |
| r6idn.32xlarge | 32 | 32 | 512 \$1 |
| R6in |
| r6in.large | 2 | 2 | 6 |
| r6in.xlarge | 4 | 4 | 16 |
| r6in.2xlarge | 8 | 8 | 32 |
| r6in.4xlarge | 8 | 16 | 64 |
| r6in.8xlarge | 16 | 32 | 128 |
| r6in.12xlarge | 16 | 32 | 128 |
| r6in.16xlarge | 16 | 32 | 240 |
| r6in.24xlarge | 32 | 32 | 480 |
| r6in.32xlarge | 32 | 32 | 512 \$1 |
| R8a |
| r8a.medium | 1 | 1 | 3 |
| r8a.large | 2 | 2 | 6 |
| r8a.xlarge | 4 | 4 | 16 |
| r8a.2xlarge | 8 | 8 | 32 |
| r8a.4xlarge | 8 | 16 | 64 |
| r8a.8xlarge | 8 | 32 | 128 |
| r8a.12xlarge | 16 | 64 | 192 |
| r8a.16xlarge | 16 | 64 | 256 |
| r8a.24xlarge | 16 | 128 | 384 |
| r8a.48xlarge | 32 | 128 | 768 |
| r8a.metal-24xl | 16 | 128 | 384 |
| r8a.metal-48xl | 32 | 128 | 768 |
| R8gb |
| r8gb.medium | 1 | 1 | 2 |
| r8gb.large | 2 | 2 | 6 |
| r8gb.xlarge | 4 | 4 | 16 |
| r8gb.2xlarge | 8 | 8 | 32 |
| r8gb.4xlarge | 8 | 16 | 64 |
| r8gb.8xlarge | 8 | 32 | 128 |
| r8gb.12xlarge | 16 | 64 | 192 |
| r8gb.16xlarge | 16 | 64 | 256 |
| r8gb.24xlarge | 16 | 128 | 384 |
| r8gb.48xlarge | 32 | 128 | 768 \$1 |
| r8gb.metal-24xl | 32 | 128 | 768 |
| r8gb.metal-48xl | 32 | 128 | 768 \$1 |
| R8gn |
| r8gn.medium | 1 | 1 | 2 |
| r8gn.large | 2 | 2 | 6 |
| r8gn.xlarge | 4 | 4 | 16 |
| r8gn.2xlarge | 8 | 8 | 32 |
| r8gn.4xlarge | 8 | 16 | 64 |
| r8gn.8xlarge | 8 | 32 | 128 |
| r8gn.12xlarge | 16 | 64 | 192 |
| r8gn.16xlarge | 16 | 64 | 256 |
| r8gn.24xlarge | 16 | 128 | 384 |
| r8gn.48xlarge | 32 | 128 | 768 \$1 |
| r8gn.metal-24xl | 32 | 128 | 768 |
| r8gn.metal-48xl | 32 | 128 | 768 \$1 |
| R8i |
| r8i.large | 2 | 2 | 6 |
| r8i.xlarge | 4 | 4 | 16 |
| r8i.2xlarge | 8 | 8 | 32 |
| r8i.4xlarge | 8 | 16 | 64 |
| r8i.8xlarge | 8 | 32 | 128 |
| r8i.12xlarge | 16 | 64 | 192 |
| r8i.16xlarge | 16 | 64 | 256 |
| r8i.24xlarge | 16 | 128 | 384 |
| r8i.32xlarge | 16 | 128 | 512 |
| r8i.48xlarge | 32 | 128 | 768 |
| r8i.96xlarge | 32 | 128 | 1536 |
| r8i.metal-48xl | 32 | 128 | 768 |
| r8i.metal-96xl | 32 | 128 | 1536 |
| R8id |
| r8id.large | 2 | 2 | 6 |
| r8id.xlarge | 4 | 4 | 16 |
| r8id.2xlarge | 8 | 8 | 32 |
| r8id.4xlarge | 8 | 16 | 64 |
| r8id.8xlarge | 8 | 32 | 128 |
| r8id.12xlarge | 16 | 64 | 192 |
| r8id.16xlarge | 16 | 64 | 256 |
| r8id.24xlarge | 16 | 128 | 384 |
| r8id.32xlarge | 16 | 128 | 512 |
| r8id.48xlarge | 32 | 128 | 768 |
| r8id.96xlarge | 32 | 128 | 1536 |
| r8id.metal-48xl | 32 | 128 | 768 |
| r8id.metal-96xl | 32 | 128 | 1536 |
| R8i-flex |
| r8i-flex.large | 1 | 1 | 3 |
| r8i-flex.xlarge | 2 | 2 | 8 |
| r8i-flex.2xlarge | 4 | 4 | 16 |
| r8i-flex.4xlarge | 4 | 8 | 32 |
| r8i-flex.8xlarge | 4 | 16 | 64 |
| r8i-flex.12xlarge | 8 | 32 | 96 |
| r8i-flex.16xlarge | 8 | 32 | 128 |
| X8aedz |
| x8aedz.large | 2 | 2 | 8 |
| x8aedz.xlarge | 4 | 4 | 16 |
| x8aedz.3xlarge | 4 | 16 | 48 |
| x8aedz.6xlarge | 8 | 32 | 96 |
| x8aedz.12xlarge | 8 | 64 | 192 |
| x8aedz.24xlarge | 16 | 128 | 384 |
| x8aedz.metal-12xl | 8 | 64 | 192 |
| x8aedz.metal-24xl | 16 | 128 | 384 |
| X8i |
| x8i.large | 2 | 2 | 6 |
| x8i.xlarge | 4 | 4 | 16 |
| x8i.2xlarge | 8 | 8 | 32 |
| x8i.4xlarge | 8 | 16 | 64 |
| x8i.8xlarge | 8 | 32 | 128 |
| x8i.12xlarge | 16 | 64 | 192 |
| x8i.16xlarge | 16 | 64 | 256 |
| x8i.24xlarge | 16 | 128 | 384 |
| x8i.32xlarge | 16 | 128 | 512 |
| x8i.48xlarge | 32 | 128 | 768 |
| x8i.64xlarge | 32 | 128 | 1024 |
| x8i.96xlarge | 32 | 128 | 1536 |
| x8i.metal-48xl | 32 | 128 | 768 |
| x8i.metal-96xl | 32 | 128 | 1536 |
**nota**
\$1 Esses tipos de instância contam com várias placas de rede. Outros tipos de instância contam com uma única placa de rede. Para obter mais informações, consulte [Placas de rede](using-eni.md#network-cards).
## Modificar o número de filas
É possível modificar o número de filas do ENA usando o Console de gerenciamento da AWS ou a AWS CLI. No Console de gerenciamento da AWS, a configuração de filas do ENA está disponível em toda configuração de **Interface de rede**.
Para modificar o número de filas do ENA usando a AWS CLI, use um dos comandos a seguir. Antes de modificar o número de filas, use o comando a seguir para verificar o número atual de filas.
```
aws ec2 describe-instances --instance-id i-1234567890abcdef0
```
**nota**
É necessário parar a instância antes de modificar o número de filas do ENA.
O valor das filas do ENA deve ser uma potência de 2, como, 1, 2, 4, 8, 16, 32 etc.
O número de filas alocadas para uma única ENI não pode exceder o número de vCPUs disponíveis na instância.
`[attach-network-interface](https://docs.aws.amazon.com/cli/latest/reference/ec2/attach-network-interface.html)`
No exemplo a seguir, 32 filas do ENA estão configuradas em uma ENI.
```
aws ec2 attach-network-interface \
--network-interface-id eni-001aa1bb223cdd4e4 \
--instance-id i-1234567890abcdef0 \
--device-index 1 \
--ena-queue-count 32
```
`[run-instances](https://docs.aws.amazon.com/cli/latest/reference/ec2/run-instances.html)`
No exemplo a seguir, 2 filas do ENA são configuradas em cada uma das 3 ENIs.
```
aws ec2 run-instances \
--image-id ami-12ab3c30 \
--instance-type c6i.large \
--min-count 1 \
--max-count 1 \
--network-interfaces \
"[{\"DeviceIndex\":0,\"SubnetId\":\"subnet-123456789012a345a\",\"EnaQueueCount\":2},
{\"DeviceIndex\":1,\"SubnetId\":\"subnet-123456789012a345a\",\"EnaQueueCount\":2},
{\"DeviceIndex\":2,\"SubnetId\":\"subnet-123456789012a345a\",\"EnaQueueCount\":2}]"
```
`[modify-network-interface-attribute](https://docs.aws.amazon.com/cli/latest/reference/ec2/modify-network-interface-attribute.html)`
No exemplo a seguir, 32 filas do ENA estão configuradas em uma ENI.
```
aws ec2 modify-network-interface-attribute \
--network-interface-id eni-1234567890abcdef0 \
--attachment AttachmentId=eni-attach-12345678,EnaQueueCount=32
```
No exemplo a seguir, a contagem do ENA é redefinida com o valor padrão.
```
aws ec2 modify-network-interface-attribute \
--network-interface-id eni-1234567890abcdef0 \
--attachment AttachmentId=eni-attach-12345678,DefaultEnaQueueCount=true
```
# Solucionar problemas do driver do kernel do ENA no Linux
O Elastic Network Adapter (ENA) é projetado para melhorar a integridade do sistema operacional e reduzir as possibilidades de interrupção de longo prazo por conta de comportamento inesperado de hardware e/ou falhas. A arquitetura do ENA mantém falhas do dispositivo ou do driver o mais transparentes possível para o sistema. Este tópico fornece informações de solução de problemas para o ENA.
Caso você não consiga se conectar à sua instância, comece com a seção [Solucionar problemas de conectividade](#ena-connectivity-issues).
Se você experimentar degradação de performance após migrar para um tipo de instância de sexta geração, consulte o artigo [What do I need to do before I migrate my EC2 instance to a sixth generation instance to make sure that I get maximum network performance?](https://repost.aws/knowledge-center/migrate-to-gen6-ec2-instance)
Se você for capaz de se conectar à sua instância, pode coletar informações de diagnóstico usando os mecanismos de detecção e recuperação de falhas, cobertos nas seções posteriores deste tópico.
**Topics**
+ [Solucionar problemas de conectividade](#ena-connectivity-issues)
+ [Mecanismo de keep-alive](#ena-keep-alive)
+ [Registre o tempo limite de leitura](#register-read-timeout-ena)
+ [Statistics](#statistics-ena)
+ [Logs de erro do driver no syslog](#driver-error-logs-ena)
+ [Notificações de configuração abaixo do ideal](#ts-ena-sub-opt-config-notification)
## Solucionar problemas de conectividade
Se você perder a conectividade ao habilitar a rede avançada, o módulo `ena` talvez seja incompatível com o kernel atualmente em execução na sua instância. Isso pode acontecer se você instalar o módulo para uma versão específica do kernel (sem **dkms** ou com um arquivo **dkms.conf** configurado indevidamente) e o kernel da instância for atualizado. Se o kernel da instância que estiver carregado no momento da inicialização não tiver o módulo `ena` corretamente instalado, sua instância não reconhecerá o adaptador de rede e sua instância ficará inacessível.
Se você habilitar a rede avançada para uma instância de PV ou AMI, isso também poderá tornar a instância inatingível.
.Se sua instância tornar-se inacessível após habilitar a rede avançada com ENA, é possível desabilitar o atributo `enaSupport` para sua instância e cairá no adaptador de rede em estoque.
**Para desabilitar a rede avançada com ENA (instâncias com suporte do EBS)**
1. No computador local, interrompa a instância usando o console do Amazon EC2, o comando [stop-instances](https://docs.aws.amazon.com/cli/latest/reference/ec2/stop-instances.html) (AWS CLI) ou o cmdlet [Stop-EC2Instance](https://docs.aws.amazon.com/powershell/latest/reference/items/Stop-EC2Instance.html) (Ferramentas da AWS para PowerShell).
1. No seu computador local, desabilite o atributo de rede avançada usando o comando [modify-instance-attribute](https://docs.aws.amazon.com/cli/latest/reference/ec2/modify-instance-attribute.html) com a opção `--no-ena-support` ou o cmdlet [Edit-EC2InstanceAttribute](https://docs.aws.amazon.com/powershell/latest/reference/items/Edit-EC2InstanceAttribute.html) com o parâmetro `-EnaSupport $false`.
1. No computador local, inicie a instância usando o console do Amazon EC2, o comandos [start-instances](https://docs.aws.amazon.com/cli/latest/reference/ec2/start-instances.html) ou o cmdlet [Start-EC2Instance](https://docs.aws.amazon.com/powershell/latest/reference/items/Start-EC2Instance.html).
1. (Opcional) Conecte-se à sua instância e tente reinstalar o módulo `ena` com a versão atual do kernel seguindo as etapas em [Habilitar redes aperfeiçoadas com o ENA em instâncias do EC2](enhanced-networking-ena.md).
**Para desabilitar a rede avançada com o ENA (instâncias com suporte do armazenamento de instâncias)**
1. Crie uma nova AMI conforme descrito em [Criação de uma AMI baseada no Amazon S3](creating-an-ami-instance-store.md).
1. Ao registrar a AMI, certifique-se de incluir a opção `--no-ena-support` no comando [stop-instances](https://docs.aws.amazon.com/cli/latest/reference/ec2/stop-instances.html) (AWS CLI) ou o parâmetro `-EnaSupport $false` no cmdlet [Register-EC2Image](https://docs.aws.amazon.com/powershell/latest/reference/items/Register-EC2Image.html).
## Mecanismo de keep-alive
O dispositivo ENA posta eventos de keep-alive em uma taxa fixa (geralmente uma vez por segundo). O driver ENA implanta um mecanismo de watchdog, que verifica a presença dessas mensagens keep-alive. Se as mensagens estiverem presentes, o watchdog será rearmado; caso contrário, o driver concluirá que o dispositivo experimentou uma falha e fará o seguinte:
+ Despejará as estatísticas atuais no syslog
+ Redefinirá o dispositivo ENA
+ Redefinirá o estado do driver do ENA
O procedimento de redefinição acima pode resultar em alguma perda de tráfego por um breve período (conexões TCP devem ser capazes recuperar), mas não deve afetar o usuário de outras formas.
O dispositivo ENA também pode indiretamente solicitar um procedimento de redefinição do dispositivo ao não enviar uma notificação de keep-alive, por exemplo, se o dispositivo ENA atingir um estado desconhecido depois de carregar uma configuração irrecuperável.
Exemplo do procedimento de redefinição:
```
[18509.800135] ena 0000:00:07.0 eth1: Keep alive watchdog timeout. // The watchdog process initiates a reset
[18509.815244] ena 0000:00:07.0 eth1: Trigger reset is on
[18509.825589] ena 0000:00:07.0 eth1: tx_timeout: 0 // The driver logs the current statistics
[18509.834253] ena 0000:00:07.0 eth1: io_suspend: 0
[18509.842674] ena 0000:00:07.0 eth1: io_resume: 0
[18509.850275] ena 0000:00:07.0 eth1: wd_expired: 1
[18509.857855] ena 0000:00:07.0 eth1: interface_up: 1
[18509.865415] ena 0000:00:07.0 eth1: interface_down: 0
[18509.873468] ena 0000:00:07.0 eth1: admin_q_pause: 0
[18509.881075] ena 0000:00:07.0 eth1: queue_0_tx_cnt: 0
[18509.888629] ena 0000:00:07.0 eth1: queue_0_tx_bytes: 0
[18509.895286] ena 0000:00:07.0 eth1: queue_0_tx_queue_stop: 0
.......
........
[18511.280972] ena 0000:00:07.0 eth1: free uncompleted tx skb qid 3 idx 0x7 // At the end of the down process, the driver discards incomplete packets.
[18511.420112] [ENA_COM: ena_com_validate_version] ena device version: 0.10 //The driver begins its up process
[18511.420119] [ENA_COM: ena_com_validate_version] ena controller version: 0.0.1 implementation version 1
[18511.420127] [ENA_COM: ena_com_admin_init] ena_defs : Version:[b9692e8] Build date [Wed Apr 6 09:54:21 IDT 2016]
[18512.252108] ena 0000:00:07.0: Device watchdog is Enabled
[18512.674877] ena 0000:00:07.0: irq 46 for MSI/MSI-X
[18512.674933] ena 0000:00:07.0: irq 47 for MSI/MSI-X
[18512.674990] ena 0000:00:07.0: irq 48 for MSI/MSI-X
[18512.675037] ena 0000:00:07.0: irq 49 for MSI/MSI-X
[18512.675085] ena 0000:00:07.0: irq 50 for MSI/MSI-X
[18512.675141] ena 0000:00:07.0: irq 51 for MSI/MSI-X
[18512.675188] ena 0000:00:07.0: irq 52 for MSI/MSI-X
[18512.675233] ena 0000:00:07.0: irq 53 for MSI/MSI-X
[18512.675279] ena 0000:00:07.0: irq 54 for MSI/MSI-X
[18512.772641] [ENA_COM: ena_com_set_hash_function] Feature 10 isn't supported
[18512.772647] [ENA_COM: ena_com_set_hash_ctrl] Feature 18 isn't supported
[18512.775945] ena 0000:00:07.0: Device reset completed successfully // The reset process is complete
```
## Registre o tempo limite de leitura
A arquitetura de ENA sugere um uso específico limitado de operações de leitura de E/S (MMIO) mapeadas de memória. Os registros de MMIO são acessados pelo driver do dispositivo ENA somente durante o procedimento de inicialização.
Se os logs do driver (disponíveis na saída do **dmesg**) indicarem falhas nas operações de leitura, isso pode ser causado por um driver incompatível ou incorretamente compilado, um dispositivo de hardware ocupado ou falha de hardware.
As entradas intermitentes do log que indicam falhas nas operações de leitura não devem ser consideradas um problema; o driver fará novas tentativas nesse caso. Contudo, uma sequência de entradas de log contendo falhas de leitura indica problema de driver ou de hardware.
Abaixo está um exemplo de entrada de log do driver indicando falha na operação de leitura devido a um tempo limite:
```
[ 47.113698] [ENA_COM: ena_com_reg_bar_read32] reading reg failed for timeout. expected: req id[1] offset[88] actual: req id[57006] offset[0]
[ 47.333715] [ENA_COM: ena_com_reg_bar_read32] reading reg failed for timeout. expected: req id[2] offset[8] actual: req id[57007] offset[0]
[ 47.346221] [ENA_COM: ena_com_dev_reset] Reg read32 timeout occurred
```
## Statistics
Se você tiver problemas de latência ou de performance de rede insuficiente, recupere as estatísticas dos dispositivos e examine-as. Essas estatísticas podem ser obtidas usando **ethtool**, como mostrado abaixo:
```
[ec2-user ~]$ ethtool -S ethN
NIC statistics:
tx_timeout: 0
suspend: 0
resume: 0
wd_expired: 0
interface_up: 1
interface_down: 0
admin_q_pause: 0
bw_in_allowance_exceeded: 0
bw_out_allowance_exceeded: 0
pps_allowance_exceeded: 0
conntrack_allowance_available: 450878
conntrack_allowance_exceeded: 0
linklocal_allowance_exceeded: 0
queue_0_tx_cnt: 4329
queue_0_tx_bytes: 1075749
queue_0_tx_queue_stop: 0
...
```
Os parâmetros de saída de comando a seguir estão descritos abaixo:
`tx_timeout`: *N*
O número de vezes que o watchdog Netdev foi ativado.
`suspend`: *N*
O número de vezes que o driver realizou uma operação de suspensão.
`resume`: *N*
O número de vezes que o driver realizou uma operação de retomada.
`wd_expired`: *N*
O número de vezes que o driver não recebeu o evento de keep-alive nos três segundos anteriores.
`interface_up`: *N*
O número de vezes que a interface do ENA foi ativada.
`interface_down`: *N*
O número de vezes que a interface do ENA foi desativada.
`admin_q_pause`: *N*
O número de vezes que a fila do administrador não foi encontrada em um estado de execução.
`bw_in_allowance_exceeded`: *N*
Número de pacotes na fila ou descartados porque a largura de banda agregada de entrada excedeu o máximo para a instância.
`bw_out_allowance_exceeded`: *N*
Número de pacotes na fila ou descartados porque a largura de banda agregada de saída excedeu o máximo para a instância.
`pps_allowance_exceeded`: *N*
Número de pacotes na fila ou descartados porque o PPS bidirecional excedeu o máximo para a instância.\$1
`conntrack_allowance_available`: *N*
O número de conexões rastreadas que podem ser estabelecidas pela instância antes de atingir a cota de conexões rastreadas desse tipo de instância. Disponível somente para instâncias baseadas em Nitro. Não é compatível com instâncias do FreeBSD ou ambientes DPDK.
`conntrack_allowance_exceeded`: *N*
Número de pacotes descartados porque o monitoramento da conexão excedeu o máximo para a instância e não foi possível estabelecer novas conexões. Isso pode resultar em perda de pacotes para tráfego indo para a instância ou vindo da instância
`linklocal_allowance_exceeded`: *N*
Número de pacotes descartados porque o PPS do tráfego para os serviços de proxy local excedeu o máximo para a interface da rede. Isso afeta o tráfego para o serviço Amazon DNS, o serviço de metadados de instância e o Serviço de Sincronização Temporal da Amazon, mas não afeta o tráfego para resolvedores personalizados de DNS.
`queue_N_tx_cnt`: *N*
O número de pacotes transmitidos para essa fila.
`queue_N_tx_bytes`: *N*
O número de bytes transmitidos para essa fila.
`queue_N_tx_queue_stop`: *N*
O número de vezes em que a fila *N* estava cheia e interrompida.
`queue_N_tx_queue_wakeup`: *N*
O número de vezes que a fila *N* foi retomada depois de ser interrompida.
`queue_N_tx_dma_mapping_err`: *N*
Contagem de erro de acesso da memória direta. Se esse valor não for 0, isso indica recursos de sistema baixos.
`queue_N_tx_linearize`: *N*
O número de vezes que a linearização de SKB foi tentada para essa fila.
`queue_N_tx_linearize_failed`: *N*
O número de vezes que a linearização de SKB apresentou falha para essa fila.
`queue_N_tx_napi_comp`: *N*
O número de vezes que o manipulador `napi` chamou `napi_complete` para essa fila.
`queue_N_tx_tx_poll`: *N*
O número de vezes que o manipulador `napi` foi programado para essa fila.
`queue_N_tx_doorbells`: *N*
O número de campainhas de transmissão para essa fila.
`queue_N_tx_prepare_ctx_err`: *N*
O número de vezes que `ena_com_prepare_tx` apresentou falha para essa fila.
`queue_N_tx_bad_req_id`: *N*
`req_id` inválido para essa fila. O `req_id` válido é zero, menos `queue_size`, menos 1.
`queue_N_tx_llq_buffer_copy`: *N*
O número de pacotes cujo tamanho dos cabeçalhos é maior do que a entrada llq para essa fila.
`queue_N_tx_missed_tx`: *N*
O número de pacotes deixados sem conclusão para essa fila.
`queue_N_tx_unmask_interrupt`: *N*
O número de vezes que a interrupção tx foi desmascarada para essa fila.
`queue_N_rx_cnt`: *N*
O número de pacotes recebidos para essa fila.
`queue_N_rx_bytes`: *N*
O número de bytes recebidos para essa fila.
`queue_N_rx_rx_copybreak_pkt`: *N*
O número de vezes que a fila rx recebeu um pacote menor que o tamanho do pacote de rx\$1copybreak para essa fila.
`queue_N_rx_csum_good`: *N*
O número de vezes que a fila rx recebeu um pacote em que a soma de verificação foi verificada e estava correta para essa fila.
`queue_N_rx_refil_partial`: *N*
O número de vezes que o driver não teve sucesso ao reabastecer a parte vazia da fila rx com buffers para essa fila. Se esse valor não for zero, isso indica recursos de memória baixa.
`queue_N_rx_bad_csum`: *N*
O número de vezes que a fila `rx` teve uma soma de verificação errada para a fila (somente se o descarregamento da soma de verificação for compatível).
`queue_N_rx_page_alloc_fail`: *N*
O número de vezes que a alocação de página apresentou falha para essa fila. Se esse valor não for zero, isso indica recursos de memória baixa.
`queue_N_rx_skb_alloc_fail`: *N*
O número de vezes que a alocação de SKB apresentou falha para essa fila. Se esse valor não for zero, isso indica recursos de sistema baixos.
`queue_N_rx_dma_mapping_err`: *N*
Contagem de erro de acesso da memória direta. Se esse valor não for 0, isso indica recursos de sistema baixos.
`queue_N_rx_bad_desc_num`: *N*
Excesso de buffers por pacote. Se o valor não for 0, isso indica o uso de buffers muito pequenos.
`queue_N_rx_bad_req_id`: *N*
O req\$1id para essa fila não é válido. O req\$1id válido é de [0, queue\$1size - 1].
`queue_N_rx_empty_rx_ring`: *N*
O número de vezes que a fila rx estava vazia para essa fila.
`queue_N_rx_csum_unchecked`: *N*
O número de vezes que a fila rx recebeu um pacote cuja soma de verificação não foi verificada para essa fila.
`queue_N_rx_xdp_aborted`: *N*
O número de vezes que um pacote XDP foi classificado como XDP\$1ABORT.
`queue_N_rx_xdp_drop`: *N*
O número de vezes que um pacote XDP foi classificado como XDP\$1DROP.
`queue_N_rx_xdp_pass`: *N*
O número de vezes que um pacote XDP foi classificado como XDP\$1PASS.
`queue_N_rx_xdp_tx`: *N*
O número de vezes que um pacote XDP foi classificado como XDP\$1TX.
`queue_N_rx_xdp_invalid`: *N*
O número de vezes que o código de retorno XDP para o pacote não foi válido.
`queue_N_rx_xdp_redirect`: *N*
O número de vezes que um pacote XDP foi classificado como XDP\$1REDIRECT.
`queue_N_xdp_tx_cnt`: *N*
O número de pacotes transmitidos para essa fila.
`queue_N_xdp_tx_bytes`: *N*
O número de bytes transmitidos para essa fila.
`queue_N_xdp_tx_queue_stop`: *N*
O número de vezes que essa fila estava cheia e interrompida.
`queue_N_xdp_tx_queue_wakeup`: *N*
O número de vezes que essa fila foi retomada depois de ser interrompida.
`queue_N_xdp_tx_dma_mapping_err`: *N*
Contagem de erro de acesso da memória direta. Se esse valor não for 0, isso indica recursos de sistema baixos.
`queue_N_xdp_tx_linearize`: *N*
O número de vezes que a linearização de buffer XDP foi tentada para essa fila.
`queue_N_xdp_tx_linearize_failed`: *N*
O número de vezes que a linearização do buffer XDP apresentou falha para essa fila.
`queue_N_xdp_tx_napi_comp`: *N*
O número de vezes que o manipulador napi chamou napi\$1complete para essa fila.
`queue_N_xdp_tx_tx_poll`: *N*
O número de vezes que o manipulador napi foi programado para essa fila.
`queue_N_xdp_tx_doorbells`: *N*
O número de campainhas de transmissão para essa fila.
`queue_N_xdp_tx_prepare_ctx_err`: *N*
O número de vezes que ena\$1com\$1prepare\$1tx apresentou falha para essa fila. Esse valor sempre deve ser zero; caso contrário, consulte os logs do driver.
`queue_N_xdp_tx_bad_req_id`: *N*
O req\$1id para essa fila não é válido. O req\$1id válido é de [0, queue\$1size - 1].
`queue_N_xdp_tx_llq_buffer_copy`: *N*
O número de pacotes que tiveram seus cabeçalhos copiados usando a cópia do buffer llq para essa fila.
`queue_N_xdp_tx_missed_tx`: *N*
O número de vezes que uma entrada de fila tx perdeu um timeout de conclusão para essa fila.
`queue_N_xdp_tx_unmask_interrupt`: *N*
O número de vezes que a interrupção tx foi desmascarada para essa fila.
`ena_admin_q_aborted_cmd`: *N*
O número de comandos de administrador que foram abortados. Isso normalmente acontece durante o procedimento de autorrecuperação.
`ena_admin_q_submitted_cmd`: *N*
O número de campainhas da fila do administrador.
`ena_admin_q_completed_cmd`: *N*
O número de conclusões da fila do administrador.
`ena_admin_q_out_of_space`: *N*
O número de vezes que o driver tentou enviar o novo comando de administrador, mas a fila estava cheia.
`ena_admin_q_no_completion`: *N*
O número de vezes o driver não obteve a conclusão de um administrador para um comando.
## Logs de erro do driver no syslog
O driver do ENA grava mensagens de log para **syslog** durante a inicialização do sistema. É possível examinar esses logs para procurar erros se estiver enfrentando problemas. Abaixo está um exemplo de informações registradas pelo driver do ENA no **syslog** durante a inicialização do sistema, junto com alguns anotações para mensagens selecionadas.
```
Jun 3 22:37:46 ip-172-31-2-186 kernel: [ 478.416939] [ENA_COM: ena_com_validate_version] ena device version: 0.10
Jun 3 22:37:46 ip-172-31-2-186 kernel: [ 478.420915] [ENA_COM: ena_com_validate_version] ena controller version: 0.0.1 implementation version 1
Jun 3 22:37:46 ip-172-31-2-186 kernel: [ 479.256831] ena 0000:00:03.0: Device watchdog is Enabled
Jun 3 22:37:46 ip-172-31-2-186 kernel: [ 479.672947] ena 0000:00:03.0: creating 8 io queues. queue size: 1024
Jun 3 22:37:46 ip-172-31-2-186 kernel: [ 479.680885] [ENA_COM: ena_com_init_interrupt_moderation] Feature 20 isn't supported // Interrupt moderation is not supported by the device
Jun 3 22:37:46 ip-172-31-2-186 kernel: [ 479.691609] [ENA_COM: ena_com_get_feature_ex] Feature 10 isn't supported // RSS HASH function configuration is not supported by the device
Jun 3 22:37:46 ip-172-31-2-186 kernel: [ 479.694583] [ENA_COM: ena_com_get_feature_ex] Feature 18 isn't supported //RSS HASH input source configuration is not supported by the device
Jun 3 22:37:46 ip-172-31-2-186 kernel: [ 479.697433] [ENA_COM: ena_com_set_host_attributes] Set host attribute isn't supported
Jun 3 22:37:46 ip-172-31-2-186 kernel: [ 479.701064] ena 0000:00:03.0 (unnamed net_device) (uninitialized): Cannot set host attributes
Jun 3 22:37:46 ip-172-31-2-186 kernel: [ 479.704917] ena 0000:00:03.0: Elastic Network Adapter (ENA) found at mem f3000000, mac addr 02:8a:3c:1e:13:b5 Queues 8
Jun 3 22:37:46 ip-172-31-2-186 kernel: [ 480.805037] EXT4-fs (xvda1): re-mounted. Opts: (null)
Jun 3 22:37:46 ip-172-31-2-186 kernel: [ 481.025842] NET: Registered protocol family 10
```
**Quais erros posso ignorar?**
Os avisos a seguir que podem aparecer nos logs de erros do seu sistema podem ser ignorados para o Elastic Network Adapter:
Não há suporte para definição do atributo do host
Este dispositivo não oferece suporte aos atributos do host.
falha em alocar buffer para a fila rx
Esse é um erro recuperável e indica que pode ter havido um problema de pressão de memória quando o erro ocorreu.
Não há suporte para o recurso *X*
O recurso mencionado não é compatível com o Elastic Network Adapter. Os valores possíveis para *X* incluem:
+ 10: a configuração da função RSS Hash não é compatível com este dispositivo.
+ 12: a configuração da tabela RSS Indirection não é compatível com este dispositivo.
+ 18: a configuração de RSS Hash Input não é compatível com este dispositivo.
+ 20: a moderação de interrupção não é compatível para este dispositivo.
+ 27: o driver Adaptador de Rede Elástica não oferece suporte à sondagem dos recursos de Ethernet de snmpd.
Falha ao configurar AENQ
O Elastic Network Adapter não oferece suporte à configuração de AENQ.
Tentativa de configurar eventos AENQ não compatíveis
Esse erro indica uma tentativa de configurar um grupo de eventos do AENQ que não são compatíveis com o Elastic Network Adapter.
## Notificações de configuração abaixo do ideal
O dispositivo ENA detecta configurações abaixo do ideal no driver, as quais podem ser alteradas. O dispositivo notifica o driver ENA e registra um aviso no console. O exemplo a seguir mostra o formato da mensagem de aviso.
```
Sub-optimal configuration notification code: 1. Refer to AWS ENA documentation for additional details and mitigation options.
```
A lista a seguir mostra detalhes do código de notificação e as ações recomendadas para descobertas de configurações abaixo do ideal.
+ **Código 1: não é recomendado utilizar o ENA Express com configuração de LLQ amplo**
A ENI do ENA Express está configurada com LLQ amplo. Essa configuração está abaixo do ideal e pode afetar a performance do ENA Express. Recomendamos desabilitar as configurações de LLQ amplo ao usar ENIs do ENA Express conforme mostrado a seguir.
```
sudo rmmod ena && sudo modprobe ena force_large_llq_header=0
```
Para obter mais informações sobre a configuração ideal do ENA Express consulte [Melhorar a performance da rede entre instâncias do EC2 com ENA Express](ena-express.md).
+ **Código 2: não é recomendado usar a ENI do ENA Express com profundidade de fila Tx abaixo do ideal**
A ENI do ENA Express está configurada com profundidade de fila Tx abaixo do ideal. Essa configuração pode afetar a performance do ENA Express. Recomendamos aumentar todas as filas Tx para o valor máximo para a interface de rede quando você usar ENIs do ENA Express como a seguir.
É possível pode executar os seguintes comandos **ethtool** para ajustar o tamanho do LLQ Para saber mais sobre como controlar, consultar e habilitar o LLQ amplo, consulte o tópico [Enfileiramento de baixa latência grande (Large LLQ)](https://github.com/amzn/amzn-drivers/tree/master/kernel/linux/ena#large-low-latency-queue-large-llq) da documentação do driver do kernel Linux para ENA no *Repositório de drivers da Amazon no GitHub*.
```
ethtool -g interface
```
Defina suas filas Tx para a profundidade máxima:
```
ethtool -G interface tx depth
```
Para obter mais informações sobre a configuração ideal do ENA Express consulte [Melhorar a performance da rede entre instâncias do EC2 com ENA Express](ena-express.md).
+ **Código 3: ENA com tamanho de LLQ normal e tráfego de pacotes Tx excede o tamanho máximo aceito pelo cabeçalho**
Por padrão, o LLQ do ENA oferece suporte a cabeçalhos de pacote Tx com até 96 bytes de tamanho. Se o tamanho do cabeçalho do pacote for maior que 96 bytes, o pacote será descartado. Para mitigar esse problema, recomendamos habilitar o LLQ amplo, o que aumenta o tamanho máximo do cabeçalho do pacote Tx para 224 bytes.
No entanto, quando você ativa o LLQ amplo, o tamanho máximo do anel Tx é reduzido de 1000 para 512 entradas. O LLQ amplo é habilitado por padrão para todos os tipos de instância Nitro v4 e posteriores.
+ Os tipos de instância Nitro v4 têm um tamanho de anel Tx de LLQ amplo máximo padrão de 512 entradas, que não pode ser alterado.
+ Os tipos de instância Nitro v5 têm um tamanho de anel Tx de LLQ amplo padrão de 512 entradas, o qual pode ser alterado para até 1000 entradas.
É possível pode executar os seguintes comandos **ethtool** para ajustar o tamanho do LLQ Para saber mais sobre como controlar, consultar e habilitar o LLQ amplo, consulte o tópico [Enfileiramento de baixa latência grande (Large LLQ)](https://github.com/amzn/amzn-drivers/tree/master/kernel/linux/ena#large-low-latency-queue-large-llq) da documentação do driver do kernel Linux para ENA no *Repositório de drivers da Amazon no GitHub*.
Encontre a profundidade máxima para suas filas Tx:
```
ethtool -g interface
```
Defina suas filas Tx para a profundidade máxima:
```
ethtool -G interface tx depth
```
# Solução de problemas do driver do Adaptador de Rede Elástica do Windows
O Elastic Network Adapter (ENA) é projetado para melhorar a integridade do sistema operacional e reduzir as possibilidades de interrupção na operação da sua instância de Windows por conta de comportamento inesperado de hardware ou falhas. A arquitetura do ENA mantém falhas do dispositivo ou do driver o mais transparentes possível para o sistema operacional.
## Colete informações de diagnóstico sobre a instância
As etapas para abrir as ferramentas do sistema operacional (SO) Windows variam, dependendo da versão do sistema operacional instalada na instância. Nas seções a seguir, usamos a caixa de diálogo **Run** (Executar) para abrir as ferramentas, o que funciona da mesma forma em todas as versões do sistema operacional. No entanto, é possível acessar essas ferramentas usando qualquer método que preferir.
**Acesse a caixa de diálogo Run (Executar)**
+ Usando a combinação de teclas do logo do Windows: `Windows` \$1 `R`
+ Usando a barra de pesquisa:
+ Insira `run` na barra de pesquisa.
+ Selecione a aplicação **Run** (Executar) a partir dos resultados da pesquisa.
Algumas etapas exigem que o menu de contexto acesse propriedades ou ações sensíveis ao contexto. Há várias maneiras de fazer isso, dependendo da versão do sistema operacional e do hardware.
**Acesse o menu de contexto**
+ Usando o mouse: clique com o botão direito do mouse em um item para abrir seu menu de contexto.
+ Usando o teclado:
+ Dependendo da versão do sistema operacional, use `Shift` \$1 `F10`, ou `Ctrl` \$1 `Shift` \$1 `F10`.
+ Se você tiver a tecla de contexto no teclado (três linhas horizontais em uma caixa), selecione o item desejado e pressione a tecla de contexto.
Se você puder se conectar à instância, use as técnicas a seguir para coletar informações de diagnóstico para solução de problemas.
### Verifique o status do dispositivo ENA
Para verificar o status do driver ENAdo Windows usando o Gerenciador de dispositivos do Windows, siga estas etapas:
1. Abra a caixa de diálogo **Run** (Executar) usando um dos métodos descritos na seção anterior.
1. Para abrir o Gerenciador de dispositivos do Windows, insira `devmgmt.msc` na caixa **Run** (Executar).
1. Escolha **OK**. Isso abre a janela Gerenciador de dispositivos.
1. Selecione a seta à esquerda de **Network adapters** (Adaptadores de rede) para expandir a lista.
1. Escolha o nome ou abra o menu de contexto para **Amazon Elastic Network Adapter** (Adaptador do Amazon Elastic Network) e, depois, escolha **Properties** (Propriedades). Isso abre a caixa de diálogo **Propriedades do Adaptador de Rede Elástica da Amazon**.
1. Verifique se a mensagem na guia **Geral** sinaliza "Este dispositivo está funcionando corretamente".
### Investigue mensagens de evento do driver
Para revisar os logs de eventos do driver ENA do Windows usando o Visualizador de eventos do Windows, siga estas etapas:
1. Abra a caixa de diálogo **Run** (Executar) usando um dos métodos descritos na seção anterior.
1. Para abrir o Visualizador de eventos do Windows, insira `eventvwr.msc` na caixa **Run** (Executar).
1. Escolha **OK**. Isso abrirá a janela Event Viewer (Visualizador de eventos).
1. Expanda o menu **Windows Logs** (Logs do Windows) e, em seguida, escolha **System** (Sistema).
1. Em **Actions** (Ações), no painel superior direito, escolha **Filter Current Log** (Filtrar log atual). Isso exibe a caixa de diálogo de filtragem.
1. Na caixa **Event sources** (Origens de eventos), insira `ena`. Isso limita os resultados a eventos gerados pelo driver ENA do Windows.
1. Escolha **OK**. Isso mostra os resultados do log de eventos filtrados nas seções de detalhes da janela.
1. Para examinar os detalhes, selecione uma mensagem de evento na lista.
O exemplo a seguir mostra um evento de driver ENA na lista de eventos do sistema do Visualizador de eventos do Windows:
![\[Exemplo: evento de driver ENA mostrado na lista de mensagens do sistema do Visualizador de eventos do Windows.\]](http://docs.aws.amazon.com/pt_br/AWSEC2/latest/UserGuide/images/ena-event-viewer-example.png)
#### Resumo da mensagem do evento
A tabela a seguir mostra as mensagens de evento geradas pelo driver ENA do Windows.
**Input**
| ID do evento | Descrição do evento do driver ENA | Tipo |
| --- | --- | --- |
| 5001 | Hardware is out of resources (O hardware está sem recursos) | Erro |
| 5002 | Adapter has detected a hardware error (O adaptador detectou um erro de hardware) | Erro |
| 5005 | Adapter has timed out on NDIS operation that did not complete in a timely manner (O adaptador expirou o tempo limite na operação do NDIS que não foi concluída em tempo hábil) | Erro |
| 5032 | Adapter has failed to reset the device (Falha do adaptador ao redefinir o dispositivo) | Erro |
| 5200 | Adapter has been initialized (O adaptador foi inicializado) | Informativo |
| 5201 | Adapter has been halted (O adaptador foi interrompido) | Informativo |
| 5202 | Adapter has been paused (O adaptador foi pausado) | Informativo |
| 5203 | Adapter has been restarted (O adaptador foi reiniciado) | Informativo |
| 5204 | Adapter has been shut down (O adaptador foi desligado) | Informativo |
| 5205 | Adapter has been reset (O adaptador foi redefinido) | Erro |
| 5206 | Adapter has been surprise removed (O adaptador foi removido de surpresa) | Erro |
| 5208 | Adapter initialization routine has failed (A rotina de inicialização do adaptador falhou) | Erro |
| 5210 | Adapter has encountered and successfully recovered an internal issue (O adaptador encontrou problema interno e recuperou com êxito) | Erro |
### Analise as métricas de performance
O driver ENA do Windows publica métricas de performance de rede de instâncias onde elas estão habilitadas. É possível exibir e habilitar métricas na instância usando a aplicação nativa Monitor de performance. Para obter mais informações sobre as métricas que o driver ENA do Windows produz, consulte [Monitorar o desempenho de rede de instâncias do EC2](monitoring-network-performance-ena.md).
Em casos em que as métricas do ENA estão habilitadas e o agente do Amazon CloudWatch está instalado, o CloudWatch coleta as métricas associadas aos contadores no Monitor de performance do Windows, bem como algumas métricas avançadas para o ENA. Essas métricas são coletadas além das métricas habilitadas por padrão em instâncias do EC2. Para obter mais informações sobre as métricas, consulte [Métricas coletadas pelo agente CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/metrics-collected-by-CloudWatch-agent.html) no *Guia do usuário do Amazon CloudWatch*.
**nota**
As métricas de performance estão disponíveis para as versões 2.4.0 e posteriores do driver ENA (também para a versão 2.2.3). O driver ENA versão 2.2.4 foi revertido devido à possível degradação da performance nas instâncias do EC2 de sexta geração. Recomendamos que você atualize para a versão atual do driver para garantir que tenha as últimas atualizações.
Algumas maneiras como usar métricas de performance são:
+ Solucionar problemas de performance de instâncias.
+ Escolher o tamanho certo de instância para um workload.
+ Planejar atividades de escalabilidade proativamente.
+ Fazer benchmark em aplicações para determinar se elas maximizam a performance disponível em uma instância.
**Taxa de atualização**
Por padrão, o driver atualiza métricas usando um intervalo de 1 segundo. No entanto, a aplicação que recupera as métricas pode usar um intervalo diferente para sondagem. É possível alterar o intervalo de atualização no Gerenciador de dispositivos, usando as propriedades avançadas do driver.
Para alterar o intervalo de atualização de métricas para o driver ENA do Windows, siga estas etapas:
1. Abra a caixa de diálogo **Run** (Executar) usando um dos métodos descritos na seção anterior.
1. Para abrir o Gerenciador de dispositivos do Windows, insira `devmgmt.msc` na caixa **Run** (Executar).
1. Escolha **OK**. Isso abre a janela Gerenciador de dispositivos.
1. Selecione a seta à esquerda de **Network adapters** (Adaptadores de rede) para expandir a lista.
1. Escolha o nome ou abra o menu de contexto para **Amazon Elastic Network Adapter** (Adaptador do Amazon Elastic Network) e, depois, escolha **Properties** (Propriedades). Isso abre a caixa de diálogo **Propriedades do Adaptador de Rede Elástica da Amazon**.
1. Abra a guia **Advanced** (Avançado) na janela suspensa.
1. Na lista **Property** (Propriedade), escolha **Metrics Refresh Interval** (Intervalo de atualização das métricas) para alterar o valor.
1. Quando tiver concluído, escolha **OK**.
## Investigar notificações de configuração aquém do ideal
O dispositivo ENA detecta configurações abaixo do ideal no driver, as quais podem ser alteradas. O dispositivo notifica o driver do ENA e registra uma notificação de evento. Para revisar os eventos de configuração aquém do ideal no Visualizador de Eventos do Windows
1. Abra a caixa de diálogo **Run** (Executar) usando um dos métodos descritos na seção anterior.
1. Para abrir o Visualizador de eventos do Windows, insira `eventvwr.msc` na caixa **Run** (Executar).
1. Escolha **OK**. Isso abrirá a janela Event Viewer (Visualizador de eventos).
1. Expanda o menu **Windows Logs** (Logs do Windows) e, em seguida, escolha **System** (Sistema).
1. Em **Actions** (Ações), no painel superior direito, escolha **Filter Current Log** (Filtrar log atual). Isso exibe a caixa de diálogo de filtragem.
1. Na caixa **Event sources** (Origens de eventos), insira `ena`. Isso limita os resultados a eventos gerados pelo driver ENA do Windows.
1. Escolha **OK**. Isso mostra os resultados do log de eventos filtrados nas seções de detalhes da janela.
Os eventos com o ID `59000` notificam você sobre descobertas de configuração aquém do ideal. Clique com o botão direito do mouse em um evento e escolha **Propriedades do evento** para abrir uma visualização detalhada ou selecione **Painel de visualização** no menu **Visualizar** para ver os mesmos detalhes.
![\[Exemplo: ID de evento de sistema 59000 mostrado no painel de visualização do Visualizador de Eventos do Windows.\]](http://docs.aws.amazon.com/pt_br/AWSEC2/latest/UserGuide/images/ena-sub-opt-event-general.png)
Abra a guia **Detalhes** para ver o código do evento. Na seção **Dados binários: em palavras**, a última palavra é o código.
![\[Exemplo: a última palavra na seção Dados binários é mostrada em realce.\]](http://docs.aws.amazon.com/pt_br/AWSEC2/latest/UserGuide/images/ena-sub-opt-event-detail.png)
A lista a seguir mostra detalhes do código de notificação e as ações recomendadas para descobertas de configurações abaixo do ideal.
+ **Código `1`: não é recomendado utilizar o ENA Express com configuração de LLQ amplo**
A ENI do ENA Express está configurada com LLQ amplo. Essa configuração está abaixo do ideal e pode afetar a performance do ENA Express. Recomendamos desabilitar as configurações de LLQ amplo ao usar ENIs do ENA Express conforme mostrado a seguir.
1. Para abrir o Gerenciador de dispositivos do Windows, insira `devmgmt.msc` na caixa **Run** (Executar).
1. Escolha **OK**. Isso abre a janela Gerenciador de dispositivos.
1. Selecione a seta à esquerda de **Network adapters** (Adaptadores de rede) para expandir a lista.
1. Abra as propriedades de dispositivo para o `Amazon Elastic Network Adapter`.
1. Ali, abra a guia **Avançado** para fazer as alterações.
1. Selecione a propriedade **Política de tamanho de cabeçalho de LLQ** e defina seu valor como `Normal (128 Bytes)`.
1. Escolha **OK** para salvar as alterações.
+ **Código `2`: ENI do ENA Express com profundidade de fila Tx abaixo do ideal não é recomendada**
A ENI do ENA Express está configurada com profundidade de fila Tx abaixo do ideal. Essa configuração pode afetar a performance do ENA Express. Recomendamos aumentar todas as filas Tx para o valor máximo para a interface de rede quando você usar ENIs do ENA Express como a seguir.
Siga estas etapas para aumentar as filas de Tx para a profundidade máxima:
1. Para abrir o Gerenciador de dispositivos do Windows, insira `devmgmt.msc` na caixa **Run** (Executar).
1. Escolha **OK**. Isso abre a janela Gerenciador de dispositivos.
1. Selecione a seta à esquerda de **Network adapters** (Adaptadores de rede) para expandir a lista.
1. Abra as propriedades de dispositivo para o `Amazon Elastic Network Adapter`.
1. Ali, abra a guia **Avançado** para fazer as alterações.
1. Selecione a propriedade **Buffers de transmissão** e defina seu valor como o máximo permitido.
1. Escolha **OK** para salvar as alterações.
## Redefinição do adaptador ENA
O processo de redefinição é iniciado quando o driver ENA do Windows detecta um erro em um adaptador e marca o adaptador como não íntegro. O driver não pode redefinir a si mesmo, portanto, depende do sistema operacional verificar o status da integridade do adaptador e chamar o identificador de redefinição para o driver ENA do Windows. O processo de redefinição pode resultar em um breve período de tempo em que ocorre perda de tráfego. No entanto, as conexões TCP devem ser capazes de se recuperar.
O adaptador ENA também pode solicitar indiretamente um procedimento de redefinição do dispositivo, ao não enviar uma notificação de manutenção de atividade. Por exemplo, se o adaptador ENA atingir um estado desconhecido depois de carregar uma configuração irrecuperável, poderá parar de enviar notificações de keep-alive.
**Causas comuns para redefinição do adaptador ENA**
+ Mensagens de keep-alive estão ausentes
O dispositivo ENA posta eventos de keep-alive em uma taxa fixa (geralmente uma vez por segundo). O driver ENA do Windows implanta um mecanismo de watchdog, que verifica a presença dessas mensagens keep-alive. Se detectar uma ou mais novas mensagens desde a última vez que foi verificada, ele registra um resultado de êxito. Caso contrário, o driver conclui que o dispositivo sofreu uma falha e inicia uma sequência de redefinição.
+ Os pacotes estão presos em filas de transmissão
O adaptador ENA verifica se os pacotes estão fluindo pelas filas de transmissão conforme esperado. O driver ENA do Windows detecta se os pacotes estão ficando presos e inicia uma sequência de redefinição caso estejam.
+ Tempo limite de leitura para registros de E/S mapeados da memória (MMIO)
Para limitar as operações de leitura de E/S mapeadas de memória (MMIO), o driver ENA do Windows acessa os registros do MMIO somente durante os processos de inicialização e redefinição. Se o driver detectar um tempo limite, ele executará uma das seguintes ações, dependendo do processo em execução:
+ Se um tempo limite for detectado durante a inicialização, ele falhará no fluxo, o que resulta na exibição de um ponto de exclamação amarelo pelo adaptador ENA no Gerenciador de dispositivos do Windows.
+ Se um tempo limite for detectado durante a reinicialização, ele falhará no fluxo. O sistema operacional inicia uma remoção surpresa do adaptador ENA e o recupera parando e iniciando o adaptador que foi removido. Para obter mais informações sobre a remoção surpresa de uma placa de interface de rede (NIC), consulte [Como lidar com a remoção surpresa de uma NIC](https://learn.microsoft.com/en-us/windows-hardware/drivers/network/handling-the-surprise-removal-of-a-nic) na documentação *Desenvolvedor de hardware do Microsoft Windows*.
## Cenários de solução de problemas
Os cenários a seguir podem ajudar a solucionar problemas que possam ocorrer com o driver ENA do Windows. Recomendamos que você comece atualizando seu driver ENA, se você não tiver a versão mais recente. Para encontrar o driver mais recente para a versão do sistema operacional Windows, consulte [Rastrear os lançamentos da versão do driver do ENA do Windows](ena-driver-releases-windows.md).
### Versão inesperada do driver ENA instalada
#### Descrição
Depois de seguir as etapas para instalar uma versão específica do driver ENA, o gerenciador de dispositivos do Windows mostra que o Windows instalou uma versão diferente do driver ENA.
#### Causa
Quando você executa a instalação de um pacote de driver, o Windows classifica todos os pacotes de drivers válidos para determinado dispositivo no [armazenamento de drivers](https://learn.microsoft.com/en-us/windows-hardware/drivers/install/driver-store) local antes da execução. Em seguida, ele seleciona o pacote com o menor valor de classificação como a melhor correspondência. Isso pode ser diferente do pacote que você pretendia instalar. Para obter mais informações sobre o processo de seleção do pacote de driver de dispositivo, consulte [Como o Windows seleciona um pacote de driver para um dispositivo](https://learn.microsoft.com/en-us/windows-hardware/drivers/install/how-windows-selects-a-driver-for-a-device) no *site de documentação da Microsoft*.
#### Solução
Para garantir que o Windows instale a versão do pacote de driver escolhida, você pode remover pacotes de drivers de classificação inferior do armazenamento de drivers com a ferramenta de linha de comando [PnPUtil](https://learn.microsoft.com/en-us/windows-hardware/drivers/devtest/pnputil).
Siga estas etapas para atualizar o driver ENA:
1. Conecte-se à instância e faça login como administrador local.
1. Abra a janela de propriedades do Gerenciador de dispositivos, conforme descrito na seção [Verifique o status do dispositivo ENA](#ts-ena-diagnostics-device-mgr). Isso abre a guia **Geral** da janela **Propriedades do Adaptador de Rede Elástica da Amazon**.
1. Abra a guia **Driver**.
1. Escolha **Update Driver (Atualizar driver)**. Isso abre a caixa de diálogo **Atualizar software do driver: Adaptador de Rede Elástica da Amazon**.
1. Na seção **Como deseja pesquisar o software de driver?**, escolha **Procurar software de driver no computador**.
1. Na página **Procurar software de driver no computador**, escolha **Permitir escolher em uma lista de drivers de dispositivo em meu computador**, localizado abaixo da barra de pesquisa.
1. Na página **Selecionar o driver do dispositivo que você deseja instalar para este hardware**, escolha **Ter disco...**.
1. Na janela **Instalar do disco**, escolha **Procurar...**, próximo à localização na lista suspensa.
1. Navegue até o local em que você fez o download do pacote de driver ENA de destino. Selecione o arquivo denominado `ena.inf` e escolha **Abrir**.
1. Para iniciar a instalação, escolha **OK** e, em seguida, escolha **Avançar**.
1. Se o instalador não reinicializar automaticamente sua instância, execute o cmdlet **Restart-Computer** do PowerShell.
```
PS C:\> Restart-Computer
```
### Aviso de dispositivo para driver ENA
#### Descrição
O ícone do adaptador ENA na seção **Network adapters** (Adaptadores de rede) do Gerenciador de dispositivos exibe um sinal de aviso (um triângulo amarelo com um ponto de exclamação dentro).
O exemplo a seguir mostra um adaptador ENA com o ícone de aviso no Gerenciador de dispositivos do Windows:
![\[Exemplo: adaptador ENA com o ícone de aviso no Gerenciador de dispositivos do Windows.\]](http://docs.aws.amazon.com/pt_br/AWSEC2/latest/UserGuide/images/ena-adapter-device-mgr-warn.png)
#### Causa
Esse aviso de dispositivo geralmente é causado por problemas de ambiente, o que pode exigir mais pesquisas, e muitas vezes exige um processo de eliminação para determinar a causa subjacente. Para obter uma lista completa de erros do dispositivo, consulte [Mensagens de erro do Gerenciador de dispositivos](https://learn.microsoft.com/en-us/windows-hardware/drivers/install/device-manager-error-messages) na documentação da Microsoft.
#### Solução
A solução para este aviso de dispositivo depende da causa raiz. O processo de eliminação descrito aqui inclui algumas etapas básicas para ajudar a identificar e resolver os problemas mais comuns que podem ter uma solução simples. É necessária uma análise de causa raiz adicional quando essas etapas não resolvem o problema.
Siga estas etapas para ajudar a identificar e resolver problemas comuns:
1.
**Interrompa e inicie o dispositivo.**
Abra a janela de propriedades do Gerenciador de dispositivos, conforme descrito na seção [Verifique o status do dispositivo ENA](#ts-ena-diagnostics-device-mgr). Isso abre a guia **General** (Geral) da janela **Amazon Elastic Network Adapter Properties** (Propriedades do adaptador do Amazon Elastic Network), onde **Device status** (Status do dispositivo) exibe o código de erro e uma mensagem curta.
1. Abra a guia **Driver**.
1. Selecione **Disable Device** (Desabilitar dispositivo) e responda **Yes** (Sim) para a mensagem de aviso exibida.
1. Selecione **Enable Device** (Habilitar dispositivo).
1.
**Interrompa e inicie a instância do EC2**
Se o adaptador ainda mostrar o ícone de aviso no Gerenciador de dispositivos, a próxima etapa é interromper e iniciar a instância do EC2. Isso reinicia a instância em hardware diferente na maioria dos casos.
1.
**Investigue possível problema de recursos da instância**
Se você interrompeu e iniciou sua instância do EC2 e o problema persistir, isso pode indicar um problema de recurso na instância, como memória insuficiente.
### Tempo limite de conexão com redefinição do adaptador (códigos de erro 5007, 5205)
#### Descrição
O Visualizador de eventos do Windows mostra o tempo limite do adaptador e os eventos de redefinição que ocorrem em combinação para adaptadores ENA. As mensagens são semelhantes aos exemplos a seguir:
+ **ID do evento 5007**: adaptador do Amazon Elastic Network: Timed out during an operation (Tempo limite durante uma operação).
+ **ID do evento 5205**: adaptador do Amazon Elastic Network Adapter: Adapter reset has been started (A redefinição do adaptador foi iniciada).
As redefinições do adaptador causam interrupção mínima no tráfego. Mesmo quando há várias redefinições, seria incomum que elas causem qualquer interrupção grave da rede.
#### Causa
Essa sequência de eventos indica que o driver ENA Windows iniciou uma redefinição para um adaptador ENA que não respondeu. No entanto, o mecanismo que o driver do dispositivo usa para detectar esse problema está sujeito a falsos positivos resultantes da falta de CPU 0.
#### Solução
Se essa combinação de erros ocorrer com frequência, verifique suas alocações de recursos para ver onde os ajustes podem ser úteis.
1. Abra a caixa de diálogo **Run** (Executar) usando um dos métodos descritos na seção anterior.
1. Para abrir o Monitor de recursos do Windows, insira `resmon` na caixa **Run** (Executar).
1. Escolha **OK**. Isso abre a janela do Monitor de recursos.
1. Abra a guia **CPU**. Gráficos de uso por CPU são mostrados ao longo do lado direito da janela Monitor de recursos.
1. Verifique os níveis de uso da CPU 0 para ver se eles estão muito altos.
Recomendamos que você configure o RSS para excluir a CPU 0 para o adaptador ENA em tipos de instância maiores (mais de 16 vCPU). Para tipos de instância menores, a configuração do RSS pode melhorar a experiência, mas devido ao menor número de núcleos disponíveis, o teste é necessário para garantir que a restrição dos núcleos da CPU não impacte negativamente a performance.
Use o comando **Set-NetAdapterRss** para configurar o RSS para seu adaptador ENA, conforme mostrado no exemplo a seguir.
```
Set-NetAdapterRss -name (Get-NetAdapter | Where-Object {$_.InterfaceDescription -like "*Elastic*"}).Name -Baseprocessorgroup 0 -BaseProcessorNumber 1
```
### A migração para uma infra-estrutura de instância de sexta geração afeta a performance ou a anexação
#### Descrição
Se você migrar para uma instância do EC2 de sexta geração, poderá ter uma performance reduzida ou falhas de anexação do ENA se não tiver atualizado a versão do driver do ENA Windows.
#### Causa
Os tipos de instância do EC2 de sexta geração exigem a seguinte versão mínima do driver ENA para Windows, com base no sistema operacional da instância.
**Versão mínima**
| Versão Windows Server | Versão do driver ENA |
| --- | --- |
| Windows Server 2008 R2 | 2.2.3 ou 2.4.0 |
| Windows Server 2012 e posterior | 2.2.3 e posterior |
| Estação de trabalho Windows | 2.2.3 e posterior |
#### Solução
Antes de fazer o upgrade para uma instância do EC2 de sexta geração, certifique-se de que a AMI a partir da qual você iniciar tenha os drivers compatíveis com base no sistema operacional da instância, como mostrado na tabela anterior. Para obter mais informações, consulte [What do I need to do before migrating my EC2 instance to a sixth generation instance to make sure that I get maximum network performance?](https://repost.aws/knowledge-center/migrate-to-gen6-ec2-instance) no *AWS re:Post Knowledge Center*.
### Performance abaixo da ideal para a interface de rede elástica (ENI)
#### Descrição
A interface ENA não está funcionando conforme o esperado.
#### Causa
A análise de causa raiz para problemas de performance é um processo de eliminação. Existem muitas variáveis envolvidas para se nomear uma causa comum.
#### Solução
A primeira etapa na análise da causa raiz é revisar as informações de diagnóstico da instância que não está funcionando conforme o esperado, para determinar se há erros que podem estar causando o problema. Para obter mais informações, consulte a [Colete informações de diagnóstico sobre a instância](#ts-ena-drv-collect-diagnostics) seção.
Para obter a máxima performance da rede em instâncias com redes avançadas, pode ser necessário modificar a configuração do sistema operacional padrão. Outras otimizações, como ativar o descarregamento de soma de verificação e a habilitação do RSS, por exemplo, já estão em vigor por padrão em AMIs oficiais do Windows. Para outras otimizações que você pode aplicar ao adaptador ENA, consulte os ajustes de performance mostrados em [Ajustes de performance do adaptador ENA](#ts-ena-drv-perf-adj).
Recomendamos que você prossiga com cautela e limite os ajustes de propriedade do dispositivo àqueles listados nesta seção ou a alterações específicas recomendadas pela equipe de suporte da AWS.
Para alterar as propriedades do adaptador ENA, siga estas etapas:
1. Abra a caixa de diálogo **Run** (Executar) usando um dos métodos descritos na seção anterior.
1. Para abrir o Gerenciador de dispositivos do Windows, insira `devmgmt.msc` na caixa **Run** (Executar).
1. Escolha **OK**. Isso abre a janela Gerenciador de dispositivos.
1. Selecione a seta à esquerda de **Network adapters** (Adaptadores de rede) para expandir a lista.
1. Escolha o nome ou abra o menu de contexto para **Amazon Elastic Network Adapter** (Adaptador do Amazon Elastic Network) e, depois, escolha **Properties** (Propriedades). Isso abre a caixa de diálogo **Propriedades do Adaptador de Rede Elástica da Amazon**.
1. Para fazer suas alterações, abra a guia **Avançado**.
1. Quando concluir, escolha **OK** para salvar suas alterações.
O exemplo a seguir mostra uma propriedade do adaptador ENA Gerenciador de dispositivos do Windows.
![\[Exemplo: propriedade do adaptador ENA mostrada no Gerenciador de dispositivos do Windows.\]](http://docs.aws.amazon.com/pt_br/AWSEC2/latest/UserGuide/images/ena-adapter-device-mgr-property.png)
##### Ajustes de performance do adaptador ENA
A tabela a seguir inclui propriedades que podem ser ajustadas para melhorar a performance da interface ENA.
**Input**
| Propriedade | Descrição | Valor padrão | Ajuste |
| --- | --- | --- | --- |
| Buffers de recebimento | Controla o número de entradas nas filas de recebimento do software. | 1024 | Pode ser aumentado até um máximo de 8192. |
| Receive Side Scaling (RSS) | Habilita a distribuição eficiente do processamento de recebimento de rede em várias CPUs em sistemas multiprocessadores. | Habilitado | É possível espalhar a carga em vários processadores. Para saber mais, consulte [Otimizar performance da rede em instâncias do Windows do EC2](enhanced-networking-os.md). |
| Número máximo de filas de RSS | Define o número máximo de filas de RSS permitidas quando `RSS` está habilitado. | 32 | O número de filas de RSS é determinado durante a inicialização do driver e inclui as seguintes limitações (entre outras): [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AWSEC2/latest/UserGuide/troubleshoot-ena-driver.html) É possível definir o valor de 1 a 32, dependendo dos limites de geração de instância e hardware. Para saber mais, consulte [Otimizar performance da rede em instâncias do Windows do EC2](enhanced-networking-os.md). |
| Pacote jumbo | Permite o uso de frames jumbo ethernet (mais de 1500 bytes de carga útil). | Desabilitado (isso limita a carga útil a 1500 bytes ou menos) | O valor pode ser configurado para `9015`, o que se traduz em 9001 bytes de carga útil. Essa é a carga útil máxima para frames ethernet jumbo. Consulte [Considerações sobre o uso de frames ethernet jumbo](#ts-ena-drv-jumbo-frames). |
##### Considerações sobre o uso de frames ethernet jumbo
Os frames jumbo permitem mais de 1500 bytes de dados ao aumentar o tamanho da carga útil por pacote, o que aumenta o percentual do pacotes que não configura sobrecarga. São necessários menos pacotes para enviar a mesma quantidade de dados usáveis. No entanto, o tráfego é limitado a um MTU máximo de 1500 nos seguintes casos:
+ Tráfego fora de uma determinada região da AWS para EC2 Classic.
+ Tráfego fora de uma única VPC
+ Tráfego em uma conexão de emparelhamento de VPC entre regiões
+ Tráfego através de ligações de VPN
+ Tráfego em um gateway de Internet
**nota**
Pacotes com mais de 1500 bytes são fragmentados. Se você tiver o sinalizador `Don't Fragment` definido no cabeçalho IP, esses pacotes são descartados.
Os frames jumbo devem ser usados com cuidado para o tráfego voltado para Internet ou qualquer tráfego que saia de uma VPC. Os pacotes são fragmentados por sistemas intermediários, que retarda o tráfego. Para usar frames jumbo dentro de uma VPC sem afetar o tráfego de saída que está saindo da VPC, tente uma das seguintes opções:
Configure o tamanho da MTU por rota.
Use várias interfaces de rede com diferentes tamanhos de MTU e rotas diferentes.
**Casos de uso recomendados para frames jumbo**
Frames jumbo podem ser úteis para tráfego dentro de e entre VPCs. Recomendamos usar frames jumbo para os seguintes casos de uso:
+ Para instâncias posicionadas em um grupo de posicionamento de cluster, os frames jumbo ajudam a alcançar a throughput máxima de rede possível. Para obter mais informações, consulte [Grupos de posicionamento para as instâncias do Amazon EC2](placement-groups.md).
+ É possível usar quadros jumbo para tráfego entre suas VPCs e suas redes on-premises por meio do Direct Connect. Para obter mais informações sobre o uso de Direct Connect e a verificação da capacidade de frames jumbo, consulte [MTU para interfaces virtuais privadas ou interfaces virtuais de trânsito](https://docs.aws.amazon.com/directconnect/latest/UserGuide/WorkingWithVirtualInterfaces.html#set-jumbo-frames-vif.html) no *Guia do usuário do Direct Connect*.
+ Para obter mais informações sobre tamanhos de MTU compatíveis com gateways de trânsito, consulte [Cotas para seus gateways de trânsito](https://docs.aws.amazon.com/vpc/latest/tgw/transit-gateway-quotas.html#mtu-quota) em *Gateways de trânsito da Amazon VPC*.
# Melhorar a performance da rede entre instâncias do EC2 com ENA Express
O ENA Express conta com a tecnologia AWS Scalable Reliable Datagram (SRD). SRD é um protocolo de transporte de rede de alta performance que usa roteamento dinâmico para aumentar o throughput e minimizar a latência final. Com o ENA Express, é possível estabelecer a comunicação entre duas instâncias do EC2 na mesma zona de disponibilidade.
**Benefícios do ENA Express**
+ Aumenta a largura de banda máxima que um fluxo único pode usar de 5 Gbps para até 25 Gbps dentro da zona de disponibilidade, respeitando o limite agregado da instância.
+ Reduz a latência final do tráfego de rede entre instâncias do EC2, especialmente durante períodos de grande carga na rede.
+ Detecta e evita caminhos de rede congestionados.
+ Executa algumas tarefas diretamente na camada da rede, como a reordenação de pacotes na extremidade receptora e a maioria das retransmissões necessárias. Isso libera a camada de aplicação para outros trabalhos.
**nota**
Se a aplicação enviar ou receber um grande volume de pacotes por segundo e precisar otimizar a latência a maioria das vezes, especialmente durante períodos em que não há congestionamento na rede, o [Redes avançadas](enhanced-networking.md) pode ser mais adequado para a sua rede.
O tráfego ENA Express não pode ser enviado numa Zona Local.
Depois que você habilita o ENA Express para a conexão da interface de rede em uma instância, a instância remetente inicia a comunicação com a instância destinatária, e o SRD detecta se o ENA Express está funcionando tanto na instância remetente quanto na instância destinatária. Se o ENA Express estiver operando, a comunicação poderá usar transmissão SRD. Se o ENA Express não estiver operando, a comunicação retornará para a transmissão por ENA padrão.
Durante períodos em que o tráfego de rede é leve, você pode notar um ligeiro aumento na latência de pacote (dezenas de microssegundos) quando o pacote usa o ENA Express. Durante esses períodos, as aplicações que priorizam características específicas de performance de rede podem se beneficiar do ENA Express da seguinte forma:
+ Os processos podem se beneficiar do aumento da largura de banda máxima de fluxo único, de 5 Gbps para até 25 Gbps, dentro da zona de disponibilidade, respeitando o limite agregado da instância. Por exemplo, se um tipo de instância específico for compatível com até 12,5 Gbps, a largura de banda de um único fluxo também será limitada a 12,5 Gbps.
+ Processos mais longos devem ter uma latência de cauda reduzida durante períodos de congestionamento da rede.
+ Os processos podem se beneficiar de uma distribuição mais suave e padrão dos tempos de resposta da rede.
**Topics**
+ [Como o ENA Express funciona](#ena-express-how-it-works)
+ [Tipos de instâncias compatíveis com o ENA Express](#ena-express-supported-instance-types)
+ [Pré-requisitos para instâncias Linux](#ena-express-prereq-linux)
+ [Ajustar a performance das configurações do ENA Express em instâncias do Linux](#ena-express-tune)
+ [Revisar as configurações do ENA Express para instâncias do EC2](ena-express-list-view.md)
+ [Definir as configurações do ENA Express para instâncias do EC2](ena-express-configure.md)
## Como o ENA Express funciona
O ENA Express conta com a tecnologia AWS Scalable Reliable Datagram (SRD). O mecanismo distribui pacotes para cada fluxo de rede em diferentes caminhos de rede da AWS e ajusta dinamicamente a distribuição quando detecta sinais de congestionamento. Ele também gerencia a reordenação de pacotes na extremidade receptora.
Para garantir que o ENA Express possa gerenciar o tráfego de rede conforme previsto, as instâncias de envio e recebimento e a comunicação entre elas devem atender a todos os seguintes requisitos:
+ Os tipos de instâncias de envio e de recebimento são compatíveis. Para obter mais informações, consulte a tabela [Tipos de instâncias compatíveis com o ENA Express](#ena-express-supported-instance-types).
+ As instâncias de envio e de recebimento devem ter o ENA Express configurado. Se houver diferenças na configuração, você pode se deparar com situações em que o tráfego use a transmissão ENA padrão. O cenário a seguir mostra o que pode acontecer.
**Cenário: diferenças na configuração**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AWSEC2/latest/UserGuide/ena-express.html)
Nesse caso, o tráfego TCP entre as duas instâncias pode usar o ENA Express, pois ambas as instâncias o habilitaram. No entanto, como uma das instâncias não usa o ENA Express para tráfego UDP, a comunicação entre essas duas instâncias por UDP usa a transmissão ENA padrão.
+ As instâncias de envio e recebimento devem ser executadas na mesma zona de disponibilidade.
+ O caminho da rede entre as instâncias não deve incluir caixas de middleware. No momento, o ENA Express não é compatível com caixas de middleware.
+ (Somente para instâncias do Linux) Para utilizar todo o potencial da largura de banda, use a versão 2.2.9 ou versões posteriores do driver.
+ (Somente para instâncias do Linux) Para produzir métricas, use a versão 2.8 ou versões posteriores do driver.
Se algum requisito não for atendido, as instâncias usarão o protocolo TCP/UDP padrão, mas sem o SRD para comunicação.
Para garantir que o driver de rede da instância esteja configurado para performance ideal, analise as melhores práticas recomendadas para drivers do ENA. Essas práticas recomendadas também se aplicam ao ENA Express. Para obter mais informações, consulte [ENA Linux Driver Best Practices and Performance Optimization Guide](https://github.com/amzn/amzn-drivers/blob/master/kernel/linux/ena/ENA_Linux_Best_Practices.rst) (Guia de Práticas Recomendadas e Otimização de Performance do Driver) no GitHub.
**nota**
O Amazon EC2 se refere à relação entre uma instância e uma interface de rede que está anexada a ela como um *anexo*. As configurações do ENA Express se aplicam ao anexo. Se a interface de rede for separada da instância, o anexo deixará de existir e as configurações do ENA Express aplicadas a ele não estarão mais em vigor. O mesmo acontece quando uma instância é encerrada, mesmo que a interface de rede permaneça.
Depois de habilitar o ENA Express para os anexos de interface de rede na instância de envio e na instância de recebimento, é possível usar as métricas do ENA Express para ajudar a garantir que as instâncias aproveitem ao máximo as melhorias de performance que a tecnologia SRD oferece. Para obter mais informações sobre as métricas do ENA Express, consulte [Métricas do ENA Express](monitoring-network-performance-ena.md#network-performance-metrics-ena-express).
## Tipos de instâncias compatíveis com o ENA Express
Os tipos de instância a seguir são compatíveis com o ENA Express.
------
#### [ General purpose ]
| Tipo de instância | Arquitetura |
| --- | --- |
| m6a.12xlarge | x86\$164 |
| m6a.16xlarge | x86\$164 |
| m6a.24xlarge | x86\$164 |
| m6a.32xlarge | x86\$164 |
| m6a.48xlarge | x86\$164 |
| m6a.metal | x86\$164 |
| m6i.8xlarge | x86\$164 |
| m6i.12xlarge | x86\$164 |
| m6i.16xlarge | x86\$164 |
| m6i.24xlarge | x86\$164 |
| m6i.32xlarge | x86\$164 |
| m6i.metal | x86\$164 |
| m6id.8xlarge | x86\$164 |
| m6id.12xlarge | x86\$164 |
| m6id.16xlarge | x86\$164 |
| m6id.24xlarge | x86\$164 |
| m6id.32xlarge | x86\$164 |
| m6id.metal | x86\$164 |
| m6idn.8xlarge | x86\$164 |
| m6idn.12xlarge | x86\$164 |
| m6idn.16xlarge | x86\$164 |
| m6idn.24xlarge | x86\$164 |
| m6idn.32xlarge | x86\$164 |
| m6idn.metal | x86\$164 |
| m6in.8xlarge | x86\$164 |
| m6in.12xlarge | x86\$164 |
| m6in.16xlarge | x86\$164 |
| m6in.24xlarge | x86\$164 |
| m6in.32xlarge | x86\$164 |
| m6in.metal | x86\$164 |
| m7a.12xlarge | x86\$164 |
| m7a.16xlarge | x86\$164 |
| m7a.24xlarge | x86\$164 |
| m7a.32xlarge | x86\$164 |
| m7a.48xlarge | x86\$164 |
| m7a.metal-48xl | x86\$164 |
| m7g.12xlarge | arm64 |
| m7g.16xlarge | arm64 |
| m7g.metal | arm64 |
| m7gd.12xlarge | arm64 |
| m7gd.16xlarge | arm64 |
| m7gd.metal | arm64 |
| m7i.12xlarge | x86\$164 |
| m7i.16xlarge | x86\$164 |
| m7i.24xlarge | x86\$164 |
| m7i.48xlarge | x86\$164 |
| m7i.metal-24xl | x86\$164 |
| m7i.metal-48xl | x86\$164 |
| m8a.16xlarge | x86\$164 |
| m8a.24xlarge | x86\$164 |
| m8a.48xlarge | x86\$164 |
| m8a.metal-24xl | x86\$164 |
| m8a.metal-48xl | x86\$164 |
| m8azn.12xlarge | x86\$164 |
| m8azn.24xlarge | x86\$164 |
| m8azn.metal-12xl | x86\$164 |
| m8azn.metal-24xl | x86\$164 |
| m8g.12xlarge | arm64 |
| m8g.16xlarge | arm64 |
| m8g.24xlarge | arm64 |
| m8g.48xlarge | arm64 |
| m8g.metal-24xl | arm64 |
| m8g.metal-48xl | arm64 |
| m8gb.8xlarge | arm64 |
| m8gb.12xlarge | arm64 |
| m8gb.16xlarge | arm64 |
| m8gb.24xlarge | arm64 |
| m8gb.48xlarge | arm64 |
| m8gb.metal-24xl | arm64 |
| m8gb.metal-48xl | arm64 |
| m8gd.12xlarge | arm64 |
| m8gd.16xlarge | arm64 |
| m8gd.24xlarge | arm64 |
| m8gd.48xlarge | arm64 |
| m8gd.metal-24xl | arm64 |
| m8gd.metal-48xl | arm64 |
| m8gn.8xlarge | arm64 |
| m8gn.12xlarge | arm64 |
| m8gn.16xlarge | arm64 |
| m8gn.24xlarge | arm64 |
| m8gn.48xlarge | arm64 |
| m8gn.metal-24xl | arm64 |
| m8gn.metal-48xl | arm64 |
| m8i.24xlarge | x86\$164 |
| m8i.32xlarge | x86\$164 |
| m8i.48xlarge | x86\$164 |
| m8i.96xlarge | x86\$164 |
| m8i.metal-48xl | x86\$164 |
| m8i.metal-96xl | x86\$164 |
| m8id.24xlarge | x86\$164 |
| m8id.32xlarge | x86\$164 |
| m8id.48xlarge | x86\$164 |
| m8id.96xlarge | x86\$164 |
| m8id.metal-48xl | x86\$164 |
| m8id.metal-96xl | x86\$164 |
------
#### [ Compute optimized ]
| Tipo de instância | Arquitetura |
| --- | --- |
| c6a.12xlarge | x86\$164 |
| c6a.16xlarge | x86\$164 |
| c6a.24xlarge | x86\$164 |
| c6a.32xlarge | x86\$164 |
| c6a.48xlarge | x86\$164 |
| c6a.metal | x86\$164 |
| c6gn.4xlarge | arm64 |
| c6gn.8xlarge | arm64 |
| c6gn.12xlarge | arm64 |
| c6gn.16xlarge | arm64 |
| c6i.8xlarge | x86\$164 |
| c6i.12xlarge | x86\$164 |
| c6i.16xlarge | x86\$164 |
| c6i.24xlarge | x86\$164 |
| c6i.32xlarge | x86\$164 |
| c6i.metal | x86\$164 |
| c6id.8xlarge | x86\$164 |
| c6id.12xlarge | x86\$164 |
| c6id.16xlarge | x86\$164 |
| c6id.24xlarge | x86\$164 |
| c6id.32xlarge | x86\$164 |
| c6id.metal | x86\$164 |
| c6in.8xlarge | x86\$164 |
| c6in.12xlarge | x86\$164 |
| c6in.16xlarge | x86\$164 |
| c6in.24xlarge | x86\$164 |
| c6in.32xlarge | x86\$164 |
| c6in.metal | x86\$164 |
| c7a.12xlarge | x86\$164 |
| c7a.16xlarge | x86\$164 |
| c7a.24xlarge | x86\$164 |
| c7a.32xlarge | x86\$164 |
| c7a.48xlarge | x86\$164 |
| c7a.metal-48xl | x86\$164 |
| c7g.12xlarge | arm64 |
| c7g.16xlarge | arm64 |
| c7g.metal | arm64 |
| c7gd.12xlarge | arm64 |
| c7gd.16xlarge | arm64 |
| c7gd.metal | arm64 |
| c7gn.4xlarge | arm64 |
| c7gn.8xlarge | arm64 |
| c7gn.12xlarge | arm64 |
| c7gn.16xlarge | arm64 |
| c7gn.metal | arm64 |
| c7i.12xlarge | x86\$164 |
| c7i.16xlarge | x86\$164 |
| c7i.24xlarge | x86\$164 |
| c7i.48xlarge | x86\$164 |
| c7i.metal-24xl | x86\$164 |
| c7i.metal-48xl | x86\$164 |
| c8a.16xlarge | x86\$164 |
| c8a.24xlarge | x86\$164 |
| c8a.48xlarge | x86\$164 |
| c8a.metal-24xl | x86\$164 |
| c8a.metal-48xl | x86\$164 |
| c8g.12xlarge | arm64 |
| c8g.16xlarge | arm64 |
| c8g.24xlarge | arm64 |
| c8g.48xlarge | arm64 |
| c8g.metal-24xl | arm64 |
| c8g.metal-48xl | arm64 |
| c8gb.8xlarge | arm64 |
| c8gb.12xlarge | arm64 |
| c8gb.16xlarge | arm64 |
| c8gb.24xlarge | arm64 |
| c8gb.48xlarge | arm64 |
| c8gb.metal-24xl | arm64 |
| c8gb.metal-48xl | arm64 |
| c8gd.12xlarge | arm64 |
| c8gd.16xlarge | arm64 |
| c8gd.24xlarge | arm64 |
| c8gd.48xlarge | arm64 |
| c8gd.metal-24xl | arm64 |
| c8gd.metal-48xl | arm64 |
| c8gn.8xlarge | arm64 |
| c8gn.12xlarge | arm64 |
| c8gn.16xlarge | arm64 |
| c8gn.24xlarge | arm64 |
| c8gn.48xlarge | arm64 |
| c8gn.metal-24xl | arm64 |
| c8gn.metal-48xl | arm64 |
| c8i.24xlarge | x86\$164 |
| c8i.32xlarge | x86\$164 |
| c8i.48xlarge | x86\$164 |
| c8i.96xlarge | x86\$164 |
| c8i.metal-48xl | x86\$164 |
| c8i.metal-96xl | x86\$164 |
| c8id.24xlarge | x86\$164 |
| c8id.32xlarge | x86\$164 |
| c8id.48xlarge | x86\$164 |
| c8id.96xlarge | x86\$164 |
| c8id.metal-48xl | x86\$164 |
| c8id.metal-96xl | x86\$164 |
------
#### [ Memory optimized ]
| Tipo de instância | Arquitetura |
| --- | --- |
| r6a.12xlarge | x86\$164 |
| r6a.16xlarge | x86\$164 |
| r6a.24xlarge | x86\$164 |
| r6a.32xlarge | x86\$164 |
| r6a.48xlarge | x86\$164 |
| r6a.metal | x86\$164 |
| r6i.8xlarge | x86\$164 |
| r6i.12xlarge | x86\$164 |
| r6i.16xlarge | x86\$164 |
| r6i.24xlarge | x86\$164 |
| r6i.32xlarge | x86\$164 |
| r6i.metal | x86\$164 |
| r6id.8xlarge | x86\$164 |
| r6id.12xlarge | x86\$164 |
| r6id.16xlarge | x86\$164 |
| r6id.24xlarge | x86\$164 |
| r6id.32xlarge | x86\$164 |
| r6id.metal | x86\$164 |
| r6idn.8xlarge | x86\$164 |
| r6idn.12xlarge | x86\$164 |
| r6idn.16xlarge | x86\$164 |
| r6idn.24xlarge | x86\$164 |
| r6idn.32xlarge | x86\$164 |
| r6idn.metal | x86\$164 |
| r6in.8xlarge | x86\$164 |
| r6in.12xlarge | x86\$164 |
| r6in.16xlarge | x86\$164 |
| r6in.24xlarge | x86\$164 |
| r6in.32xlarge | x86\$164 |
| r6in.metal | x86\$164 |
| r7a.12xlarge | x86\$164 |
| r7a.16xlarge | x86\$164 |
| r7a.24xlarge | x86\$164 |
| r7a.32xlarge | x86\$164 |
| r7a.48xlarge | x86\$164 |
| r7a.metal-48xl | x86\$164 |
| r7g.12xlarge | arm64 |
| r7g.16xlarge | arm64 |
| r7g.metal | arm64 |
| r7gd.12xlarge | arm64 |
| r7gd.16xlarge | arm64 |
| r7gd.metal | arm64 |
| r7i.12xlarge | x86\$164 |
| r7i.16xlarge | x86\$164 |
| r7i.24xlarge | x86\$164 |
| r7i.48xlarge | x86\$164 |
| r7i.metal-24xl | x86\$164 |
| r7i.metal-48xl | x86\$164 |
| r7iz.8xlarge | x86\$164 |
| r7iz.12xlarge | x86\$164 |
| r7iz.16xlarge | x86\$164 |
| r7iz.32xlarge | x86\$164 |
| r7iz.metal-16xl | x86\$164 |
| r7iz.metal-32xl | x86\$164 |
| r8a.16xlarge | x86\$164 |
| r8a.24xlarge | x86\$164 |
| r8a.48xlarge | x86\$164 |
| r8a.metal-24xl | x86\$164 |
| r8a.metal-48xl | x86\$164 |
| r8g.12xlarge | arm64 |
| r8g.16xlarge | arm64 |
| r8g.24xlarge | arm64 |
| r8g.48xlarge | arm64 |
| r8g.metal-24xl | arm64 |
| r8g.metal-48xl | arm64 |
| r8gb.8xlarge | arm64 |
| r8gb.12xlarge | arm64 |
| r8gb.16xlarge | arm64 |
| r8gb.24xlarge | arm64 |
| r8gb.48xlarge | arm64 |
| r8gb.metal-24xl | arm64 |
| r8gb.metal-48xl | arm64 |
| r8gd.12xlarge | arm64 |
| r8gd.16xlarge | arm64 |
| r8gd.24xlarge | arm64 |
| r8gd.48xlarge | arm64 |
| r8gd.metal-24xl | arm64 |
| r8gd.metal-48xl | arm64 |
| r8gn.8xlarge | arm64 |
| r8gn.12xlarge | arm64 |
| r8gn.16xlarge | arm64 |
| r8gn.24xlarge | arm64 |
| r8gn.48xlarge | arm64 |
| r8gn.metal-24xl | arm64 |
| r8gn.metal-48xl | arm64 |
| r8i.24xlarge | x86\$164 |
| r8i.32xlarge | x86\$164 |
| r8i.48xlarge | x86\$164 |
| r8i.96xlarge | x86\$164 |
| r8i.metal-48xl | x86\$164 |
| r8i.metal-96xl | x86\$164 |
| r8id.24xlarge | x86\$164 |
| r8id.32xlarge | x86\$164 |
| r8id.48xlarge | x86\$164 |
| r8id.96xlarge | x86\$164 |
| r8id.metal-48xl | x86\$164 |
| r8id.metal-96xl | x86\$164 |
| u7i-6tb.112xlarge | x86\$164 |
| u7i-8tb.112xlarge | x86\$164 |
| u7i-12tb.224xlarge | x86\$164 |
| u7in-16tb.224xlarge | x86\$164 |
| u7in-24tb.224xlarge | x86\$164 |
| u7in-32tb.224xlarge | x86\$164 |
| u7inh-32tb.480xlarge | x86\$164 |
| x2idn.16xlarge | x86\$164 |
| x2idn.24xlarge | x86\$164 |
| x2idn.32xlarge | x86\$164 |
| x2idn.metal | x86\$164 |
| x2iedn.8xlarge | x86\$164 |
| x2iedn.16xlarge | x86\$164 |
| x2iedn.24xlarge | x86\$164 |
| x2iedn.32xlarge | x86\$164 |
| x2iedn.metal | x86\$164 |
| x8g.12xlarge | arm64 |
| x8g.16xlarge | arm64 |
| x8g.24xlarge | arm64 |
| x8g.48xlarge | arm64 |
| x8g.metal-24xl | arm64 |
| x8g.metal-48xl | arm64 |
| x8aedz.24xlarge | x86\$164 |
| x8aedz.metal-24xl | x86\$164 |
| x8i.24xlarge | x86\$164 |
| x8i.32xlarge | x86\$164 |
| x8i.48xlarge | x86\$164 |
| x8i.64xlarge | x86\$164 |
| x8i.96xlarge | x86\$164 |
| x8i.metal-48xl | x86\$164 |
| x8i.metal-96xl | x86\$164 |
------
#### [ Accelerated computing ]
| Tipo de instância | Arquitetura |
| --- | --- |
| g6.48xlarge | x86\$164 |
| g6e.12xlarge | x86\$164 |
| g6e.24xlarge | x86\$164 |
| g6e.48xlarge | x86\$164 |
| g7e.12xlarge | x86\$164 |
| g7e.24xlarge | x86\$164 |
| g7e.48xlarge | x86\$164 |
| p5.4xlarge | x86\$164 |
| p5.48xlarge | x86\$164 |
| p5e.48xlarge | x86\$164 |
| p5en.48xlarge | x86\$164 |
| p6-b200.48xlarge | x86\$164 |
| p6-b300.48xlarge | x86\$164 |
------
#### [ Storage optimized ]
| Tipo de instância | Arquitetura |
| --- | --- |
| i4g.4xlarge | arm64 |
| i4g.8xlarge | arm64 |
| i4g.16xlarge | arm64 |
| i4i.8xlarge | x86\$164 |
| i4i.12xlarge | x86\$164 |
| i4i.16xlarge | x86\$164 |
| i4i.24xlarge | x86\$164 |
| i4i.32xlarge | x86\$164 |
| i4i.metal | x86\$164 |
| i7i.12xlarge | x86\$164 |
| i7i.16xlarge | x86\$164 |
| i7i.24xlarge | x86\$164 |
| i7i.48xlarge | x86\$164 |
| i7i.metal-24xl | x86\$164 |
| i7i.metal-48xl | x86\$164 |
| i7ie.12xlarge | x86\$164 |
| i7ie.18xlarge | x86\$164 |
| i7ie.24xlarge | x86\$164 |
| i7ie.48xlarge | x86\$164 |
| i7ie.metal-24xl | x86\$164 |
| i7ie.metal-48xl | x86\$164 |
| i8g.12xlarge | arm64 |
| i8g.16xlarge | arm64 |
| i8g.24xlarge | arm64 |
| i8g.48xlarge | arm64 |
| i8g.metal-24xl | arm64 |
| i8g.metal-48xl | arm64 |
| i8ge.12xlarge | arm64 |
| i8ge.18xlarge | arm64 |
| i8ge.24xlarge | arm64 |
| i8ge.48xlarge | arm64 |
| i8ge.metal-24xl | arm64 |
| i8ge.metal-48xl | arm64 |
| im4gn.4xlarge | arm64 |
| im4gn.8xlarge | arm64 |
| im4gn.16xlarge | arm64 |
------
## Pré-requisitos para instâncias Linux
Para garantir que o ENA Express possa operar de forma eficaz, atualize as configurações da instância do Linux, como mostrado a seguir.
+ Se sua instância usar frames jumbo, execute o comando a seguir para definir a unidade máxima de transmissão (MTU) como `8900`.
```
[ec2-user ~]$ sudo ip link set dev eth0 mtu 8900
```
+ Aumente o tamanho do anel do receptor (Rx), da seguinte forma:
```
[ec2-user ~]$ ethtool -G device rx 8192
```
+ Para maximizar a largura de banda do ENA Express, configure seus limites de fila TCP da seguinte forma:
1. Defina o limite de fila pequena do TCP para 1 MB ou mais. Isso aumenta a quantidade de dados enfileirados para transmissão em um soquete.
```
sudo sh -c 'echo 1048576 > /proc/sys/net/ipv4/tcp_limit_output_bytes'
```
1. Desabilite os limites da fila de bytes no enésimo dispositivo se eles estiverem habilitados para sua distribuição Linux. Fazer isso aumenta os dados enfileirados para transmissão para a fila do dispositivo.
```
sudo sh -c 'for txq in /sys/class/net/eth0/queues/tx-*; do echo max > ${txq}/byte_queue_limits/limit_min; done'
```
**nota**
O driver do ENA para a distribuição Amazon Linux desabilita os limites da fila de bytes por padrão.
+ Para minimizar a latência do tráfego TCP do ENA Express, você pode desativar o recurso de autocorking do TCP. Essa alteração pode resultar em um aumento mínimo na sobrecarga de pacotes:
```
sudo bash -c 'echo 0 > /proc/sys/net/ipv4/tcp_autocorking'
```
## Ajustar a performance das configurações do ENA Express em instâncias do Linux
Para verificar a configuração da sua instância Linux a fim de extrair a performance ideal do ENA Express, é possível executar o seguinte script que está disponível no repositório do Amazon GitHub:
[https://github.com/amzn/amzn-ec2-ena-utilities/blob/main/ena-express/check-ena-express-settings.sh](https://github.com/amzn/amzn-ec2-ena-utilities/blob/main/ena-express/check-ena-express-settings.sh)
O script executa uma série de testes e sugere as alterações de configuração recomendadas e necessárias.
# Revisar as configurações do ENA Express para instâncias do EC2
É possível verificar as configurações do ENA Express por instância ou por interface de rede. Para atualizar as configurações do ENA Express, consulte [Definir as configurações do ENA Express para instâncias do EC2](ena-express-configure.md).
------
#### [ Console ]
**Para visualizar as configurações do ENA Express para uma interface de rede**
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 **Network Interfaces** (Interfaces de rede).
1. Selecione uma interface de rede para ver os detalhes dessa instância. É possível escolher o link **Network interface ID** (ID da interface de rede) para abrir a página de detalhes ou pode marcar a caixa de seleção no lado esquerdo da lista para ver os detalhes no painel de detalhes na parte inferior da página.
1. Na seção **Anexo da interface de rede** na guia **Detalhes** ou na página de detalhes, revise as configurações de **ENA Express** e **ENA Express UDP**.
**Para visualizar as configurações do ENA Express para uma instância**
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 à esquerda, selecione **Instâncias**.
1. Selecione uma instância para ver os detalhes dessa instância. É possível escolher o link **Instance ID** (ID da instância) para abrir a página de detalhes ou pode marcar a caixa de seleção no lado esquerdo da lista para ver os detalhes no painel de detalhes na parte inferior da página.
1. Na seção **Network interfaces** (Interfaces de rede) na guia **Networking** (Rede), role para a direita para revisar as configurações do **ENA Express** e do **UDP do ENA Express**.
------
#### [ AWS CLI ]
**Para obter as configurações do ENA Express para uma instância**
Use o comando [https://docs.aws.amazon.com/cli/latest/reference/describe-instances.html](https://docs.aws.amazon.com/cli/latest/reference/describe-instances.html). Esse exemplo de comando retorna uma lista de configurações do ENA Express para as interfaces de rede associadas a cada uma das instâncias em execução especificadas pelo parâmetro `--instance-ids`.
```
aws ec2 describe-instances \
--instance-ids i-1234567890abcdef0 i-0598c7d356eba48d7 \
--query 'Reservations[*].Instances[*].[InstanceId, NetworkInterfaces[*].Attachment.EnaSrdSpecification]'
```
O seguinte é um exemplo de saída.
```
[
[
[
"i-1234567890abcdef0",
[
{
"EnaSrdEnabled": true,
"EnaSrdUdpSpecification": {
"EnaSrdUdpEnabled": false
}
}
]
]
],
[
[
"i-0598c7d356eba48d7",
[
{
"EnaSrdEnabled": true,
"EnaSrdUdpSpecification": {
"EnaSrdUdpEnabled": false
}
}
]
]
]
]
```
**Para obter as configurações do ENA Express para uma interface de rede**
Use o comando [https://docs.aws.amazon.com/cli/latest/reference/describe-network-interfaces.html](https://docs.aws.amazon.com/cli/latest/reference/describe-network-interfaces.html).
```
aws ec2 describe-network-interfaces \
--network-interface-ids eni-1234567890abcdef0 \
--query NetworkInterfaces[].[NetworkInterfaceId,Attachment.EnaSrdSpecification]
```
O seguinte é um exemplo de saída.
```
[
[
"eni-1234567890abcdef0",
{
"EnaSrdEnabled": true,
"EnaSrdUdpSpecification": {
"EnaSrdUdpEnabled": false
}
}
]
]
```
------
#### [ PowerShell ]
**Para obter as configurações do ENA Express para uma interface de rede**
Use o cmdlet [https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2NetworkInterface.html](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2NetworkInterface.html).
```
Get-EC2NetworkInterface `
-NetworkInterfaceId eni-1234567890abcdef0 | `
Select-Object `
Association,
NetworkInterfaceId,
OwnerId,
@{Name = 'AttachTime'; Expression = { $_.Attachment.AttachTime } },
@{Name = 'AttachmentId'; Expression = { $_.Attachment.AttachmentId } },
@{Name = 'DeleteOnTermination'; Expression = { $_.Attachment.DeleteOnTermination } },
@{Name = 'NetworkCardIndex'; Expression = { $_.Attachment.NetworkCardIndex } },
@{Name = 'InstanceId'; Expression = { $_.Attachment.InstanceId } },
@{Name = 'InstanceOwnerId'; Expression = { $_.Attachment.InstanceOwnerId } },
@{Name = 'Status'; Expression = { $_.Attachment.Status } },
@{Name = 'EnaSrdEnabled'; Expression = { $_.Attachment.EnaSrdSpecification.EnaSrdEnabled } },
@{Name = 'EnaSrdUdpEnabled'; Expression = { $_.Attachment.EnaSrdSpecification.EnaSrdUdpSpecification.EnaSrdUdpEnabled } }
```
O seguinte é um exemplo de saída.
```
Association :
NetworkInterfaceId : eni-0d1234e5f6a78901b
OwnerId : 111122223333
AttachTime : 6/11/2022 1:13:11 AM
AttachmentId : eni-attach-0d1234e5f6a78901b
DeleteOnTermination : True
NetworkCardIndex : 0
InstanceId : i-1234567890abcdef0
InstanceOwnerId : 111122223333
Status : attached
EnaSrdEnabled : True
EnaSrdUdpEnabled : False
```
------
# Definir as configurações do ENA Express para instâncias do EC2
É possível configurar o ENA Express para os tipos de instância do EC2 compatíveis sem precisar instalar qualquer software adicional. Para obter mais informações, consulte [Tipos de instâncias compatíveis com o ENA Express](ena-express.md#ena-express-supported-instance-types).
------
#### [ Console ]
**Para gerenciar o ENA Express para uma interface de rede**
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 **Network Interfaces** (Interfaces de rede).
1. Selecione uma interface de rede que é anexada a uma instância. É possível escolher o link **Network interface ID** (ID da interface de rede) para abrir a página de detalhes ou pode marcar a caixa de seleção no lado esquerdo da lista.
1. Escolha **Manage ENA Express** (Gerenciar o ENA Express) no menu **Action** (Ação) no canto superior direito da página. Isso abre a caixa de diálogo **Manage ENA Express** (Gerenciar o ENA Express), com o ID da interface de rede selecionado e as configurações atuais exibidas.
Se a interface de rede selecionada não estiver anexada a uma instância, essa ação não aparecerá no menu.
1. Para usar o **ENA Express**, marque a caixa de seleção **Habilitar**.
1. Quando o ENA Express está habilitado, você pode definir as configurações de UDP. Para usar o **UDP do ENA Express**, marque a caixa de seleção **Habilitar**.
1. Para salvar suas configurações, escolha **Save** (Salvar).
**Para gerenciar o ENA Express para uma instância**
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 à esquerda, selecione **Instâncias**.
1. Selecione a instância que você quer gerenciar. É possível escolher o link **Instance ID** (ID da instância) para abrir a página de detalhes ou pode marcar a caixa de seleção no lado esquerdo da lista.
1. Selecione a **Network interface** (Interface de rede) a ser configurada para sua instância.
1. Escolha **Manage ENA Express** (Gerenciar o ENA Express) no menu **Action** (Ação) no canto superior direito da página.
1. Para configurar o ENA Express para uma interface de rede anexada à instância, selecione-a na lista **Network interface** (Interface de rede).
1. Para usar o **ENA Express** no anexo de interface de rede selecionado, marque a caixa de seleção **Habilitar**.
1. Quando o ENA Express está habilitado, você pode definir as configurações de UDP. Para usar o **UDP do ENA Express**, marque a caixa de seleção **Habilitar**.
1. Para salvar suas configurações, escolha **Save** (Salvar).
**Para configurar o ENA Express ao anexar uma interface de rede**
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 **Network Interfaces** (Interfaces de rede).
1. Selecione uma interface que não esteja anexada a uma instância (o **Status** é **Available** [Disponível]). É possível escolher o link **Network interface ID** (ID da interface de rede) para abrir a página de detalhes ou pode marcar a caixa de seleção no lado esquerdo da lista.
1. Selecione a **Instance** (Instância) à qual você vai anexar.
1. Para usar o **ENA Express** depois de anexar a interface de rede à instância, marque a caixa de seleção **Habilitar**.
1. Quando o ENA Express está habilitado, você pode definir as configurações de UDP. Para usar o **UDP do ENA Express**, marque a caixa de seleção **Habilitar**.
1. Para anexar a interface de rede à instância e salvar as configurações do ENA Express, escolha **Attach** (Anexar).
------
#### [ AWS CLI ]
**Para configurar o ENA Express ao anexar uma interface de rede**
Utilize o comando [https://docs.aws.amazon.com/cli/latest/reference/;attach-network-interface.html](https://docs.aws.amazon.com/cli/latest/reference/;attach-network-interface.html), conforme mostrado nos exemplos a seguir.
**Exemplo 1: usar o ENA Express para tráfego TCP, mas não para tráfego UDP**
Este exemplo configura `EnaSrdEnabled` como `true` e permite que `EnaSrdUdpEnabled` use `false` como padrão.
```
aws ec2 attach-network-interface \
--network-interface-id eni-1234567890abcdef0 \
--instance-id i-1234567890abcdef0 \
--device-index 1 \
--ena-srd-specification 'EnaSrdEnabled=true'
```
**Exemplo 2: usar o ENA Express para tráfego TCP e tráfego UDP**
Este exemplo configura `EnaSrdEnabled` e `EnaSrdUdpEnabled` como `true`.
```
aws ec2 attach-network-interface \
--network-interface-id eni-1234567890abcdef0 \
--instance-id i-1234567890abcdef0 \
--device-index 1 \
--ena-srd-specification 'EnaSrdEnabled=true,EnaSrdUdpSpecification={EnaSrdUdpEnabled=true}'
```
**Para atualizar as configurações do ENA Express para um anexo da interface de rede**
Utilize o comando [https://docs.aws.amazon.com/cli/latest/reference/modify-network-interface-attribute.html](https://docs.aws.amazon.com/cli/latest/reference/modify-network-interface-attribute.html), conforme mostrado nos exemplos a seguir.
**Exemplo 1: usar o ENA Express para tráfego TCP, mas não para tráfego UDP**
Este exemplo configura `EnaSrdEnabled` como `true` e permitirá que `EnaSrdUdpEnabled` use `false` como padrão se ele nunca tiver sido definido antes.
```
aws ec2 modify-network-interface-attribute \
--network-interface-id eni-1234567890abcdef0 \
--ena-srd-specification 'EnaSrdEnabled=true'
```
**Exemplo 2: usar o ENA Express para tráfego TCP e tráfego UDP**
Este exemplo configura `EnaSrdEnabled` e `EnaSrdUdpEnabled` como `true`.
```
aws ec2 modify-network-interface-attribute \
--network-interface-id eni-1234567890abcdef0 \
--ena-srd-specification 'EnaSrdEnabled=true,EnaSrdUdpSpecification={EnaSrdUdpEnabled=true}'
```
**Exemplo 3: parar de usar o ENA Express para tráfego UDP**
Este exemplo configura `EnaSrdUdpEnabled` como `false`.
```
aws ec2 modify-network-interface-attribute \
--network-interface-id eni-1234567890abcdef0 \
--ena-srd-specification 'EnaSrdUdpSpecification={EnaSrdUdpEnabled=false}'
```
------
#### [ PowerShell ]
**Para configurar o ENA Express ao anexar uma interface de rede**
Utilize o cmdlet [https://docs.aws.amazon.com/powershell/latest/reference/items/Add-EC2NetworkInterface.html](https://docs.aws.amazon.com/powershell/latest/reference/items/Add-EC2NetworkInterface.html), conforme mostrado nos exemplos a seguir.
**Exemplo 1: usar o ENA Express para tráfego TCP, mas não para tráfego UDP**
Este exemplo configura `EnaSrdEnabled` como `true` e permite que `EnaSrdUdpEnabled` use `false` como padrão.
```
Add-EC2NetworkInterface `
-NetworkInterfaceId eni-1234567890abcdef0 `
-InstanceId i-1234567890abcdef0 `
-DeviceIndex 1 `
-EnaSrdSpecification_EnaSrdEnabled $true
```
**Exemplo 2: usar o ENA Express para tráfego TCP e tráfego UDP**
Este exemplo configura `EnaSrdEnabled` e `EnaSrdUdpEnabled` como `true`.
```
Add-EC2NetworkInterface `
-NetworkInterfaceId eni-1234567890abcdef0 `
-InstanceId i-1234567890abcdef0 `
-DeviceIndex 1 `
-EnaSrdSpecification_EnaSrdEnabled $true `
-EnaSrdUdpSpecification_EnaSrdUdpEnabled $true
```
**Para configurar o ENA Express para o anexo da interface de rede**
Utilize o cmdlet [https://docs.aws.amazon.com/powershell/latest/reference/items/Edit-EC2NetworkInterfaceAttribute.html](https://docs.aws.amazon.com/powershell/latest/reference/items/Edit-EC2NetworkInterfaceAttribute.html), conforme mostrado nos exemplos a seguir.
**Exemplo 1: usar o ENA Express para tráfego TCP, mas não para tráfego UDP**
Este exemplo configura `EnaSrdEnabled` como `true` e permitirá que `EnaSrdUdpEnabled` use `false` como padrão se ele nunca tiver sido definido antes.
```
Edit-EC2NetworkInterfaceAttribute `
-NetworkInterfaceId eni-1234567890abcdef0 `
-EnaSrdSpecification_EnaSrdEnabled $true ;
Get-EC2NetworkInterface -NetworkInterfaceId eni-0123f4567890a1b23 | `
Select-Object `
NetworkInterfaceId,
@{Name = 'EnaSrdEnabled'; Expression = { $_.Attachment.EnaSrdSpecification.EnaSrdEnabled }},
@{Name = 'EnaSrdUdpEnabled'; Expression = { $_.Attachment.EnaSrdSpecification.EnaSrdUdpSpecification.EnaSrdUdpEnabled }} | `
Format-List
```
**Exemplo 2: usar o ENA Express para tráfego TCP e tráfego UDP**
Este exemplo configura `EnaSrdEnabled` e `EnaSrdUdpEnabled` como `true`.
```
Edit-EC2NetworkInterfaceAttribute `
-NetworkInterfaceId eni-1234567890abcdef0 `
-EnaSrdSpecification_EnaSrdEnabled $true `
-EnaSrdSpecification_EnaSrdUdpSpecification_EnaSrdUdpEnabled $true ;
Get-EC2NetworkInterface -NetworkInterfaceId eni-1234567890abcdef0 | `
Select-Object `
NetworkInterfaceId,
@{Name = 'EnaSrdEnabled'; Expression = { $_.Attachment.EnaSrdSpecification.EnaSrdEnabled }},
@{Name = 'EnaSrdUdpEnabled'; Expression = { $_.Attachment.EnaSrdSpecification.EnaSrdUdpSpecification.EnaSrdUdpEnabled }} | `
Format-List
```
**Exemplo 3: parar de usar o ENA Express para tráfego UDP**
Este exemplo configura `EnaSrdUdpEnabled` como `false`.
```
Edit-EC2NetworkInterfaceAttribute `
-NetworkInterfaceId eni-0123f4567890a1b23 `
-EnaSrdSpecification_EnaSrdUdpSpecification_EnaSrdUdpEnabled $false ;
Get-EC2NetworkInterface -NetworkInterfaceId eni-0123f4567890a1b23 | `
Select-Object `
NetworkInterfaceId,
@{Name = 'EnaSrdEnabled'; Expression = { $_.Attachment.EnaSrdSpecification.EnaSrdEnabled }},
@{Name = 'EnaSrdUdpEnabled'; Expression = { $_.Attachment.EnaSrdSpecification.EnaSrdUdpSpecification.EnaSrdUdpEnabled }} | `
Format-List
```
------
## Configuração do ENA Express na inicialização
É possível usar um dos métodos a seguir para configurar o ENA Express diretamente quando iniciar uma instância. Os links especificados encaminham você para as instruções do Console de gerenciamento da AWS para esses métodos.
+ **Assistente de inicialização de instâncias**: é possível configurar o ENA Express na inicialização com o assistente de inicialização de instâncias. Para obter mais informações, consulte **Configuração avançada de rede** nas [Configurações de rede](ec2-instance-launch-parameters.md#liw-network-settings) para o assistente de inicialização de instâncias.
+ **Modelo de inicialização**: é possível configurar o ENA Express na inicialização ao usar um modelo de inicialização. Para obter mais informações, consulte a página [Criar um modelo de execução do Amazon EC2](create-launch-template.md) e, em seguida, expanda a seção **Configurações de rede** e revise a **Configuração de rede avançada**.
# Habilitar redes aperfeiçoadas com a interface Intel 82599 VF
Para [instâncias baseadas em Xen](instance-types.md#instance-hypervisor-type), a interface Intel 82599 Virtual Function (VF) fornece recursos de redes aperfeiçoadas. A interface usa o driver Intel `ixgbevf`.
As guias a seguir mostram como verificar o driver do adaptador de rede instalado no sistema operacional da instância.
------
#### [ Linux ]
**Driver da interface de rede do Linux**
Use o comando a seguir para verificar se o módulo está sendo usado em uma interface específica, substituindo o nome da interface que você deseja verificar. Se estiver usando uma única interface (padrão), ela será `eth0`. Se o sistema operacional oferecer suporte a [nomes de rede previsíveis](#predictable-network-names-sriov), esse poderá ser um nome como `ens5`.
No exemplo acima, o módulo `ixgbevf` não está carregado porque o driver listado é `vif`.
```
[ec2-user ~]$ ethtool -i eth0
driver: vif
version:
firmware-version:
bus-info: vif-0
supports-statistics: yes
supports-test: no
supports-eeprom-access: no
supports-register-dump: no
supports-priv-flags: no
```
Nesse exemplo, o módulo `ixgbevf` está carregado. Essa instância configurou a rede avançada corretamente.
```
[ec2-user ~]$ ethtool -i eth0
driver: ixgbevf
version: 4.0.3
firmware-version: N/A
bus-info: 0000:00:03.0
supports-statistics: yes
supports-test: yes
supports-eeprom-access: no
supports-register-dump: yes
supports-priv-flags: no
```
------
#### [ Windows ]
**Adaptador de rede do Windows**
Para verificar se o driver está instalado, conecte-se à instância e abra o Gerenciador de dispositivos. Você deve ver `Intel(R) 82599 Virtual Function` listado em **Adaptadores de rede**.
------
**Topics**
+ [Preparar a instância para redes aperfeiçoadas](#ixgbevf-requirements)
+ [Testar se a rede avançada está habilitada](#test-enhanced-networking)
+ [Habilitar redes avançadas na instância](#enable-enhanced-networking)
+ [Solucionar problemas de conectividade](#enhanced-networking-troubleshooting)
## Preparar a instância para redes aperfeiçoadas
Para se preparar para a rede avançada com a interface Intel 82599 VF, configure a instância da seguinte forma:
+ Verifique se o tipo de instância é um dos seguintes: C3, C4, D2, I2, M4 (exceto`m4.16xlarge`) e R3.
+ Verifique se a instância tem conectividade com a Internet.
+ Se houver dados importantes na instância que deseja preservar, você deverá fazer backup desses dados agora criando uma AMI na instância. A atualização de kernels e módulos de kernel e a habilitação do atributo `sriovNetSupport` podem renderizar instâncias incompatíveis ou sistemas operacionais inacessíveis. Se você tiver um backup recente, seus dados ainda serão retidos, caso isso ocorra.
+ **Instâncias do Linux**: inicie a instância usando uma AMI de HVM com a versão 2.6.32 ou com versões posteriores do kernel do Linux. As AMIs HVM do Amazon Linux mais recentes têm os módulos necessários para a rede avançada instalada e também têm os atributos necessários definidos. Portanto, se você executar uma instância compatível com redes avançadas com Amazon EBS que usa uma AMI de HVM do Amazon Linux, a rede avançada já estará habilitada para a instância.
**Atenção**
A rede avançada é compatível apenas com instâncias de HVM. A habilitação da rede avançada com uma instância PV pode torná-la inacessível. A configuração desse atributo sem o módulo ou a versão do módulo adequados também pode tornar a instância inacessível.
+ **Instâncias do Windows**: inicie a instância usando uma AMI de HVM de 64 bits. Não é possível habilitar as redes aperfeiçoadas no Windows Server 2008. A rede avançada já está habilitada para AMIs do Windows Server 2012 R2 e do Windows Server 2016 e posterior. O Windows Server 2012 R2 inclui o driver 1.0.15.3 da Intel e recomendamos atualizar esse driver para a versão mais recente usando o utilitário Pnputil.exe.
+ Use o [AWS CloudShell](https://console.aws.amazon.com/cloudshell) no Console de gerenciamento da AWS ou instale e configure a [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) ou o [AWS Tools for Windows PowerShell](https://docs.aws.amazon.com/powershell/latest/userguide/) em qualquer computador de sua escolha, de preferência em seu desktop local ou notebook. Para obter mais informações sobre o ACM, consulte [Acessar o Amazon EC2](concepts.md#access-ec2) ou o [Guia do usuário do AWS CloudShell](https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html). A rede avançada não pode ser gerenciada no console do Amazon EC2.
## Testar se a rede avançada está habilitada
Verifique se o atributo `sriovNetSupport` está definido na instância ou na imagem.
------
#### [ AWS CLI ]
**Para verificar o atributo de instância (sriovNetSupport)**
Use o seguinte comando [https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-instance-attribute.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-instance-attribute.html): Se o atributo estiver definido, o valor será `simple`.
```
aws ec2 describe-instance-attribute \
--instance-id i-1234567890abcdef0 \
--attribute sriovNetSupport
```
**Para verificar o atributo de imagem (sriovNetSupport)**
Use o seguinte comando [https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-images.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-images.html): Se o atributo estiver definido, o valor será `simple`.
```
aws ec2 describe-images \
--image-id ami-0abcdef1234567890 \
--query "Images[].SriovNetSupport"
```
------
#### [ PowerShell ]
**Para verificar o atributo de instância (sriovNetSupport)**
Use o cmdlet [https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2InstanceAttribute.html](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2InstanceAttribute.html). Se o atributo estiver definido, o valor será `simple`.
```
Get-EC2InstanceAttribute `
-InstanceId i-1234567890abcdef0 `
-Attribute sriovNetSupport
```
**Para verificar o atributo de imagem (sriovNetSupport)**
Use o seguinte comando [https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-images.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-images.html): Se o atributo estiver definido, o valor será `simple`.
```
(Get-EC2Image -ImageId ami-0abcdef1234567890).SriovNetSupport
```
------
## Habilitar redes avançadas na instância
O procedimento usado dependerá do sistema operacional da instância.
**Atenção**
Não há nenhuma maneira de desabilitar o atributo de rede avançada depois de ele ser habilitado.
### Amazon Linux
As AMIs de HVM do Amazon Linux têm o módulo `ixgbevf` necessário para a rede avançada instalado e também têm o atributo necessário `sriovNetSupport` definido. Portanto, se você executar um tipo de instância que use uma AMI de HVM do Amazon Linux, a rede avançada já estará habilitada para a instância. Para obter mais informações, consulte [Testar se a rede avançada está habilitada](#test-enhanced-networking).
Se você executou a instância usando uma AMI do Amazon Linux mais antiga e ela ainda não tiver a rede avançada habilitada, use o seguinte procedimento para habilitar a rede avançada.
**Para habilitar a rede avançada**
1. Conecte-se à sua instância.
1. Na instância, execute o seguinte comando para atualizar a instância com o kernel e os módulos de kernel mais recentes incluindo `ixgbevf`:
```
[ec2-user ~]$ sudo yum update
```
1. A partir do computador local, reinicialize sua instância usando o console do Amazon EC2 ou um dos comandos a seguir: [https://docs.aws.amazon.com/cli/latest/reference/ec2/reboot-instances.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/reboot-instances.html) (AWS CLI) ou [https://docs.aws.amazon.com/powershell/latest/reference/items/Restart-EC2Instance.html](https://docs.aws.amazon.com/powershell/latest/reference/items/Restart-EC2Instance.html) (AWS Tools for Windows PowerShell).
1. Conecte-se à instância novamente e verifique se o módulo `ixgbevf` está instalado e na versão mínima recomendada usando o comando **modinfo ixgbevf** em [Testar se a rede avançada está habilitada](#test-enhanced-networking).
1. [Instância com EBS] A partir do computador local, interrompa a instância usando o console do Amazon EC2 ou um dos seguintes comandos: [https://docs.aws.amazon.com/cli/latest/reference/ec2/stop-instances.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/stop-instances.html) (AWS CLI) ou [https://docs.aws.amazon.com/powershell/latest/reference/items/Stop-EC2Instance.html](https://docs.aws.amazon.com/powershell/latest/reference/items/Stop-EC2Instance.html) (AWS Tools for Windows PowerShell).
[Instância baseada em armazenamento de instâncias] Você não pode parar a instância para modificar o atributo. Em vez disso, pule o próximo procedimento.
1. No computador local, ative o atributo de rede avançada usando um dos seguintes comandos:
------
#### [ AWS CLI ]
Use o comando [https://docs.aws.amazon.com/cli/latest/reference/ec2/modify-instance-attribute.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/modify-instance-attribute.html) da seguinte forma.
```
aws ec2 modify-instance-attribute \
--instance-id i-1234567890abcdef0 \
--sriov-net-support simple
```
------
#### [ PowerShell ]
Use o cmdlet [https://docs.aws.amazon.com/powershell/latest/reference/items/Edit-EC2InstanceAttribute.html](https://docs.aws.amazon.com/powershell/latest/reference/items/Edit-EC2InstanceAttribute.html) conforme mostrado a seguir.
```
Edit-EC2InstanceAttribute `
-InstanceId i-1234567890abcdef0 `
-SriovNetSupport "simple"
```
------
1. (Opcional) Crie uma AMI na instância, conforme descrito em [Criação de uma AMI baseada no Amazon EBS](creating-an-ami-ebs.md). A AMI herda o atributo da rede avançada da instância. Portanto, é possível usar essa AMI para executar outra instância com a rede avançada habilitada por padrão.
1. A partir do computador local, inicie a instância usando o console do Amazon EC2 ou um dos seguintes comandos: [https://docs.aws.amazon.com/cli/latest/reference/ec2/start-instances.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/start-instances.html) (AWS CLI) ou [https://docs.aws.amazon.com/powershell/latest/reference/items/Start-EC2Instance.html](https://docs.aws.amazon.com/powershell/latest/reference/items/Start-EC2Instance.html) (AWS Tools for Windows PowerShell).
1. Conecte-se à instância e verifique se o módulo `ixgbevf` está instalado e carregado na interface de rede usando o comando **ethtool -i eth*n*** em [Testar se a rede avançada está habilitada](#test-enhanced-networking).
**Para habilitar a rede avançada (instâncias compatíveis com o armazenamento de instâncias)**
Siga o procedimento anterior até a etapa onde você para a instância. Crie uma nova AMI como descrito em [Criação de uma AMI baseada no Amazon S3](creating-an-ami-instance-store.md), habilitando o atributo de rede avançada ao registrar a AMI.
------
#### [ AWS CLI ]
Use o comando [https://docs.aws.amazon.com/cli/latest/reference/ec2/register-image.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/register-image.html) da seguinte forma.
```
aws ec2 register-image --sriov-net-support simple ...
```
------
#### [ PowerShell ]
Use [https://docs.aws.amazon.com/powershell/latest/reference/items/Register-EC2Image.html](https://docs.aws.amazon.com/powershell/latest/reference/items/Register-EC2Image.html) da seguinte forma:
```
Register-EC2Image -SriovNetSupport "simple" ...
```
------
### Ubuntu
Antes de começar, o [verifica se a rede avançada já está habilitada](#test-enhanced-networking) em sua instância.
As AMIs do Ubuntu HVM Quick Start incluem os drivers necessários para redes aprimoradas. Se você tiver uma versão de `ixgbevf` anterior a 2.16.4, poderá instalar o `linux-aws` pacote do kernel para obter os drivers de rede aprimorados mais recentes.
O procedimento a seguir fornece as etapas gerais para compilar o módulo `ixgbevf` em uma instância do Ubuntu.
**Para instalar o pacote do kernel `linux-aws`**
1. Conecte-se à sua instância.
1. Atualize o cache de pacotes e os pacotes.
```
ubuntu:~$ sudo apt-get update && sudo apt-get upgrade -y linux-aws
```
**Importante**
Se, durante o processo de atualização, for solicitada a instalação do `grub`, use o `/dev/xvda` para instalar o `grub` e, em seguida, escolha manter a versão atual do `/boot/grub/menu.lst`.
### Outras distribuições do Linux
Antes de começar, o [verifica se a rede avançada já está habilitada](#test-enhanced-networking) em sua instância. As AMIs do HVM Quick Start mais recentes incluem os drivers necessários para rede avançada, portanto, você não precisa executar etapas adicionais.
O procedimento a seguir fornece as etapas gerais se precisar habilitar a rede avançada com a interface Intel 82599 VF em uma distribuição do Linux diferente do Amazon Linux ou do Ubuntu. Para obter mais informações, como a sintaxe detalhada dos comandos, os locais dos arquivos ou suporte para o pacote e a ferramenta, consulte a documentação específica à sua distribuição do Linux.
**Para habilitar a rede avançada no Linux**
1. Conecte-se à sua instância.
1. Faça download da fonte para o módulo `ixgbevf` na instância do Sourceforge em [https://sourceforge.net/projects/e1000/files/ixgbevf%20stable/](https://sourceforge.net/projects/e1000/files/ixgbevf%20stable/).
Versões do `ixgbevf` anteriores à 2.16.4, incluindo a versão 2.14.2, não são compiladas adequadamente em algumas distribuições do Linux, incluindo certas versões do Ubuntu.
1. Compile e instale o módulo `ixgbevf` na instância.
**Atenção**
Se você compilar o módulo `ixgbevf` para o kernel atual e, depois, atualizar o kernel sem recompilar o driver para o novo kernel, o sistema poderá reverter o módulo `ixgbevf` específico à distribuição na próxima reinicialização. Isso poderá tornar o sistema inacessível se a versão específica à distribuição for incompatível com a rede avançada.
1. Execute o comando **sudo depmod** para atualizar as dependências do módulo.
1. Atualize o `initramfs` na instância para garantir que o novo módulo seja carregado na hora da inicialização.
1. Determine se o sistema usa nomes previsíveis de interface de rede por padrão. Os sistemas que usam as versões 197 ou superiores do **systemd** ou **udev** podem renomear dispositivos de Ethernet e não garantem que uma única interface de rede será nomeada `eth0`. Esse comportamento pode causar problemas para conexão à instância. Para mais informações e ver outras opções de configuração, consulte [Nomes previsíveis de interface de rede](https://www.freedesktop.org/wiki/Software/systemd/PredictableNetworkInterfaceNames/) no site freedesktop.org.
1. É possível verificar as versões do **systemd** ou **udev** em sistemas baseados em RPM com o seguinte comando:
```
[ec2-user ~]$ rpm -qa | grep -e '^systemd-[0-9]\+\|^udev-[0-9]\+'
systemd-208-11.el7_0.2.x86_64
```
No exemplo do Red Hat Enterprise Linux 7 acima, a versão do **systemd** é a 208, portanto, os nomes previsíveis de interface de rede devem ser desativados.
1. Desabilite nomes previsíveis de interface de rede adicionando a opção `net.ifnames=0` à linha `GRUB_CMDLINE_LINUX` no `/etc/default/grub`.
```
[ec2-user ~]$ sudo sed -i '/^GRUB\_CMDLINE\_LINUX/s/\"$/\ net\.ifnames\=0\"/' /etc/default/grub
```
1. Recompile o arquivo de configuração do grub.
```
[ec2-user ~]$ sudo grub2-mkconfig -o /boot/grub2/grub.cfg
```
1. [Instância com EBS] A partir do computador local, interrompa a instância usando o console do Amazon EC2 ou um dos seguintes comandos: [stop-instances](https://docs.aws.amazon.com/cli/latest/reference/ec2/stop-instances.html) (AWS CLI) ou [https://docs.aws.amazon.com/powershell/latest/reference/items/Stop-EC2Instance.html](https://docs.aws.amazon.com/powershell/latest/reference/items/Stop-EC2Instance.html) (AWS Tools for Windows PowerShell).
[Instância baseada em armazenamento de instâncias] Você não pode parar a instância para modificar o atributo. Em vez disso, pule o próximo procedimento.
1. No computador local, ative o atributo de rede avançada usando um dos seguintes comandos:
------
#### [ AWS CLI ]
Use o comando [https://docs.aws.amazon.com/cli/latest/reference/ec2/modify-instance-attribute.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/modify-instance-attribute.html) da seguinte forma.
```
aws ec2 modify-instance-attribute \
--instance-id i-1234567890abcdef0 -\
-sriov-net-support simple
```
------
#### [ PowerShell ]
Use o cmdlet [https://docs.aws.amazon.com/powershell/latest/reference/items/Edit-EC2InstanceAttribute.html](https://docs.aws.amazon.com/powershell/latest/reference/items/Edit-EC2InstanceAttribute.html) conforme mostrado a seguir.
```
Edit-EC2InstanceAttribute `
-InstanceId i-1234567890abcdef0 `
-SriovNetSupport "simple"
```
------
1. (Opcional) Crie uma AMI na instância, conforme descrito em [Criação de uma AMI baseada no Amazon EBS](creating-an-ami-ebs.md). A AMI herda o atributo da rede avançada da instância. Portanto, é possível usar essa AMI para executar outra instância com a rede avançada habilitada por padrão.
Se o sistema operacional da instância contiver um arquivo `/etc/udev/rules.d/70-persistent-net.rules`, você deverá excluí-lo antes de criar a AMI. Esse arquivo contém o endereço MAC do adaptador de Ethernet da instância original. Se outra instância for iniciada com esse arquivo, o sistema operacional será incapaz de localizar o dispositivo e o `eth0` poderá falhar causando problemas de inicialização. Esse arquivo é gerado novamente no próximo ciclo de inicialização, e todas as instâncias executadas na AMI criam sua própria versão do arquivo.
1. A partir do computador local, inicie a instância usando o console do Amazon EC2 ou um dos seguintes comandos: [https://docs.aws.amazon.com/cli/latest/reference/ec2/start-instances.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/start-instances.html) (AWS CLI) ou [https://docs.aws.amazon.com/powershell/latest/reference/items/Start-EC2Instance.html](https://docs.aws.amazon.com/powershell/latest/reference/items/Start-EC2Instance.html) (AWS Tools for Windows PowerShell).
1. (Opcional) Conecte-se à instância e verifique se o módulo está instalado.
**Para habilitar as redes avançadas (instâncias compatíveis com o armazenamento de instância)**
Siga o procedimento anterior até a etapa onde você para a instância. Crie uma nova AMI como descrito em [Criação de uma AMI baseada no Amazon S3](creating-an-ami-instance-store.md), habilitando o atributo de rede avançada ao registrar a AMI.
------
#### [ AWS CLI ]
Use o comando [https://docs.aws.amazon.com/cli/latest/reference/ec2/register-image.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/register-image.html) da seguinte forma.
```
aws ec2 register-image --sriov-net-support simple ...
```
------
#### [ PowerShell ]
Use [https://docs.aws.amazon.com/powershell/latest/reference/items/Register-EC2Image.html](https://docs.aws.amazon.com/powershell/latest/reference/items/Register-EC2Image.html) da seguinte forma:
```
Register-EC2Image -SriovNetSupport "simple" ...
```
------
### Windows
Se você executou a instância e ela ainda não tiver a rede avançada habilitada, você deverá fazer download e instalar o driver do adaptador de rede necessário na instância e, em seguida, definir o atributo `sriovNetSupport` da instância para ativar a rede avançada. Você só pode habilitar esse atributo em tipos de instâncias compatíveis. Para obter mais informações, consulte [Redes aperfeiçoadas para instâncias do Amazon EC2](enhanced-networking.md).
**Importante**
Para ver as atualizações de driver mais recentes nas AMIs do Windows, consulte o [histórico de versões da AMI do Windows](https://docs.aws.amazon.com/ec2/latest/windows-ami-reference/ec2-windows-ami-version-history.html) na *Referência da AMI do AWS Windows*.
**Para habilitar a rede avançada**
1. Conecte-se à instância e faça login como administrador local.
1. [Windows Server 2016 e posterior] Execute o seguinte script PowerShell do EC2 Launch para configurar a instância depois de instalar o driver.
```
PS C:\> C:\ProgramData\Amazon\EC2-Windows\Launch\Scripts\InitializeInstance.ps1 -Schedule
```
**Importante**
A senha do administrador será redefinida quando você habilitar o script de inicialização do EC2 da instância. É possível modificar o arquivo de configuração para desabilitar a redefinição da senha do administrador especificando-a nas configurações das tarefas de inicialização.
1. Na instância, faça download do driver do adaptador de rede da Intel para seu sistema operacional:
+ **Windows Server 2022**
Visite a [página de download](https://www.intel.com/content/www/us/en/download/706171/intel-network-adapter-driver-for-windows-server-2022.html) e faça download do `Wired_driver_version_x64.zip`.
+ **Windows Server 2019**, inclusive para a versão de servidor 1809 e posterior\$1
Visite a [página de download](https://www.intel.com/content/www/us/en/download/19372/intel-network-adapter-driver-for-windows-server-2019.html) e faça download do `Wired_driver_version_x64.zip`.
+ **Windows Server 2016**, inclusive para a versão de servidor 1803 e anterior\$1
Visite a [página de download](https://www.intel.com/content/www/us/en/download/18737/intel-network-adapter-driver-for-windows-server-2016.html) e faça download do `Wired_driver_version_x64.zip`.
+ **Windows Server 2012 R2**
Visite a [página de download](https://www.intel.com/content/www/us/en/download/17480/intel-network-adapter-driver-for-windows-server-2012-r2.html) e faça download do `Wired_driver_version_x64.zip`.
+ **Windows Server 2012**
Visite a [página de download](https://www.intel.com/content/www/us/en/download/16789/intel-network-adapter-driver-for-windows-server-2012.html) e faça download do `Wired_driver_version_x64.zip`.
+ **Windows Server 2008 R2**
Visite a [página de download](https://www.intel.com/content/www/us/en/download/15590/intel-network-adapter-driver-for-windows-7-final-release.html) e faça download do `PROWinx64Legacy.exe`.
\$1As versões de servidor 1803 e anteriores, bem como a 1809 e posterior, não são especificamente abordadas nas páginas de Drivers e Software da Intel.
1. Instale o driver do adaptador de rede da Intel para seu sistema operacional:
+ **Windows Server 2008 R2**
1. Na pasta **Downloads**, localize o arquivo `PROWinx64Legacy.exe` e renomeie-o como `PROWinx64Legacy.zip`.
1. Extraia o conteúdo do arquivo `PROWinx64Legacy.zip`.
1. Abra a linha de comando, navegue até a pasta com os arquivos extraídos e execute o comando a seguir a fim de usar o utilitário `pnputil` para adicionar e instalar o arquivo INF no armazenamento de drivers.
```
C:\> pnputil -a PROXGB\Winx64\NDIS62\vxn62x64.inf
```
+ **Windows Server 2022, Windows Server 2019, Windows Server 2016, Windows Server 2012 R2 e Windows Server 2012**
1. Na pasta **Downloads**, extraia o conteúdo do arquivo `Wired_driver_version_x64.zip`.
1. Abra a linha de comando, navegue até a pasta com os arquivos extraídos e execute os comandos a seguir a fim de usar o utilitário `pnputil` para adicionar e instalar o arquivo INF no armazenamento de drivers.
+ Windows Server 2022
```
pnputil -i -a PROXGB\Winx64\NDIS68\vxn68x64.inf
```
+ Windows Server 2019
```
pnputil -i -a PROXGB\Winx64\NDIS68\vxn68x64.inf
```
+ Windows Server 2016
```
pnputil -i -a PROXGB\Winx64\NDIS65\vxn65x64.inf
```
+ Windows Server 2012 R2
```
pnputil -i -a PROXGB\Winx64\NDIS64\vxn64x64.inf
```
+ Windows Server 2012
```
pnputil -i -a PROXGB\Winx64\NDIS63\vxn63x64.inf
```
1. No computador local, ative o atributo de rede avançada usando um dos seguintes comandos:
------
#### [ AWS CLI ]
Use o comando [https://docs.aws.amazon.com/cli/latest/reference/ec2/modify-instance-attribute.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/modify-instance-attribute.html) da seguinte forma.
```
aws ec2 modify-instance-attribute \
--instance-id i-1234567890abcdef0 \
--sriov-net-support simple
```
------
#### [ PowerShell ]
Use o cmdlet [https://docs.aws.amazon.com/powershell/latest/reference/items/Edit-EC2InstanceAttribute.html](https://docs.aws.amazon.com/powershell/latest/reference/items/Edit-EC2InstanceAttribute.html) conforme mostrado a seguir.
```
Edit-EC2InstanceAttribute `
-InstanceId i-1234567890abcdef0 `
-SriovNetSupport "simple"
```
------
1. (Opcional) Crie uma AMI na instância, conforme descrito em [Criação de uma AMI baseada no Amazon EBS](creating-an-ami-ebs.md). A AMI herda o atributo da rede avançada da instância. Portanto, é possível usar essa AMI para executar outra instância com a rede avançada habilitada por padrão.
1. A partir do computador local, inicie a instância usando o console do Amazon EC2 ou um dos seguintes comandos: [https://docs.aws.amazon.com/cli/latest/reference/ec2/start-instances.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/start-instances.html) (AWS CLI) ou [https://docs.aws.amazon.com/powershell/latest/reference/items/Start-EC2Instance.html](https://docs.aws.amazon.com/powershell/latest/reference/items/Start-EC2Instance.html) (AWS Tools for Windows PowerShell).
## Solucionar problemas de conectividade
Se você perder a conectividade ao habilitar a rede avançada, o módulo `ixgbevf` talvez seja incompatível com o kernel. Tente instalar a versão do módulo `ixgbevf` incluída com a distribuição do Linux para a instância.
Se você habilitar a rede avançada para uma instância de PV ou de AMI, poderá tornar a instância inatingível.
Para obter mais informações, consulte [Como faço para ativar e configurar a rede aprimorada em minhas instâncias do EC2?](https://repost.aws/knowledge-center/enable-configure-enhanced-networking)
# Monitorar o desempenho de rede de instâncias do EC2
O driver Elastic Network Adapter (ENA) publica métricas de performance de rede com base nas instâncias em que elas estão habilitadas. É possível usar essas métricas para solucionar problemas de performance da instância, escolher o tamanho certo da instância para uma workload, planejar atividades de dimensionamento proativamente e comparar aplicações para determinar se eles maximizam a performance disponível em uma instância.
O Amazon EC2 define os máximos de rede no nível da instância para garantir uma experiência de rede de alta qualidade, incluindo performance consistente da rede entre tamanhos de instância. A AWS fornece máximos para o seguinte em cada instância:
+ **Capacidade de largura de banda**: cada instância do EC2 tem uma largura de banda máxima para tráfego agregado de entrada e saída, com base no tipo e no tamanho da instância. Algumas instâncias usam um mecanismo de crédito de E/S para alocar a largura de banda da rede com base na utilização média da largura de banda. O Amazon EC2 também tem largura de banda máxima para o tráfego da Direct Connect e da Internet. Para obter mais informações, consulte [Largura de banda de rede de instâncias do Amazon EC2](ec2-instance-network-bandwidth.md).
+ **Performance de pacote por segundo (PPS)**: cada instância do EC2 tem uma performance máxima de PPS, com base no tipo e no tamanho da instância.
+ **Conexões rastreadas**: o grupo de segurança rastreia cada conexão estabelecida para garantir que os pacotes de retorno sejam entregues como esperado. Há um número máximo de conexões que podem ser rastreadas por instância. Para obter mais informações, consulte . [Rastreamento de conexão de grupo de segurança do Amazon EC2](security-group-connection-tracking.md)
+ **Acesso ao serviço de link local**: o Amazon EC2 fornece um PPS máximo por interface de rede para o tráfego de serviços de proxy local, como o serviço Amazon DNS, o serviço de metadados de instância e o Serviço de Sincronização Temporal da Amazon.
Quando o tráfego de rede de uma instância excede um máximo, a AWS formata o tráfego que excede o máximo ao enfileirar e eliminar pacotes de rede. É possível monitorar quando o tráfego excede um máximo usando as métricas de performance de rede. Essas métricas informam sobre o impacto no tráfego da rede e possíveis problemas de performance da rede, em tempo real.
**Topics**
+ [Requisitos](#network-performance-metrics-requirements)
+ [Métricas para o driver ENA](#network-performance-metrics)
+ [Exibir as métricas de performance de rede para sua instância do](#view-network-performance-metrics)
+ [Métricas do ENA Express](#network-performance-metrics-ena-express)
+ [Métricas de performance de rede com o driver DPDK para ENA](#network-performance-metrics-dpdk)
+ [Métricas em instâncias que executam o FreeBSD](#network-performance-metrics-freebsd)
## Requisitos
**Instâncias do Linux**
+ Instale o driver ENA versão 2.2.10 ou posterior. Para verificar a versão instalada, use o comando **ethtool**. No exemplo a seguir, a versão atende ao requisito mínimo.
```
[ec2-user ~]$ ethtool -i eth0 | grep version
version: 2.2.10
```
Para atualizar seu driver ENA, consulte [Redes avançadas](enhanced-networking-ena.md).
+ Para importar essas métricas para o Amazon CloudWatch, instale o agente CloudWatch. Para obter mais informações, consulte [Coletar métricas de performance de rede](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch-Agent-network-performance.html) no *Guia do usuário do Amazon CloudWatch*.
+ Para oferecer suporte à métrica `conntrack_allowance_available`, instale a versão 2.8.1 ou anterior do driver do ENA.
+ Para substituir o limite de PPS de fragmento de saída de 1024, instale o driver do ENA versão 2.13.3 ou posterior.
**Instâncias do Windows**
+ Instalar o driver ENA versão 2.2.2 ou posterior. Para verificar a versão instalada, use o Gerenciador de dispositivos da seguinte forma.
1. Abra o Gerenciador de dispositivos executando `devmgmt.msc`.
1. **Expanda Network Adapters (Adaptadores de rede)**.
1. Escolha **Amazon Elastic Network Adapter **, **Properties (Propriedades)**.
1. Na guia **Driver**, localize **Driver Version (Versão do driver)**.
Para atualizar seu driver ENA, consulte [Redes avançadas](enhanced-networking-ena.md).
+ Para importar essas métricas para o Amazon CloudWatch, instale o agente CloudWatch. Para obter mais informações, consulte [Coletar métricas avançadas de rede](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch-Agent-network-performance.html) no *Guia do usuário do Amazon CloudWatch*.
## Métricas para o driver ENA
O driver ENA entrega as seguintes métricas para a instância em tempo real. Elas fornecem o número cumulativo de pacotes na fila ou descartados em cada interface de rede desde a última restauração do driver.
| Métrica | Descrição | Com suporte para |
| --- | --- | --- |
| bw\$1in\$1allowance\$1exceeded | Número de pacotes na fila ou descartados porque a largura de banda agregada de entrada excedeu o máximo para a instância. | Todos os tipos de instâncias |
| bw\$1out\$1allowance\$1exceeded | Número de pacotes na fila ou descartados porque a largura de banda agregada de saída excedeu o máximo para a instância. | Todos os tipos de instâncias |
| conntrack\$1allowance\$1exceeded | Número de pacotes descartados porque o monitoramento da conexão excedeu o máximo para a instância e não foi possível estabelecer novas conexões. Isso pode resultar em perda de pacotes para tráfego indo para a instância ou vindo da instância | Todos os tipos de instâncias |
| conntrack\$1allowance\$1available | O número de conexões rastreadas que podem ser estabelecidas pela instância antes de atingir a cota de conexões rastreadas desse tipo de instância. | Somente [instâncias baseadas em Nitro](instance-types.md#instance-hypervisor-type) |
| linklocal\$1allowance\$1exceeded | Número de pacotes descartados porque o PPS do tráfego para os serviços de proxy local excedeu o máximo para a interface da rede. Isso afeta o tráfego para o serviço Amazon DNS, o serviço de metadados de instância e o Serviço de Sincronização Temporal da Amazon, mas não afeta o tráfego para resolvedores personalizados de DNS. | Todos os tipos de instâncias |
| pps\$1allowance\$1exceeded | Número de pacotes na fila ou descartados porque o PPS bidirecional excedeu o máximo para a instância.\$1 | Todos os tipos de instâncias |
\$1 Dependendo da configuração do modo proxy de fragmento para o driver do ENA Linux v2.13.3 ou posterior, esse limite também pode incluir descartes de fragmentos de saída que excedem 1024 PPS para a interface de rede. Se o modo de proxy de fragmento estiver habilitado para o driver Linux, as quedas de fragmento de saída ignoram o limite de 1024 PPS normalmente aplicável e são contadas dentro das permissões de PPS padrão. O modo proxy de fragmento está desabilitado por padrão.
## Exibir as métricas de performance de rede para sua instância do
O procedimento usado dependerá do sistema operacional da instância.
### Instâncias do Linux
É possível publicar métricas em suas ferramentas favoritas para visualizar os dados das métricas. Por exemplo, é possível publicar as métricas em Amazon CloudWatch usando o agente CloudWatch. O agente permite que você selecione métricas individuais e controle a publicação.
Também é possível usar o **ethtool** para recuperar as métricas para cada interface de rede, como eth0, conforme mostrado a seguir.
```
[ec2-user ~]$ ethtool -S eth0
bw_in_allowance_exceeded: 0
bw_out_allowance_exceeded: 0
pps_allowance_exceeded: 0
conntrack_allowance_exceeded: 0
linklocal_allowance_exceeded: 0
conntrack_allowance_available: 136812
```
### Instâncias do Windows
É possível visualizar as métricas usando qualquer consumidor de contadores de performance do Windows. Os dados podem ser analisados de acordo com o manifesto EnaperfCounters. Esse é um arquivo XML que define o provedor do contador de performance e seus countersets.
**Para instalar o manifesto**
Se você executou a instância usando uma AMI que contém o driver ENA 2.2.2 ou posterior ou usou o script de instalação no pacote de driver para o driver ENA 2.2.2, o manifesto já está instalado. Para instalar o manifesto manualmente, use as seguintes etapas:
1. Remova o manifesto existente usando o seguinte comando:
```
unlodctr /m:EnaPerfCounters.man
```
1. Copie o arquivo manifesto `EnaPerfCounters.man` do pacote de instalação do driver para `%SystemRoot%\System32\drivers`.
1. Instale o novo manifesto usando o seguinte comando:
```
lodctr /m:EnaPerfCounters.man
```
**Para visualizar métricas usando o monitor de desempenho**
1. Abra o Monitor de performance.
1. Pressione Ctrl\$1N para adicionar novos contadores.
1. Escolha **ENA Packets Shaping (Modelagem de pacotes de ENA** na lista.
1. Selecione as instâncias a serem monitoradas e escolha **Add (Adicionar)**.
1. Escolha **OK**.
## Métricas do ENA Express
O ENA Express conta com a tecnologia AWS Scalable Reliable Datagram (SRD). SRD é um protocolo de transporte de rede de alta performance que usa roteamento dinâmico para aumentar o throughput e minimizar a latência final. Se você tiver habilitado o ENA Express para as anexos de interface de rede na instância de envio e na instância de recebimento, poderá usar as métricas do ENA Express para ajudar a garantir que as instâncias aproveitem ao máximo as melhorias de desempenho que a tecnologia SRD oferece. Por exemplo:
+ Avalie os recursos para garantir que tenham capacidade suficiente para estabelecer mais conexões por SRD.
+ Identifique onde existem potenciais problemas que impedem que pacotes de saída elegíveis usem o SRD.
+ Calcule a porcentagem de tráfego de saída que usa SRD para a instância.
+ Calcule a porcentagem de tráfego de entrada que usa SRD para a instância.
**nota**
Para produzir métricas, use a versão 2.8 ou superior do driver.
Para ver uma lista de métricas para instâncias do Linux filtradas para o ENA Express, execute o comando **ethtool** a seguir para a interface de rede (mostrado aqui como `eth0`). Anote o valor da métrica `ena_srd_mode`.
```
[ec2-user ~]$ ethtool -S eth0 | grep ena_srd
NIC statistics:
ena_srd_mode: 1
ena_srd_tx_pkts: 0
ena_srd_eligible_tx_pkts: 0
ena_srd_rx_pkts: 0
ena_srd_resource_utilization: 0
```
As métricas a seguir estão disponíveis para todas as instâncias que têm o ENA Express habilitado.
**ena\$1srd\$1mode**
Descreve quais recursos do ENA Express estão habilitados. Os valores são os seguintes:
+ `0` = ENA Express desativado, UDP desativado
+ `1` = ENA Express ativado, UDP desativado
+ `2` = ENA Express desativado, UDP ativado
**nota**
Isso só acontece quando o ENA Express foi originalmente habilitado e o UDP foi configurado para usá-lo. O valor anterior é retido para tráfego UDP.
+ `3` = ENA Express ativado, UDP ativado
**ena\$1srd\$1eligible\$1tx\$1pkts**
O número de redes é o seguinte:
+ Os tipos de instâncias de envio e de recebimento são compatíveis. Para obter mais informações, consulte a tabela [Tipos de instâncias compatíveis com o ENA Express](ena-express.md#ena-express-supported-instance-types).
+ As instâncias de envio e de recebimento devem ter o ENA Express configurado.
+ As instâncias de envio e recebimento devem ser executadas na mesma zona de disponibilidade.
+ O caminho da rede entre as instâncias não deve incluir caixas de middleware. No momento, o ENA Express não é compatível com caixas de middleware.
A métrica de elegibilidade do ENA Express abrange os requisitos de origem e destino e a rede entre os dois endpoints. Pacotes elegíveis ainda podem ser desqualificados depois de já terem sido contados. Por exemplo, se um pacote elegível estiver acima do limite da unidade de transmissão máxima (MTU), ele retornará para a transmissão ENA padrão, embora o pacote ainda apareça como elegível no contador.
**ena\$1srd\$1tx\$1pkts**
O número de pacotes de SRD transmitidos em um determinado período.
**ena\$1srd\$1rx\$1pkts**
O número de pacotes de SRD recebidos em um determinado período.
**ena\$1srd\$1resource\$1utilization**
A porcentagem da utilização da memória máxima permitida para conexões por SRD simultâneas que a instância consumiu.
Para confirmar se a transmissão de pacotes está usando SRD, você pode comparar o número de pacotes elegíveis (métrica `ena_srd_eligible_tx_pkts`) com o número de pacotes por SRD transmitidos (métrica `ena_srd_tx_pkts`) durante um determinado período.
**Tráfego de saída (pacotes de saída)**
Para garantir que o tráfego de saída use SRD conforme esperado, compare o número de pacotes elegíveis para SRD (`ena_srd_eligible_tx_pkts`) com o número de pacotes SRD enviados (`ena_srd_tx_pkts`) em um determinado período.
Diferenças significativas entre o número de pacotes elegíveis e o número de pacotes SRD enviados geralmente são causadas por problemas de utilização de recursos. Quando a placa de rede anexada à instância esgota seus recursos máximos ou seus pacotes estão acima do limite de MTU, os pacotes elegíveis não podem ser transmitidos por SRD e devem retornar à transmissão ENA padrão. Os pacotes também podem apresentar essa diferença durante as migrações em tempo real ou as atualizações de servidores em tempo real. É necessária uma avaliação adicional para determinar a causa raiz.
**nota**
Você pode ignorar pequenas diferenças ocasionais entre o número de pacotes elegíveis e o número de pacotes SRD. Isso pode acontecer quando a instância estabelece uma conexão com outra instância para tráfego SRD, por exemplo.
Para descobrir qual porcentagem do tráfego total de saída em um determinado período usa SRD, compare o número de pacotes SRD enviados (`ena_srd_tx_pkts`) com o número total de pacotes enviados para a instância (`NetworkPacketOut`) durante esse período.
**Tráfego de entrada (pacotes recebidos)**
Para descobrir qual porcentagem do tráfego de entrada usa SRD, compare o número de pacotes SRD recebidos (`ena_srd_rx_pkts`) em um determinado período com o número total de pacotes recebidos para a instância (`NetworkPacketIn`) durante esse período.
**Utilização de recursos**
A utilização de recursos é baseada no número de conexões SRD simultâneas que uma única instância pode manter em um determinado momento. A métrica de utilização de recursos (`ena_srd_resource_utilization`) monitora a utilização atual da instância. À medida que a utilização se aproxima de 100%, você pode esperar problemas de performance. O ENA Express deixa de usar SRD e volta à transmissão ENA padrão, e a possibilidade de pacotes descartados aumenta. A alta utilização de recursos é um sinal de que está na hora de aumentar a escala da instância horizontalmente para melhorar a performance da rede.
**nota**
Quando o tráfego de rede de uma instância excede um máximo, a AWS formata o tráfego que excede o máximo ao enfileirar e eliminar pacotes de rede.
**Persistência**
As métricas de saída e entrada são cumulativas enquanto o ENA Express está habilitado para a instância. As métricas deixarão de ser acumulativas se o ENA Express for desativado, mas persistirão enquanto a instância ainda estiver em execução. As métricas serão redefinidas se a instância for reinicializada ou encerrada ou se a interface de rede for desconectada da instância.
## Métricas de performance de rede com o driver DPDK para ENA
O driver ENA versão 2.2.0 e posterior oferece suporte a relatórios de métricas de rede. O DPDK 20.11 inclui o driver ENA 2.2.0 e é a primeira versão do DPDK a suportar esse recurso.
O driver DPDK v25.03 ou posterior oferece suporte ao modo de proxy de fragmento. Se o modo de proxy de fragmento estiver habilitado para o driver DPDK, os descartes de fragmentos de saída ignoram o limite de 1024 PPS normalmente aplicável e são contados dentro das permissões de PPS padrão. O modo proxy de fragmento está desabilitado por padrão.
É possível usar uma aplicação de exemplo para visualizar estatísticas DPDK. Para iniciar uma versão interativa da aplicação de exemplo, execute o seguinte comando.
```
./app/dpdk-testpmd -- -i
```
Dentro desta sessão interativa, é possível inserir um comando para recuperar dados estatísticos estendidos para uma porta. O comando de exemplo a seguir recupera as estatísticas da porta 0.
```
show port xstats 0
```
Veja a seguir um exemplo de uma sessão interativa com a aplicação de exemplo DPDK.
```
[root@ip-192.0.2.0 build]# ./app/dpdk-testpmd -- -i
EAL: Detected 4 lcore(s)
EAL: Detected 1 NUMA nodes
EAL: Multi-process socket /var/run/dpdk/rte/mp_socket
EAL: Selected IOVA mode 'PA'
EAL: Probing VFIO support...
EAL: Invalid NUMA socket, default to 0
EAL: Invalid NUMA socket, default to 0
EAL: Probe PCI driver: net_ena (1d0f:ec20) device: 0000:00:06.0
(socket 0)
EAL: No legacy callbacks, legacy socket not created
Interactive-mode selected
Port 0: link state change event
testpmd: create a new mbuf pool : n=171456,
size=2176, socket=0
testpmd: preferred mempool ops selected: ring_mp_mc
Warning! port-topology=paired and odd forward ports number, the
last port will pair with itself.
Configuring Port 0 (socket 0)
Port 0: 02:C7:17:A2:60:B1
Checking link statuses...
Done
Error during enabling promiscuous mode for port 0: Operation
not supported - ignore
testpmd> show port xstats 0
###### NIC extended statistics for port 0
rx_good_packets: 0
tx_good_packets: 0
rx_good_bytes: 0
tx_good_bytes: 0
rx_missed_errors: 0
rx_errors: 0
tx_errors: 0
rx_mbuf_allocation_errors: 0
rx_q0_packets: 0
rx_q0_bytes: 0
rx_q0_errors: 0
tx_q0_packets: 0
tx_q0_bytes: 0
wd_expired: 0
dev_start: 1
dev_stop: 0
tx_drops: 0
bw_in_allowance_exceeded: 0
bw_out_allowance_exceeded: 0
pps_allowance_exceeded: 0
conntrack_allowance_exceeded: 0
linklocal_allowance_exceeded: 0
rx_q0_cnt: 0
rx_q0_bytes: 0
rx_q0_refill_partial: 0
rx_q0_bad_csum: 0
rx_q0_mbuf_alloc_fail: 0
rx_q0_bad_desc_num: 0
rx_q0_bad_req_id: 0
tx_q0_cnt: 0
tx_q0_bytes: 0
tx_q0_prepare_ctx_err: 0
tx_q0_linearize: 0
tx_q0_linearize_failed: 0
tx_q0_tx_poll: 0
tx_q0_doorbells: 0
tx_q0_bad_req_id: 0
tx_q0_available_desc: 1023
testpmd>
```
Para obter mais informações sobre a aplicação de exemplo e usá-lo para recuperar dados estatísticos estendidos, consulte [Guia do usuário da aplicação Testpmd](https://doc.dpdk.org/guides/testpmd_app_ug/) na documentação do DPDK.
## Métricas em instâncias que executam o FreeBSD
A partir da versão 2.3.0, o driver ENA FreeBSD suporta a coleta de métricas de performance de rede em instâncias que executam o FreeBSD. Para habilitar a coleção de métricas do FreeBSD, insira o seguinte comando e defina o *intervalo* como um valor entre 1 e 3.600. Isso especifica com que frequência, em segundos, serão coletadas métricas do FreeBSD.
```
sysctl dev.ena.network_interface.eni_metrics.sample_interval=interval
```
Por exemplo, o comando a seguir define o driver para coletar métricas do FreeBSD na interface de rede 1 a cada 10 segundos:
```
sysctl dev.ena.1.eni_metrics.sample_interval=10
```
Para desativar a coleta de métricas do FreeBSD, é possível executar o comando anterior e especificar `0` como o *intervalo*.
Depois de habilitar a coleta de métricas do FreeBSD, é possível recuperar o conjunto mais recente de métricas coletadas ao executar o comando apresentado a seguir.
```
sysctl dev.ena.network_interface.eni_metrics
```
# Aprimorar a latência de rede para instâncias do EC2 baseadas no Linux
A latência de rede corresponde à quantidade de tempo que um pacote de dados demora para se deslocar da origem até o destino. As aplicações que enviam dados pela rede dependem de respostas em tempo hábil para fornecer uma experiência positiva ao usuário. A alta latência de rede pode acarretar diversos problemas, como os seguintes:
+ Tempos de carregamento lentos para páginas da Web.
+ Atraso na transmissão de vídeo.
+ Dificuldade de acesso aos recursos online.
Esta seção descreve as etapas que podem ser seguidas para aprimorar a latência de rede em instâncias do Amazon EC2 executadas em Linux. Para obter a latência ideal, siga estas etapas para definir as configurações de sua instância, kernel e driver ENA. Para obter orientação de configurações adicionais, consulte o [Guia de práticas recomendadas e otimização de performance para o driver ENA do Linux](https://github.com/amzn/amzn-drivers/blob/master/kernel/linux/ena/ENA_Linux_Best_Practices.rst) no GitHub.
**nota**
As etapas e configurações podem variar um pouco, dependendo do hardware de rede específico, da AMI da qual você executou a instância e do caso de uso da aplicação. Antes de realizar qualquer alteração, teste e monitore minuciosamente a performance da rede para garantir que esteja obtendo os resultados desejados.
## Reduzir o número de saltos de rede para pacotes de dados
Cada salto que um pacote de dados tem ao se mover de um roteador para outro aumenta a latência da rede. Normalmente, o tráfego passa por diversos saltos para chegar ao seu destino. Há duas maneiras de reduzir os saltos de rede para as instâncias do Amazon EC2, conforme apresentado a seguir:
+ **Grupo com posicionamento em cluster**: ao especificar um [grupo com posicionamento em cluster](placement-strategies.md#placement-groups-cluster), o Amazon EC2 executa instâncias que estão com grande proximidade umas das outras, fisicamente na mesma zona de disponibilidade (AZ) comempacotamento mais restrito. A proximidade física das instâncias no grupo permite que elas aproveitem a conectividade de alta velocidade, resultando em baixa latência e alta throughput de fluxo único.
+ **Host dedicado**: um [host dedicado](dedicated-hosts-overview.md) é um servidor físico dedicado para seu uso. Com um host dedicado, é possível executar as instâncias no mesmo servidor físico. A comunicação entre instâncias executada no mesmo host dedicado pode ocorrer sem nenhum salto extra de rede.
## Como a configuração do kernel do Linux afeta a latência
A configuração do kernel do Linux pode aumentar ou diminuir a latência da rede. Para atingir suas metas de otimização de latência, é importante ajustar a configuração do kernel do Linux de acordo com os requisitos específicos de sua workload.
Existem várias opções de configuração para o kernel do Linux que podem ajudar a diminuir a latência da rede. As opções mais impactantes são as seguintes.
+ **Ativação do modo de pesquisa ocupada**: o modo de pesquisa ocupada reduz a latência no caminho de recebimento da rede. Ao ativar o modo de pesquisa ocupada, o código da camada de soquete pode pesquisar diretamente a fila de recebimento de um dispositivo de rede. A desvantagem de uma sondagem ocupada é o maior uso da CPU no host, resultante da sondagem de novos dados em um ciclo restrito. Há duas configurações globais que controlam o número de microssegundos para aguardar os pacotes para todas as interfaces.
`busy_read`
Um tempo limite de sondagem ocupada de baixa latência para leituras de soquete. Ele controla o número de microssegundos a aguardar para camada de soquete ler os pacotes na fila de dispositivos. Para habilitar o recurso globalmente com o comando **sysctl**, a organização Linux Kernel recomenda um valor de 50 microssegundos. Para obter mais informações, consulte [busy\$1read](https://www.kernel.org/doc/html/v5.19/admin-guide/sysctl/net.html?highlight=busy_read) no *Guia do usuário e do administrador do kernel doo Linux*.
```
[ec2-user ~]$ sudo sysctl -w net.core.busy_read=50
```
`busy_poll`
Um tempo limite de sondagem ocupada de baixa latência para sondagem e seleção. Isso controla o número de microssegundos a aguardar por eventos. O valor recomendado está entre 50-100 microssegundos, dependendo do número de soquetes que você estiver sondando. Quanto mais soquetes você adicionar, maior deve ser o número.
```
[ec2-user ~]$ sudo sysctl -w net.core.busy_poll=50
```
+ **Configuração dos estados de energia da CPU (C-states)**: os C-states controlam os níveis de suspensão em que um núcleo pode entrar quando está inativo. Você pode desejar controlar os C-states para ajustar o sistema em relação à latência versus performance. Em estados C mais profundos, a CPU está essencialmente “adormecida” e não poderá responder às solicitações até acordar e fazer a transição de volta ao estado ativo. Desativar núcleos leva tempo e, embora um núcleo desativado forneça mais espaço para um núcleo funcionar em uma frequência mais alta, leva tempo para que esse núcleo desativado seja reativado e execute o trabalho.
Por exemplo, se um núcleo que receber a tarefa de lidar com interrupções de pacotes da Internet estiver desativado, poderá ocorrer um atraso em lidar com essa interrupção. É possível configurar o sistema para que ele não use estados C mais profundos. No entanto, embora essa configuração reduza a latência de reação do processador, ela também reduz o espaço disponível para outros núcleos para o Turbo Boost.
Para reduzir a latência de reação do processador, é possível limitar mais profundamente os C-states. Para obter mais informações, consulte [High performance and low latency by limiting deeper C-states](https://docs.aws.amazon.com/linux/al2/ug/processor_state_control.html#c-states) no *Amazon Linux 2 User Guide*.
## Moderação de interrupção
O driver de rede ENA possibilita a comunicação entre uma instância e uma rede. O driver processa os pacotes de rede e os repassa à pilha de rede ou ao cartão Nitro. Quando um pacote de rede chega, o cartão Nitro gera uma interrupção para a CPU notificar o software sobre um evento.
Interromper
Uma interrupção é um sinal que um dispositivo ou aplicação envia ao processador. A interrupção informa ao processador que ocorreu um evento ou que foi atendida uma condição que requer atenção imediata. As interrupções podem lidar com tarefas urgentes, como receber dados de uma interface de rede, lidar com eventos de hardware ou atender a solicitações de outros dispositivos.
Moderação de interrupção
A moderação de interrupções é uma técnica que reduz o número de interrupções que um dispositivo gera agregando ou atrasando-as. O objetivo da moderação de interrupções é melhorar o desempenho do sistema, reduzindo a sobrecarga associada ao tratamento de um grande número de interrupções. Interrupções demais aumentam o uso da CPU, afetando negativamente a throughput, enquanto poucas interrupções aumentam a latência.
Moderação dinâmico de interrupções
A moderação dinâmica de interrupções é uma forma aprimorada de moderação de interrupção que ajusta dinamicamente a taxa de interrupções com base nos padrões atuais de carga e tráfego do sistema. O objetivo é encontrar um equilíbrio entre reduzir a sobrecarga de interrupções e os pacotes por segundo, ou a largura de banda.
A moderação dinâmica de interrupções é habilitada por padrão em algumas AMIs (mas pode ser habilitada ou desabilitada em todas as AMIs).
Para minimizar a latência da rede, pode ser necessário desabilitar a moderação de interrupções. No entanto, isso também pode aumentar a sobrecarga do processamento de interrupção. É importante descobrir o balanceamento adequado entre reduzir a latência e minimizar a sobrecarga. Os comandos `ethtool` podem ajudar você a configurar a moderação de interrupção. Por padrão, `rx-usecs` está definido como `20` e `tx-usecs` está definido como `64`.
Para obter a configuração de modificação de interrupção atual, use o comando a seguir.
```
[ec2-user ~]$ ethtool -c interface | egrep "rx-usecs:|tx-usecs:|Adaptive RX"
Adaptive RX: on TX: off
rx-usecs: 20
tx-usecs: 64
```
Para desativar a modificação de interrupções, use o comando a seguir.
```
[ec2-user ~]$ sudo ethtool -C interface adaptive-rx off rx-usecs 0 tx-usecs 0
```
# Considerações sobre o Nitro System para ajuste de performance
O Sistema Nitro é uma coleção de hardware e componentes de software desenvolvidos pela AWS que permitem alta performance, alta disponibilidade e alta segurança. O Nitro System fornece funcionalidades semelhantes às funcionalidades do bare metal que eliminam a sobrecarga de virtualização e são compatíveis com workloads que requerem acesso total ao hardware de host. Para obter informações mais detalhadas, consulte [AWS Nitro System](https://aws.amazon.com/ec2/nitro/).
Todos os tipos de instância do EC2 da geração atual executam o processamento de pacotes de rede em cartões Nitro do EC2. Este tópico aborda a manipulação de pacotes de alto nível no cartão Nitro, os aspectos conhecidos da arquitetura e da configuração de rede que afetam a performance da manipulação de pacotes e as ações você pode executar para atingir a performance máxima para as instâncias baseadas no Nitro.
Os cartões Nitro lidam com todas as interfaces de entrada e saída (E/S), como aquelas necessárias para as nuvens privadas virtuais (VPCs). Para todos os componentes que enviam ou recebem informações pela rede, os cartões Nitro atuam como um dispositivo de computação independente para o tráfego de E/S que é fisicamente separado da placa principal do sistema na qual as workloads do cliente são executadas.
## Fluxo de pacotes de rede em cartões Nitro
As instâncias do EC2 desenvolvidas no Nitro System têm funcionalidades de aceleração de hardware que facilitam um processamento de pacotes mais rápido, conforme medido pelas taxas de throughput de pacotes por segundo (PPS). Quando um cartão Nitro executa a avaliação inicial para um novo fluxo, ele salva informações semelhantes para todos os pacotes no fluxo, como os grupos de segurança, as listas de controle de acesso e as entradas da tabela de rotas. Ao processar pacotes adicionais para o mesmo fluxo, ele pode usar as informações salvas para reduzir a sobrecarga desses pacotes.
A taxa de conexão é medida pela métrica de conexões por segundo (CPS). Cada nova conexão requer uma sobrecarga de processamento adicional que deve ser considerada nas estimativas de capacidade para a workload. É importante considerar as métricas de CPS e de PPS ao projetar as workloads.
**Como uma conexão é estabelecida**
Quando uma conexão é estabelecida entre uma instância baseada no Nitro e outro endpoint, o cartão Nitro avalia o fluxo completo do primeiro pacote enviado ou recebido entre os dois endpoints. Em geral não é necessária uma reavaliação completa para pacotes subsequentes do mesmo fluxo. No entanto, existem exceções. Para obter mais informações sobre as exceções, consulte [Pacotes que não usam a aceleração de hardware](#ena-nitro-perf-exceptions).
As propriedades apresentadas a seguir definem os dois endpoints e o fluxo de pacotes entre eles. Essas cinco propriedades em conjunto são conhecidas como um fluxo de cinco tuplas.
+ IP de origem
+ Porta de origem
+ IP de destino
+ Porta de destino
+ Protocolo de comunicação
A direção do fluxo de pacotes é conhecida como *ingress* (entrada) e *egress* (saída). As descrições de alto nível apresentadas a seguir resumem o fluxo de pacotes de rede de ponta a ponta.
+ **Ingress**: quando um cartão Nitro lida com um pacote de rede de entrada, ele avalia o pacote em relação a regras de firewall com estado e a listas de controle de acesso. Ele rastreia a conexão, realiza a medição dela e executa outras ações, conforme aplicável. Em seguida, ele encaminha o pacote ao destino na CPU de host.
+ **Egress**: quando um cartão Nitro lida com um pacote de rede de saída, ele procura o destino da interface remota, avalia diversas funções da VPC, aplica limites de taxa e executa outras ações aplicáveis. Em seguida, ele encaminha o pacote para o destino do próximo salto na rede.
## Projetar sua rede para desempenho ideal
Para aproveitar as funcionalidades de performance do Nitro System, é necessário compreender quais são as suas necessidades de processamento de rede e como elas afetam a workload dos seus recursos do Nitro. Em seguida, será possível realizar um projeto para obtenção de uma performance ideal para seu cenário de rede. As definições de infraestrutura, design e configuração da workload da aplicação podem afetar o processamento de pacotes e as taxas de conexão. Por exemplo, se a aplicação tiver uma alta taxa de estabelecimento de conexão, como um serviço de DNS, um firewall ou um roteador virtual, ela terá menos oportunidades de aproveitar a aceleração de hardware que ocorre somente após o estabelecimento da conexão.
É possível definir as configurações da aplicação e da infraestrutura para simplificar as workloads e aprimorar a performance da rede. No entanto, nem todos os pacotes que estão qualificados para a aceleração. O Nitro System utiliza todo o fluxo de rede para novas conexões e para pacotes que não estão qualificados para a aceleração.
O restante desta seção se concentrará nas considerações de projeto para a aplicação e para a infraestrutura com a finalidade de ajudar a garantir que os pacotes fluam dentro do caminho com aceleração, tanto quanto possível.
### Considerações de projeto de rede para o Nitro System
Ao configurar o tráfego de rede para a instância, existem muitos aspectos a serem considerados que podem afetar a performance de PPS. Depois que um fluxo é estabelecido, a maioria dos pacotes que entram ou saem regularmente está qualificado para a aceleração. No entanto, existem exceções para garantir que os projetos de infraestrutura e os fluxos de pacotes continuem atendendo aos padrões dos protocolos.
Para obter a melhor performance do cartão Nitro, é necessário considerar com atenção os prós e os contras dos detalhes de configuração apresentados a seguir para a infraestrutura e para as aplicações.
#### Considerações sobre infraestrutura
A configuração da infraestrutura pode afetar o fluxo de pacotes e a eficiência do processamento. A lista apresentada a seguir inclui algumas considerações importantes.
**Configuração da interface de rede com assimetria**
Os grupos de segurança usam o rastreamento de conexão para rastrear informações sobre o tráfego que flui de e para a instância. O roteamento assimétrico, em que o tráfego entra em uma instância por meio de uma interface de rede e sai por meio de uma interface de rede diferente, pode reduzir a performance máxima que uma instância poderá alcançar se os fluxos forem rastreados. Para obter mais informações sobre o rastreamento de conexões para grupos de segurança, conexões não rastreadas e conexões rastreadas automaticamente, consulte [Rastreamento de conexão de grupo de segurança do Amazon EC2](security-group-connection-tracking.md).
**Drivers de rede**
Os drivers de rede são atualizados e lançados regularmente. A performance poderá ser significativamente prejudicada se os drivers estiverem desatualizados. Mantenha os drivers atualizados para garantir que você tenha os patches mais recentes e possa aproveitar as vantagens fornecidas pelos aprimoramentos de performance, como o recurso de caminho com aceleração que está disponível somente para a última geração de drivers. Os drivers anteriores não são compatíveis com o recurso de caminho com aceleração.
Para aproveitar o recurso de caminho com aceleração, recomendamos instalar o driver do ENA mais recente nas instâncias.
**Instâncias do Linux**: driver do ENA para o Linux na versão 2.2.9 ou em versões posteriores. Para instalar ou atualizar o driver do ENA para Linux usando o repositório Amazon Drivers no GitHub, consulte a seção [Driver compilation](https://github.com/amzn/amzn-drivers/tree/master/kernel/linux/ena#driver-compilation) do arquivo “leia-me”.
**Instâncias do Windows**: driver do ENA para o Windows na versão 2.0.0 ou em versões posteriores. Para instalar ou atualizar o driver do ENA para o Windows, consulte [Instalar o driver do ENA em instâncias do Windows do EC2](ena-adapter-driver-install-upgrade-win.md).
**Distância entre os endpoints**
Uma conexão entre duas instâncias na mesma zona de disponibilidade pode processar mais pacotes por segundo do que uma conexão entre regiões, como resultado do janelamento de TCP na camada da aplicação, que define quantos dados podem estar em trânsito a qualquer momento. As longas distâncias entre as instâncias aumentam a latência e diminuem o número de pacotes que os endpoints podem processar.
**Limite de fila de bytes (BQL)**
O BQL é um recurso que limita o número de bytes passados para a placa Nitro para reduzir o enfileiramento. O BQL é desabilitado por padrão nos drivers do ENA, nos sistemas operacionais Amazon Linux e na maioria das distribuições Linux. Se o BQL e a substituição do proxy de fragmento estiverem habilitados, isso pode resultar em limitações de desempenho, restringindo o número de bytes passados para o Nitro antes que todos os fragmentos sejam processados.
#### Considerações sobre o projeto da aplicação
Existem aspectos do projeto e da configuração da aplicação que podem afetar a eficiência do processamento. A lista apresentada a seguir inclui algumas considerações importantes.
**Tamanho do pacote**
Os pacotes com tamanhos maiores podem aumentar o throughput para os dados que uma instância pode enviar e receber na rede. O Amazon EC2 é compatível com jumbo frames de 9001 bytes, mas outros serviços podem impor limites diferentes. Os pacotes com tamanhos menores podem aumentar a taxa de processamento de pacotes, mas podem reduzir a largura de banda máxima alcançada quando o número de pacotes excede as permissões de PPS.
Se o tamanho de um pacote exceder a Unidade Máxima de Transmissão (MTU) de um salto de rede, um roteador ao longo do caminho poderá fragmentá-lo. Os fragmentos de pacotes resultantes são considerados exceções e são normalmente processados na taxa padrão (não acelerada). Isso pode causar variações na performance. No entanto, você pode substituir o comportamento padrão para pacotes fragmentados de saída com a configuração do modo de proxy de fragmentos. Para obter mais informações, consulte [Maximização da performance da rede no Nitro System](#ena-nitro-perf-maximize). Recomendamos avaliar a topologia ao configurar a MTU.
**Compensações de protocolo**
Os protocolos confiáveis, como o TCP, têm mais sobrecarga do que os protocolos não confiáveis, como o UDP. A menor sobrecarga e o processamento de rede simplificado para o protocolo de transporte UDP podem resultar em uma taxa de PPS mais alta, mas às custas da entrega confiável de pacotes. Se a entrega confiável de pacotes não for crítica para a aplicação, o protocolo UDP pode ser uma boa opção.
**Microexpansão**
A Microexpansão ocorre quando o tráfego excede as permissões durante breves períodos de tempo, em vez de ser distribuído uniformemente. Isso costuma acontecer em uma escala de microssegundos.
Por exemplo, suponhamos que você tenha uma instância que pode enviar até 10 Gbps e a aplicação envie 10 Gb completos em meio segundo. Essa microexpansão excede o permitido durante a primeira metade do segundo e não deixa nada para o restante da segunda. Mesmo que você tenha enviado 10 Gb no período de um segundo, as permissões na primeira metade do segundo podem resultar em pacotes enfileirados ou descartados.
É possível usar um programador de rede, como o Traffic Control do Linux, para ajudar no controle do throughput e evitar provocar pacotes enfileirados ou descartados como resultado de uma microexpansão.
**Número de fluxos**
Um único fluxo é limitado a 5 Gbps, a menos que esteja em um grupo de posicionamento de cluster que oferece suporte para até 10 Gbps ou que use o ENA Express, que oferece suporte para até 25 Gbps.
Da mesma forma que um cartão Nitro pode processar mais pacotes em vários fluxos, em vez de usar um único fluxo. Para atingir a taxa máxima de processamento de pacotes por instância, recomendamos, no mínimo, cem fluxos em instâncias com largura de banda agregada de 100 Gbps ou superior. À medida que as funcionalidades agregadas de largura de banda aumentam, o número de fluxos necessários para atingir as taxas de processamento máximas também aumenta. A avaliação comparativa ajudará você a definir qual configuração é necessária para atingir as taxas máximas em sua rede.
**Filas do Adaptador de Rede Elástica (ENA)**
O ENA (Elastic Network Adapter) usa várias filas de recepção (Rx) e transmissão (Tx) (filas do ENA) para melhorar a performance e a escalabilidade de rede nas instâncias do EC2. Essas filas gerenciam eficientemente o tráfego de rede balanceando a carga de dados enviados e recebidos entre as filas disponíveis.
Para obter mais informações, consulte [Filas do ENA](ena-queues.md).
**Sobrecarga no processamento de recursos**
Os recursos, como o Espelhamento de Tráfego e o ENA Express, podem adicionar mais sobrecarga de processamento, o que pode reduzir a performance absoluta do processamento de pacotes. É possível limitar o uso de recursos ou desativá-los para aumentar as taxas de processamento de pacotes.
**Rastreamento de conexão para manutenção do estado**
Os grupos de segurança usam o rastreamento de conexão para armazenar as informações sobre o tráfego de entrada e de saída da instância. O rastreamento de conexão aplica regras a cada fluxo de tráfego de rede individual para determinar se o tráfego será permitido ou negado. O cartão Nitro usa o rastreamento de fluxo para realizar a manutenção do estado para o fluxo. À medida que mais regras do grupo de segurança são aplicadas, mais trabalho é necessário para avaliar o fluxo.
Não são todos os fluxos de tráfego de rede que são rastreados. Se uma regra do grupo de segurança estiver configurada com [Conexões não rastreadas](security-group-connection-tracking.md#untracked-connections), nenhum trabalho adicional será necessário, exceto para conexões que são rastreadas automaticamente a fim de garantir o roteamento simétrico quando houver vários caminhos de resposta válidos.
#### Pacotes que não usam a aceleração de hardware
Não são todos os pacotes que podem aproveitar a aceleração de hardware. O tratamento dessas exceções envolve alguma sobrecarga de processamento necessária para garantir a integridade dos fluxos de rede. Os fluxos de rede devem atender aos padrões de protocolo com confiabilidade, estar em conformidade com as alterações no projeto da VPC e rotear pacotes somente para destinos permitidos. No entanto, a sobrecarga reduz a performance.
**Fragmentos de pacote**
Conforme mencionado em **Considerações da aplicação**, os fragmentos de pacotes resultantes de pacotes que excedem a MTU da rede são tratados normalmente como exceções e não podem aproveitar a aceleração de hardware. Entretanto, é possível contornar as limitações do fragmento de saída com o modo de proxy de fragmento, dependendo da versão do driver. Para obter mais informações, consulte as ações que podem ser tomadas na seção [Maximização da performance da rede no Nitro System](#ena-nitro-perf-maximize).
**Conexões ociosas**
Quando uma conexão não tiver atividade por um período, mesmo que não tenha atingido o tempo limite, o sistema pode deixar de priorizá-la. Assim, se os dados forem recebidos depois que a conexão deixar de ser priorizada, o sistema precisará tratá-los como uma exceção para se reconectar.
Para gerenciar as conexões, é possível usar tempos limite de rastreamento de conexão para fechar as conexões ociosas. Além disso, é possível usar a opção keep-alive do TCP para manter as conexões ociosas abertas. Para obter mais informações, consulte [Tempo limite de rastreamento de conexão ociosa](security-group-connection-tracking.md#connection-tracking-timeouts).
**Mutação da VPC**
As atualizações em grupos de segurança, tabelas de rotas e listas de controle de acesso precisam ser avaliadas novamente no caminho de processamento para garantir que as entradas de rota e as regras do grupo de segurança ainda sejam aplicadas conforme o esperado.
**Fluxos ICMP**
O Internet Control Message Protocol (ICMP) é um protocolo de camada de rede que os dispositivos de rede usam para diagnosticar problemas de comunicação de rede. Esses pacotes sempre usam o fluxo completo.
**Fluxos assimétricos de L2**
O NitroV3 e as plataformas anteriores não usam aceleração de hardware para tráfego entre duas ENIs na mesma sub-rede quando uma ENI está usando o roteador de gateway padrão e a outra não. As plataformas NitroV4 e posteriores utilizam aceleração de hardware nesse cenário. Para obter uma melhor performance na plataforma NitroV3 ou anteriores, certifique-se de que o roteador de gateway padrão usado seja o mesmo em ambas as ENIs ou que essas ENIs estejam em sub-redes diferentes.
## Maximização da performance da rede no Nitro System
Você pode maximizar a performance da rede no sistema Nitro ajustando as configurações de rede.
**Topics**
+ [Considerações](#considerations)
+ [Ajustar a performance de PPS](#tuning)
+ [Configurar a alocação da fila ENA](#max-perf-ena-queues)
+ [Monitoramento da performance em instâncias do Linux](#monitoring)
### Considerações
Antes de tomar qualquer decisão em relação ao projeto ou ajustar quaisquer configurações de rede na instância, recomendamos que você siga etapas apresentadas a seguir para obter o melhor resultado:
1. Compreenda os prós e os contras das ações que você pode executar para aprimorar a performance ao analisar as [Considerações de projeto de rede para o Nitro System](#ena-nitro-perf-considerations).
Para obter mais considerações e as práticas recomendadas para a configuração da instância no Linux, consulte [ENA Linux Driver Best Practices and Performance Optimization Guide](https://github.com/amzn/amzn-drivers/blob/master/kernel/linux/ena/ENA_Linux_Best_Practices.rst) no GitHub.
1. Faça uma avaliação comparativa das workloads com a contagem máxima de fluxo ativo para definir uma referência para a performance da aplicação. Com uma referência para a performance, é possível testar variações nas configurações ou no projeto da aplicação para compreender quais considerações terão maior impacto, sobretudo se você planeja aumentar a escala verticalmente ou aumentar a escala horizontalmente.
### Ajustar a performance de PPS
A seguinte lista contém ações que podem ser executadas para ajustar a performance de PPS, conforme as necessidades do sistema.
+ Reduzir a distância física entre duas instâncias. Quando as instâncias de envio e de recebimento estão localizadas na mesma zona de disponibilidade ou usam grupos de posicionamento de cluster, é possível reduzir o número de saltos que um pacote precisa realizar para se deslocar de um endpoint para outro.
+ Usar [Conexões não rastreadas](security-group-connection-tracking.md#untracked-connections).
+ Usar o protocolo UDP para o tráfego de rede.
+ Para instâncias do EC2 com largura de banda agregada de 100 Gbps ou mais, distribuir a workload em cem ou mais fluxos individuais para distribuir o trabalho uniformemente pelo cartão Nitro.
+ Para superar o limite de PPS do fragmento de saída nas instâncias do EC2, você pode habilitar o modo de proxy de fragmento (dependendo da versão do driver). Essa configuração permite que pacotes fragmentados sejam avaliados no caminho de processamento, superando, assim, o limite de PPS de saída de 1024. Ao carregar o driver, execute um dos seguintes comandos para habilitar ou desabilitar o modo proxy de fragmento:
**Habilitar o modo proxy de fragmento**
```
sudo insmod ena.ko enable_frag_bypass=1
```
**Desabilitar o modo proxy de fragmento**
```
sudo insmod ena.ko enable_frag_bypass=0
```
### Configurar a alocação da fila ENA
Nos tipos de instância compatíveis, você pode alocar dinamicamente essas filas nas Interfaces de Rede Elástica (ENIs). A alocação flexível de filas do ENA otimiza a distribuição de recursos, permitindo a máxima utilização da vCPU. Workloads de alta performance de rede normalmente exigem várias filas do ENA. Para obter mais informações, consulte [Filas do ENA](ena-queues.md).
### Monitoramento da performance em instâncias do Linux
É possível usar métricas do plug-in Ethtool em instâncias do Linux para monitorar indicadores de performance de rede de instâncias, como a largura de banda, a taxa de pacotes e o rastreamento de conexão. Para obter mais informações, consulte [Monitorar o desempenho de rede de instâncias do EC2](monitoring-network-performance-ena.md).
# Otimizar performance da rede em instâncias do Windows do EC2
Para obter a máxima performance da rede nas instâncias do Windows com redes aperfeiçoadas, pode ser necessário modificar a configuração padrão do sistema operacional. Recomendamos as seguintes alterações de configuração para aplicações que exigem alta performance de rede. Outras otimizações (como ativar o descarregamento de soma de verificação e habilitar RSS, por exemplo) já estão configuradas nas AMIs oficiais do Windows.
**nota**
O descarregamento do TCP chimney deve ser desabilitado na maioria dos casos de uso e se tornou obsoleto a partir do Windows Server 2016.
Além dessas otimizações do sistema operacional, você também deve considerar a unidade de transmissão máxima (MTU - maximum transmission unit) de seu tráfego de rede e ajustá-la de acordo com sua workload e arquitetura de rede. Para obter mais informações, consulte [Unidade de transmissão máxima (MTU) de rede para a instância do EC2](network_mtu.md).
A AWS mede regularmente as latências médias de ida e volta entre instâncias iniciadas em um grupo de posicionamento de cluster de 50 us e latência final de 200 us no percentil 99,9. Se suas aplicações exigirem baixas latências de forma consistente, recomendamos usar a versão mais recente dos drivers ENA em instâncias de performance fixa criadas no sistema Nitro.
## Configurar a afinidade de CPU do Receive Side Scaling
O Receive Side Scaling (RSS) é usado para distribuir a carga da CPU do tráfego de rede em vários processadores. Por padrão, as AMIs oficiais do Amazon Windows são configuradas com RSS ativado. Interfaces de rede elástica do ENA fornecem até oito filas RSS. Com a definição de afinidade de CPU para filas RSS, bem como para outros processos do sistema, é possível distribuir a carga de CPU pelos sistemas com vários núcleos, permitindo que mais tráfego de rede seja processado. Em tipos de instância com mais de 16 vCPUs, recomendamos que você use o cmdlet `Set-NetAdapterRSS` do PowerShell, que exclui manualmente o processador de inicialização (processador lógico 0 e 1 quando o hyper-threading está ativado) da configuração de RSS para todas as interfaces de rede elástica, para evitar a contenção com vários componentes do sistema.
O Windows reconhece o hyper-thread e garante que as filas RSS de uma única placa de interface de rede (NIC) sejam sempre colocadas em diferentes núcleos físicos. Portanto, a menos que o hyper-threading esteja desabilitado, para evitar completamente a contenção com outras NICs, propague a configuração RSS de cada NIC entre um intervalo de 16 processadores lógicos. O cmdlet `Set-NetAdapterRss` permite que você defina o intervalo por NIC de processadores lógicos válidos definindo os valores de BaseProcessorGroup, BaseProcessorNumber, MaxProcessingGroup, MaxProcessorNumber e NumaNode (opcional). Se não houver núcleos físicos suficientes para eliminar completamente a contenção entre NICs, minimize os intervalos de sobreposição ou reduza o número de processadores lógicos nos intervalos de interface de rede elástica, dependendo da workload esperada da interface (ou seja, uma interface de rede administrativa de baixo volume talvez não precise de tantas filas RSS atribuídas). Além disso, como observado anteriormente, diversos componentes devem ser executados na CPU 0 e, por isso, recomendamos a exclusão em todas as configurações RSS quando houver vCPUs suficientes disponíveis.
Por exemplo, quando existem três interfaces de rede elástica em uma instância de 72 vCPUs com dois nós NUMA com o hyper-threading habilitado, os comandos a seguir distribuem a carga de rede entre as duas CPUs sem sobreposição e impedem completamente o uso do núcleo 0.
```
Set-NetAdapterRss -Name NIC1 -BaseProcessorGroup 0 -BaseProcessorNumber 2 -MaxProcessorNumber 16
Set-NetAdapterRss -Name NIC2 -BaseProcessorGroup 1 -BaseProcessorNumber 0 -MaxProcessorNumber 14
Set-NetAdapterRss -Name NIC3 -BaseProcessorGroup 1 -BaseProcessorNumber 16 -MaxProcessorNumber 30
```
Observe que essas configurações são persistentes para cada adaptador de rede. Se uma instância for redimensionada para outra com um número diferente de vCPUs, você deverá reavaliar a configuração de RSS para cada interface de rede elástica habilitada. A documentação completa da Microsoft para o cmdlet pode ser encontrada aqui: [Set-NetAdapterRss](https://learn.microsoft.com/en-us/powershell/module/netadapter/set-netadapterrss).
Observação especial para workloads SQL: também recomendamos que você revise suas configurações de afinidade de thread de E/S com sua configuração RSS da interface de rede elástica para minimizar a contenção de E/S e de rede para as mesmas CPUs. Consulte [Configuração do servidor: máscara de afinidade](https://learn.microsoft.com/en-us/sql/database-engine/configure-windows/affinity-mask-server-configuration-option).