Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Rete avanzata su EC2 istanze Amazon
La rete avanzata utilizza la I/O virtualizzazione a root singolo (SR-IOV) per fornire funzionalità di rete ad alte prestazioni sui tipi di istanze supportati. SR-IOV è un metodo di virtualizzazione dei dispositivi che offre I/O prestazioni più elevate e un minore utilizzo della CPU rispetto alle tradizionali interfacce di rete virtualizzate. Le reti avanzate forniscono infatti una larghezza di banda più alta, prestazioni PPS (pacchetti al secondo) superiori e latenze tra istanze significativamente più basse. L'utilizzo di questo servizio avanzato non comporta costi supplementari.
Per informazioni sulla velocità di rete supportata per ogni tipo di istanza, consulta [Amazon EC2 Instance Types](https://aws.amazon.com/ec2/instance-types/).
È possibile abilitare la rete avanzata utilizzando uno dei seguenti meccanismi:
**Elastic Network Adapter (ENA)**
Elastic Network Adapter (ENA) supporta velocità di rete fino a 100 Gbps per i tipi di istanza supportati.
Tutte le [istanze basate su Nitro](instance-types.md#instance-hypervisor-type) utilizzano ENA per le reti avanzate. Inoltre, i seguenti tipi di istanza basati su Xen utilizzano ENA: H1, I3, G3, `m4.16xlarge`, P2, P3, P3dn e R4.
Per ulteriori informazioni, consulta [Abilitazione delle reti avanzate con ENA su istanze EC2](enhanced-networking-ena.md).
**Interfaccia VF (Virtual Function) Intel 82599**
L'interfaccia VF (Virtual Function) Intel 82599 supporta velocità di rete fino a 10 Gbps per i tipi di istanza supportati.
I seguenti tipi di istanza utilizzano l'interfaccia Intel 82599 VF per una rete avanzata: C3, C4, D2, I2, M4 (tranne m4.16xlarge) e R3.
Per ulteriori informazioni, consulta [Reti avanzate con l'interfaccia VF Intel 82599 sulle istanze](sriov-networking.md).
**Topics**
+ [Adattatore elastico di rete (ENA)](enhanced-networking-ena.md)
+ [ENA Express](ena-express.md)
+ [Intel 82599 VF](sriov-networking.md)
+ [Monitoraggio delle prestazioni di rete](monitoring-network-performance-ena.md)
+ [Miglioramento della latenza di rete su Linux](ena-improve-network-latency-linux.md)
+ [Considerazioni sulle prestazioni di Nitro](ena-nitro-perf.md)
+ [Ottimizza le prestazioni di rete su Windows](enhanced-networking-os.md)
# Abilitazione delle reti avanzate con ENA su istanze EC2
Amazon EC2 fornisce funzionalità di rete avanzate tramite Elastic Network Adapter (ENA). Per utilizzare la rete avanzata, devi utilizzare un’AMI che includa il driver ENA richiesto o installarlo manualmente. Quindi puoi abilitare il supporto ENA sull’istanza.
Per rivedere le note di rilascio o le istruzioni di installazione di un driver ENA, consulta la scheda corrispondente alla piattaforma del sistema operativo dell’istanza.
------
#### [ Linux ]
È possibile consultare la seguente documentazione su GitHub:
+ Consulta le [note di rilascio del driver del kernel Linux ENA](https://github.com/amzn/amzn-drivers/blob/master/kernel/linux/ena/RELEASENOTES.md) su GitHub.
+ Per una panoramica del driver del kernel Linux ENA che include le istruzioni di installazione, consulta [Linux kernel driver per la famiglia Elastic Network Adapter (ENA)](https://github.com/amzn/amzn-drivers/blob/master/kernel/linux/ena/README.rst) su. GitHub
------
#### [ Windows ]
Puoi consultare la seguente documentazione nella sezione **Gestisci driver dei dispositivi** di questa guida:
+ [Traccia rilasci della versione del driver ENA Windows](ena-driver-releases-windows.md).
+ [Installa il driver ENA su istanze EC2 Windows](ena-adapter-driver-install-upgrade-win.md).
------
Per le istanze basate su Nitro, le funzionalità di rete avanzate variano a seconda della versione di Nitro implementata dal tipo di istanza.
Per esaminare le specifiche di rete per la tua istanza, scegli il link della famiglia di istanze per il tipo di istanza. Se non sei sicuro della famiglia di istanze applicabile, consulta [Convenzioni di denominazione](https://docs.aws.amazon.com/ec2/latest/instancetypes/instance-type-names.html) nella guida ai *Tipi di istanza di Amazon EC2*.
+ [Specifiche di rete per istanze a calcolo accelerato](https://docs.aws.amazon.com/ec2/latest/instancetypes/ac.html#ac_network)
+ [Specifiche di rete per istanze ottimizzate per il calcolo](https://docs.aws.amazon.com/ec2/latest/instancetypes/co.html#co_network)
+ [Specifiche di rete per istanze per uso generico](https://docs.aws.amazon.com/ec2/latest/instancetypes/gp.html#gp_network)
+ [Specifiche di rete per istanze di calcolo ad alte prestazioni](https://docs.aws.amazon.com/ec2/latest/instancetypes/hpc.html#hpc_network)
+ [Specifiche di rete per istanze ottimizzate per la memoria](https://docs.aws.amazon.com/ec2/latest/instancetypes/mo.html#mo_network)
+ [Specifiche di rete per istanze ottimizzate per l’archiviazione](https://docs.aws.amazon.com/ec2/latest/instancetypes/so.html#so_network)
**Topics**
+ [Prerequisiti per reti avanzate con ENA](#ena-requirements)
+ [Verifica dell’abilitazione delle reti avanzate](test-enhanced-networking-ena.md)
+ [Abilitazione delle reti avanzate su un’istanza](enabling_enhanced_networking.md)
+ [Code ENA](ena-queues.md)
+ [Risolvere i problemi relativi al driver ENA kernel su Linux](troubleshooting-ena.md)
+ [Risoluzione dei problemi del driver dell'Adattatore elastico di rete per Windows](troubleshoot-ena-driver.md)
## Prerequisiti per reti avanzate con ENA
Per preparare la configurazione delle funzionalità delle reti avanzate tramite ENA, configura l’istanza nel seguente modo:
+ Avvia un’[istanza basata su Nitro](instance-types.md#instance-hypervisor-type).
+ Verificare che l’istanza disponga di connettività Internet.
+ Se sull’istanza sono presenti dati importanti che devono essere conservati, è consigliabile eseguire una copia di backup di tali dati ora mediante la creazione di un’AMI dall’istanza. L’aggiornamento dei kernel ENA e l’abilitazione dell’attributo `enaSupport` potrebbero rendere non compatibili le istanze o irraggiungibili i sistemi operativi. Se disponi di un backup recente, i tuoi dati saranno mantenuti.
+ **Istanze Linux** – Avvia l’istanza utilizzando una versione supportata del kernel Linux e una distribuzione supportata, in modo che la rete avanzata ENA sia abilitata automaticamente per la tua istanza. Per ulteriori informazioni, consulta le [note di rilascio del driver ENA Linux Kernel](https://github.com/amzn/amzn-drivers/blob/master/kernel/linux/ena/RELEASENOTES.md).
+ **Istanze Windows**: se l'istanza esegue Windows Server 2008 R2 SP1, assicurati che sia installato l'aggiornamento per il supporto alla firma del codice [SHA-2](https://support.microsoft.com/en-us/help/4474419/sha-2-code-signing-support-update).
+ Puoi utilizzarlo [AWS CloudShell](https://console.aws.amazon.com/cloudshell)da Console di gestione AWS, oppure installarlo e configurarlo [AWS Tools for Windows PowerShell](https://docs.aws.amazon.com/powershell/latest/userguide/)su qualsiasi computer a tua scelta, preferibilmente sul desktop [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html)o sul laptop locale. Per ulteriori informazioni, consulta [Accesso a Amazon EC2](concepts.md#access-ec2) o la [Guida per l’utente di AWS CloudShell](https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html). Le reti avanzate non possono essere gestite dalla console Amazon EC2.
# Verifica dell’abilitazione delle reti avanzate
Puoi verificare se la rete avanzata è abilitata nelle tue istanze o nelle tue. AMIs
**Attributo dell’istanza**
Controlla il valore dell’attributo dell’istanza `enaSupport`.
------
#### [ AWS CLI ]
Utilizza il 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 le reti avanzate sono abilitate, viene visualizzato il seguente output.
```
[
true
]
```
------
#### [ PowerShell ]
Utilizza il 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 le reti avanzate sono abilitate, viene visualizzato il seguente output.
```
True
```
------
**Attributo dell’immagine**
Controlla il valore dell’attributo dell’immagine `enaSupport`.
------
#### [ AWS CLI ]
Utilizza il 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 le reti avanzate sono abilitate, viene visualizzato il seguente output.
```
[
true
]
```
------
#### [ PowerShell ]
Utilizza il 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 le reti avanzate sono abilitate, viene visualizzato il seguente output.
```
True
```
------
**Driver dell’interfaccia di rete Linux**
Utilizza il comando seguente per verificare se il driver del kernel `ena` viene utilizzato su un’interfaccia specifica, sostituendo il nome dell’interfaccia che desideri controllare. Se usi una singola interfaccia (impostazione predefinita), essa sarà `eth0`. Se la tua distribuzione Linux supporta nomi di rete prevedibili, questo potrebbe essere un nome simile a `ens5`. Per ulteriori informazioni, espandi la sezione relativa a RHEL, SUSE e CentOS in [Abilitazione delle reti avanzate su un’istanza](enabling_enhanced_networking.md).
Nell’esempio seguente, il driver del kernel `ena` non viene caricato, perché il driver nell’elenco è `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
```
In questo caso, il driver del kernel `ena` è caricato con la versione minima consigliata. Questa istanza dispone della funzionalità per reti avanzate adeguatamente configurata.
```
[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
```
# Abilitazione delle reti avanzate su un’istanza
La procedura utilizzata dipende dal sistema operativo dell’istanza.
## Amazon Linux
I AMIs per Amazon Linux includono il driver del kernel necessario per una rete avanzata con ENA installato e il supporto ENA abilitato. Pertanto, se si avvia un’istanza con una versione HVM di Amazon Linux su un tipo di istanza supportato, l’istanza dispone già dell’abilitazione delle reti avanzate. Per ulteriori informazioni, consulta [Verifica dell’abilitazione delle reti avanzate](test-enhanced-networking-ena.md).
## Ubuntu
L'ultima versione di Ubuntu HVM AMIs include il driver del kernel necessario per una rete avanzata con ENA installato e il supporto ENA abilitato. Pertanto, se si avvia un’istanza con la più recente versione Ubuntu HVM AMI; su un tipo di istanza supportato, l’istanza dispone già dell’abilitazione delle reti avanzate. Per ulteriori informazioni, consulta [Verifica dell’abilitazione delle reti avanzate](test-enhanced-networking-ena.md).
Se l’istanza è stata avviata utilizzando un’AMI di una versione precedente per la quale la funzionalità di reti avanzate non è abilitata, puoi installare il pacchetto kernel `linux-aws` per avere i driver di rete ottimizzati più recenti e aggiornare l’attributo richiesto.
**Come installare il pacchetto `linux-aws` kernel (Ubuntu 16.04 o versioni successive)**
Ubuntu 16.04 e 18.04 vengono forniti con il kernel personalizzato Ubuntu (pacchetto kernel `linux-aws`). Per usare un kernel diverso, contatta [Supporto](https://console.aws.amazon.com/support).
**Come installare il pacchetto `linux-aws` kernel (Ubuntu Trusty 14.04)**
1. Connettiti alla tua istanza.
1. Aggiorna la cache dei pacchetti e i pacchetti.
```
ubuntu:~$ sudo apt-get update && sudo apt-get upgrade -y linux-aws
```
**Importante**
Se durante il processo di aggiornamento viene richiesto di installare `grub`, utilizza `/dev/xvda` per installare `grub`, quindi scegli di conservare la versione corrente di `/boot/grub/menu.lst`.
1. [Istanza supportata da EBS] Dal computer locale, arresta l’istanza utilizzando la console Amazon EC2 o uno dei comandi seguenti: [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) o [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).
[Istanza supportata da instance store] Non è possibile arrestare l’istanza per modificare l’attributo. Segui invece questa procedura: [Per abilitare le reti avanzate su Ubuntu (istanze supportate da instance store)](#enhanced-networking-ena-instance-store-ubuntu).
1. Dal computer locale, abilita l’attributo relativo alle reti avanzate utilizzando uno dei seguenti comandi:
+ [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)(Strumenti per Windows) PowerShell
```
Edit-EC2InstanceAttribute -InstanceId i-1234567890abcdef0 -EnaSupport $true
```
1. (Facoltativo) Crea un’AMI dall’istanza, come descritto in [Creare un'AMI supportata da Amazon EBS](creating-an-ami-ebs.md). L’AMI eredita l’attributo `enaSupport` relativo alle reti avanzate dall’istanza. Pertanto, è possibile utilizzare questa AMI per avviare un’altra istanza con le reti avanzate abilitate per impostazione di default.
1. Dal computer locale, avvia l’istanza utilizzando la console Amazon EC2 o uno dei comandi seguenti: [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) o [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).
**Per abilitare le reti avanzate su Ubuntu (istanze supportate da instance store)**
Segui la procedura precedente fino al punto in cui si arresta l’istanza. Crea una nuova AMI come descritto in [Creare un’AMI supportata da Amazon S3](creating-an-ami-instance-store.md), assicurandoti di abilitare l’attributo relativo alle reti avanzate durante la registrazione dell’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, CentOS
Le ultime novità AMIs per Red Hat Enterprise Linux, SUSE Linux Enterprise Server e CentOS includono il driver kernel necessario per una rete avanzata con ENA e il supporto ENA abilitato. Pertanto, se si lancia un’istanza con la più recente versione di AMI su un tipo di istanza supportato, l’istanza dispone già dell’abilitazione delle reti avanzate. Per ulteriori informazioni, consulta [Verifica dell’abilitazione delle reti avanzate](test-enhanced-networking-ena.md).
La procedura seguente descrive le fasi generali per abilitare le reti avanzate ENA su una distribuzione Linux diversa da AMI Amazon Linux o Ubuntu. Per ulteriori informazioni, ad esempio sintassi dettagliata dei comandi, posizione dei file o supporto di pacchetti e strumenti, consulta la documentazione per la distribuzione Linux in uso.
**Per abilitare le reti avanzate su Linux**
1. Connettiti alla tua istanza.
1. Clona il codice sorgente per il driver del `ena` kernel sulla tua istanza da at. GitHub [https://github.com/amzn/amzn-drivers](https://github.com/amzn/amzn-drivers) (SUSE Linux Enterprise Server 12 SP2 e versioni successive includono ENA 2.02 per impostazione predefinita, quindi non è necessario scaricare e compilare il driver ENA. Per SUSE Linux Enterprise Server 12 SP2 e versioni successive, è necessario presentare una richiesta per aggiungere la versione del driver desiderata al kernel di serie).
```
git clone https://github.com/amzn/amzn-drivers
```
1. Compila e installa il driver del kernel `ena` sull’istanza. Questi passaggi dipendono dalla distribuzione Linux. Per ulteriori informazioni sulla compilazione del driver del kernel su Red Hat Enterprise Linux, consulta [Come installare il driver ENS più recente per un supporto di rete avanzato su un’istanza Amazon EC2 che esegue RHEL?](https://repost.aws/knowledge-center/install-ena-driver-rhel-ec2)
1. Esegui il comando **sudo depmod** per aggiornare le dipendenze del driver del kernel.
1. Aggiorna `initramfs` sull’istanza in modo che il nuovo driver del kernel venga caricato in fase di avvio. Ad esempio, se la distribuzione supporta **dracut**, è possibile utilizzare il seguente comando:
```
dracut -f -v
```
1. Determina se il sistema utilizza nomi di interfaccia di rete prevedibili per impostazione di default. I sistemi che utilizzano **systemd** o **udev** versione 197 o successive possono rinominare i dispositivi Ethernet e pertanto non garantiscono che la singola interfaccia di rete venga rinominata in `eth0`. Questo comportamento potrebbe causare problemi durante la connessione all’istanza. Per ulteriori informazioni e per informazioni sulle altre opzioni di configurazione disponibili, consulta l’argomento relativo ai [nomi di interfaccia di rete prevedibili](https://www.freedesktop.org/wiki/Software/systemd/PredictableNetworkInterfaceNames/) sul sito Web freedesktop.org.
1. È possibile controllare le versioni di **systemd** o **udev** sui sistemi basati su RPM utilizzando il seguente comando:
```
rpm -qa | grep -e '^systemd-[0-9]\+\|^udev-[0-9]\+'
systemd-208-11.el7_0.2.x86_64
```
Nell’esempio precedente relativo a Red Hat Enterprise Linux 7, la versione di **systemd** è 208, pertanto, i nomi di interfaccia di rete prevedibili devono essere disabilitati.
1. Disabilitare i nomi di interfaccia di rete prevedibili aggiungendo l’opzione `net.ifnames=0` alla riga `GRUB_CMDLINE_LINUX` in `/etc/default/grub`.
```
sudo sed -i '/^GRUB\_CMDLINE\_LINUX/s/\"$/\ net\.ifnames\=0\"/' /etc/default/grub
```
1. Ricompila il file di configurazione di grub.
```
sudo grub2-mkconfig -o /boot/grub2/grub.cfg
```
1. [Istanza supportata da EBS] Dal computer locale, arresta l’istanza utilizzando la console Amazon EC2 o uno dei comandi seguenti: [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).
[Istanza supportata da instance store] Non è possibile arrestare l’istanza per modificare l’attributo. Segui invece questa procedura: [Per abilitare le reti avanzate su Linux (istanze supportate da archivio istanze)](#other-linux-enhanced-networking-ena-instance-store).
1. Dal computer locale, abilita l’attributo `enaSupport` relativo alle reti avanzate utilizzando uno dei seguenti comandi:
+ [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)(Strumenti per Windows) PowerShell
```
Edit-EC2InstanceAttribute -InstanceId i-1234567890abcdef0 -EnaSupport $true
```
1. (Facoltativo) Crea un’AMI dall’istanza, come descritto in [Creare un'AMI supportata da Amazon EBS](creating-an-ami-ebs.md). L’AMI eredita l’attributo `enaSupport` relativo alle reti avanzate dall’istanza. Pertanto, è possibile utilizzare questa AMI per avviare un’altra istanza con le reti avanzate abilitate per impostazione di default.
Se il sistema operativo dell’istanza contiene un file `/etc/udev/rules.d/70-persistent-net.rules`, è necessario eliminarlo prima di creare l’AMI. Questo file contiene l’indirizzo MAC per la scheda Ethernet dell’istanza originale. Se un’altra istanza viene avviata con questo file, il sistema operativo non sarà in grado di trovare il dispositivo ed `eth0` potrebbe non funzionare causando problemi di avvio. Questo file viene rigenerato al successivo ciclo di avvio e qualsiasi istanza avviata dall’AMI crea la propria versione del file.
1. Dal computer locale, avvia l’istanza utilizzando la console Amazon EC2 o uno dei comandi seguenti: [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) o [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. (Facoltativo) Connettiti all’istanza e verifica che il driver del kernel sia installato.
Se è impossibile connettersi all’istanza dopo aver abilitato le reti avanzate, consulta [Risolvere i problemi relativi al driver ENA kernel su Linux](troubleshooting-ena.md).
**Per abilitare le reti avanzate su Linux (istanze supportate da archivio istanze)**
Segui la procedura precedente fino al punto in cui si arresta l’istanza. Crea una nuova AMI come descritto in [Creare un’AMI supportata da Amazon S3](creating-an-ami-instance-store.md), assicurandoti di abilitare l’attributo relativo alle reti avanzate durante la registrazione dell’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 con DKMS
Questo metodo è solo per scopi di test e feedback. Non è pensato per l’utilizzo con distribuzioni di produzione. Per distribuzioni di produzione, consulta [Ubuntu](#enhanced-networking-ena-ubuntu).
**Importante**
L’uso di DKMS annulla il contratto di assistenza per l’abbonamento. Non deve essere utilizzato per le distribuzioni di produzione.
**Per abilitare le reti avanzate con ENA su Ubuntu (istanze supportate da EBS)**
1. Seguire le fasi 1 e 2 in [Ubuntu](#enhanced-networking-ena-ubuntu).
1. Installare i pacchetti `build-essential` per compilare il driver del kernel e il pacchetto `dkms` in modo che il driver del kernel `ena` venga ricompilato a ogni aggiornamento del kernel.
```
ubuntu:~$ sudo apt-get install -y build-essential dkms
```
1. Clona il codice sorgente per il driver del `ena` kernel sull'istanza da GitHub at. [https://github.com/amzn/amzn-drivers](https://github.com/amzn/amzn-drivers)
```
ubuntu:~$ git clone https://github.com/amzn/amzn-drivers
```
1. Spostare il pacchetto `amzn-drivers` nella directory `/usr/src/` in modo che DKMS riesca a individuarlo e compilarlo per ogni aggiornamento del kernel. Aggiungere il numero di versione (il numero di versione corrente è disponibile nelle note di rilascio) del codice sorgente al nome della directory. Nell’esempio seguente viene visualizzata la seguente versione `1.0.0`.
```
ubuntu:~$ sudo mv amzn-drivers /usr/src/amzn-drivers-1.0.0
```
1. Creare il file di configurazione DKMS con i seguenti valori, sostituendo la versione in uso di `ena`.
Creare il file.
```
ubuntu:~$ sudo touch /usr/src/amzn-drivers-1.0.0/dkms.conf
```
Modificare il file e aggiungere i valori seguenti.
```
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. Aggiungere, compilare e installare il driver del kernel `ena` sull’istanza utilizzando DKMS.
Aggiungere il driver del kernel a DKMS.
```
ubuntu:~$ sudo dkms add -m amzn-drivers -v 1.0.0
```
Compilare il driver del kernel usando il comando **dkms**.
```
ubuntu:~$ sudo dkms build -m amzn-drivers -v 1.0.0
```
Installare il driver del kernel usando **dkms**.
```
ubuntu:~$ sudo dkms install -m amzn-drivers -v 1.0.0
```
1. Ricompilare `initramfs` in modo che il driver del kernel corretto venga caricato in fase di avvio.
```
ubuntu:~$ sudo update-initramfs -u -k all
```
1. Verificare che il driver del kernel `ena` sia installato utilizzando il comando modinfo ena disponibile in [Verifica dell’abilitazione delle reti avanzate](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. Continuare con la fase 3 in [Ubuntu](#enhanced-networking-ena-ubuntu).
## Abilitazione delle reti avanzate su Windows
Se hai avviato l’istanza per la quale la funzionalità di reti avanzate non è già abilitata, devi scaricare e installare il driver per la scheda di rete richiesto sull’istanza e quindi impostare l’attributo `enaSupport` dell’istanza in modo da attivare le reti avanzate.
**Per abilitare le reti avanzate**
1. Connettersi all’istanza ed eseguire l’accesso come amministratore locale.
1. [Solo Windows Server 2016 e 2019] Esegui il seguente PowerShell script di EC2 avvio per configurare l'istanza dopo l'installazione del driver.
```
PS C:\> C:\ProgramData\Amazon\EC2-Windows\Launch\Scripts\InitializeInstance.ps1 -Schedule
```
1. Dall’istanza, installare il driver nel seguente modo:
1. [Scarica](https://s3.amazonaws.com/ec2-windows-drivers-downloads/ENA/Latest/AwsEnaNetworkDriver.zip) il driver più recente per l’istanza.
1. Estrai l’archivio .zip.
1. Installa il driver eseguendo lo `install.ps1` PowerShell script.
**Nota**
Se si verifica un errore della policy di esecuzione, impostare la policy su `Unrestricted` (per impostazione predefinita è impostata su `Restricted` o `RemoteSigned`). In una riga di comando`Set-ExecutionPolicy -ExecutionPolicy Unrestricted`, esegui e quindi esegui nuovamente `install.ps1` PowerShell lo script.
1. Dal computer locale, arresta l’istanza utilizzando la console Amazon EC2 o uno dei comandi seguenti: [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) oppure [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. Abilita il supporto ENA sull’istanza nel seguente modo:
1. Dal computer locale, controlla l’attributo relativo al supporto ENA per l’istanza EC2 sull’istanza eseguendo uno dei seguenti comandi. Se l’attributo non è abilitato, l’output riporterà “[]” o sarà vuoto. `EnaSupport` è configurato su `false` per impostazione predefinita.
+ [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)(Strumenti per Windows PowerShell)
```
(Get-EC2Instance -InstanceId i-1234567890abcdef0).Instances.EnaSupport
```
1. Per abilitare il supporto ENA, esegui uno dei comandi riportati di seguito:
+ [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 si verificano problemi durante il riavvio dell’istanza, è possibile disabilitare il supporto ENA utilizzando uno dei seguenti comandi:
+ [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. Verifica che l’attributo sia stato impostato su `true` utilizzando **describe-instances** o **Get-EC2Instance** come descritto in precedenza. Ora l’output restituito sarà simile al seguente:
```
[
true
]
```
1. Dal computer locale, avvia l’istanza utilizzando la console Amazon EC2 o uno dei comandi seguenti: [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) o [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. Nell’istanza, verifica che il driver ENA sia installato e abilitato nel seguente modo:
1. Fai clic con il pulsante destro del mouse sull’icona di rete e scegli **Open Network and Sharing Center (Apri centro connessioni di rete e condivisione)**.
1. Seleziona la scheda Ethernet (ad esempio, **Ethernet 2**).
1. Seleziona **Details (Dettagli)**. In **Network Connection Details (Dettagli connessione di rete)**, verifica che nel campo **Description (Descrizione)** sia visualizzato **Amazon Elastic Network Adapter**.
1. (Facoltativo) Crea un’AMI dall’istanza. L’AMI eredita l’attributo `enaSupport` dall’istanza. Pertanto, è possibile utilizzare questa AMI per avviare un’altra istanza con ENA abilitato per impostazione di default.
# Code ENA
Le code ENA sono allocate alle interfacce di rete con limiti statici predefiniti in base al tipo e alla dimensione dell’istanza. Sui tipi di istanze supportati, puoi allocare dinamicamente queste code su Elastic Network Interfaces (). ENIs Sebbene il numero totale di code per istanza dipenda dal tipo e dalla dimensione, è possibile configurarne più code ENIs con ENA fino a raggiungere il numero massimo di code per l'ENI e l'istanza.
L’allocazione flessibile delle code ENA ottimizza la distribuzione delle risorse, consentendo il massimo utilizzo della vCPU. I carichi di lavoro ad alte prestazioni di rete richiedono in genere molteplici code ENA. Puoi ottimizzare le prestazioni di rete e i pacchetti al secondo (PPS) regolando il numero di code in base alle esigenze specifiche del carico di lavoro. Ad esempio, le applicazioni a uso intensivo della rete possono richiedere più code rispetto alle applicazioni a uso intensivo della CPU.
**Topics**
+ [Istanze supportate](#supported-instances)
+ [Modifica il numero di code](#modify)
## Istanze supportate
Le seguenti istanze supportano l’allocazione dinamica di più code ENA.
### Uso generale
| Tipo di istanza | Code ENA predefinite per interfaccia | Numero massimo di code ENA per interfaccia | Numero massimo di code ENA per istanza |
| --- | --- | --- | --- |
| 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 |
| M6 pollici |
| 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 |
| M8 Azn |
| 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 |
| M8 GB |
| 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 |
| M8 gn |
| 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 |
| M8 iD |
| 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 Questi tipi di istanze presentano più schede di rete. Altri tipi di istanza presentano un’unica scheda di rete. Per ulteriori informazioni, consulta [Schede di rete](using-eni.md#network-cards).
### Calcolo ottimizzato
| Tipo di istanza | Code ENA predefinite per interfaccia | Numero massimo di code ENA per interfaccia | Numero massimo di code ENA per istanza |
| --- | --- | --- | --- |
| 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 |
| C8 GB |
| 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 Questi tipi di istanze presentano più schede di rete. Altri tipi di istanza presentano un’unica scheda di rete. Per ulteriori informazioni, consulta [Schede di rete](using-eni.md#network-cards).
### Memoria ottimizzata
| Tipo di istanza | Code ENA predefinite per interfaccia | Numero massimo di code ENA per interfaccia | Numero massimo di code ENA per istanza |
| --- | --- | --- | --- |
| 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 |
| R8 id |
| 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 | 1.024 |
| x8i.96xlarge | 32 | 128 | 1536 |
| x8i.metal-48xl | 32 | 128 | 768 |
| x8i.metal-96xl | 32 | 128 | 1536 |
**Nota**
\$1 Questi tipi di istanze presentano più schede di rete. Altri tipi di istanza presentano un’unica scheda di rete. Per ulteriori informazioni, consulta [Schede di rete](using-eni.md#network-cards).
## Modifica il numero di code
È possibile modificare il numero di code ENA utilizzando o. Console di gestione AWS AWS CLI Nella Console di gestione AWS, la configurazione delle code ENA è disponibile in ciascuna impostazione dell’**Interfaccia di rete**.
Per modificare il numero di code ENA utilizzando il AWS CLI, utilizzare uno dei seguenti comandi. Prima di modificare il numero delle code, utilizza il seguente comando per controllare il numero attuale delle code.
```
aws ec2 describe-instances --instance-id i-1234567890abcdef0
```
**Nota**
La tua istanza deve essere arrestata prima di modificare il numero di code ENA.
Il valore per le code ENA deve essere una potenza di 2, ad esempio: 1, 2, 4, 8, 16, 32, ecc.
Il numero di code assegnate a ogni singolo ENI non può superare il numero di v CPUs disponibili sull'istanza.
`[attach-network-interface](https://docs.aws.amazon.com/cli/latest/reference/ec2/attach-network-interface.html)`
Nell’esempio seguente, 32 code ENA sono configurate su una 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)`
Nell'esempio seguente, 2 code ENA sono configurate ciascuna su 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)`
Nell’esempio seguente, 32 code ENA sono configurate su una ENI.
```
aws ec2 modify-network-interface-attribute \
--network-interface-id eni-1234567890abcdef0 \
--attachment AttachmentId=eni-attach-12345678,EnaQueueCount=32
```
Nell’esempio seguente, il numero di ENA viene ripristinato al valore predefinito.
```
aws ec2 modify-network-interface-attribute \
--network-interface-id eni-1234567890abcdef0 \
--attachment AttachmentId=eni-attach-12345678,DefaultEnaQueueCount=true
```
# Risolvere i problemi relativi al driver ENA kernel su Linux
L'Adattatore elastico di rete (ENA) è progettato per migliorare lo stato del sistema operativo e ridurre le possibilità di interruzione a lungo termine a causa di un comportamento inatteso dell'hardware e/o di guasti. La struttura dell'ENA rende i guasti dei dispositivi o dei driver il più chiari possibile al sistema. Questo argomento fornisce le informazioni relative alla risoluzione dei problemi dell'ENA.
Se è impossibile connettersi all'istanza, iniziare dalla sezione [Risolvere i problemi di connettività](#ena-connectivity-issues).
Se si verifica un peggioramento delle prestazioni dopo la migrazione a un tipo di istanza di sesta generazione, consulta l'articolo [Cosa devo fare prima di migrare la mia EC2 istanza a un'istanza di sesta generazione per assicurarmi di ottenere le massime](https://repost.aws/knowledge-center/migrate-to-gen6-ec2-instance) prestazioni di rete?
Se è possibile connettersi all'istanza, è possibile raccogliere informazioni diagnostiche utilizzando i meccanismi di rilevamento e riparazione dei guasti descritti nelle sezioni successive di questo argomento.
**Topics**
+ [Risolvere i problemi di connettività](#ena-connectivity-issues)
+ [Meccanismo keep-alive](#ena-keep-alive)
+ [Timeout lettura registro](#register-read-timeout-ena)
+ [Statistiche](#statistics-ena)
+ [Log di errore driver in Syslog](#driver-error-logs-ena)
+ [Notifiche di configurazione non ottimale](#ts-ena-sub-opt-config-notification)
## Risolvere i problemi di connettività
Se si perde la connettività durante l'abilitazione della rete avanzata, il modulo `ena` potrebbe essere incompatibile con il kernel dell'istanza attualmente in esecuzione. Questo può accadere se si installa il modulo per una specifica versione del kernel (senza **dkms** o con un file **dkms.conf** non configurato correttamente), quindi il kernel di istanza viene aggiornato. Se il kernel di istanza caricato al momento dell'avvio non ha il modulo `ena` correttamente installato, l'istanza non riconoscerà l'adattatore di rete e l'istanza diventerà irraggiungibile.
Se si attivano le reti avanzate per un'istanza PV o AMI, l'istanza può risultare irraggiungibile.
Se l'istanza diventa irraggiungibile dopo aver abilitato le reti avanzate con l'ENA, è possibile disattivare l'attributo `enaSupport` per l'istanza e quest'ultima tornerà all'adattatore di rete originale.
**Disattivare le reti avanzate con l'ENA (istanze supportate da EBS)**
1. Dal tuo computer locale, arresta l'istanza utilizzando la EC2 console Amazon, il comando [stop-instances](https://docs.aws.amazon.com/cli/latest/reference/ec2/stop-instances.html) (AWS CLI) o il [Stop-EC2Instance](https://docs.aws.amazon.com/powershell/latest/reference/items/Stop-EC2Instance.html)cmdlet ().AWS Strumenti per PowerShell
1. Dal tuo computer locale, disabilita l'attributo di rete avanzato utilizzando il [modify-instance-attribute](https://docs.aws.amazon.com/cli/latest/reference/ec2/modify-instance-attribute.html)comando con l'`--no-ena-support`opzione o il cmdlet con il [Edit-EC2InstanceAttribute](https://docs.aws.amazon.com/powershell/latest/reference/items/Edit-EC2InstanceAttribute.html)parametro. `-EnaSupport $false`
1. Dal tuo computer locale, avvia l'istanza utilizzando la EC2 console Amazon, il comando [start-instances](https://docs.aws.amazon.com/cli/latest/reference/ec2/start-instances.html) o il cmdlet. [Start-EC2Instance](https://docs.aws.amazon.com/powershell/latest/reference/items/Start-EC2Instance.html)
1. (Facoltativo) Connettersi all'istanza e provare a reinstallare il modulo `ena` con la versione del kernel attuale seguendo i passaggi in [Abilitazione delle reti avanzate con ENA su istanze EC2](enhanced-networking-ena.md).
**Disattivare le reti avanzate con l'ENA (istanze supportate da instance store)**
1. Creare una nuova AMI come descritto in [Creare un’AMI supportata da Amazon S3](creating-an-ami-instance-store.md).
1. Quando registri l'AMI, assicurati di includere l'`--no-ena-support`opzione nel comando [stop-instances](https://docs.aws.amazon.com/cli/latest/reference/ec2/stop-instances.html) (AWS CLI) o il `-EnaSupport $false` parametro nel cmdlet. [Register-EC2Image](https://docs.aws.amazon.com/powershell/latest/reference/items/Register-EC2Image.html)
## Meccanismo keep-alive
Il dispositivo ENA segnala gli eventi keep-alive con una frequenza fissa (di solito una volta al secondo). Il driver dell'ENA è dotato di un meccanismo watchdog che controlla la presenza di questi messaggi keep-alive. Se sono presenti uno o più messaggi, il watchdog viene riarrestato, altrimenti il driver ritiene che il dispositivo abbia subito un guasto e procede come segue:
+ Scarica le sue statistiche attuali su syslog
+ Reimposta il dispositivo ENA
+ Reimposta lo stato del driver ENA
La procedura di ripristino sopra descritta può provocare una perdita di traffico per un breve periodo di tempo (le connessioni TCP devono poter essere ripristinate), ma non dovrebbe influire in altro modo sull'utente.
Il dispositivo ENA può anche richiedere indirettamente una procedura di ripristino del dispositivo, non inviando una notifica keep-alive, per esempio se il dispositivo ENA raggiunge uno stato sconosciuto dopo aver caricato una configurazione irrecuperabile.
Di seguito è riportato un esempio della procedura di ripristino:
```
[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
```
## Timeout lettura registro
L'architettura ENA suggerisce un uso limitato delle operazioni di lettura mappate in memoria (MMIO I/O ). I registri MMIO sono accessibili dal driver del dispositivo ENA solo durante la procedura di inizializzazione.
Se i log del driver (disponibili nell'output **dmesg**) indicano errori nelle operazioni di lettura, ciò può essere causato da un driver incompatibile o compilato in modo errato, da un dispositivo hardware occupato o da un guasto hardware.
Le voci di log intermittenti che indicano errori nelle operazioni di lettura non devono essere considerate un problema; in questo caso il driver le riproverà. Tuttavia, una sequenza di voci di log contenenti errori di lettura indica un problema al driver o all'hardware.
Di seguito è riportato un esempio di voce di log del driver che indica un errore nell'operazione di lettura dovuto a un timeout:
```
[ 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
```
## Statistiche
Se si verificano prestazioni di rete insufficienti o problemi di latenza, è necessario recuperare le statistiche del dispositivo ed esaminarle. Si possono ottenere tali statistiche utilizzando **ethtool**, come mostrato di seguito.
```
[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
...
```
I seguenti parametri di output del comando sono descritti di seguito:
`tx_timeout`: *N*
Numero di volte in cui il watchdog Netdev è stato attivato.
`suspend`: *N*
Numero di volte in cui il driver ha eseguito un'operazione di sospensione.
`resume`: *N*
Numero di volte in cui il driver ha eseguito un'operazione di ripresa.
`wd_expired`: *N*
Numero di volte in cui il driver non ha ricevuto l'evento keep-alive nei tre secondi precedenti.
`interface_up`: *N*
Numero di volte in cui l'interfaccia ENA è stata attivata.
`interface_down`: *N*
Numero di volte in cui l'interfaccia ENA è stata disattivata.
`admin_q_pause`: *N*
Numero di volte in cui la coda di amministrazione non è stata trovata in uno stato di esecuzione.
`bw_in_allowance_exceeded`: *N*
Il numero di pacchetti accordati o rilasciati perché la larghezza di banda aggregata in ingresso ha superato il valore massimo per l'istanza.
`bw_out_allowance_exceeded`: *N*
Il numero di pacchetti accodati o rilasciati perché la larghezza di banda aggregata in uscita ha superato il valore massimo per l'istanza.
`pps_allowance_exceeded`: *N*
Il numero di pacchetti accodati o rilasciati perché il PPS bidirezionale ha superato il valore massimo per l’istanza. \$1
`conntrack_allowance_available`: *N*
Il numero di connessioni tracciate che possono essere stabilite dall'istanza prima di raggiungere il limite Connessioni tracciate di quel tipo di istanza. Disponibile solo per le istanze basate su Nitro. Non supportato con le istanze FreeBSD o gli ambienti DPDK.
`conntrack_allowance_exceeded`: *N*
Il numero di pacchetti accodati o rilasciati perché il rilevamento delle connessioni ha superato il valore massimo per l'istanza e non è stato possibile stabilire nuove connessioni. Ciò può comportare la perdita di pacchetti per il traffico da o verso l'istanza.
`linklocal_allowance_exceeded`: *N*
Il numero di pacchetti accodati o rilasciati perché il PPS del traffico verso i servizi proxy locali ha superato il valore massimo per l'interfaccia di rete. Ciò influisce sul traffico verso il servizio Amazon DNS, il servizio di metadati dell’istanza e il servizio di sincronizzazione oraria di Amazon, ma non influisce sul traffico verso i resolver DNS personalizzati.
`queue_N_tx_cnt`: *N*
Numero di pacchetti trasmessi per questa coda.
`queue_N_tx_bytes`: *N*
Numero di byte trasmessi per questa coda.
`queue_N_tx_queue_stop`: *N*
Il numero di volte in cui la coda *N* è stata piena e interrotta.
`queue_N_tx_queue_wakeup`: *N*
Il numero di volte in cui la coda è *N* stata ripresa dopo essere stata interrotta.
`queue_N_tx_dma_mapping_err`: *N*
Conteggio errori di accesso diretto alla memoria. Se questo valore non è pari a 0, significa che le risorse di sistema sono scarse.
`queue_N_tx_linearize`: *N*
Numero di volte in cui è stata tentata la linearizzazione SKB per questa coda.
`queue_N_tx_linearize_failed`: *N*
Numero di volte in cui la linearizzazione SKB non è andata a buon fine per questa coda.
`queue_N_tx_napi_comp`: *N*
Numero di volte in cui il gestore `napi` ha chiamato `napi_complete` per questa coda.
`queue_N_tx_tx_poll`: *N*
Numero di volte in cui il gestore `napi` è stato programmato per questa coda.
`queue_N_tx_doorbells`: *N*
Numero di campanelli di trasmissione per questa coda.
`queue_N_tx_prepare_ctx_err`: *N*
Numero di volte in cui `ena_com_prepare_tx` non è andato a buon fine per questa coda.
`queue_N_tx_bad_req_id`: *N*
`req_id` non valido per questa coda. Il `req_id` valido è zero, meno la `queue_size`, meno 1.
`queue_N_tx_llq_buffer_copy`: *N*
Numero di pacchetti la cui dimensione delle intestazioni è maggiore della voce llq per questa coda.
`queue_N_tx_missed_tx`: *N*
Numero di pacchetti trasmessi lasciati incompleti per questa coda.
`queue_N_tx_unmask_interrupt`: *N*
Numero di volte in cui l'interrupt tx è stato smascherato per questa coda.
`queue_N_rx_cnt`: *N*
Numero di pacchetti ricevuti per questa coda.
`queue_N_rx_bytes`: *N*
Numero di byte ricevuti per questa coda.
`queue_N_rx_rx_copybreak_pkt`: *N*
Numero di volte in cui la coda rx ha ricevuto un pacchetto inferiore alla dimensione del pacchetto rx\$1copybreak per questa coda.
`queue_N_rx_csum_good`: *N*
Numero di volte in cui la coda rx ha ricevuto un pacchetto in cui il checksum è stato controllato ed era corretto per questa coda.
`queue_N_rx_refil_partial`: *N*
Numero di volte in cui il driver non è riuscito a riempire la parte vuota della coda rx con i buffer per questa coda. Se questo valore non è pari a 0, significa che le risorse di memoria sono scarse.
`queue_N_rx_bad_csum`: *N*
Numero di volte che la coda `rx` ha avuto un checksum negativo per questa coda (solo se è supportato l'offload del checksum).
`queue_N_rx_page_alloc_fail`: *N*
Numero di volte in cui l'assegnazione della pagina non è andata a buon fine per questa coda. Se questo valore non è pari a 0, significa che le risorse di memoria sono scarse.
`queue_N_rx_skb_alloc_fail`: *N*
Numero di volte in cui l'assegnazione dell'SKB non è andata a buon fine per questa coda. Se questo valore non è pari a 0, significa che le risorse di sistema sono scarse.
`queue_N_rx_dma_mapping_err`: *N*
Conteggio errori di accesso diretto alla memoria. Se questo valore non è pari a 0, significa che le risorse di sistema sono scarse.
`queue_N_rx_bad_desc_num`: *N*
Troppi buffer per pacchetto. Se questo valore non è pari a 0, significa che si utilizzano buffer molto piccoli.
`queue_N_rx_bad_req_id`: *N*
Il req\$1id per questa coda non è valido. Il req\$1id valido è compreso tra [0, queue\$1size - 1].
`queue_N_rx_empty_rx_ring`: *N*
Numero di volte in cui la coda rx è stata vuota per questa coda.
`queue_N_rx_csum_unchecked`: *N*
Numero di volte in cui la coda rx ha ricevuto un pacchetto il cui checksum non è stato controllato per questa coda.
`queue_N_rx_xdp_aborted`: *N*
Numero di volte in cui un pacchetto XDP è stato classificato come XDP\$1ABORT.
`queue_N_rx_xdp_drop`: *N*
Numero di volte in cui un pacchetto XDP è stato classificato come XDP\$1DROP.
`queue_N_rx_xdp_pass`: *N*
Numero di volte in cui un pacchetto XDP è stato classificato come XDP\$1PASS.
`queue_N_rx_xdp_tx`: *N*
Numero di volte in cui un pacchetto XDP è stato classificato come XDP\$1TX.
`queue_N_rx_xdp_invalid`: *N*
Numero di volte in cui il codice restituito da XDP per il pacchetto non era valido.
`queue_N_rx_xdp_redirect`: *N*
Numero di volte in cui un pacchetto XDP è stato classificato come XDP\$1REDIRECT.
`queue_N_xdp_tx_cnt`: *N*
Numero di pacchetti trasmessi per questa coda.
`queue_N_xdp_tx_bytes`: *N*
Numero di byte trasmessi per questa coda.
`queue_N_xdp_tx_queue_stop`: *N*
Numero di volte in cui questa coda era piena e si è arrestata.
`queue_N_xdp_tx_queue_wakeup`: *N*
Numero di volte in cui questa coda ha ripreso dopo essersi arrestata.
`queue_N_xdp_tx_dma_mapping_err`: *N*
Conteggio errori di accesso diretto alla memoria. Se questo valore non è pari a 0, significa che le risorse di sistema sono scarse.
`queue_N_xdp_tx_linearize`: *N*
Numero di volte in cui è stata tentata la linearizzazione del buffer XDP per questa coda.
`queue_N_xdp_tx_linearize_failed`: *N*
Numero di volte in cui la linearizzazione del buffer XDP non è andata a buon fine per questa coda.
`queue_N_xdp_tx_napi_comp`: *N*
Numero di volte in cui il gestore napi ha chiamato napi\$1complete per questa coda.
`queue_N_xdp_tx_tx_poll`: *N*
Numero di volte in cui il gestore napi è stato programmato per questa coda.
`queue_N_xdp_tx_doorbells`: *N*
Numero di campanelli di trasmissione per questa coda.
`queue_N_xdp_tx_prepare_ctx_err`: *N*
Numero di volte in cui ena\$1com\$1prepare\$1tx non è andato a buon fine per questa coda. Questo valore deve essere sempre zero; altrimenti, consultare i log del driver.
`queue_N_xdp_tx_bad_req_id`: *N*
Il req\$1id per questa coda non è valido. Il req\$1id valido è compreso tra [0, queue\$1size - 1].
`queue_N_xdp_tx_llq_buffer_copy`: *N*
Numero di pacchetti che hanno copiato le intestazioni utilizzando la copia del buffer llq per questa coda.
`queue_N_xdp_tx_missed_tx`: *N*
Numero di volte in cui una voce di coda tx ha perso un timeout di completamento per questa coda.
`queue_N_xdp_tx_unmask_interrupt`: *N*
Numero di volte in cui l'interrupt tx è stato smascherato per questa coda.
`ena_admin_q_aborted_cmd`: *N*
Il numero di comandi di amministrazione che sono stati interrotti. Questo solitamente accade durante la procedura di auto-ripristino.
`ena_admin_q_submitted_cmd`: *N*
Numero di campanelli di coda di amministrazione.
`ena_admin_q_completed_cmd`: *N*
Numero di completamenti di coda di amministrazione.
`ena_admin_q_out_of_space`: *N*
Numero di volte in cui il driver ha tentato di inviare un nuovo comando di amministrazione, ma la coda era piena.
`ena_admin_q_no_completion`: *N*
Numero di volte in cui il driver non ha ricevuto un completamento di amministrazione per un comando.
## Log di errore driver in Syslog
Il driver ENA scrive messaggi di log a **syslog** durante l'avvio del sistema. In caso di problemi, è possibile esaminare questi log per cercare errori. Di seguito è riportato un esempio di informazioni registrate dal driver ENA in **syslog** durante l'avvio del sistema, insieme ad alcune annotazioni per la selezione dei messaggi.
```
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
```
**Quali errori posso ignorare?**
I seguenti avvisi, che possono apparire nei log di errore del sistema, possono essere ignorati per l'Adattatore elastico di rete:
Set host attribute isn't supported (L'impostazione dell'attributo dell'host non è supportata)
Gli attributi dell'host non sono supportati da questo dispositivo.
failed to alloc buffer for rx queue (allocazione del buffer per la coda rx non riuscita)
Si tratta di un errore recuperabile, che indica che potrebbe essersi verificato un problema di pressione di memoria quando l'errore è stato generato.
La funzionalità *X* non è supportata
La funzionalità a cui si fa riferimento non è supportata dall'Adattatore elastico di rete. I valori possibili *X* includono:
+ 10: la configurazione della funzione Hash RSS non è supportata per questo dispositivo.
+ 12: la configurazione della tabella di Riferimento indiretto RSS non è supportata per questo dispositivo.
+ 18: la configurazione dell'Input Hash RSS non è supportata per questo dispositivo.
+ 20: la moderazione dell'interruzione non è supportata per questo dispositivo.
+ 27: il driver dell'Adattatore elastico di rete non supporta il polling delle funzionalità Ethernet da snmpd.
Failed to config AENQ (Impossibile configurare AENQ)
L'Adattatore elastico di rete non supporta la configurazione AENQ.
Trying to set unsupported AENQ events (Tentativo di impostare eventi AENQ non supportati)
Questo errore indica un tentativo di impostare un gruppo di eventi AENQ non supportato dall'Adattatore elastico di rete.
## Notifiche di configurazione non ottimale
Il dispositivo ENA rileva le impostazioni di configurazione non ottimali nel driver che è possibile modificare. Il dispositivo notifica il driver ENA e registra un avviso sulla console. Nell'esempio seguente viene illustrato il formato del messaggio di avviso.
```
Sub-optimal configuration notification code: 1. Refer to AWS ENA documentation for additional details and mitigation options.
```
L'elenco seguente mostra i dettagli del codice di notifica e le operazioni consigliate per gli esiti di configurazione non ottimali.
+ **Codice 1: non è consigliato utilizzare ENA Express con la configurazione LLQ estesa**
ENA Express ENI è configurato con LLQ esteso. Questa configurazione non è ottimale e potrebbe influire sulle prestazioni di ENA Express. Si consiglia di disabilitare le impostazioni LLQ estese quando si utilizza ENA Express ENIs come segue.
```
sudo rmmod ena && sudo modprobe ena force_large_llq_header=0
```
Per ulteriori informazioni sulla configurazione ottimale di ENA Express, consulta la pagina [Migliora le prestazioni di rete tra le istanze EC2 con ENA Express](ena-express.md).
+ **Codice 2: non è consigliato utilizzare ENI ENA Express con una profondità di coda Tx non ottimale**
ENI ENA Express è configurato con una profondità di coda Tx non ottimale. Questa configurazione potrebbe influire sulle prestazioni di ENA Express. Si consiglia di allargare tutte le code Tx al valore massimo per l'interfaccia di rete quando si utilizza ENA Express come segue. ENIs
Per regolare le dimensioni della LLQ, è possibile eseguire i seguenti comandi **ethtool**. *Per ulteriori informazioni su come controllare, interrogare e abilitare Wide-LLQ, consulta l'argomento Large [Low-Latency Queue (Large LLQ)](https://github.com/amzn/amzn-drivers/tree/master/kernel/linux/ena#large-low-latency-queue-large-llq) del driver del kernel Linux per la documentazione ENA nel repository Amazon Drivers. GitHub *
```
ethtool -g interface
```
Imposta le code Tx alla profondità massima:
```
ethtool -G interface tx depth
```
Per ulteriori informazioni sulla configurazione ottimale di ENA Express, consulta la pagina [Migliora le prestazioni di rete tra le istanze EC2 con ENA Express](ena-express.md).
+ **Codice 3: un file ENA con dimensioni LLQ regolari e traffico di pacchetti Tx supera la dimensione massima supportata dall'intestazione**
Per impostazione predefinita, ENA LLQ supporta intestazioni del pacchetto Tx di dimensioni fino a 96 byte. Se la dimensione dell'intestazione del pacchetto è maggiore di 96 byte, il pacchetto viene eliminato. Per mitigare questo problema, si consiglia di abilitare una LLQ estesa, che aumenta la dimensione dell'intestazione del pacchetto Tx supportata fino a un massimo di 224 byte.
Tuttavia, quando si abilita una LLQ estesa, la dimensione massima dell'anello Tx viene ridotta da 1000 a 512 voci. LLQ estesa è abilitata per impostazione predefinita per tutti i tipi di istanza Nitro v4 e versioni successive.
+ I tipi di istanza Nitro v4 hanno una dimensione massima predefinita dell'anello Tx con LLQ estesa di 512 voci, che non può essere modificata.
+ I tipi di istanza Nitro v5 hanno una dimensione predefinita dell'anello Tx con LLQ estesa di 512 voci, che può essere aumentata fino a 1000 voci.
Per regolare le dimensioni della LLQ, è possibile eseguire i seguenti comandi **ethtool**. *Per ulteriori informazioni su come controllare, interrogare e abilitare Wide-LLQ, consulta l'argomento Large [Low-Latency Queue (Large LLQ)](https://github.com/amzn/amzn-drivers/tree/master/kernel/linux/ena#large-low-latency-queue-large-llq) del driver del kernel Linux per la documentazione ENA nel repository Amazon Drivers. GitHub *
Trova la profondità massima delle code:
```
ethtool -g interface
```
Imposta le code Tx alla profondità massima:
```
ethtool -G interface tx depth
```
# Risoluzione dei problemi del driver dell'Adattatore elastico di rete per Windows
L'Adattatore elastico di rete (ENA) è progettato per migliorare lo stato del sistema operativo e ridurre le possibilità di interruzione a causa di un comportamento inatteso dell'hardware e/o di guasti che può alterare il funzionamento dell'istanza Windows. La struttura dell'ENA rende i guasti dei dispositivi o dei driver il più chiari possibile al sistema operativo.
## Raccogliere informazioni diagnostiche sull'istanza
I passaggi per aprire gli strumenti del sistema operativo Windows (OS) variano a seconda della versione del sistema operativo installata nell'istanza. Nelle seguenti sezioni, utilizziamo la finestra di dialogo **Esegui** per aprire gli strumenti, che funziona allo stesso modo in tutte le versioni del sistema operativo. Tuttavia, è possibile accedere a questi strumenti utilizzando qualsiasi metodo si preferisca.
**Accesso alla finestra di dialogo Esegui**
+ Utilizzando la combinazione di tasti logo Windows: `Windows` \$1 `R`
+ Utilizzando la barra di ricerca:
+ Inserire `run` nella barra di ricerca.
+ Selezionare l'applicazione **Esegui** dai risultati di ricerca.
Alcuni passaggi richiedono che il menu contestuale acceda alle proprietà o alle azioni sensibili al contesto. Esistono diversi modi per eseguire questa operazione, a seconda della versione del sistema operativo e dell'hardware.
**Accesso al menu contestuale**
+ Utilizzando il mouse: fare clic con il pulsante destro del mouse su un elemento per visualizzare il menu contestuale.
+ Utilizzando la tastiera:
+ A seconda della versione del sistema operativo, utilizzare `Shift` \$1 `F10`, oppure `Ctrl` \$1 `Shift` \$1 `F10`.
+ Se la tastiera presenta il tasto contestuale (tre linee orizzontali in una casella), seleziona l'elemento desiderato e premi il tasto contestuale.
Se è possibile connettersi all'istanza, utilizzare le seguenti tecniche per raccogliere informazioni diagnostiche per la risoluzione dei problemi.
### Controllo dello stato del dispositivo ENA
Per controllare lo stato del driver ENA per Windows utilizzando Gestione dispositivi in Windows, attenersi alla seguente procedura:
1. Aprire la finestra di dialogo **Esegui** utilizzando uno dei metodi descritti nella sezione precedente.
1. Per aprire Gestione dispositivi in Windows, inserire `devmgmt.msc` nel campo **Esegui**.
1. Scegli **OK**. Viene visualizzata la finestra Gestione dispositivi.
1. Selezionare la freccia visualizzata a sinistra di **Schede di rete** per espandere l’elenco.
1. Scegliere il nome o aprire il menu contestuale per **Adattatore elastico di rete Amazon** e quindi **Proprietà**. In questo modo si apre la finestra di dialogo **Proprietà di Amazon Elastic Network Adapter**.
1. Verificare che il messaggio nella scheda **Generale** mostri "Questo dispositivo funziona correttamente".
### Indagare sui messaggi di evento del driver
Per esaminare i registri degli eventi del driver ENA per Windows utilizzando il Visualizzatore eventi di Windows, attenersi alla seguente procedura:
1. Aprire la finestra di dialogo **Esegui** utilizzando uno dei metodi descritti nella sezione precedente.
1. Per aprire Visualizzatore eventi in Windows, inserire `eventvwr.msc` nel campo **Esegui**.
1. Scegli **OK**. Viene visualizzata la finestra del Visualizzatore eventi di Windows.
1. Espandere il menu **Eventi di Windows**, quindi scegliere **Sistema**.
1. In **Operazioni**, nel pannello in alto a destra, scegliere **Filtra log corrente**. Viene visualizzata la finestra di dialogo di filtro.
1. Nel campo **Origine eventi**, inserire `ena`. Ciò limita i risultati agli eventi generati dal driver ENA per Windows.
1. Scegli **OK**. Ciò mostra i risultati del log degli eventi filtrati nelle sezioni di dettaglio della finestra.
1. Per espandere i dettagli, selezionare un messaggio di evento dall'elenco.
L'esempio seguente mostra un evento driver ENA nell'elenco degli eventi di sistema del Visualizzatore eventi di Windows:
![\[Esempio: evento driver ENA mostrato nell'elenco dei messaggi di sistema del Visualizzatore eventi di Windows.\]](http://docs.aws.amazon.com/it_it/AWSEC2/latest/UserGuide/images/ena-event-viewer-example.png)
#### Sintesi del messaggio di evento
La tabella seguente mostra i messaggi di evento generati dal driver ENA per Windows.
**Input**
| ID evento | Descrizione dell'evento del driver ENA | Tipo |
| --- | --- | --- |
| 5001 | Le risorse del hardware sono esaurite | Errore |
| 5002 | L'adattatore ha rilevato un errore hardware | Errore |
| 5005 | Il timeout impostato sull'adattatore per un'operazione NDIS non completata in modo tempestivo è scaduto. | Errore |
| 5032 | Impossibile ripristinare il dispositivo | Errore |
| 5200 | L'adattatore è stato inizializzato | Messaggio informativo |
| 5201 | L'adattatore è stato arrestato | Messaggio informativo |
| 5202 | L'adattatore è stato sospeso | Messaggio informativo |
| 5203 | L'adattatore è stato riavviato | Messaggio informativo |
| 5204 | L'adattatore è stato spento | Messaggio informativo |
| 5205 | L'adattatore è stato ripristinato | Errore |
| 5206 | L'adattatore è stato rimosso inaspettatamente | Errore |
| 5208 | La routine di inizializzazione dell'adattatore non è riuscita | Errore |
| 5210 | L'adattatore ha riscontrato e risolto con successo un problema interno | Errore |
### Visualizzazione dei parametri relativi alle prestazioni
Il driver ENA per Windows pubblica i parametri delle prestazioni di rete dalle istanze in cui sono attivati. È possibile visualizzare e abilitare le metriche sull'istanza utilizzando l'applicazione nativa Performance Monitor (Monitor di sistema). Per ulteriori informazioni sui parametri prodotti dal driver ENA per Windows, consultare [Monitoraggio delle prestazioni di rete per le impostazioni ENA dell'istanza EC2](monitoring-network-performance-ena.md).
Nei casi in cui le metriche ENA sono abilitate e CloudWatch l'agente Amazon è installato, CloudWatch raccoglie le metriche associate ai contatori in Windows Performance Monitor, nonché alcune metriche avanzate per ENA. Queste parametri vengono raccolti in aggiunta ai parametri abilitati per impostazione predefinita nelle istanze EC2. Per ulteriori informazioni sui parametri, consulta [Metriche raccolte dall' CloudWatch agente nella](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/metrics-collected-by-CloudWatch-agent.html) *Amazon CloudWatch User* Guide.
**Nota**
I parametri delle prestazioni sono disponibili per le versioni 2.4.0 e successive dei driver ENA (anche per la versione 2.2.3). È stato eseguito il ripristino dello stato precedente del driver ENA versione 2.2.4 a causa del potenziale peggioramento delle prestazioni nelle istanze EC2 di sesta generazione. Si consiglia di eseguire l'aggiornamento alla versione corrente del driver per assicurarsi di disporre degli aggiornamenti più recenti.
Alcuni dei modi in cui è possibile utilizzare i parametri delle prestazioni includono:
+ Risoluzione dei problemi di prestazioni delle istanze.
+ Scegliere la dimensione dell'istanza corretta per un dato carico di lavoro.
+ Pianificare in modo proattivo le attività di dimensionamento.
+ Applicazioni di benchmark per determinare se le prestazioni sono massimizzate sono disponibili su un'istanza.
**Frequenza di aggiornamento**
Per impostazione predefinita, il driver aggiorna i parametri utilizzando un intervallo di 1 secondo. Tuttavia, l'applicazione che raccoglie i parametri potrebbe utilizzare un intervallo diverso per il polling. È possibile modificare l'intervallo di aggiornamento in Gestione dispositivi, utilizzando le proprietà avanzate per il driver.
Per modificare l'intervallo di aggiornamento dei parametri per il driver ENA per Windows, attenersi alla seguente procedura:
1. Aprire la finestra di dialogo **Esegui** utilizzando uno dei metodi descritti nella sezione precedente.
1. Per aprire Gestione dispositivi in Windows, inserire `devmgmt.msc` nel campo **Esegui**.
1. Scegli **OK**. Viene visualizzata la finestra Gestione dispositivi.
1. Selezionare la freccia visualizzata a sinistra di **Schede di rete** per espandere l’elenco.
1. Scegliere il nome o aprire il menu contestuale per **Adattatore elastico di rete Amazon** e quindi **Proprietà**. In questo modo si apre la finestra di dialogo **Proprietà di Amazon Elastic Network Adapter**.
1. Apertura della scheda **Avanzate** nella finestra popup.
1. Dalla **Proprietà**, scegliere **Intervallo di aggiornamento dei parametri** per modificare il valore.
1. Al termine, scegliere **OK**.
## Analizzare le notifiche di configurazione non ottimali
Il dispositivo ENA rileva le impostazioni di configurazione non ottimali nel driver che è possibile modificare. Il dispositivo notifica il driver ENA e registra una notifica di evento. Esaminare gli eventi non ottimali in Visualizzatore eventi di Windows
1. Aprire la finestra di dialogo **Esegui** utilizzando uno dei metodi descritti nella sezione precedente.
1. Per aprire Visualizzatore eventi in Windows, inserire `eventvwr.msc` nel campo **Esegui**.
1. Scegli **OK**. Viene visualizzata la finestra del Visualizzatore eventi di Windows.
1. Espandere il menu **Eventi di Windows**, quindi scegliere **Sistema**.
1. In **Operazioni**, nel pannello in alto a destra, scegliere **Filtra log corrente**. Viene visualizzata la finestra di dialogo di filtro.
1. Nel campo **Origine eventi**, inserire `ena`. Ciò limita i risultati agli eventi generati dal driver ENA per Windows.
1. Scegli **OK**. Ciò mostra i risultati del log degli eventi filtrati nelle sezioni di dettaglio della finestra.
Gli eventi con ID `59000` notificano all'utente esiti di configurazione non ottimali. Fare clic con il pulsante destro del mouse su un evento e scegliere **Proprietà evento** per aprire una visualizzazione dettagliata oppure selezionare **Riquadro di anteprima** dal menu **Visualizza** per vedere gli stessi dettagli.
![\[Esempio: ID evento di sistema 59000 mostrato nel riquadro di anteprima del Visualizzatore eventi di Windows.\]](http://docs.aws.amazon.com/it_it/AWSEC2/latest/UserGuide/images/ena-sub-opt-event-general.png)
Aprire la scheda **Dettagli** per visualizzare il codice dell'evento. Nella sezione **Dati binari: in parole**, l'ultima parola è il codice.
![\[Esempio: l'ultima parola nella sezione Dati binari viene mostrata in evidenza.\]](http://docs.aws.amazon.com/it_it/AWSEC2/latest/UserGuide/images/ena-sub-opt-event-detail.png)
L'elenco seguente mostra i dettagli del codice di notifica e le operazioni consigliate per gli esiti di configurazione non ottimali.
+ **Codice `1`: non è consigliato utilizzare ENA Express con la configurazione LLQ estesa**
ENA Express ENI è configurato con LLQ esteso. Questa configurazione non è ottimale e potrebbe influire sulle prestazioni di ENA Express. Ti consigliamo di disabilitare le impostazioni LLQ estese quando usi ENA Express ENIs come segue.
1. Per aprire Gestione dispositivi in Windows, inserire `devmgmt.msc` nel campo **Esegui**.
1. Scegli **OK**. Viene visualizzata la finestra Gestione dispositivi.
1. Selezionare la freccia visualizzata a sinistra di **Schede di rete** per espandere l’elenco.
1. Aprire le proprietà del dispositivo per `Amazon Elastic Network Adapter`.
1. Per apportare le modifiche, aprire la scheda **Avanzate**.
1. Selezionare la proprietà **Policy relativa alla dimensione dell'intestazione LLQ** e impostare il valore su `Normal (128 Bytes)`.
1. Scegliere **OK** per salvare le modifiche.
+ **Codice `2`: ENI ENA Express con una profondità di coda Tx non ottimale non è consigliato**
ENI ENA Express è configurato con una profondità di coda Tx non ottimale. Questa configurazione potrebbe influire sulle prestazioni di ENA Express. Si consiglia di allargare tutte le code Tx al valore massimo per l'interfaccia di rete quando si utilizza ENA Express come segue. ENIs
Attenersi alla seguente procedura per estendere le code Tx alla profondità massima:
1. Per aprire Gestione dispositivi in Windows, inserire `devmgmt.msc` nel campo **Esegui**.
1. Scegli **OK**. Viene visualizzata la finestra Gestione dispositivi.
1. Selezionare la freccia visualizzata a sinistra di **Schede di rete** per espandere l’elenco.
1. Aprire le proprietà del dispositivo per `Amazon Elastic Network Adapter`.
1. Per apportare le modifiche, aprire la scheda **Avanzate**.
1. Selezionare la proprietà **Trasmetti Buffer** e impostarne il valore sul valore massimo supportato.
1. Scegliere **OK** per salvare le modifiche.
## Ripristino dell'adattatore ENA
Il processo di ripristino viene avviato quando il driver ENA per Windows rileva un errore su una scheda di rete e contrassegna l'adattatore come non integro. Il driver non può ripristinarsi da solo, quindi dipende dal sistema operativo controllare lo stato di integrità dell'adattatore e invocare il gestore di ripristino per il driver ENA per Windows. Il processo di ripristino potrebbe comportare un breve periodo di tempo in cui si verifica una perdita di traffico. Tuttavia, le connessioni TCP dovrebbero essere in grado di essere ripristinate.
L'adattatore ENA potrebbe anche richiedere indirettamente una procedura di ripristino del dispositivo, in caso di mancato invio di una notifica keep-alive. Ad esempio, se l'adattatore ENA raggiunge uno stato non riconosciuto dopo aver caricato una configurazione non ripristinabile, potrebbe interrompere l'invio di notifiche keep-alive.
**Cause comuni del ripristino dell'adattatore ENA**
+ Messaggi keep-alive mancanti
L'adattatore ENA segnala gli eventi keep-alive con una frequenza fissa (di solito una volta al secondo). Il driver ENA per Windows è dotato di un meccanismo watchdog che controlla periodicamente la presenza di questi messaggi keep-alive. Se uno o più nuovi messaggi vengono rilevati dall'ultima volta in cui sono stati controllati, registra un risultato positivo. In caso contrario, il driver conclude che il dispositivo ha riscontrato un utilizzo fuori limite e avvia una sequenza di ripristino.
+ Pacchetti bloccati nelle code di trasmissione
L'adattatore ENA verifica che i pacchetti scorrano attraverso le code di trasmissione come previsto. Il driver ENA per Windows rileva se i pacchetti si bloccano e avvia una sequenza di ripristino, nel caso in cui questo si verifichi.
+ Timeout di lettura per i registri Memory Mapped (MMIO I/O )
Per limitare le operazioni di lettura con mappatura della memoria I/O (MMIO), il driver ENA Windows accede ai registri MMIO solo durante i processi di inizializzazione e ripristino. Se il driver rileva un timeout, richiede una delle seguenti azioni, a seconda del processo in esecuzione:
+ Se viene rilevato un timeout durante l'inizializzazione, il flusso viene interrotto, il che comporta la visualizzazione di un punto esclamativo giallo accanto all'adattatore ENA in Gestione dispositivi di Windows.
+ Se viene rilevato un timeout durante il ripristino, il flusso viene interrotto. Il sistema operativo avvia quindi una rimozione inaspettata dell'adattatore ENA e lo ripristina arrestando e avviando l'adattatore che è stato rimosso. Per ulteriori informazioni sulla rimozione inaspettata di una scheda di interfaccia di rete (NIC), consultare [Gestione della rimozione inaspettata di una NIC](https://learn.microsoft.com/en-us/windows-hardware/drivers/network/handling-the-surprise-removal-of-a-nic) nella documentazione *Sviluppatore hardware di Microsoft Windows*.
## Scenari per la risoluzione dei problemi
Gli scenari seguenti possono essere utili per risolvere i problemi che possono verificarsi con il driver ENA per Windows. Si consiglia di iniziare con l'aggiornamento del driver ENA, se non si dispone della versione più recente. Per trovare il driver più recente per la versione del sistema operativo Windows, consultare [Traccia rilasci della versione del driver ENA Windows](ena-driver-releases-windows.md).
### Versione del driver ENA installata non prevista
#### Description
Dopo aver eseguito i passaggi per installare una versione specifica del driver ENA, Windows Device Manager mostra che Windows ha installato una versione diversa del driver ENA.
#### Causa
Quando si esegue l'installazione di un pacchetto driver, Windows classifica tutti i pacchetti driver validi per il dispositivo specificato nel [Archivio driver](https://learn.microsoft.com/en-us/windows-hardware/drivers/install/driver-store) locale prima di iniziare. Quindi seleziona il pacchetto con il valore più basso come migliore abbinamento. Può essere diverso dal pacchetto che intendevi installare. Per ulteriori informazioni sul processo di selezione dei pacchetti driver del dispositivo, consulta [Modalità con cui Windows seleziona un pacchetto driver per un dispositivo](https://learn.microsoft.com/en-us/windows-hardware/drivers/install/how-windows-selects-a-driver-for-a-device) nel *sito web della documentazione Microsoft*.
#### Soluzione
[Per garantire che Windows installi la versione del pacchetto driver prescelta, è possibile rimuovere i pacchetti driver di livello inferiore dal Driver Store con lo strumento da riga di comando Pn. PUtil](https://learn.microsoft.com/en-us/windows-hardware/drivers/devtest/pnputil)
Segui questi passaggi per aggiornare il driver ENA:
1. Connettersi all’istanza ed eseguire l’accesso come amministratore locale.
1. Aprire la finestra delle proprietà Gestione dispositivi, come descritto nella sezione [Controllo dello stato del dispositivo ENA](#ts-ena-diagnostics-device-mgr). In questo modo si apre la scheda **Generale** della finestra **Proprietà di Amazon Elastic Network Adapter**.
1. Apertura della scheda **Driver**.
1. Scegliere **Update Driver (Aggiorna driver)**. Si apre la finestra di dialogo **Aggiornamento del software del driver — Amazon Elastic Network Adapter**.
1. Nella pagina **Modalità di ricerca software driver?**, scegli **Cerca driver nel computer**.
1. Nella pagina **Cerca il software dei driver sul computer**, scegli **Fammi scegliere da un elenco di driver di periferica sul mio computer**, situato sotto la barra di ricerca.
1. Nella pagina **Seleziona il driver del dispositivo che desideri installare per questo hardware**, scegli **Disco...** .
1. Nella finestra **Installa da disco**, scegli **Cerca...** , accanto alla posizione di file dall'elenco discesa
1. Accedere alla posizione in cui è stato scaricato il pacchetto driver ENA di destinazione. Scegli il file `ena.inf` e seleziona **Apri**.
1. Per avviare l'installazione, scegli **OK**, quindi scegli **Avanti**.
1. Se il programma di installazione non riavvia automaticamente l'istanza, esegui il cmdlet. **Restart-Computer** PowerShell
```
PS C:\> Restart-Computer
```
### Avviso dispositivo per driver ENA
#### Description
L'icona dell'adattatore ENA in Gestione dispositivi nella sezione **Schede di rete** visualizza un segnale di avviso (un triangolo giallo con un punto esclamativo all'interno).
L'esempio seguente mostra un adattatore ENA con l'icona di avviso in Gestione dispositivi di Windows:
![\[Esempio: adattatore ENA con l'icona di avviso in Gestione dispositivi di Windows.\]](http://docs.aws.amazon.com/it_it/AWSEC2/latest/UserGuide/images/ena-adapter-device-mgr-warn.png)
#### Causa
Questo avviso del dispositivo è comunemente causato da problemi di ambiente, che potrebbero richiedere ulteriori ricerche e spesso richiedono un procedimento per esclusione per determinare la causa sottostante. Per un elenco completo degli errori del dispositivo, consulta [Device Manager Error Messages](https://learn.microsoft.com/en-us/windows-hardware/drivers/install/device-manager-error-messages) nella documentazione Microsoft.
#### Soluzione
La soluzione per questo avviso del dispositivo dipende dalla causa principale. Il procedimento per esclusione qui descritto include alcuni passaggi fondamentali per aiutare a identificare e risolvere i problemi più comuni che potrebbero avere una soluzione semplice. Un'ulteriore analisi della causa principale è necessaria quando questi passaggi non risolvono il problema.
Seguire questi passaggi per identificare e risolvere i problemi più comuni:
1.
**Avviare e arrestare il dispositivo**
Aprire la finestra delle proprietà Gestione dispositivi, come descritto nella sezione [Controllo dello stato del dispositivo ENA](#ts-ena-diagnostics-device-mgr). In questo modo si apre la scheda **Generale** della finestra **Proprietà di Amazon Elastic Network Adapter**, dove lo **Stato del dispositivo** visualizza il codice di errore e un breve messaggio.
1. Apertura della scheda **Driver**.
1. Scegliere **Disabilitare il dispositivo** e selezionare **Sì** al messaggio di avviso visualizzato.
1. Scegliere **Abilitare dispositivo**.
1.
**Arrestare e avviare l'istanza EC2**
Se l'adattatore mostra ancora l'icona di avviso in Gestione dispositivi, il passo successivo consiste nell'arrestare e avviare l'istanza EC2. Questo passo rilancia l'istanza su un hardware diverso nella maggior parte dei casi.
1.
**Indagare il possibile problema delle risorse dell'istanza**
Se l'istanza EC2 si è interrotta e avviata e il problema persiste, potrebbe indicare un problema di risorse sull'istanza, ad esempio memoria insufficiente.
### Timeout di connessione con ripristino dell'adattatore (codici di errore 5007, 5205)
#### Description
Il visualizzatore eventi di Windows mostra il timeout dell'adattatore e gli eventi di ripristino verificati in combinazione per gli adattatori ENA. I messaggi sono simili ai seguenti esempi:
+ **ID evento 5007**: Adattatore Amazon Elastic Network: timeout scaduto durante un'operazione.
+ **ID evento 5205**: Adattatore Amazon Elastic Network: il ripristino dell'adattatore è stato avviato.
I ripristini dell'adattatore causano un'interruzione minima del traffico. Anche quando ci sono più ripristini, sarebbe insolito causare gravi interruzioni della rete.
#### Causa
Questa sequenza di eventi indica che il driver ENA per Windows ha avviato un ripristino per una scheda ENA che non rispondeva. Tuttavia, il meccanismo utilizzato dal driver del dispositivo per rilevare questo problema è soggetto a falsi positivi derivanti dalla starvation della CPU 0.
#### Soluzione
Se questa combinazione di errori si verifica frequentemente, controllare le allocazioni delle risorse per vedere dove potrebbero essere utile effettuare degli aggiustamenti.
1. Aprire la finestra di dialogo **Esegui** utilizzando uno dei metodi descritti nella sezione precedente.
1. Per aprire il Resource Monitor di Windows, inserire `resmon` nel campo **Esegui**.
1. Scegli **OK**. Viene visualizzata la finestra di Resource Monitor.
1. Apertura della scheda **CPU**. I grafici di utilizzo per CPU sono mostrati sul lato destro della finestra di Resource Monitor.
1. Controllare i livelli di utilizzo della CPU 0 per vedere se sono troppo alti.
Si consiglia di configurare RSS per escludere la CPU 0 per l'adattatore ENA su tipi di istanza più grandi (più di 16 vCPU). Per i tipi di istanza più piccoli, la configurazione di RSS potrebbe migliorare l'esperienza, ma a causa del minor numero di core disponibili, è necessario eseguire test per garantire che il vincolo dei core della CPU non influisca negativamente sulle prestazioni.
Utilizzare il comando **Set-NetAdapterRss** per configurare RSS per l'adattatore ENA, come illustrato nell'esempio seguente.
```
Set-NetAdapterRss -name (Get-NetAdapter | Where-Object {$_.InterfaceDescription -like "*Elastic*"}).Name -Baseprocessorgroup 0 -BaseProcessorNumber 1
```
### La migrazione a un'infrastruttura di istanza di sesta generazione influisce sulle prestazioni o sull'allegato
#### Description
Se si esegue la migrazione a un'istanza EC2 di sesta generazione, è possibile che si verifichino prestazioni ridotte o errori degli allegati ENA nel caso in cui la versione del driver ENA per Windows non sia stata aggiornata.
#### Causa
I tipi di istanze EC2 di sesta generazione richiedono la seguente versione minima del driver ENA Windows, basata sul sistema operativo (SO) dell'istanza.
**Versione minima**
| Versione di Windows Server | Versione driver ENA |
| --- | --- |
| Windows Server 2008 R2 | 2.2.3 o 2.4.0 |
| Windows Server 2012 e versioni successive | Versione 2.2.3 e successive |
| Workstation Windows | Versione 2.2.3 e successive |
#### Soluzione
Prima di eseguire l'aggiornamento a un'istanza EC2 di sesta generazione, assicurati che l'AMI da cui esegui l'avvio disponga di driver compatibili basati sul sistema operativo dell'istanza, come mostrato nella tabella precedente. Per ulteriori informazioni, consulta l'articolo [Cosa devo fare prima di eseguire la migrazione della mia istanza EC2 a un'istanza di sesta generazione per assicurarmi di ottenere le massime prestazioni di rete?](https://repost.aws/knowledge-center/migrate-to-gen6-ec2-instance) nel *Knowledge Center di AWS re:Post *.
### Prestazioni non ottimali per l'interfaccia di rete elastica (ENI)
#### Description
L'interfaccia ENA non funziona come previsto.
#### Causa
L'analisi della causa principale per i problemi di prestazioni è un procedimento per esclusione. Ci sono troppe variabili coinvolte per identificare una causa comune.
#### Soluzione
Il primo passo nell'analisi della causa principale consiste nell'esaminare le informazioni diagnostiche per l'istanza che non funziona come previsto, per determinare se ci sono errori che potrebbero causare il problema. Per ulteriori informazioni, consulta la sezione [Raccogliere informazioni diagnostiche sull'istanza](#ts-ena-drv-collect-diagnostics).
Per ottenere le massime prestazioni di rete sulle istanze con reti avanzate, potrebbe essere necessario modificare la configurazione del sistema operativo predefinita. Alcune ottimizzazioni, come l'attivazione dell'offload con checksum e l'abilitazione di RSS, sono configurate per impostazione predefinita nei Windows ufficiali. AMIs Per altre ottimizzazioni che è possibile applicare all'adattatore ENA, vedere le regolazioni delle prestazioni mostrate in [Regolazione delle prestazioni dell'adattatore ENA](#ts-ena-drv-perf-adj).
Si consiglia di procedere con cautela e di limitare le regolazioni delle proprietà del dispositivo a quelle elencate in questa sezione o a modifiche specifiche consigliate dal team di supporto. AWS
Per modificare le proprietà dell'adattatore ENA, attenersi alla seguente procedura:
1. Aprire la finestra di dialogo **Esegui** utilizzando uno dei metodi descritti nella sezione precedente.
1. Per aprire Gestione dispositivi in Windows, inserire `devmgmt.msc` nel campo **Esegui**.
1. Scegli **OK**. Viene visualizzata la finestra Gestione dispositivi.
1. Selezionare la freccia visualizzata a sinistra di **Schede di rete** per espandere l’elenco.
1. Scegliere il nome o aprire il menu contestuale per **Adattatore elastico di rete Amazon** e quindi **Proprietà**. In questo modo si apre la finestra di dialogo **Proprietà di Amazon Elastic Network Adapter**.
1. Per apportare le modifiche, apri la scheda **Avanzate**.
1. Al termine, scegli **OK** per salvare le modifiche.
L'esempio seguente mostra una proprietà dell'adattatore ENA in Gestione dispositivi di Windows:
![\[Esempio: proprietà dell'adattatore ENA in Gestione dispositivi di Windows.\]](http://docs.aws.amazon.com/it_it/AWSEC2/latest/UserGuide/images/ena-adapter-device-mgr-property.png)
##### Regolazione delle prestazioni dell'adattatore ENA
La tabella seguente include le proprietà che possono essere regolate per migliorare le prestazioni dell'interfaccia ENA.
**Input**
| Proprietà | Description | Valore predefinito | Regolazione |
| --- | --- | --- | --- |
| Buffer di ricezione | Controlla il numero di voci nelle code di ricezione del software. | 1.024 | Questa quota può essere aumentata fino a un massimo di 8192. |
| Receive Side Scaling (RSS) | Consente la distribuzione efficiente dell'elaborazione della ricezione CPUs in rete su più sistemi multiprocessore. | Abilitato | È possibile distribuire il carico su più processori. Per ulteriori informazioni, consulta [Ottimizzazione delle prestazioni di rete sulle istanze EC2 Windows](enhanced-networking-os.md). |
| Numero massimo di code RSS | Imposta il numero massimo di code RSS consentite quando `RSS` è abilitato. | 32 | Il numero di code RSS viene determinato durante l'inizializzazione del driver e include, tra le altre, le seguenti limitazioni: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AWSEC2/latest/UserGuide/troubleshoot-ena-driver.html) È possibile impostare il valore da 1 a 32, a seconda dei limiti di generazione dell'istanza e dell'hardware. Per ulteriori informazioni, consulta [Ottimizzazione delle prestazioni di rete sulle istanze EC2 Windows](enhanced-networking-os.md). |
| Pacchetti Jumbo | Consente l'utilizzo di frame jumbo ethernet (oltre 1500 byte di payload). | Disabilitato (questo limita il payload a 1500 byte o meno) | Il valore può essere impostato su `9015`, che si traduce in 9001 byte di payload. Questo è il payload massimo per i frame jumbo ethernet. Per informazioni, consulta [Considerazioni sull'utilizzo dei frame jumbo ethernet](#ts-ena-drv-jumbo-frames). |
##### Considerazioni sull'utilizzo dei frame jumbo ethernet
I frame jumbo consentono più di 1500 byte di dati aumentando la dimensione di payload per pacchetto, aumentando quindi la percentuale del pacchetto che non suppone un sovraccarico del pacchetto. È quindi necessario un numero minore di pacchetti per inviare la stessa quantità di dati utilizzabili. Tuttavia, il traffico è limitato a un MTU massimo di 1500 nei seguenti casi:
+ Traffico al di fuori di una determinata AWS regione per EC2 Classic.
+ Traffico esterno a un singolo VPC.
+ Traffico su una connessione di peering VPC tra regioni.
+ Traffico su connessioni VPN.
+ Traffico su un gateway Internet.
**Nota**
I pacchetti superiori a 1500 byte sono frammentati. Se hai flag `Don't Fragment` è impostato nell'intestazione IP, questi pacchetti vengono eliminati.
I frame jumbo devono essere utilizzati con cautela per il traffico vincolato a Internet o qualsiasi traffico che esca da un VPC. I pacchetti vengono frammentati da sistemi intermedi, i quali rallentano tale traffico. Per utilizzare i frame jumbo all'interno di un VPC senza influire sul traffico in uscita dal VPC, provare una delle seguenti opzioni:
Configurare la dimensione MTU per routing.
Puoi usare più interfacce di rete con dimensioni MTU diverse e instradamenti diversi.
**Casi d'uso consigliati per frame jumbo**
I jumbo frame possono essere utili per il traffico interno e intermedio. VPCs Si consiglia di utilizzare i frame jumbo per i seguenti casi d'uso:
+ Per le istanze collocate in un gruppo di posizionamento cluster, i frame jumbo aiutano a raggiungere il massimo throughput della rete possibile. Per ulteriori informazioni, consulta [Gruppi di posizionamento per le tue EC2 istanze Amazon](placement-groups.md).
+ Puoi utilizzare i jumbo frame per il traffico tra la tua rete VPCs e quella locale. Direct Connect*Per ulteriori informazioni sull'utilizzo e la verifica della funzionalità jumbo frame Direct Connect, consulta [MTU per interfacce virtuali private o interfacce virtuali di transito](https://docs.aws.amazon.com/directconnect/latest/UserGuide/WorkingWithVirtualInterfaces.html#set-jumbo-frames-vif.html) nella Guida per l'utente.Direct Connect *
+ Per ulteriori informazioni sulle dimensioni MTU supportate per i Transit Gateway, consultare [Quote per Transit Gateway](https://docs.aws.amazon.com/vpc/latest/tgw/transit-gateway-quotas.html#mtu-quota) in *Amazon VPC Transit Gateway*.
# Migliora le prestazioni di rete tra le istanze EC2 con ENA Express
ENA Express è alimentato dalla tecnologia AWS Scalable Reliable Datagram (SRD). SRD è un protocollo di trasporto di rete ad alte prestazioni che utilizza l’instradamento dinamico per aumentare il throughput e ridurre al minimo la latenza di coda. Con ENA Express, puoi comunicare tra due istanze EC2 nella stessa zona di disponibilità.
**Vantaggi di ENA Express**
+ Aumenta la larghezza di banda massima che può usare un singolo flusso da 5 Gbps fino a 25 Gbps all’interno della zona di disponibilità, fino al limite di istanza aggregato.
+ Riduce la latenza di coda del traffico di rete tra le istanze EC2, specialmente durante i periodi di elevato carico di rete.
+ Rileva ed evita i percorsi di rete congestionati.
+ Gestisce alcune attività direttamente a livello di rete, come il riordino dei pacchetti sul lato di ricezione e la maggior parte delle ritrasmissioni necessarie. Questo libera il livello dell’applicazione per altre attività.
**Nota**
Se l’applicazione invia o riceve un volume elevato di pacchetti al secondo e deve ottimizzare la latenza per la maggior parte del tempo, specialmente nei periodi in cui la rete non è congestionata, [Reti avanzate](enhanced-networking.md) potrebbe essere la soluzione più adatta alla rete.
Il traffico di ENA Express non può essere inviato in una zona locale.
Dopo aver abilitato ENA Express per il collegamento dell’interfaccia di rete su un’istanza, l’istanza di invio avvia la comunicazione con l’istanza di ricezione e SRD rileva se ENA Express è in funzione sia sull’istanza di invio sia sull’istanza di ricezione. Se ENA Express è in funzione, la comunicazione può utilizzare la trasmissione SRD. Se ENA Express non è in funzione, la comunicazione torna alla trasmissione ENA standard.
Durante i periodi di tempo in cui il traffico di rete è scarso, potresti notare un leggero aumento della latenza dei pacchetti (decine di microsecondi) quando il pacchetto utilizza ENA Express. In questi periodi, le applicazioni che danno priorità a specifiche caratteristiche prestazionali di rete possono trarre vantaggio da ENA Express come segue:
+ I processi possono trarre vantaggio dall’aumento della larghezza di banda massima a flusso singolo da 5 Gbps fino a 25 Gbps all’interno della stessa zona di disponibilità fino al limite dell’istanza aggregata. Ad esempio, se un tipo di istanza specifico supporta fino a 12,5 Gbps, anche la larghezza di banda a flusso singolo è limitata a 12,5 Gbps.
+ I processi in esecuzione più a lungo termine dovrebbero avere una latenza di coda ridotta durante i periodi di congestione della rete.
+ I processi possono trarre vantaggio da una distribuzione più fluida e standard per i tempi di risposta della rete.
**Topics**
+ [Come funziona ENA Express](#ena-express-how-it-works)
+ [Tipi di istanza supportati per ENA Express](#ena-express-supported-instance-types)
+ [Prerequisiti per istanze Linux](#ena-express-prereq-linux)
+ [Ottimizza le prestazioni per le impostazioni ENA Express su istanze Linux](#ena-express-tune)
+ [Rivedi le impostazioni di ENA Express per la tua istanza EC2](ena-express-list-view.md)
+ [Configura le impostazioni di ENA Express per la tua istanza EC2](ena-express-configure.md)
## Come funziona ENA Express
ENA Express è alimentato dalla tecnologia AWS Scalable Reliable Datagram (SRD). Distribuisce i pacchetti per ogni flusso di rete su diversi AWS percorsi di rete e regola dinamicamente la distribuzione quando rileva segni di congestione. Gestisce anche il riordino dei pacchetti sul lato di ricezione.
Per garantire che ENA Express sia in grado di gestire il traffico di rete come previsto, le istanze di invio e ricezione e la comunicazione tra di esse devono soddisfare tutti i seguenti requisiti:
+ Sono supportati i tipi sia delle istanze di invio sia di quelle di ricezione. Per ulteriori informazioni, consulta la tabella [Tipi di istanza supportati per ENA Express](#ena-express-supported-instance-types).
+ Sia le istanze di invio sia quelle di ricezione devono avere ENA Express configurato. Se esistono differenze nella configurazione, si possono verificare situazioni in cui il traffico è impostato automaticamente sulla trasmissione ENA standard. Lo scenario seguente mostra ciò che accade in questo caso.
**Scenario: differenze nella configurazione**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AWSEC2/latest/UserGuide/ena-express.html)
In questo caso, il traffico TCP tra le due istanze può utilizzare ENA Express, poiché è abilitato su entrambe le istanze. Tuttavia, poiché una delle istanze non utilizza ENA Express per il traffico UDP, la comunicazione tra queste due istanze tramite UDP utilizza la trasmissione ENA standard.
+ Le istanze di invio e ricezione devono essere eseguite nella stessa zona di disponibilità.
+ Il percorso di rete tra le istanze non deve includere box middleware (software intermediario). ENA Express attualmente non supporta i box middleware (software intermediario).
+ (Solo istanze Linux) Per utilizzare tutto il potenziale della larghezza di banda, utilizza la versione 2.2.9 o successiva del driver.
+ (Solo istanze Linux) Per produrre parametri, utilizza la versione 2.8 o successiva del driver.
Se un requisito non viene soddisfatto, le istanze utilizzano il protocollo standard ma senza SRD per comunicare. TCP/UDP
Per assicurarti che il driver di rete dell’istanza sia configurato per prestazioni ottimali, consulta le best practice consigliate per i driver ENA. Queste best practice si applicano anche a ENA Express. Per ulteriori informazioni, consulta la guida [ENA Linux Driver Best Practices and Performance Optimization Guide sul sito Web](https://github.com/amzn/amzn-drivers/blob/master/kernel/linux/ena/ENA_Linux_Best_Practices.rst). GitHub
**Nota**
Per Amazon EC2, una relazione tra un’istanza e un’interfaccia di rete a essa collegata è un *collegamento*. Le impostazioni di ENA Express si applicano al collegamento. Se l’interfaccia di rete è scollegata dall’istanza, il collegamento non esiste più e le impostazioni di ENA Express ad esso applicate non sono più valide. Lo stesso vale quando un’istanza viene terminata, anche se l’interfaccia di rete rimane.
Dopo avere abilitato ENA Express per i collegamenti dell’interfaccia di rete sia sull’istanza di invio sia sull’istanza di ricezione, è possibile utilizzare i parametri di ENA Express per garantire che le istanze traggano il massimo vantaggio dai miglioramenti delle prestazioni offerti dalla tecnologia SRD. Per ulteriori informazioni sui parametri di ENA Express, consulta la pagina [Parametri di ENA Express](monitoring-network-performance-ena.md#network-performance-metrics-ena-express).
## Tipi di istanza supportati per ENA Express
I seguenti tipi di istanza supportano ENA Express.
------
#### [ General purpose ]
| Tipo di istanza | Architecture |
| --- | --- |
| 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 di istanza | Architecture |
| --- | --- |
| 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 di istanza | Architecture |
| --- | --- |
| 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 di istanza | Architecture |
| --- | --- |
| 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 di istanza | Architecture |
| --- | --- |
| 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 |
------
## Prerequisiti per istanze Linux
Per assicurarti che ENA Express possa funzionare in modo efficace, aggiorna le impostazioni per l’istanza Linux come indicato di seguito.
+ Se l’istanza utilizza frame jumbo, esegui il comando seguente per impostare la tua unità di trasmissione massima (MTU) su `8900`.
```
[ec2-user ~]$ sudo ip link set dev eth0 mtu 8900
```
+ Aumenta la dimensione dell’anello ricevitore (Rx) nel modo seguente:
```
[ec2-user ~]$ ethtool -G device rx 8192
```
+ Per massimizzare la larghezza di banda di ENA Express, configura i limiti della coda TCP come segue:
1. Imposta il limite di coda ridotta TCP su 1 MB o più. Ciò aumenta i dati in coda per la trasmissione su un socket:
```
sudo sh -c 'echo 1048576 > /proc/sys/net/ipv4/tcp_limit_output_bytes'
```
1. Disabilita i limiti della coda di byte sul dispositivo eth se sono abilitati per la tua distribuzione Linux. Ciò aumenta anche i dati in coda per la trasmissione, ma a livello di coda del dispositivo:
```
sudo sh -c 'for txq in /sys/class/net/eth0/queues/tx-*; do echo max > ${txq}/byte_queue_limits/limit_min; done'
```
**Nota**
Il driver ENA per la distribuzione Amazon Linux disattiva i limiti delle code di byte per impostazione predefinita.
+ Per ridurre al minimo la latenza del traffico TCP di ENA Express, puoi disabilitare la funzione di autocorking TCP. Ciò potrebbe comportare un aumento minimo del sovraccarico dei pacchetti:
```
sudo bash -c 'echo 0 > /proc/sys/net/ipv4/tcp_autocorking'
```
## Ottimizza le prestazioni per le impostazioni ENA Express su istanze Linux
Per verificare la configurazione dell'istanza Linux per prestazioni ottimali di ENA Express, puoi eseguire il seguente script disponibile nel GitHub repository Amazon:
[https://github.com/amzn/amzn-ec2-ena- - .sh utilities/blob/main/ena-express/check ena-express-settings](https://github.com/amzn/amzn-ec2-ena-utilities/blob/main/ena-express/check-ena-express-settings.sh)
Lo script esegue una serie di test e suggerisce le modifiche di configurazione consigliate e obbligatorie.
# Rivedi le impostazioni di ENA Express per la tua istanza EC2
Puoi verificare le impostazioni di ENA Express per istanza o per interfaccia di rete. Per aggiornare le impostazioni di ENA Express, consulta [Configura le impostazioni di ENA Express per la tua istanza EC2](ena-express-configure.md).
------
#### [ Console ]
**Per visualizzare le impostazioni di ENA Express per un’interfaccia di rete**
1. Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Nel pannello di navigazione a sinistra, scegli **Network interfaces** (Interfacce di rete).
1. Seleziona un’interfaccia di rete per visualizzare i dettagli relativi a quell’istanza. Puoi scegliere il collegamento **Network interface ID** (ID interfaccia di rete) per aprire la pagina dei dettagli oppure puoi selezionare la casella di controllo alla sinistra dell’elenco per visualizzare i dettagli nel riquadro dei dettagli in fondo alla pagina.
1. Nella sezione **Collegamento dell’interfaccia di rete** della scheda **Dettagli** o della pagina dei dettagli, rivedi le impostazioni per **ENA Express** ed **ENA Express UDP**
**Per visualizzare le impostazioni di ENA Express per un’istanza**
1. Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Nel riquadro di navigazione a sinistra, scegli **Istanze**.
1. Seleziona un’istanza per visualizzarne i dettagli. Puoi scegliere il collegamento **Instance ID** (ID dell’istanza) per aprire la pagina dei dettagli oppure puoi selezionare la casella di controllo alla sinistra dell’elenco per visualizzare i dettagli nel riquadro dei dettagli in fondo alla pagina.
1. Nella sezione **Network interfaces** (Interfacce di rete) della scheda**Networking** (Reti), scorri verso destra per rivedere le impostazioni per **ENA Express** ed **ENA Express UDP**.
------
#### [ AWS CLI ]
**Per ottenere le impostazioni di ENA Express per un’istanza**
Utilizza il comando [https://docs.aws.amazon.com/cli/latest/reference/describe-instances.html](https://docs.aws.amazon.com/cli/latest/reference/describe-instances.html). Questo esempio di comando restituisce un elenco di configurazioni ENA Express per le interfacce di rete collegate a ciascuna delle istanze in esecuzione specificate dal parametro `--instance-ids`.
```
aws ec2 describe-instances \
--instance-ids i-1234567890abcdef0 i-0598c7d356eba48d7 \
--query 'Reservations[*].Instances[*].[InstanceId, NetworkInterfaces[*].Attachment.EnaSrdSpecification]'
```
Di seguito è riportato un output di esempio.
```
[
[
[
"i-1234567890abcdef0",
[
{
"EnaSrdEnabled": true,
"EnaSrdUdpSpecification": {
"EnaSrdUdpEnabled": false
}
}
]
]
],
[
[
"i-0598c7d356eba48d7",
[
{
"EnaSrdEnabled": true,
"EnaSrdUdpSpecification": {
"EnaSrdUdpEnabled": false
}
}
]
]
]
]
```
**Per ottenere le impostazioni di ENA Express per un’interfaccia di rete**
Utilizza il 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]
```
Di seguito è riportato un output di esempio.
```
[
[
"eni-1234567890abcdef0",
{
"EnaSrdEnabled": true,
"EnaSrdUdpSpecification": {
"EnaSrdUdpEnabled": false
}
}
]
]
```
------
#### [ PowerShell ]
**Per ottenere le impostazioni di ENA Express per un’interfaccia di rete**
Utilizza il 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 } }
```
Di seguito è riportato un output di esempio.
```
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
```
------
# Configura le impostazioni di ENA Express per la tua istanza EC2
È possibile configurare ENA Express per i tipi di istanze EC2 supportati senza dover installare alcun software aggiuntivo. Per ulteriori informazioni, consulta [Tipi di istanza supportati per ENA Express](ena-express.md#ena-express-supported-instance-types).
------
#### [ Console ]
**Per gestire ENA Express per un’interfaccia di rete**
1. Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Nel pannello di navigazione a sinistra, scegli **Network interfaces** (Interfacce di rete).
1. Seleziona un’interfaccia di rete collegata a un’istanza. Puoi scegliere il collegamento **Network interface ID** (ID interfaccia di rete) per aprire la pagina dei dettagli oppure puoi selezionare la casella di controllo alla sinistra dell’elenco.
1. Scegli **Manage ENA Express** (Gestisci ENA Express) dal menu **Action** (Operazione) in alto a destra della pagina. Si apre la finestra di dialogo **Manage ENA Express** (Gestisci ENA Express), dove vengono visualizzati l’ID dell’interfaccia di rete selezionata e le impostazioni correnti.
Se l’interfaccia di rete selezionata non è collegata a un’istanza, questa operazione non viene visualizzata nel menu.
1. Per utilizzare **ENA Express**, seleziona la casella di spunta **Abilita**.
1. Quando ENA Express è abilitato, puoi configurare le impostazioni UDP. Per utilizzare **ENA Express UDP**, seleziona la casella di controllo **Abilita**.
1. Per salvare le impostazioni, scegli **Save** (Salva).
**Per gestire ENA Express per un’istanza**
1. Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Nel riquadro di navigazione a sinistra, scegli **Istanze**.
1. Seleziona il tipo di istanza che vuoi gestire. Puoi scegliere il collegamento **Instance ID** (ID dell’istanza) per aprire la pagina dei dettagli oppure puoi selezionare la casella di controllo alla sinistra dell’elenco.
1. Seleziona la **Network interface** (Interfaccia di rete) da configurare per l’istanza.
1. Scegli **Manage ENA Express** (Gestisci ENA Express) dal menu **Action** (Operazione) in alto a destra della pagina.
1. Per configurare ENA Express per un’interfaccia di rete collegata all’istanza, selezionala dall’elenco **Network interface** (Interfaccia di rete).
1. Per utilizzare **ENA Express** per il collegamento dell’interfaccia di rete selezionato, seleziona la casella di controllo **Abilita**.
1. Quando ENA Express è abilitato, puoi configurare le impostazioni UDP. Per utilizzare **ENA Express UDP**, seleziona la casella di controllo **Abilita**.
1. Per salvare le impostazioni, scegli **Save** (Salva).
**Per configurare ENA Express durante il collegamento di un’interfaccia di rete**
1. Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Nel pannello di navigazione a sinistra, scegli **Network interfaces** (Interfacce di rete).
1. Seleziona un’interfaccia di rete non collegata a un’istanza, dove **Status** (Stato) è **Available** (Disponibile). Puoi scegliere il collegamento **Network interface ID** (ID interfaccia di rete) per aprire la pagina dei dettagli oppure puoi selezionare la casella di controllo alla sinistra dell’elenco.
1. Seleziona l’**Instance** (Istanza) a cui collegarti.
1. Per utilizzare **ENA Express** dopo il collegamento dell’interfaccia di rete all’istanza, seleziona la casella di controllo **Abilita**.
1. Quando ENA Express è abilitato, puoi configurare le impostazioni UDP. Per utilizzare **ENA Express UDP**, seleziona la casella di controllo **Abilita**.
1. Per collegare l’interfaccia di rete all’istanza e salvare le impostazioni di ENA Express, scegli **Collega**.
------
#### [ AWS CLI ]
**Per configurare ENA Express durante il collegamento di un’interfaccia di rete**
Utilizza il 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) come visualizzato negli esempi seguenti.
**Esempio 1: Utilizza ENA Express per il traffico TCP ma non per il traffico UDP**
Questo esempio configura `EnaSrdEnabled` come `true` e consente l’impostazione predefinita di `EnaSrdUdpEnabled` su `false`.
```
aws ec2 attach-network-interface \
--network-interface-id eni-1234567890abcdef0 \
--instance-id i-1234567890abcdef0 \
--device-index 1 \
--ena-srd-specification 'EnaSrdEnabled=true'
```
**Esempio 2: utilizzo di ENA Express sia per il traffico TCP sia per il traffico UDP**
Questo esempio configura sia `EnaSrdEnabled` sia `EnaSrdUdpEnabled` come `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}'
```
**Per aggiornare le impostazioni di ENA Express per il collegamento dell’interfaccia di rete**
Utilizza il 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) come mostrato negli esempi seguenti.
**Esempio 1: Utilizza ENA Express per il traffico TCP ma non per il traffico UDP**
Questo esempio configura `EnaSrdEnabled` come `true` e consente l’impostazione predefinita di `EnaSrdUdpEnabled` su `false`, se non è stato fatto in precedenza.
```
aws ec2 modify-network-interface-attribute \
--network-interface-id eni-1234567890abcdef0 \
--ena-srd-specification 'EnaSrdEnabled=true'
```
**Esempio 2: utilizzo di ENA Express sia per il traffico TCP sia per il traffico UDP**
Questo esempio configura sia `EnaSrdEnabled` sia `EnaSrdUdpEnabled` come `true`.
```
aws ec2 modify-network-interface-attribute \
--network-interface-id eni-1234567890abcdef0 \
--ena-srd-specification 'EnaSrdEnabled=true,EnaSrdUdpSpecification={EnaSrdUdpEnabled=true}'
```
**Esempio 3: abbandono dell’utilizzo di ENA Express per il traffico UDP**
Questo esempio configura `EnaSrdUdpEnabled` come `false`.
```
aws ec2 modify-network-interface-attribute \
--network-interface-id eni-1234567890abcdef0 \
--ena-srd-specification 'EnaSrdUdpSpecification={EnaSrdUdpEnabled=false}'
```
------
#### [ PowerShell ]
**Per configurare ENA Express durante il collegamento di un’interfaccia di rete**
Utilizza il 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) come mostrato negli esempi seguenti.
**Esempio 1: Utilizza ENA Express per il traffico TCP ma non per il traffico UDP**
Questo esempio configura `EnaSrdEnabled` come `true` e consente l’impostazione predefinita di `EnaSrdUdpEnabled` su `false`.
```
Add-EC2NetworkInterface `
-NetworkInterfaceId eni-1234567890abcdef0 `
-InstanceId i-1234567890abcdef0 `
-DeviceIndex 1 `
-EnaSrdSpecification_EnaSrdEnabled $true
```
**Esempio 2: utilizzo di ENA Express sia per il traffico TCP sia per il traffico UDP**
Questo esempio configura sia `EnaSrdEnabled` sia `EnaSrdUdpEnabled` come `true`.
```
Add-EC2NetworkInterface `
-NetworkInterfaceId eni-1234567890abcdef0 `
-InstanceId i-1234567890abcdef0 `
-DeviceIndex 1 `
-EnaSrdSpecification_EnaSrdEnabled $true `
-EnaSrdUdpSpecification_EnaSrdUdpEnabled $true
```
**Per configurare le impostazioni di ENA Express per il collegamento dell’interfaccia di rete**
Utilizza il 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) come mostrato negli esempi seguenti.
**Esempio 1: Utilizza ENA Express per il traffico TCP ma non per il traffico UDP**
Questo esempio configura `EnaSrdEnabled` come `true` e consente l’impostazione predefinita di `EnaSrdUdpEnabled` su `false`, se non è stato fatto in precedenza.
```
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
```
**Esempio 2: utilizzo di ENA Express sia per il traffico TCP sia per il traffico UDP**
Questo esempio configura sia `EnaSrdEnabled` sia `EnaSrdUdpEnabled` come `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
```
**Esempio 3: abbandono dell’utilizzo di ENA Express per il traffico UDP**
Questo esempio configura `EnaSrdUdpEnabled` come `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 ENA Express al momento dell’avvio
Puoi utilizzare uno dei seguenti metodi per configurare direttamente ENA Express quando si avvia un’istanza. I link specificati rimandano alle istruzioni per questi metodi. Console di gestione AWS
+ **Procedura guidata di avvio dell’istanza**: puoi configurare ENA Express all’avvio con la procedura guidata di avvio dell’istanza. Per maggiori informazioni, consulta **Configurazione avanzata di rete** nelle [Impostazioni di rete](ec2-instance-launch-parameters.md#liw-network-settings) per la procedura guidata di avvio dell’istanza.
+ **Modello di avvio**: puoi configurare ENA Express all’avvio quando usi un modello di avvio. Per ulteriori informazioni, consulta la pagina [Creare un modello di avvio Amazon EC2](create-launch-template.md), quindi espandi la sezione **Impostazioni di rete** e rivedi la **Configurazione di rete avanzata**.
# Reti avanzate con l'interfaccia VF Intel 82599 sulle istanze
Per le [istanze basate su Xen](instance-types.md#instance-hypervisor-type), la Funzione virtuale (VF) dell'interfaccia Intel 82599 offre funzionalità di rete avanzate. L'interfaccia utilizza il driver Intel `ixgbevf`.
Le schede seguenti mostrano come verificare il driver della scheda di rete installato per il sistema operativo dell'istanza.
------
#### [ Linux ]
**Driver dell'interfaccia di rete Linux**
Utilizza il comando seguente per verificare se il modulo viene utilizzato su un'interfaccia specifica, sostituendo il nome dell'interfaccia che desideri controllare. Se usi una singola interfaccia (impostazione predefinita), essa sarà `eth0`. Se il sistema operativo supporta [nomi di rete prevedibili](#predictable-network-names-sriov), questo potrebbe essere un nome simile a `ens5`.
Nell'esempio seguente, il modulo `ixgbevf` non viene caricato, perché il driver nell'elenco è `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
```
In questo esempio, viene caricato il modulo `ixgbevf`. Questa istanza dispone della funzionalità per reti avanzate adeguatamente configurata.
```
[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 ]
**Adattatore di rete Windows**
Per verificare se il driver è installato, connettiti all'istanza e apri Device Manager (Gestione dispositivi). Dovresti vedere `Intel(R) 82599 Virtual Function` elencato nella sezione **Adattatori di rete**.
------
**Topics**
+ [Prepara l'istanza per le reti avanzate](#ixgbevf-requirements)
+ [Verifica dell’abilitazione delle reti avanzate](#test-enhanced-networking)
+ [Abilitazione delle reti avanzate su un’istanza](#enable-enhanced-networking)
+ [Risolvere i problemi di connettività](#enhanced-networking-troubleshooting)
## Prepara l'istanza per le reti avanzate
Per preparare la configurazione delle funzionalità delle reti avanzate tramite l'interfaccia VF Intel 82599, configura l'istanza nel seguente modo:
+ Verifica che il tipo di istanza sia uno dei seguenti: C3, C4, D2, I2, M4 (esclusi`m4.16xlarge`) e R3.
+ Verificare che l’istanza disponga di connettività Internet.
+ Se sull’istanza sono presenti dati importanti che devono essere conservati, è consigliabile eseguire una copia di backup di tali dati ora mediante la creazione di un’AMI dall’istanza. L'aggiornamento dei kernel e dei relativi moduli, nonché l'abilitazione dell'attributo `sriovNetSupport`, potrebbero rendere non compatibili le istanze o irraggiungibili i sistemi operativi. Se disponi di un backup recente, i tuoi dati saranno mantenuti.
+ **Istanze Linux**: avvia l'istanza da un'AMI HVM tramite il kernel Linux versione 2.6.32 o successive. Nella versione più recente di Amazon Linux HVM AMIs sono installati i moduli necessari per una rete avanzata e sono impostati gli attributi richiesti. Pertanto, se viene avviata un'istanza supportata da Amazon EBS e che include il supporto delle reti avanzate tramite un'AMI HVM di Amazon Linux corrente, le reti avanzate sono già abilitate per l'istanza.
**avvertimento**
Le reti avanzate sono supportate solo per le istanze HVM. L'abilitazione delle reti avanzate con un'istanza PV potrebbe rendere irraggiungibile l'istanza. L'impostazione di questo attributo senza un modulo appropriato o una versione di modulo corretta può rendere irraggiungibile l'istanza.
+ **Istanze Windows**: avvia l'istanza da un'AMI HVM a 64 bit. Non puoi abilitare le reti avanzate su Windows Server 2008. La rete avanzata è già abilitata per Windows Server 2012 R2 e Windows Server 2016 e versioni successive. AMIs Windows Server 2012 R2 include il driver Intel 1.0.15.3. Consigliamo di aggiornare questo driver alla versione più recente utilizzando la utility Pnputil.exe.
+ Puoi utilizzarlo [AWS CloudShell](https://console.aws.amazon.com/cloudshell)da oppure installarlo e configurarlo [AWS Tools for Windows PowerShell](https://docs.aws.amazon.com/powershell/latest/userguide/)su qualsiasi computer a tua scelta, preferibilmente sul desktop o sul laptop locale. Console di gestione AWS[AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) Per ulteriori informazioni, consulta [Accesso a Amazon EC2](concepts.md#access-ec2) o la [Guida per l’utente di AWS CloudShell](https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html). Le reti avanzate non possono essere gestite dalla console Amazon EC2.
## Verifica dell’abilitazione delle reti avanzate
Verifica che l’attributo `sriovNetSupport` sia impostato sull’istanza o sull’immagine.
------
#### [ AWS CLI ]
**Per controllare l'attributo di istanza (sriovNetSupport)**
Utilizza il seguente 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 l'attributo è impostato, il valore è `simple`.
```
aws ec2 describe-instance-attribute \
--instance-id i-1234567890abcdef0 \
--attribute sriovNetSupport
```
**Per controllare l'attributo image (sriovNetSupport)**
Utilizza il seguente 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 l'attributo è impostato, il valore è `simple`.
```
aws ec2 describe-images \
--image-id ami-0abcdef1234567890 \
--query "Images[].SriovNetSupport"
```
------
#### [ PowerShell ]
**Per controllare l'attributo di istanza (sriovNetSupport)**
Utilizzare il 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 l'attributo è impostato, il valore è `simple`.
```
Get-EC2InstanceAttribute `
-InstanceId i-1234567890abcdef0 `
-Attribute sriovNetSupport
```
**Per controllare l'attributo image (sriovNetSupport)**
Utilizza il seguente 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 l'attributo è impostato, il valore è `simple`.
```
(Get-EC2Image -ImageId ami-0abcdef1234567890).SriovNetSupport
```
------
## Abilitazione delle reti avanzate su un’istanza
La procedura utilizzata dipende dal sistema operativo dell'istanza.
**avvertimento**
Non sono disponibili procedure per disabilitare l'attributo delle reti avanzate dopo averlo abilitato.
### Amazon Linux
Nell'ultima versione di Amazon Linux HVM è AMIs installato il `ixgbevf` modulo necessario per le reti avanzate e il set di `sriovNetSupport` attributi richiesto. Pertanto, se avvii un tipo di istanza tramite un'AMI HVM di Amazon Linux corrente, le reti avanzate sono già abilitate per l'istanza. Per ulteriori informazioni, consulta [Verifica dell’abilitazione delle reti avanzate](#test-enhanced-networking).
Se l'istanza è stata avviata utilizzando una AMI Amazon Linux più vecchia che non dispone delle reti avanzate già abilitate, utilizzare la seguente procedura per abilitare le reti avanzate.
**Per abilitare le reti avanzate**
1. Connettiti alla tua istanza.
1. Dall'istanza, esegui il seguente comando per aggiornare l'istanza in base al nuovo kernel e ai nuovi moduli kernel, compreso `ixgbevf`:
```
[ec2-user ~]$ sudo yum update
```
1. Dal computer locale, riavvia l’istanza utilizzando la console Amazon EC2 o uno dei comandi seguenti: [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) o [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. Ricollegati all'istanza e verifica che il modulo `ixgbevf` sia installato con la versione minima consigliata utilizzando il comando **modinfo ixgbevf** disponibile in [Verifica dell’abilitazione delle reti avanzate](#test-enhanced-networking).
1. [Istanza supportata da EBS] Dal computer locale, arresta l’istanza utilizzando la console Amazon EC2 o uno dei comandi seguenti: [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) o [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).
[Istanza supportata da instance store] Non è possibile arrestare l’istanza per modificare l’attributo. Passa invece alla procedura successiva.
1. Dal computer locale, abilita l’attributo relativo alle reti avanzate utilizzando uno dei seguenti comandi:
------
#### [ AWS CLI ]
Utilizza il 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) come riportato di seguito.
```
aws ec2 modify-instance-attribute \
--instance-id i-1234567890abcdef0 \
--sriov-net-support simple
```
------
#### [ PowerShell ]
Utilizza il 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) come riportato di seguito.
```
Edit-EC2InstanceAttribute `
-InstanceId i-1234567890abcdef0 `
-SriovNetSupport "simple"
```
------
1. (Facoltativo) Crea un’AMI dall’istanza, come descritto in [Creare un'AMI supportata da Amazon EBS](creating-an-ami-ebs.md). L’AMI eredita l’attributo relativo alle reti avanzate dall’istanza. Pertanto, è possibile utilizzare questa AMI per avviare un’altra istanza con le reti avanzate abilitate per impostazione di default.
1. Dal computer locale, avvia l’istanza utilizzando la console Amazon EC2 o uno dei comandi seguenti: [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) o [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. Connettiti all'istanza e verifica che il modulo `ixgbevf` sia installato e caricato sull'interfaccia di rete in uso tramite il comando **ethtool -i eth*n*** disponibile in [Verifica dell’abilitazione delle reti avanzate](#test-enhanced-networking).
**Per abilitare le reti avanzate (istanze supportate da instance store)**
Segui la procedura precedente fino al punto in cui si arresta l'istanza. Crea una nuova AMI come descritto in [Creare un’AMI supportata da Amazon S3](creating-an-ami-instance-store.md), assicurandoti di abilitare l’attributo relativo alle reti avanzate durante la registrazione dell’AMI.
------
#### [ AWS CLI ]
Utilizza il 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) come riportato di seguito.
```
aws ec2 register-image --sriov-net-support simple ...
```
------
#### [ PowerShell ]
Utilizza [https://docs.aws.amazon.com/powershell/latest/reference/items/Register-EC2Image.html](https://docs.aws.amazon.com/powershell/latest/reference/items/Register-EC2Image.html) come segue.
```
Register-EC2Image -SriovNetSupport "simple" ...
```
------
### Ubuntu
Prima di iniziare, [controlla se le reti avanzate sono già abilitate](#test-enhanced-networking) nell'istanza.
Il Quick Start Ubuntu HVM AMIs include i driver necessari per una rete avanzata. Se hai una versione di `ixgbevf` precedente alla 2.16.4, puoi installare il pacchetto kernel `linux-aws` per avere i driver di rete ottimizzati più recenti.
La seguente procedura descrive le fasi generali necessarie per compilare il modulo `ixgbevf` su un'istanza Ubuntu.
**Come installare il pacchetto `linux-aws` kernel**
1. Connettiti alla tua istanza.
1. Aggiorna la cache dei pacchetti e i pacchetti.
```
ubuntu:~$ sudo apt-get update && sudo apt-get upgrade -y linux-aws
```
**Importante**
Se durante il processo di aggiornamento viene richiesto di installare `grub`, utilizza `/dev/xvda` per installare `grub`, quindi scegli di conservare la versione corrente di `/boot/grub/menu.lst`.
### Altre distribuzioni Linux
Prima di iniziare, [controlla se le reti avanzate sono già abilitate](#test-enhanced-networking) nell'istanza. L'ultima versione di Quick Start HVM AMIs include i driver necessari per una rete avanzata, pertanto non è necessario eseguire passaggi aggiuntivi.
La procedura seguente descrive le fasi generali da eseguire se devi abilitare le reti avanzate con l'interfaccia VF Intel 82599 su una distribuzione Linux diversa da Amazon Linux o Ubuntu. Per ulteriori informazioni, ad esempio sintassi dettagliata dei comandi, posizione dei file o supporto di pacchetti e strumenti, consulta la documentazione specifica per la distribuzione Linux in uso.
**Per abilitare le reti avanzate su Linux**
1. Connettiti alla tua istanza.
1. [Scaricate il codice sorgente del `ixgbevf` modulo sulla vostra istanza da Sourceforge all'indirizzo https://sourceforge. net/projects/e1000/files/ixgbevf%20stable/.](https://sourceforge.net/projects/e1000/files/ixgbevf%20stable/)
Le versioni di `ixgbevf` precedenti alla 2.16.4, compresa la versione 2.14.2, non vengono compilate correttamente su alcune distribuzioni Linux, comprese determinate versioni di Ubuntu.
1. Compila e installa il modulo `ixgbevf` sull'istanza.
**avvertimento**
Se si esegue la compilazione del modulo `ixgbevf` per il kernel corrente e quindi si aggiorna il kernel senza ricompilare il driver per il nuovo kernel, al successivo riavvio il sistema potrebbe ripristinare il modulo `ixgbevf` specifico della distribuzione. Questo potrebbe rendere irraggiungibile il sistema se la versione specifica della distribuzione è incompatibile con la rete migliorata.
1. Esegui il comando **sudo depmod** per aggiornare le dipendenze del modulo.
1. Aggiorna `initramfs` sull'istanza in modo che il nuovo modulo venga caricato in fase di avvio.
1. Determina se il sistema utilizza nomi di interfaccia di rete prevedibili per impostazione di default. I sistemi che utilizzano **systemd** o **udev** versione 197 o successive possono rinominare i dispositivi Ethernet e pertanto non garantiscono che la singola interfaccia di rete venga rinominata in `eth0`. Questo comportamento potrebbe causare problemi durante la connessione all’istanza. Per ulteriori informazioni e per informazioni sulle altre opzioni di configurazione disponibili, consulta l'argomento relativo ai [nomi di interfaccia di rete prevedibili](https://www.freedesktop.org/wiki/Software/systemd/PredictableNetworkInterfaceNames/) sul sito Web freedesktop.org.
1. È possibile controllare le versioni di **systemd** o **udev** sui sistemi basati su RPM utilizzando il seguente comando:
```
[ec2-user ~]$ rpm -qa | grep -e '^systemd-[0-9]\+\|^udev-[0-9]\+'
systemd-208-11.el7_0.2.x86_64
```
Nell’esempio precedente relativo a Red Hat Enterprise Linux 7, la versione di **systemd** è 208, pertanto, i nomi di interfaccia di rete prevedibili devono essere disabilitati.
1. Disabilitare i nomi di interfaccia di rete prevedibili aggiungendo l’opzione `net.ifnames=0` alla riga `GRUB_CMDLINE_LINUX` in `/etc/default/grub`.
```
[ec2-user ~]$ sudo sed -i '/^GRUB\_CMDLINE\_LINUX/s/\"$/\ net\.ifnames\=0\"/' /etc/default/grub
```
1. Ricompila il file di configurazione di grub.
```
[ec2-user ~]$ sudo grub2-mkconfig -o /boot/grub2/grub.cfg
```
1. [Istanza supportata da EBS] Dal computer locale, arresta l’istanza utilizzando la console Amazon EC2 o uno dei comandi seguenti: [stop-instances](https://docs.aws.amazon.com/cli/latest/reference/ec2/stop-instances.html) (AWS CLI) o [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).
[Istanza supportata da instance store] Non è possibile arrestare l’istanza per modificare l’attributo. Passa invece alla procedura successiva.
1. Dal computer locale, abilita l’attributo relativo alle reti avanzate utilizzando uno dei seguenti comandi:
------
#### [ AWS CLI ]
Utilizza il 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) come riportato di seguito.
```
aws ec2 modify-instance-attribute \
--instance-id i-1234567890abcdef0 -\
-sriov-net-support simple
```
------
#### [ PowerShell ]
Utilizza il 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) come riportato di seguito.
```
Edit-EC2InstanceAttribute `
-InstanceId i-1234567890abcdef0 `
-SriovNetSupport "simple"
```
------
1. (Facoltativo) Crea un’AMI dall’istanza, come descritto in [Creare un'AMI supportata da Amazon EBS](creating-an-ami-ebs.md). L’AMI eredita l’attributo relativo alle reti avanzate dall’istanza. Pertanto, è possibile utilizzare questa AMI per avviare un’altra istanza con le reti avanzate abilitate per impostazione di default.
Se il sistema operativo dell’istanza contiene un file `/etc/udev/rules.d/70-persistent-net.rules`, è necessario eliminarlo prima di creare l’AMI. Questo file contiene l’indirizzo MAC per la scheda Ethernet dell’istanza originale. Se un’altra istanza viene avviata con questo file, il sistema operativo non sarà in grado di trovare il dispositivo ed `eth0` potrebbe non funzionare causando problemi di avvio. Questo file viene rigenerato al successivo ciclo di avvio e qualsiasi istanza avviata dall’AMI crea la propria versione del file.
1. Dal computer locale, avvia l’istanza utilizzando la console Amazon EC2 o uno dei comandi seguenti: [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) o [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. (Facoltativo) Connettiti all'istanza e verifica che il modulo sia installato.
**Per abilitare le reti avanzate (istanze supportate da archivio istanze)**
Segui la procedura precedente fino al punto in cui si arresta l'istanza. Crea una nuova AMI come descritto in [Creare un’AMI supportata da Amazon S3](creating-an-ami-instance-store.md), assicurandoti di abilitare l’attributo relativo alle reti avanzate durante la registrazione dell’AMI.
------
#### [ AWS CLI ]
Utilizza il 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) come riportato di seguito.
```
aws ec2 register-image --sriov-net-support simple ...
```
------
#### [ PowerShell ]
Utilizza [https://docs.aws.amazon.com/powershell/latest/reference/items/Register-EC2Image.html](https://docs.aws.amazon.com/powershell/latest/reference/items/Register-EC2Image.html) come segue.
```
Register-EC2Image -SriovNetSupport "simple" ...
```
------
### Windows
Se hai avviato l’istanza per la quale la funzionalità di reti avanzate non è già abilitata, devi scaricare e installare il driver per la scheda di rete richiesto sull’istanza e quindi impostare l’attributo `sriovNetSupport` dell’istanza in modo da attivare le reti avanzate. Puoi abilitare questo attributo solo sui tipi di istanza supportati. Per ulteriori informazioni, consulta [Rete avanzata su EC2 istanze Amazon](enhanced-networking.md).
**Importante**
Per visualizzare gli ultimi aggiornamenti dei driver in Windows AMIs, consulta la [cronologia delle versioni di Windows AMI](https://docs.aws.amazon.com/ec2/latest/windows-ami-reference/ec2-windows-ami-version-history.html) nel *AWS Windows AMI Reference*.
**Per abilitare le reti avanzate**
1. Connettersi all’istanza ed eseguire l’accesso come amministratore locale.
1. [Windows Server 2016 e versioni successive] Esegui il seguente PowerShell script di avvio EC2 per configurare l'istanza dopo l'installazione del driver.
```
PS C:\> C:\ProgramData\Amazon\EC2-Windows\Launch\Scripts\InitializeInstance.ps1 -Schedule
```
**Importante**
La password amministratore verrà reimpostata quando abiliti lo script EC2 Launch dell'istanza di inizializzazione. Puoi modificare il file di configurazione per disattivare la reimpostazione della password amministratore specificandolo nelle impostazioni delle attività di inizializzazione.
1. Dall'istanza, scaricare il driver della scheda di rete Intel per il sistema operativo in uso:
+ **Windows Server 2022**
Visita la [pagina di download](https://www.intel.com/content/www/us/en/download/706171/intel-network-adapter-driver-for-windows-server-2022.html) e scarica `Wired_driver_version_x64.zip`.
+ **Windows Server 2019** incluso per Server versione 1809 e successive\$1
Visita la [pagina di download](https://www.intel.com/content/www/us/en/download/19372/intel-network-adapter-driver-for-windows-server-2019.html) e scarica `Wired_driver_version_x64.zip`.
+ **Windows Server 2016** incluso per Server versione 1803 e precedenti\$1
Visita la [pagina di download](https://www.intel.com/content/www/us/en/download/18737/intel-network-adapter-driver-for-windows-server-2016.html) e scarica `Wired_driver_version_x64.zip`.
+ **Windows Server 2012 R2**
Visita la [pagina di download](https://www.intel.com/content/www/us/en/download/17480/intel-network-adapter-driver-for-windows-server-2012-r2.html) e scarica `Wired_driver_version_x64.zip`.
+ **Windows Server 2012**
Visita la [pagina di download](https://www.intel.com/content/www/us/en/download/16789/intel-network-adapter-driver-for-windows-server-2012.html) e scarica `Wired_driver_version_x64.zip`.
+ **Windows Server 2008 R2**
Visita la [pagina di download](https://www.intel.com/content/www/us/en/download/15590/intel-network-adapter-driver-for-windows-7-final-release.html) e scarica `PROWinx64Legacy.exe`.
\$1Le versioni Server 1803 e precedenti e 1809 e successive non sono specificatamente trattate nelle pagine Driver e Software Intel.
1. Installa il driver della scheda di rete Intel per il sistema operativo in uso.
+ **Windows Server 2008 R2**
1. Nella cartella **Downloads**, individua il file `PROWinx64Legacy.exe` e rinominalo `PROWinx64Legacy.zip`.
1. Estrai i contenuti del file `PROWinx64Legacy.zip`.
1. Apri la riga di comando, passa alla cartella contenente i file estratti e utilizza l'utility `pnputil` per aggiungere e installare il file INF nell'archivio dei driver.
```
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. Nella cartella **Downloads**, estrarre i contenuti del file `Wired_driver_version_x64.zip`.
1. Apri la riga di comando, passa alla cartella contenente i file estratti ed esegui uno dei seguenti comandi per utilizzare l'utility `pnputil` per aggiungere e installare il file INF nell'archivio dei driver.
+ 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. Dal computer locale, abilita l’attributo relativo alle reti avanzate utilizzando uno dei seguenti comandi:
------
#### [ AWS CLI ]
Utilizza il 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) come riportato di seguito.
```
aws ec2 modify-instance-attribute \
--instance-id i-1234567890abcdef0 \
--sriov-net-support simple
```
------
#### [ PowerShell ]
Utilizza il 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) come riportato di seguito.
```
Edit-EC2InstanceAttribute `
-InstanceId i-1234567890abcdef0 `
-SriovNetSupport "simple"
```
------
1. (Facoltativo) Crea un’AMI dall’istanza, come descritto in [Creare un'AMI supportata da Amazon EBS](creating-an-ami-ebs.md). L’AMI eredita l’attributo relativo alle reti avanzate dall’istanza. Pertanto, è possibile utilizzare questa AMI per avviare un’altra istanza con le reti avanzate abilitate per impostazione di default.
1. Dal computer locale, avvia l’istanza utilizzando la console Amazon EC2 o uno dei comandi seguenti: [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) o [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).
## Risolvere i problemi di connettività
Se si perde la connettività durante l'abilitazione delle reti avanzate, il modulo `ixgbevf` potrebbe non essere compatibile con il kernel. Prova a installare la versione del modulo `ixgbevf` inclusa nella distribuzione di Linux per l'istanza in uso.
Se si abilitano le reti avanzate per un'istanza PV o AMI, l'istanza può risultare irraggiungibile.
Per ulteriori informazioni, consulta [Come abilitare e configurare le reti avanzate sulle mie istanze EC2?](https://repost.aws/knowledge-center/enable-configure-enhanced-networking)
# Monitoraggio delle prestazioni di rete per le impostazioni ENA dell'istanza EC2
Il driver ENA (Elastic Network Adapter) pubblica i parametri delle prestazioni di rete dalle istanze in cui sono attivati. È possibile utilizzare questi parametri per risolvere i problemi relativi alle prestazioni delle istanze, scegliere la dimensione dell'istanza appropriata per un carico di lavoro, pianificare le attività di scalabilità in modo proattivo e confrontare le applicazioni per determinare se massimizzano le prestazioni disponibili in un'istanza.
Amazon EC2 definisce i valori massimi di rete a livello di istanza per garantire un'esperienza di rete di alta qualità, comprese prestazioni di rete costanti per tutte le dimensioni delle istanze. AWS fornisce i valori massimi per quanto segue per ogni istanza:
+ **Capacità di larghezza di banda**: ogni istanza EC2 ha una larghezza di banda massima per il traffico aggregato in entrata e in uscita, in base al tipo e alle dimensioni dell'istanza. Alcune istanze utilizzano un meccanismo di I/O credito di rete per allocare la larghezza di banda della rete in base all'utilizzo medio della larghezza di banda. Amazon EC2 offre inoltre la larghezza di banda massima per il traffico verso Direct Connect e Internet. Per ulteriori informazioni, consulta [Larghezza di banda di rete delle EC2 istanze Amazon](ec2-instance-network-bandwidth.md).
+ Packet-per-second Prestazioni **(PPS): ogni istanza EC2 offre prestazioni** PPS massime, in base al tipo e alle dimensioni dell'istanza.
+ **Connessioni tracciate**: il gruppo di sicurezza tiene traccia di ogni connessione stabilita per garantire che i pacchetti restituiti vengano consegnati come previsto. Per ciascuna istanza esiste un numero massimo di connessioni che possono essere monitorate. Per ulteriori informazioni, consulta [Monitoraggio della connessione al gruppo di sicurezza Amazon EC2](security-group-connection-tracking.md)
+ **Accesso al servizio locale del collegamento**: Amazon EC2 fornisce un PPS massimo per interfaccia di rete per il traffico verso servizi proxy locali quali il servizio Amazon DNS, il servizio di metadati dell’istanza e il servizio di sincronizzazione oraria di Amazon.
Quando il traffico di rete di un'istanza supera il limite massimo, AWS modella il traffico che supera il massimo mettendo in coda e quindi eliminando i pacchetti di rete. Utilizzando i parametri delle prestazioni di rete è possibile monitorare quando il traffico supera un valore massimo. Questi parametri indicano in tempo reale l'impatto sul traffico di rete e i possibili problemi relativi alle prestazioni della rete.
**Topics**
+ [Requisiti](#network-performance-metrics-requirements)
+ [Parametri per il driver ENA](#network-performance-metrics)
+ [Visualizzare i parametri delle prestazioni di rete per l'istanza](#view-network-performance-metrics)
+ [Parametri di ENA Express](#network-performance-metrics-ena-express)
+ [Parametri delle prestazioni di rete con il driver DPDK per ENA](#network-performance-metrics-dpdk)
+ [Parametri sulle istanze che eseguono FreeBSD](#network-performance-metrics-freebsd)
## Requisiti
**Istanze Linux**
+ Installare il driver ENA versione 2.2.10 o successiva. Per verificare la versione installata, utilizzare il comando **ethtool**. Nell'esempio seguente, la versione soddisfa il requisito minimo.
```
[ec2-user ~]$ ethtool -i eth0 | grep version
version: 2.2.10
```
Per aggiornare il driver ENA, consulta [Reti avanzate](enhanced-networking-ena.md).
+ Per importare questi parametri su Amazon CloudWatch, installa l' CloudWatch agente. Per ulteriori informazioni, consulta [Collect network performance metrics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch-Agent-network-performance.html) nella *Amazon CloudWatch User Guide*.
+ Per supportare la metrica `conntrack_allowance_available`, installa la versione 2.8.1 o successiva del driver ENA.
+ Per ignorare il limite PPS del frammento di uscita di 1024, installa la versione 2.13.3 o successiva del driver ENA.
**Istanze Windows**
+ Installare il driver ENA versione 2.2.2 o successiva. Per verificare la versione installata, utilizzare Gestione periferiche come segue.
1. Aprire Gestione periferiche eseguendo `devmgmt.msc`.
1. Espandere **Network Adapters (Schede di rete)**.
1. Scegliere **Amazon Elastic Network Adapter (Adattatore di rete elastico di Amazon)**, quindi **Properties (Proprietà)**.
1. Nella scheda **Driver** individuare **Driver Version (Versione driver)**.
Per aggiornare il driver ENA, consulta [Reti avanzate](enhanced-networking-ena.md).
+ Per importare questi parametri su Amazon CloudWatch, installa l' CloudWatch agente. Per ulteriori informazioni, consulta [Collect advanced network metrics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch-Agent-network-performance.html) nella *Amazon CloudWatch User Guide*.
## Parametri per il driver ENA
Il driver ENA fornisce i seguenti parametri all'istanza in tempo reale. Questi forniscono il numero complessivo di pacchetti accodati o rilasciati su ciascuna interfaccia di rete dall'ultimo ripristino del driver.
| Metrica | Description | Supportato su |
| --- | --- | --- |
| bw\$1in\$1allowance\$1exceeded | Il numero di pacchetti accordati o rilasciati perché la larghezza di banda aggregata in ingresso ha superato il valore massimo per l'istanza. | Tutti i tipi di istanza |
| bw\$1out\$1allowance\$1exceeded | Il numero di pacchetti accodati o rilasciati perché la larghezza di banda aggregata in uscita ha superato il valore massimo per l'istanza. | Tutti i tipi di istanza |
| conntrack\$1allowance\$1exceeded | Il numero di pacchetti accodati o rilasciati perché il rilevamento delle connessioni ha superato il valore massimo per l'istanza e non è stato possibile stabilire nuove connessioni. Ciò può comportare la perdita di pacchetti per il traffico da o verso l'istanza. | Tutti i tipi di istanza |
| conntrack\$1allowance\$1available | Il numero di connessioni tracciate che possono essere stabilite dall'istanza prima di raggiungere il limite Connessioni tracciate di quel tipo di istanza. | Solo [istanze basate su Nitro](instance-types.md#instance-hypervisor-type) |
| linklocal\$1allowance\$1exceeded | Il numero di pacchetti accodati o rilasciati perché il PPS del traffico verso i servizi proxy locali ha superato il valore massimo per l'interfaccia di rete. Ciò influisce sul traffico verso il servizio Amazon DNS, il servizio di metadati dell’istanza e il servizio di sincronizzazione oraria di Amazon, ma non influisce sul traffico verso i resolver DNS personalizzati. | Tutti i tipi di istanza |
| pps\$1allowance\$1exceeded | Il numero di pacchetti in coda o abbandonati perché il PPS bidirezionale ha superato il valore massimo per l’istanza. \$1 | Tutti i tipi di istanza |
\$1 A seconda dell’impostazione della modalità proxy a frammenti per il driver ENA Linux v2.13.3 o successiva, tale limite può includere anche abbandono di frammenti in uscita superiori a 1024 PPS per l’interfaccia di rete. Se la modalità proxy a frammenti è abilitata per il driver Linux, gli abbandoni di frammenti in uscita aggirano il limite di 1024 PPS normalmente applicato e sono conteggiate entro le autorizzazioni PPS standard. Per impostazione predefinita, la modalità proxy a frammenti è disabilitata.
## Visualizzare i parametri delle prestazioni di rete per l'istanza
La procedura utilizzata dipende dal sistema operativo dell'istanza.
### Istanze Linux
È possibile pubblicare parametri negli strumenti preferiti per visualizzare i dati dei parametri. Ad esempio, puoi pubblicare le metriche su Amazon CloudWatch utilizzando l' CloudWatch agente. L'agente consente di selezionare singoli parametri e di controllare la pubblicazione.
Inoltre, è possibile utilizzare **ethtool** per recuperare i parametri per ogni interfaccia di rete, ad esempio eth0, come indicato di seguito.
```
[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
```
### Istanze Windows
È possibile visualizzare i parametri utilizzando qualsiasi consumer di contatori delle prestazioni di Windows. I dati possono essere analizzati in base al manifesto. EnaPerfCounters Si tratta di un file XML che definisce il fornitore del contatore delle prestazioni e i relativi set di contatori.
**Per installare il manifesto**
Se l'istanza è stata avviata utilizzando una AMI contenente il driver ENA 2.2.2 o versione successiva, o si è utilizzato lo script di installazione nel pacchetto driver per il driver ENA 2.2.2, il manifest è già installato. Per installare manualmente il manifest, attenersi alla seguente procedura:
1. Rimuovere il manifest esistente utilizzando il seguente comando:
```
unlodctr /m:EnaPerfCounters.man
```
1. Copiare il file manifest `EnaPerfCounters.man` dal pacchetto di installazione del driver a `%SystemRoot%\System32\drivers`.
1. Installare il nuovo manifest utilizzando il seguente comando:
```
lodctr /m:EnaPerfCounters.man
```
**Per visualizzare i parametri utilizzando Performance Monitor**
1. Aprire Performance Monitor.
1. Premere Ctrl\$1N per aggiungere nuovi contatori.
1. Scegliere **ENA Packets Shaping (Modellazione pacchetti ENA)** dall'elenco.
1. Selezionare le istanze da monitorare e scegliere **Add (Aggiungi)**.
1. Seleziona **OK**.
## Parametri di ENA Express
ENA Express è alimentato dalla tecnologia AWS Scalable Reliable Datagram (SRD). SRD è un protocollo di trasporto di rete ad alte prestazioni che utilizza l'instradamento dinamico per aumentare il throughput e ridurre al minimo la latenza di coda. Se è stato abilitato ENA Express per i collegamenti dell'interfaccia di rete sia sull'istanza di invio sia sull'istanza di ricezione, è possibile utilizzare i parametri di ENA Express per garantire che le istanze traggano il massimo vantaggio dai miglioramenti delle prestazioni offerti dalla tecnologia SRD. Esempio:
+ Valuta le tue risorse per assicurarti che abbiano una capacità sufficiente per stabilire più connessioni SRD.
+ Identifica dove risiedono i potenziali problemi che impediscono ai pacchetti in uscita idonei di utilizzare SRD.
+ Calcola la percentuale di traffico in uscita che utilizza SRD per l'istanza.
+ Calcola la percentuale di traffico in entrata che utilizza SRD per l'istanza.
**Nota**
Per produrre parametri, utilizza la versione 2.8 o successiva del driver.
Per visualizzare un elenco di parametri per l'istanza Linux filtrati per ENA Express, eseguire il comando **ethtool** per l'interfaccia di rete (mostrata qui come `eth0`). Prendere nota del valore del parametro `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
```
I seguenti parametri sono disponibili per tutte le istanze con ENA Express abilitato.
**ena\$1srd\$1mode**
Descrive quali funzionalità ENA Express sono abilitate. I valori sono i seguenti:
+ `0` = ENA Express disattivato, UDP disattivato
+ `1` = ENA Express attivato, UDP disattivato
+ `2` = ENA Express disattivato, UDP attivato
**Nota**
Ciò accade solo quando ENA Express è stato abilitato in origine e UDP è stato configurato per il suo utilizzo. Il valore precedente viene mantenuto per il traffico UDP.
+ `3` = ENA Express attivato, UDP attivato
**ena\$1srd\$1eligible\$1tx\$1pkts**
Il numero di rete è il seguente:
+ Sono supportati i tipi sia delle istanze di invio sia di quelle di ricezione. Per ulteriori informazioni, consulta la tabella [Tipi di istanza supportati per ENA Express](ena-express.md#ena-express-supported-instance-types).
+ Sia le istanze di invio sia quelle di ricezione devono avere ENA Express configurato.
+ Le istanze di invio e ricezione devono essere eseguite nella stessa zona di disponibilità.
+ Il percorso di rete tra le istanze non deve includere box middleware (software intermediario). ENA Express attualmente non supporta i box middleware (software intermediario).
Il parametro di idoneità ENA Express copre i requisiti di origine e destinazione e la rete tra i due endpoint. I pacchetti idonei possono comunque essere squalificati dopo che sono già stati contati. Ad esempio, se un pacchetto idoneo supera il limite massimo di unità di trasmissione (MTU), torna alla trasmissione ENA standard, sebbene il pacchetto sia comunque indicato come idoneo nel contatore.
**ena\$1srd\$1tx\$1pkts**
Il numero di pacchetti SRD trasmessi in un determinato periodo di tempo.
**ena\$1srd\$1rx\$1pkts**
Il numero di pacchetti SRD ricevuti in un determinato periodo di tempo.
**ena\$1srd\$1resource\$1utilization**
La percentuale di utilizzo massimo della memoria consentita per le connessioni SRD simultanee adoperate dall'istanza.
Per verificare se la trasmissione dei pacchetti utilizza SRD, è possibile confrontare il numero di pacchetti idonei (parametro `ena_srd_eligible_tx_pkts`) con il numero di pacchetti SRD trasmessi (parametro `ena_srd_tx_pkts`) durante un determinato periodo di tempo.
**Traffico in uscita (pacchetti in uscita)**
Per assicurarti che il traffico in uscita utilizzi SRD come previsto, confronta il numero di pacchetti SRD idonei (`ena_srd_eligible_tx_pkts`) con il numero di pacchetti SRD inviati (`ena_srd_tx_pkts`) in un determinato periodo di tempo.
Differenze significative tra il numero di pacchetti idonei e il numero di pacchetti SRD inviati sono spesso causate da problemi di utilizzo delle risorse. Quando la scheda di rete collegata all'istanza ha esaurito il massimo delle risorse o se i pacchetti superano il limite MTU, i pacchetti idonei non sono in grado di trasmettere tramite SRD e devono ricorrere alla trasmissione ENA standard. I pacchetti possono rientrare in questa lacuna anche durante le migrazioni in tempo reale o gli aggiornamenti del server in tempo reale. È necessaria un'ulteriore risoluzione dei problemi per determinare la causa principale.
**Nota**
È possibile ignorare le piccole differenze occasionali tra il numero di pacchetti idonei e il numero di pacchetti SRD. Tali differenze possono verificarsi, ad esempio, quando l'istanza stabilisce una connessione a un'altra istanza per il traffico SRD.
Per scoprire quale percentuale del traffico totale in uscita in un determinato periodo di tempo utilizza SRD, confronta il numero di pacchetti SRD inviati (`ena_srd_tx_pkts`) con il numero totale di pacchetti inviati per l'istanza (`NetworkPacketOut`) durante tale periodo.
**Traffico in ingresso (pacchetti in entrata)**
Per scoprire quale percentuale del traffico in entrata utilizza SRD, confronta il numero di pacchetti SRD ricevuti (`ena_srd_rx_pkts`) in un determinato periodo di tempo con il numero totale di pacchetti ricevuti per l'istanza (`NetworkPacketIn`) durante tale periodo.
**Utilizzo delle risorse**
L'utilizzo delle risorse si basa sul numero di connessioni SRD simultanee che una singola istanza può sostenere in un dato momento. Il parametro di utilizzo delle risorse (`ena_srd_resource_utilization`) tiene traccia dell'utilizzo corrente per l'istanza. A mano a mano che l'utilizzo si avvicina al 100%, puoi aspettarti di riscontrare problemi di prestazioni. ENA Express passa dalla trasmissione SRD alla trasmissione ENA standard e la possibilità di perdita di pacchetti aumenta. L'elevato utilizzo delle risorse indica che è giunto il momento di dimensionare l'istanza per migliorare le prestazioni della rete.
**Nota**
Quando il traffico di rete di un'istanza supera il limite massimo, AWS modella il traffico che supera il massimo mettendo in coda e poi facendo cadere i pacchetti di rete.
**Persistenza**
I parametri di uscita e ingresso si accumulano quando ENA Express è abilitato per l'istanza. I parametri smettono di accumularsi se ENA Express è disattivato, ma persistono fintantoché l'istanza è in esecuzione. I parametri vengono ripristinati se l'istanza si riavvia o viene terminata oppure se l'interfaccia di rete viene scollegata dall'istanza.
## Parametri delle prestazioni di rete con il driver DPDK per ENA
Il driver ENA versione 2.2.0 e successive supporta il reporting dei parametri di rete. DPDK 20.11 include il driver ENA 2.2.0 ed è la prima versione di DPDK a supportare questa funzionalità.
Il driver DPDK v25.03 o versione successiva supporta la modalità proxy a frammenti. Se la modalità proxy a frammenti è abilitata per il driver DPDK, gli abbandoni di frammenti in uscita aggirano il limite di 1024 PPS normalmente applicato e sono conteggiate entro le autorizzazioni PPS standard. Per impostazione predefinita, la modalità proxy a frammenti è disabilitata.
È possibile utilizzare un'applicazione di esempio per visualizzare le statistiche DPDK. Per avviare una versione interattiva dell'applicazione di esempio, esegui il comando seguente.
```
./app/dpdk-testpmd -- -i
```
All'interno di questa sessione interattiva, è possibile immettere un comando per recuperare le statistiche estese per una porta. Il seguente comando di esempio recupera le statistiche per la porta 0.
```
show port xstats 0
```
Di seguito è riportato un esempio di sessione interattiva con l'applicazione di esempio 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>
```
Per ulteriori informazioni sull'applicazione di esempio e sul suo utilizzo per recuperare statistiche estese, consulta [Testpmd Application User Guide](https://doc.dpdk.org/guides/testpmd_app_ug/) nella documentazione di DPDK.
## Parametri sulle istanze che eseguono FreeBSD
A partire dalla versione 2.3.0, il driver ENA FreeBSD supporta la raccolta di parametri sulle prestazioni di rete su istanze che eseguono FreeBSD. Per abilitare la raccolta di FreeBSD metriche, inserisci il comando seguente e imposta un valore compreso tra 1 e 3600*interval*. Questo specifica la frequenza con cui, in pochi secondi, raccogliere i parametri di FreeBSD.
```
sysctl dev.ena.network_interface.eni_metrics.sample_interval=interval
```
Ad esempio, il seguente comando imposta il driver affinché raccolga i parametri di FreeBSD sull'interfaccia di rete 1 ogni 10 secondi:
```
sysctl dev.ena.1.eni_metrics.sample_interval=10
```
Per disattivare la raccolta di FreeBSD metriche, puoi eseguire il comando precedente e specificare come. `0` *interval*
Dopo aver abilitato la raccolta dei parametri di FreeBSD, è possibile recuperare l'ultima serie di parametri raccolti eseguendo il seguente comando.
```
sysctl dev.ena.network_interface.eni_metrics
```
# Migliora la latenza di rete per le istanze basate su EC2 Linux
La latenza di rete è il tempo che un pacchetto di dati impiega per viaggiare dall'origine alla destinazione. Le applicazioni che inviano dati attraverso la rete dipendono da risposte tempestive per fornire un'esperienza utente positiva. Una latenza di rete elevata può portare a vari problemi, come i seguenti:
+ Tempi di caricamento lenti per le pagine Web
+ Ritardi nello streaming video
+ Difficoltà di accesso alle risorse online
Questa sezione descrive i passaggi che puoi intraprendere per migliorare la latenza di rete EC2 sulle istanze Amazon eseguite su Linux. Per ottenere una latenza ottimale, segui questi passaggi per configurare le impostazioni dell'istanza, del kernel e del driver ENA. Per ulteriori indicazioni sulla configurazione, consulta la Guida alle [best practice e all'ottimizzazione delle prestazioni dei driver ENA Linux su](https://github.com/amzn/amzn-drivers/blob/master/kernel/linux/ena/ENA_Linux_Best_Practices.rst). GitHub
**Nota**
I passaggi e le impostazioni possono variare leggermente a seconda dell'hardware di rete specifico, dell'AMI dalla quale hai avviato l'istanza e del caso d'uso dell'applicazione. Prima di apportare modifiche, verifica e monitora accuratamente le prestazioni della rete per assicurarti di ottenere i risultati desiderati.
## Ridurre il numero di hop di rete per i pacchetti di dati
Ogni hop eseguito da un pacchetto di dati mentre si sposta da un router all'altro aumenta la latenza di rete. In genere, il traffico deve compiere più hop per raggiungere la destinazione. Esistono due modi per ridurre gli hop di rete per le EC2 istanze Amazon, come segue:
+ **Gruppo di posizionamento dei cluster**: quando si specifica un [gruppo di collocazione del cluster](placement-strategies.md#placement-groups-cluster), Amazon EC2 lancia istanze che si trovano in prossimità l'una dell'altra, fisicamente all'interno della stessa zona di disponibilità (AZ) con un imballaggio più rigoroso. La vicinanza fisica delle istanze del gruppo consente loro di sfruttare la connettività ad alta velocità, con conseguente bassa latenza ed elevato throughput a flusso singolo.
+ **Host dedicato**: un [host dedicato](dedicated-hosts-overview.md) è un server fisico dedicato al tuo utilizzo. Con un host dedicato, puoi avviare le tue istanze per eseguirle sullo stesso server fisico. La comunicazione tra istanze eseguite sullo stesso host dedicato può avvenire senza hop di rete aggiuntivi.
## In che modo la configurazione del kernel Linux influisce sulla latenza
La configurazione del kernel Linux può aumentare o diminuire la latenza di rete. Per raggiungere gli obiettivi di ottimizzazione della latenza, è importante ottimizzare la configurazione del kernel Linux in base ai requisiti specifici del tuo carico di lavoro.
Molte opzioni di configurazione per il kernel Linux potrebbero contribuire a ridurre la latenza di rete. Le opzioni che hanno un impatto maggiore sono le seguenti.
+ **Abilita la modalità polling occupato**: la modalità polling occupato riduce la latenza sul percorso di ricezione della rete. Quando si abilita la modalità polling occupato, il codice del socket layer può interrogare direttamente la coda di ricezione di un dispositivo di rete. L'aspetto negativo del polling attivo è il maggiore utilizzo della CPU nell'host, derivante dall'analisi di nuovi dati in un ciclo ristretto. Esistono due impostazioni globali che controllano il numero di microsecondi di attesa per i pacchetti in tutte le interfacce.
`busy_read`
Un timeout di polling attivo a bassa latenza per le letture del socket. Controlla il numero di microsecondi di attesa concessi al socket layer per leggere i pacchetti nella coda del dispositivo. Per abilitare la funzionalità a livello globale con il comando **sysctl**, l'organizzazione del kernel Linux consiglia un valore di 50 microsecondi. Per ulteriori informazioni, consulta [busy\$1read](https://www.kernel.org/doc/html/v5.19/admin-guide/sysctl/net.html?highlight=busy_read) nella *Guida per l'utente e l'amministratore del kernel Linux*.
```
[ec2-user ~]$ sudo sysctl -w net.core.busy_read=50
```
`busy_poll`
Un timeout di polling attivo a bassa latenza per il polling e la selezione. Questo timeout controlla il numero di microsecondi di attesa per gli eventi. Il valore consigliato è tra 50-100 microsecondi, in base al numero di socket di cui esegui il polling. Più socket aggiungi, più alto dovrebbe essere il numero.
```
[ec2-user ~]$ sudo sysctl -w net.core.busy_poll=50
```
+ **Configura gli stati di alimentazione CPU (C-state)**: gli stati C-state controllano i livelli di sospensione in cui potrebbe entrare un core quando è inattivo. Potresti voler controllare gli stati C-state per ottimizzare la latenza rispetto alle prestazioni del sistema. Negli stati C più profondi, la CPU è essenzialmente "addormentata" e non può rispondere alle richieste finché non si risveglia e torna in uno stato attivo. Inserire i core nello stato di sospensione richiedete del tempo. Sebbene un core sospeso consenta maggiore capacità aggiuntiva per un altro core per raggiungere una frequenza più elevata, è necessario del tempo affinché il core sospeso torni attivo e in funzione.
Ad esempio, se un core assegnato per gestire le interruzioni di un pacchetto di rete è addormentato, potrebbe verificarsi un ritardo nel lavoro su tale interruzione. Puoi configurare il sistema in modo che non utilizzi stati C più profondi. Tuttavia, questa configurazione non solo riduce la latenza della reazione del processore, ma anche la capacità disponibile negli altri core per il Turbo Boost.
Per ridurre la latenza di reazione del processore, è possibile limitare gli stati C-state più profondi. Per maggiori informazioni, consulta [Prestazioni elevate e bassa latenza tramite limitazione degli stati C-state più profondi](https://docs.aws.amazon.com/linux/al2/ug/processor_state_control.html#c-states) nella *Guida per l'utente di Amazon Linux 2*.
## Moderazione delle interruzioni
Il driver di rete ENA consente la comunicazione tra un'istanza e una rete. Il driver elabora i pacchetti di rete e li trasmette allo stack di rete o alla scheda Nitro. Quando arriva un pacchetto di rete, la scheda Nitro genera un'interruzione per consentire alla CPU di notificare al software un evento.
Interruzione
Un'interruzione è un segnale che un dispositivo o un'applicazione invia al processore. L'interruzione indica al processore che si è verificato un evento o è stata soddisfatta una condizione che richiede un'attenzione immediata. Le interruzioni possono gestire attività urgenti come la ricezione di dati da un'interfaccia di rete, la gestione di eventi hardware o di richieste di assistenza da altri dispositivi.
Moderazione delle interruzioni
La moderazione delle interruzioni è una tecnica che riduce il numero di interruzioni generate da un dispositivo aggregandole o ritardandole. Lo scopo della moderazione delle interruzioni è migliorare le prestazioni del sistema riducendo il sovraccarico associato alla gestione di un numero elevato di interruzioni. Troppe interruzioni aumentano l'utilizzo della CPU, influendo negativamente sulil throughput, mentre un numero insufficiente di interruzioni aumenta la latenza.
Moderazione dinamica delle interruzioni
La moderazione dinamica delle interruzioni è una forma avanzata di moderazione delle interruzioni che regola dinamicamente la frequenza di interruzione in base al carico del sistema e ai modelli di traffico correnti. Ha l'obiettivo di trovare un equilibrio tra la riduzione del sovraccarico delle interruzioni e dei pacchetti al secondo e la larghezza di banda.
La moderazione dinamica delle interruzioni è abilitata per impostazione predefinita in alcuni AMIs (ma può essere abilitata o disabilitata in tutti). AMIs
Per ridurre al minimo la latenza di rete, potrebbe essere necessario disabilitare la moderazione delle interruzioni. Tuttavia, ciò può anche aumentare il sovraccarico dato dall'elaborazione delle interruzioni. È importante trovare il giusto equilibrio tra riduzione della latenza e riduzione al minimo del sovraccarico. I comandi `ethtool` possono aiutarti a configurare la moderazione delle interruzioni. Per impostazione predefinita, `rx-usecs` è impostato su `20` e `tx-usecs` è impostato su `64`.
Per ottenere la configurazione di modifica dell'interruzione corrente, utilizza il comando seguente.
```
[ec2-user ~]$ ethtool -c interface | egrep "rx-usecs:|tx-usecs:|Adaptive RX"
Adaptive RX: on TX: off
rx-usecs: 20
tx-usecs: 64
```
Per disabilitare la moderazione dell'interruzione e la moderazione dinamica dell'interruzione, utilizza il comando seguente.
```
[ec2-user ~]$ sudo ethtool -C interface adaptive-rx off rx-usecs 0 tx-usecs 0
```
# Considerazioni sul sistema Nitro per l’ottimizzazione delle prestazioni
Il sistema Nitro è una raccolta di componenti hardware e software creati da AWS che consentono alte prestazioni, alta disponibilità e alta sicurezza. Inoltre, Nitro System fornisce funzionalità simili a bare metal che eliminano gli impegni di virtualizzazione e supportano i carichi di lavoro che richiedono accesso completo per l’hosting di hardware. Per ulteriori informazioni dettagliate, consulta [Nitro System AWS](https://aws.amazon.com/ec2/nitro/).
Tutti i tipi di istanze EC2 della generazione attuale eseguono l’elaborazione dei pacchetti di rete su schede Nitro EC2. Questo argomento illustra la gestione di pacchetti di alto livello sulla scheda Nitro, gli aspetti comuni dell’architettura e della configurazione di rete che influiscono sulle prestazioni di gestione dei pacchetti e le azioni che si possono intraprendere per ottenere le massime prestazioni per le istanze basate su Nitro.
Le schede Nitro gestiscono tutto il traffico in ingresso e in uscita (I/O) interfaces, such as those needed for Virtual Private Clouds (VPCs). For all of the components that send or receive information over the network, the Nitro cards act as a self-contained computing device for I/Otraffico fisicamente separato) dalla scheda madre del sistema su cui vengono eseguiti i carichi di lavoro dei clienti.
## Flusso di pacchetti di rete sulle schede Nitro
Le istanze EC2 basate sul sistema Nitro dispongono di funzionalità di accelerazione hardware che consentono un’elaborazione più rapida dei pacchetti, misurata in base al throughput dei pacchetti al secondo (PPS). Quando una scheda Nitro esegue la valutazione iniziale di un nuovo flusso, salva le informazioni condivise per tutti i pacchetti del flusso, come i gruppi di sicurezza, gli elenchi di controllo degli accessi e le voci della tabella di routing. Quando elabora pacchetti aggiuntivi per lo stesso flusso, può utilizzare le informazioni salvate per ridurre il sovraccarico di tali pacchetti.
La velocità di connessione è misurata in base alla metrica delle connessioni al secondo (CPS). Ogni nuova connessione richiede un sovraccarico di elaborazione aggiuntivo che deve essere tenuto in considerazione nelle stime di capacità del carico di lavoro. È importante considerare sia le metriche CPS che PPS durante la progettazione dei carichi di lavoro.
**Come viene stabilita una connessione**
Quando viene stabilita una connessione tra un’istanza basata su Nitro e un altro endpoint, la scheda Nitro valuta l’intero flusso per il primo pacchetto inviato o ricevuto tra i due endpoint. Per i pacchetti successivi dello stesso flusso, generalmente non è necessaria una rivalutazione completa. Tuttavia, ci sono alcune eccezioni. Per ulteriori informazioni sulle eccezioni, consulta [Pacchetti che non utilizzano l’accelerazione hardware](#ena-nitro-perf-exceptions).
Le seguenti proprietà definiscono i due endpoint e il flusso di pacchetti tra di loro. Queste cinque proprietà insieme sono note come flusso a 5 tuple.
+ IP di origine
+ Porta sorgente
+ IP di destinazione
+ Porta di destinazione
+ Protocollo di comunicazione
La direzione del flusso di pacchetti è nota come *ingresso* (in entrata) e *uscita* (in uscita). Le seguenti descrizioni generali riassumono il flusso di pacchetti di rete end-to-end.
+ **Ingresso**: quando una scheda Nitro gestisce un pacchetto di rete in entrata, valuta il pacchetto rispetto alle regole del firewall stateful e agli elenchi di controllo degli accessi. Tiene traccia della connessione, la misura ed esegue altre azioni, a seconda dei casi. Poi inoltra il pacchetto alla sua destinazione sulla CPU host.
+ **Uscita**: quando una scheda Nitro gestisce un pacchetto di rete in uscita, cerca la destinazione di interfaccia remota, valuta varie funzioni VPC, applica limiti di velocità ed esegue altre azioni pertinenti. Poi inoltra il pacchetto alla sua prossima destinazione dell’hopping sulla rete.
## Progetta la tua rete per ottenere prestazioni ottimali
Per sfruttare le funzionalità prestazionali del sistema Nitro, devi capire quali sono le esigenze di elaborazione di rete e in che modo tali esigenze influiscono sul carico di lavoro delle risorse Nitro. Quindi puoi progettare per ottenere prestazioni ottimali per il tuo panorama di rete. Le impostazioni dell’infrastruttura e la progettazione e configurazione del carico di lavoro delle applicazioni possono influenzare l’elaborazione dei pacchetti e le velocità di connessione. Ad esempio, se l’applicazione ha un’elevata velocità di creazione delle connessioni, come un servizio DNS, un firewall o un router virtuale, avrà meno possibilità di sfruttare l’accelerazione hardware che si verifica solo dopo aver stabilito la connessione.
Puoi configurare le impostazioni dell’applicazione e dell’infrastruttura per snellire i carichi di lavoro e migliorare le prestazioni di rete. Tuttavia, non tutti i pacchetti sono idonei all’accelerazione. Il sistema Nitro utilizza l’intero flusso di rete per nuove connessioni e per pacchetti non idonei all’accelerazione.
La parte restante di questa sezione si concentrerà sulle considerazioni relative alla progettazione di applicazioni e infrastruttura per aiutare a garantire che i pacchetti fluiscano il più possibile all’interno del percorso accelerato.
### Considerazioni sulla progettazione di rete per il sistema Nitro
Quando si configura il traffico di rete per la tua istanza, occorre considerare molti aspetti che possono influenzare le prestazioni del PPS. Una volta stabilito un flusso, la maggior parte dei pacchetti regolarmente in entrata o uscita sono idonei all’accelerazione. Tuttavia, vi sono alcune eccezioni per garantire che i progetti dell’infrastruttura e i flussi di pacchetti continuino a soddisfare gli standard del protocollo.
Per ottenere le migliori prestazioni dalla tua scheda Nitro, occorre considerare attentamente i pro e i contro dei seguenti dettagli di configurazione per infrastruttura e applicazioni.
#### Considerazioni sull’infrastruttura
La configurazione dell’infrastruttura può influire sul flusso dei pacchetti e sull’efficienza di elaborazione. L’elenco seguente include alcune importanti considerazioni.
**Configurazione dell’interfaccia di rete con asimmetria**
I gruppi di sicurezza utilizzano il monitoraggio delle connessioni per tracciare le informazioni sul traffico che fluisce da e verso l’istanza. Il routing asimmetrico, in cui il traffico entra in un’istanza attraverso un’interfaccia di rete ed esce da un’altra interfaccia di rete, può ridurre le prestazioni di picco che un’istanza può raggiungere se i flussi vengono tracciati. Per ulteriori informazioni sul tracciamento delle connessioni dei gruppi di sicurezza, sulle connessioni non tracciate e sulle connessioni tracciate automaticamente, consulta [Monitoraggio della connessione al gruppo di sicurezza Amazon EC2](security-group-connection-tracking.md).
**Driver di rete**
I driver di rete vengono aggiornati e rilasciati periodicamente. Se i driver non sono aggiornati, ciò può influire in modo significativo sulle prestazioni. Mantieni aggiornati i driver per assicurarti di avere le patch più recenti e di poter sfruttare i miglioramenti delle prestazioni, come la funzionalità di percorso accelerato disponibile solo per i driver di ultima generazione. I driver precedenti non supportano la funzionalità di percorso accelerato.
Per sfruttare la funzionalità di percorso accelerato, ti consigliamo di installare il driver ENA più recente sulle tue istanze.
**Istanze Linux** – Driver ENA Linux 2.2.9 o versione successiva. Per installare o aggiornare il driver ENA Linux dal GitHub repository Amazon Drivers, consulta la sezione sulla [compilazione dei driver](https://github.com/amzn/amzn-drivers/tree/master/kernel/linux/ena#driver-compilation) del file readme.
**Istanze Windows** – Driver ENA Windows 2.0.0 o versione successiva. Per installare o aggiornare il driver ENA Windows, consulta [Installa il driver ENA su istanze EC2 Windows](ena-adapter-driver-install-upgrade-win.md).
**Distanza tra endpoint**
Una connessione tra due istanze nella stessa zona di disponibilità può elaborare più pacchetti al secondo rispetto a una connessione tra regioni per via della finestra TCP a livello di applicazione, che determina la quantità di dati che possono essere trasmessi in un dato momento. Le lunghe distanze tra le istanze aumentano la latenza e diminuiscono il numero di pacchetti che gli endpoint possono elaborare.
**Limite di coda di byte (BQL)**
BQL è una funzionalità che limita il numero di byte passati alla scheda Nitro per ridurre la coda. BQL è disabilitato per impostazione predefinita nei driver ENA, nei sistemi operativi Amazon Linux e nella maggior parte delle distribuzioni Linux. Se BQL e l’override del proxy a frammenti sono entrambi abilitati, ciò può comportare limitazioni delle prestazioni vincolando il numero di byte passati a Nitro prima che tutti i frammenti vengano elaborati.
#### Considerazioni sulla progettazione delle applicazioni
Vi sono alcuni aspetti della progettazione e della configurazione delle applicazioni che possono influire sull’efficienza di elaborazione. L’elenco seguente include alcune importanti considerazioni.
**Dimensioni del pacchetto**
Pacchetti di dimensioni maggiori possono aumentare il throughput dei dati che un’istanza è in grado di inviare e ricevere sulla rete. Amazon EC2 supporta frame jumbo da 9.001 byte, ma altri servizi possono imporre limiti diversi. Pacchetti di dimensioni minori possono aumentare la velocità di elaborazione dei pacchetti, ma ciò può ridurre la larghezza di banda massima ottenuta quando il numero di pacchetti supera le tolleranze PPS.
Se la dimensione di un pacchetto supera l’unità di trasmissione massima (MTU) di un hop di rete, un router lungo il percorso potrebbe frammentarlo. I frammenti di pacchetto risultanti sono considerati eccezioni e di norma vengono elaborati alla velocità standard (non accelerata). Ciò può causare variazioni nelle prestazioni. Tuttavia, puoi escludere il comportamento standard per i pacchetti frammentati in uscita con l’impostazione della modalità proxy a frammenti. Per ulteriori informazioni, consulta [Massimizza le prestazioni di rete sul sistema Nitro](#ena-nitro-perf-maximize). Consigliamo di valutare la topologia per la configurazione della MTU.
**Compromessi del protocollo**
I protocolli affidabili come TCP hanno un sovraccarico maggiore rispetto ai protocolli inaffidabili come UDP. Il minore sovraccarico e l’elaborazione di rete semplificata per il protocollo di trasporto UDP possono comportare un tasso di PPS più elevato, ma a scapito di una fornitura affidabile dei pacchetti. Se la fornitura affidabile dei pacchetti non è fondamentale per la tua applicazione, UDP potrebbe essere una buona opzione.
**Micro-bursting**
Il micro-bursting avviene quando il traffico supera le tolleranze consentite per brevi periodi di tempo anziché essere distribuito uniformemente. Ciò si verifica in genere su una scala di microsecondi.
Ad esempio, supponiamo di avere un’istanza in grado di inviare fino a 10 Gbps e che l’applicazione invii tutti i 10 Gb in mezzo secondo. Questo micro-burst supera la tolleranza consentita durante il primo mezzo secondo e non lascia nulla per il resto del secondo. Anche se hai inviato 10 Gb nell’arco di tempo di 1 secondo, le tolleranze nel primo mezzo secondo possono far sì che i pacchetti vengano messi in coda o eliminati.
Puoi utilizzare uno strumento di pianificazione di rete come Linux Traffic Control per aiutare a velocizzare il throughput ed evitare che i pacchetti vengano messi in coda o persi a causa del micro-bursting.
**Numero di flussi**
Un singolo flusso è limitato a 5 Gbps a meno che non si trovi all’interno di un gruppo di posizionamento cluster che supporta fino a 10 Gbps o se utilizzi ENA Express, che supporta fino a 25 Gbps.
Allo stesso modo, una scheda Nitro può elaborare più pacchetti su molteplici flussi invece di utilizzare un singolo flusso. Per raggiungere la massima velocità di elaborazione dei pacchetti per istanza, consigliamo almeno 100 flussi su istanze con una larghezza di banda aggregata pari o superiore a 100 Gbps. Con l’aumento delle capacità di larghezza di banda aggregata, aumenta anche il numero di flussi necessari per raggiungere le velocità di elaborazione di picco. Il benchmarking aiuta a determinare la configurazione necessaria per raggiungere le velocità di picco sulla rete.
**Code per Adattatore elastico di rete (ENA)**
ENA (Elastic Network Adapter) utilizza più code di ricezione (Rx) e trasmissione (Tx) (code ENA) per migliorare le prestazioni e la scalabilità della rete sulle istanze EC2. Queste code gestiscono in modo efficiente il traffico di rete mediante il bilanciamento del carico di dati inviati e ricevuti tra le code disponibili.
Per ulteriori informazioni, consulta [Code ENA](ena-queues.md).
**Sovraccarico di elaborazione delle funzionalità**
Funzionalità come Traffic Mirroring ed ENA Express possono aumentare il sovraccarico di elaborazione, il che può ridurre le prestazioni assolute di elaborazione dei pacchetti. Puoi limitare l’uso delle funzionalità o disabilitarle per aumentare la velocità di elaborazione dei pacchetti.
**Monitoraggio della connessione per mantenere lo stato**
I gruppi di sicurezza utilizzano il monitoraggio delle connessioni per archiviare le informazioni sul traffico da e verso l’istanza. Il tracciamento delle connessioni applica regole a ogni singolo flusso di traffico di rete per stabilire se il traffico è consentito o negato. La scheda Nitro usa il tracciamento del flusso per mantenere lo stato del flusso. Man mano che vengono applicate più regole del gruppo di sicurezza, è necessario più lavoro per valutare il flusso.
Non vengono monitorati tutti i flussi di traffico di rete. Se una regola del gruppo di sicurezza è configurata con [Connessioni non tracciate](security-group-connection-tracking.md#untracked-connections), non è necessario alcun lavoro aggiuntivo, ad eccezione delle connessioni che vengono tracciate automaticamente per garantire un routing simmetrico in presenza di molteplici percorsi di risposta validi.
#### Pacchetti che non utilizzano l’accelerazione hardware
Non tutti i pacchetti possono sfruttare l’accelerazione hardware. La gestione di queste eccezioni comporta un sovraccarico di elaborazione, necessario per garantire l’integrità dei flussi di rete. I flussi di rete devono soddisfare in modo affidabile gli standard del protocollo, conformarsi alle modifiche nella progettazione del VPC ed effettuare il routing dei pacchetti solo verso destinazioni consentite. Tuttavia, il sovraccarico riduce le prestazioni.
**Frammenti di pacchetti**
Come indicato nella sezione **Considerazioni sull’applicazione**, i frammenti di pacchetti derivanti da pacchetti che superano l’MTU di rete vengono gestiti di norma come eccezioni e non possono sfruttare l’accelerazione hardware. Tuttavia, puoi aggirare i limiti dei frammenti in uscita con la modalità proxy a frammenti, a seconda della versione del driver. Per ulteriori informazioni, consulta le azioni che puoi intraprendere nella sezione [Massimizza le prestazioni di rete sul sistema Nitro](#ena-nitro-perf-maximize).
**Connessioni inattive**
Quando una connessione non ha attività per un certo periodo di tempo, anche se non ha raggiunto il limite di timeout, il sistema può sottoporla a un abbassamento della priorità. Quindi, se i dati arrivano dopo l’abbassamento della priorità della connessione, il sistema deve gestirli come un’eccezione per riconnettersi.
Per gestire le connessioni, puoi utilizzare i timeout di tracciamento delle connessioni per chiudere le connessioni inattive. Puoi anche utilizzare i keepalive TCP per mantenere aperte le connessioni inattive. Per ulteriori informazioni, consulta [Timeout di tracciamento delle connessioni inattive](security-group-connection-tracking.md#connection-tracking-timeouts).
**Mutazione del VPC**
Gli aggiornamenti ai gruppi di sicurezza, alle tabelle di routing e agli elenchi di controllo degli accessi devono essere tutti rivalutati nel percorso di elaborazione per garantire che le voci route e le regole dei gruppi di sicurezza continuino ad essere applicate come previsto.
**Flussi ICMP**
Internet Control Message Protocol (ICMP) è un protocollo a livello di rete utilizzato dai dispositivi di rete per diagnosticare i problemi di comunicazione di rete. Questi pacchetti usano sempre il flusso completo.
**Flussi L2 asimmetrici**
Le piattaforme NitroV3 e precedenti non utilizzano l'accelerazione hardware per il traffico tra due ENIs nella stessa sottorete, in cui un ENI utilizza il router gateway predefinito e l'altro no. Le piattaforme NitroV4 e successive utilizzano l’accelerazione hardware in questo scenario. Per prestazioni migliori su piattaforme NitroV3 o precedenti, assicurati che il router gateway predefinito utilizzato corrisponda a entrambi o che si trovino in ENIs sottoreti diverse. ENIs
## Massimizza le prestazioni di rete sul sistema Nitro
Puoi massimizzare le prestazioni di rete sul sistema Nitro modificando le impostazioni di rete.
**Topics**
+ [Considerazioni](#considerations)
+ [Ottimizzazione delle prestazioni PPS](#tuning)
+ [Configura l’allocazione delle code ENA](#max-perf-ena-queues)
+ [Monitora le prestazioni sulle istanze Linux](#monitoring)
### Considerazioni
Prima di prendere decisioni di progettazione o modificare le impostazioni di rete sulla tua istanza, ti consigliamo di attenerti alla seguente procedura per aiutarti a ottenere il miglior risultato:
1. Scopri i pro e i contro delle azioni che puoi intraprendere per migliorare le prestazioni esaminando [Considerazioni sulla progettazione di rete per il sistema Nitro](#ena-nitro-perf-considerations).
Per ulteriori considerazioni e best practice per la configurazione dell'istanza su Linux, consulta [ENA Linux Driver Best Practices and](https://github.com/amzn/amzn-drivers/blob/master/kernel/linux/ena/ENA_Linux_Best_Practices.rst) Performance Optimization Guide su. GitHub
1. Effettua un benchmark dei tuoi carichi di lavoro con il numero di flussi attivi di picco per determinare un riferimento per le prestazioni delle tue applicazioni. Con una linea di base delle prestazioni, puoi testare le variazioni nelle impostazioni o nella progettazione dell’applicazione per capire quali considerazioni avranno l’impatto maggiore, soprattutto se prevedi di aumentare orizzontalmente o aumentare verticalmente.
### Ottimizzazione delle prestazioni PPS
L’elenco seguente contiene le azioni che puoi intraprendere per ottimizzare le prestazioni del PPS, a seconda delle esigenze del sistema.
+ Riduci la distanza fisica tra due istanze. Quando le istanze di invio e ricezione si trovano nella stessa zona di disponibilità o utilizzano gruppi di posizionamento cluster, puoi ridurre il numero di hop necessari a un pacchetto per viaggiare da un endpoint all’altro.
+ Utilizza [Connessioni non tracciate](security-group-connection-tracking.md#untracked-connections).
+ Utilizza il protocollo UDP per il traffico di rete.
+ Per le istanze EC2 con larghezza di banda aggregata pari o superiore a 100 Gbps, distribuisci il carico di lavoro su 100 o più flussi individuali per distribuire il lavoro in modo uniforme sulla scheda Nitro.
+ Per superare il limite PPS dei frammenti in uscita sulle istanze EC2, puoi abilitare la modalità proxy a frammenti (in funzione della versione del driver). Questa impostazione consente di valutare i pacchetti frammentati nel percorso di elaborazione, superando in tal modo il limite PPS in uscita di 1.024. Durante il caricamento del driver, esegui uno dei seguenti comandi per abilitare o disabilitare la modalità proxy a frammenti:
**Abilita la modalità proxy a frammenti**
```
sudo insmod ena.ko enable_frag_bypass=1
```
**Disabilita la modalità proxy a frammenti**
```
sudo insmod ena.ko enable_frag_bypass=0
```
### Configura l’allocazione delle code ENA
Sui tipi di istanze supportati, puoi allocare dinamicamente queste code su Elastic Network Interfaces (). ENIs L’allocazione flessibile delle code ENA ottimizza la distribuzione delle risorse, consentendo il massimo utilizzo della vCPU. I carichi di lavoro ad alte prestazioni di rete richiedono in genere molteplici code ENA. Per ulteriori informazioni, consulta [Code ENA](ena-queues.md).
### Monitora le prestazioni sulle istanze Linux
Puoi utilizzare le metriche Ethtool sulle istanze Linux per monitorare gli indicatori delle prestazioni di rete delle istanze, come larghezza di banda, velocità dei pacchetti e tracciamento della connessione. Per ulteriori informazioni, consulta [Monitoraggio delle prestazioni di rete per le impostazioni ENA dell'istanza EC2](monitoring-network-performance-ena.md).
# Ottimizzazione delle prestazioni di rete sulle istanze EC2 Windows
Per ottenere le massime prestazioni di rete sulle istanze Windows con reti avanzate, potrebbe essere necessario modificare la configurazione del sistema operativo predefinita. Si consiglia di apportare le seguenti modifiche alla configurazione per le applicazioni che richiedono prestazioni di rete elevate. Altre ottimizzazioni (come l'attivazione dell'offloading con checksum e l'abilitazione di RSS, ad esempio) sono già configurate su Windows ufficiale. AMIs
**Nota**
TCP chimney offload dovrebbe essere disabilitato nella maggior parti dei casi d’uso ed è stato reso obsoleto con Windows Server 2016.
Oltre a queste ottimizzazioni del sistema operativo, devi anche considerare l’unità di trasmissione massima (MTU) del traffico di rete e regolare in base al carico di lavoro e all’architettura di rete. Per ulteriori informazioni, consulta [Unità di trasmissione massima di rete (MTU) per la tua istanza EC2](network_mtu.md).
AWS misura regolarmente le latenze medie di andata e ritorno tra le istanze avviate in un gruppo di posizionamento del cluster di 50us e le latenze di coda di 200us al 99,9%. Se le tue applicazioni richiedono costantemente latenze basse, consigliamo di utilizzare l’ultima versione dei driver ENA nelle istanze basate sul sistema Nitro con prestazioni fisse.
## Configura l’affinità della CPU con Receive Side Scaling
Receive Side Scaling (RSS) viene utilizzato per distribuire il carico della CPU del traffico di rete su più processori. Per impostazione predefinita, gli Amazon Windows ufficiali AMIs sono configurati con RSS abilitato. Le interfacce di rete elastiche ENA forniscono fino a otto code RSS. Definendo l’affinità dei CPU per le code RSS, nonché per altri processi del sistema, è possibile distribuire il carico di lavoro della CPU su sistemi multi-core e consentire l’elaborazione di più traffico di rete. Per i tipi di istanza con più di 16 vCPUs, si consiglia di utilizzare il `Set-NetAdapterRSS` PowerShell cmdlet, che esclude manualmente il processore di avvio (processore logico 0 e 1 quando l'hyper-threading è abilitato) dalla configurazione RSS per tutte le interfacce di rete elastiche, al fine di evitare conflitti con vari componenti del sistema.
Windows è compatibile con hyperthreading e garantisce che le code RSS di una singola scheda di interfaccia di rete vengano sempre posizionate su diversi core fisici. Pertanto, a meno che l'hyper-threading non sia disabilitato, per evitare completamente il conflitto con altri NICs, distribuisci la configurazione RSS di ogni NIC tra un intervallo di 16 processori logici. Il `Set-NetAdapterRss` cmdlet consente di definire la gamma Per-NIC di processori logici validi definendo i valori di BaseProcessorGroup,,, e (opzionale). BaseProcessorNumber MaxProcessingGroup MaxProcessorNumber NumaNode Se non ci sono abbastanza core fisici per eliminare completamente conflitti inter-NIC, minimizza le gamme in sovrapposizione o riduci il numero di processori logici nelle gamme di interfaccia elastica di rete in base al carico di lavoro previsto dell’interfaccia (in altre parole, un’interfaccia di rete amministrativa di basso volume potrebbe non aver bisogno di così tante code RSS assegnate). Inoltre, come indicato in precedenza, diversi componenti devono essere eseguiti sulla CPU 0, pertanto si consiglia di escluderla da tutte le configurazioni RSS quando è disponibile una quantità sufficiente di v. CPUs
Ad esempio, quando sono presenti tre interfacce di rete elastiche su un'istanza da 72 vCPU con 2 nodi NUMA con hyper-threading abilitato, i seguenti comandi distribuiscono il carico di rete tra i CPUs due senza sovrapposizioni e impediscono completamente l'uso del core 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
```
Nota che queste impostazioni sono persistenti per ogni adattatore di rete. Se un'istanza viene ridimensionata a un'istanza con un numero diverso di vCPUs, è necessario rivalutare la configurazione RSS per ogni elastic network interface abilitata. La documentazione Microsoft completa per il cmdlet è disponibile qui: [Set](https://learn.microsoft.com/en-us/powershell/module/netadapter/set-netadapterrss) -. NetAdapterRss
Nota speciale per i carichi di lavoro SQL: ti consigliamo inoltre di rivedere le impostazioni di affinità dei I/O thread insieme alla configurazione RSS dell'interfaccia di rete elastica per ridurre al minimo i conflitti di rete per I/O gli stessi. CPUs Consulta [Server configuration: affinity mask](https://learn.microsoft.com/en-us/sql/database-engine/configure-windows/affinity-mask-server-configuration-option).