Questa pagina è stata tradotta dall'API Cloud Translation.

Calcolare la velocità effettiva di rete tramite Interconnect

Questo tutorial descrive come calcolare il throughput di rete, sia all'interno di Google Cloud sia verso le tue posizioni cloud on-premise o di terze parti connesse tramite Cloud Interconnect. Questo documento descrive come analizzare i risultati, elenca le variabili che possono influire sulle prestazioni della rete e fornisce alcuni suggerimenti per la risoluzione dei problemi.

Limitazioni e considerazioni

Si applicano limitazioni di Cloud Interconnect. Per maggiori informazioni, consulta la pagina Quote di Cloud Interconnect.
Limiti NIC: Google Cloud tiene conto della larghezza di banda di ogni istanza di macchina virtuale (VM), non di ogni interfaccia di rete (NIC) o indirizzo IP. Il tipo di macchina di una VM ne definisce la velocità di uscita massima. Tuttavia, questa velocità può essere raggiunta solo in situazioni specifiche. Consulta questa tabella per il numero di vCPU per tipo di macchina.
Si applicano altri dispositivi nel percorso (firewall, switch con buffer piccoli e dispositivi di altri fornitori) e le relative limitazioni. Esegui le seguenti attività per mitigare queste limitazioni.
- Raccogli le statistiche di rete su firewall e switch nel percorso.
- Per il test di Cloud Interconnect, esegui il bypass del maggior numero possibile di dispositivi tra l'host on-premise e il dispositivo Google Edge.
- Identifica e verifica tutti i dispositivi nel percorso tra la rete on-premise e la VM Google Cloud se possono essere la causa di problemi di velocità effettiva.

Panoramica degli strumenti per misurare il throughput di rete

Questo tutorial mostra l'utilizzo dei seguenti strumenti per calcolare il throughput di rete:

iPerf3: uno strumento di test di rete in grado di creare flussi di dati TCP/UDP (a thread singolo o multithread) e misurare la velocità effettiva della rete che li trasporta.

Nota: iPerf3 è consigliato solo per le macchine con una sola CPU.
Netperf: uno strumento simile a iPerf3, ma adatto per test di velocità effettiva su istanze multi-CPU che sono vincolate alla CPU su una singola CPU.
tcpdump: un analizzatore di pacchetti da riga di comando che acquisisce i dettagli dei pacchetti e le comunicazioni TCP/IP per la risoluzione dei problemi più avanzata. Lo strumento tcpdump è compatibile con altri strumenti, come Wireshark.
Netstat: un'utilità di rete da riga di comando che mostra le connessioni di rete per il Transmission Control Protocol (sia in entrata che in uscita), le tabelle di routing e diverse statistiche relative a interfacce di rete (scheda di interfaccia di rete o interfaccia di rete definita dal software) e protocolli di rete.
mtr: uno strumento di diagnostica di rete che esegue le funzioni traceroute e ping. Esegue il probing dei router sul percorso di routing limitando il numero di hop che i singoli pacchetti possono attraversare e ascolta le risposte alla scadenza.

Misurare il throughput con iPerf3

Segui questa procedura per misurare la velocità effettiva da una singola istanza VM.

Scegliere un tipo di macchina di grandi dimensioni

Per eseguire test di velocità effettiva, utilizza un tipo di macchina di grandi dimensioni, ad esempio n1-standard-8. Questo tipo di macchina fornisce un limite massimo di velocità effettiva in uscita di 16 Gbps, quindi la velocità effettiva in uscita per VM non interferisce con i test.

Installare gli strumenti

Installa iPerf3, mtr, netstat e tcpdump su un'istanza VM Linux

Per le distribuzioni basate su Debian, esegui questi comandi:

    sudo apt-get update
    sudo apt-get install iperf3 tcpdump mtr netstat

Per le distribuzioni basate su Redhat, esegui questi comandi:

    yum update
    yum install iperf3 tcpdump mtr netstat

Installare netperf

Per le distribuzioni basate su Debian, esegui questi comandi:

    sudo apt-get install git build-essential autoconf texinfo -y
    git clone https://github.com/HewlettPackard/netperf.git
    cd netperf
    ./autogen.sh
    ./configure --enable-histogram --enable-demo=yes
    make
    cp src/netserver ~/.local/bin
    cp src/netperf ~/.local/bin

Per le distribuzioni basate su Redhat, esegui questi comandi:

    sudo yum install git build-essential autoconf texinfo -y
    git clone https://github.com/HewlettPackard/netperf.git
    cd netperf
    ./autogen.sh
    ./configure --enable-histogram --enable-demo=yes
    make
    cp src/netserver ~/.local/bin
    cp src/netperf ~/.local/bin

Esegui i test dei prerequisiti

Assicurati che le dimensioni collegamento VLAN siano configurate correttamente. Per ulteriori informazioni, consulta Modifica dei collegamenti VLAN.
A entrambe le estremità della connessione (ogni terminale), esegui il comando top o htop per monitorare l'utilizzo della CPU.
Raccogli le statistiche di rete utilizzando il comando netstat prima di eseguire qualsiasi test.
```
netstat -s >> netstat.log
```
In un altro terminale, esegui il comando tcpdump prima di qualsiasi acquisizione con il valore parametroo snaplen pari a 128.

Esegui questo comando su entrambi gli endpoint.
```
sudo /usr/sbin/tcpdump -s 128 -i [DEVICE_INTERFACE] host [IP_ADDRESS of remote side] -w mycap.pcap
```

Ottieni le dimensioni della memoria di lettura e scrittura sugli host di origine e di destinazione.

$ sysctl net.ipv4.tcp_rmem
$ sysctl net.ipv4.tcp_wmem
$ sysctl net.core.rmem_max
$ sysctl net.core.rmem_default
$ net.core.wmem_max
$ net.core.wmem_default
$ uname -r
$ cat /etc/os-release

Esegui i test iperf3

Ti consigliamo di eseguire più flussi paralleli di test iperf3. Ti consigliamo di eseguire un minimo di quattro test e un massimo di dieci test per ottenere risultati utili.

In un altro terminale, esegui il server iperf3 su un'estremità della connessione (una VM o una macchina on-premise). Più stream richiedono più server iperf3.
Esegui lo strumento iPerf3 con il flag udp per il test di Cloud Interconnect. Se viene raggiunto il throughput scelto con UDP, devi eseguire ulteriori passaggi per la risoluzione dei problemi.
Per eseguire più server iperf3 dalla riga di comando, esegui i seguenti comandi:
```
$ iperf3 -s -p 5101&; iperf3 -s -t 30 -p 5102&; iperf3 -s  -p 5103 &
```

Utilizza il seguente script bash per eseguire più server iperf3:

#!/bin/bash
#start iperf3 server running in background

for i in `seq 0 9`;
do
        iperf3 -s  -B 10.0.100.35 -t 30 -u -p 521$i &
done

iperf3 client viene eseguito per 10 secondi per impostazione predefinita, il che potrebbe non essere sufficiente perché TCP raggiunga la velocità effettiva massima. Imposta il valore di DURATION su almeno 30 secondi per ottenere risultati più affidabili.

    iperf3 -c [server IP address] -P [THREADS] -t [DURATION]

Script bash per eseguire più stream UDP iperf3

echo "UDP iperf test - 10 streams"
for i in `seq 0 9`;
do
       iperf3 -B 10.0.100.35 -c 192.168.50.3 --logfile ~/gcpvm_client-521$i.log -u -b 1G  -l 1390 -t10 -p 521$i    &

done

Script bash per eseguire più stream TCP iperf3

echo "UDP iperf test - 10 streams"
for i in `seq 0 9`;
do
       iperf3 -B 10.0.100.35 -c 192.168.50.3 --logfile ~/gcpvm_client-521$i.log -b 1G  -l 1390 -t10 -p 521$i    &

done

Durante l'esecuzione del test iperf3, monitora il carico della CPU su entrambi i dispositivi. Se il carico della CPU è vicino al 100%, la CPU è un collo di bottiglia per un thread iperf3. In questo caso, utilizza lo strumento Netperf, perché supporta più CPU.

Se non riesci a eseguire Netperf, puoi avviare più server iPerf3 e client su terminali e porte diversi contemporaneamente.

Analizzare i risultati del test

Segui questi passaggi.

Controlla i risultati del client iperf3 per la larghezza di banda e la perdita di pacchetti.
Controlla i risultati del server iperf3 per eventuali pacchetti fuori sequenza.
Eseguire l'analisi dell'acquisizione pacchetti. Esegui questo comando per convertire il file pcap in un file di testo.
```
tcpdump -A -[PCAP-FILENAME].pcap > [TXT-FILENAME].txt
```

Esegui questo comando per ottenere il totale dei pacchetti e dei pacchetti non in ordine.

grep -e "Total" -A1 pcap [TXT-FILENAME]

L'output è il seguente:

gcpvm-send-5210.txt:Total UDP packets: 874032
gcpvm-send-5210.txt:Total out-of-order packets: 0, missing packets: 0
gcpvm-send-5211.txt:Total UDP packets: 791218
gcpvm-send-5211.txt:Total out-of-order packets: 0, missing packets: 0
gcpvm-send-5212.txt:Total UDP packets: 961510
gcpvm-send-5212.txt:Total out-of-order packets: 0, missing packets: 0
gcpvm-send-5213.txt:Total UDP packets: 961517
gcpvm-send-5213.txt:Total out-of-order packets: 0, missing packets: 0
gcpvm-send-5214.txt:Total UDP packets: 961501
gcpvm-send-5214.txt:Total out-of-order packets: 0, missing packets: 0
gcpvm-send-5215.txt:Total UDP packets: 961521
gcpvm-send-5215.txt:Total out-of-order packets: 0, missing packets: 0
gcpvm-send-5216.txt:Total UDP packets: 889932
gcpvm-send-5216.txt:Total out-of-order packets: 0, missing packets: 0
gcpvm-send-5217.txt:Total UDP packets: 961483
gcpvm-send-5217.txt:Total out-of-order packets: 0, missing packets: 0
gcpvm-send-5218.txt:Total UDP packets: 961479
gcpvm-send-5218.txt:Total out-of-order packets: 0, missing packets: 0
gcpvm-send-5219.txt:Total UDP packets: 961518
gcpvm-send-5219.txt:Total out-of-order packets: 0, missing packets: 0

La seguente analisi mostra la perdita di pacchetti durante un test delle prestazioni:

$ grep -e "Total" -A1 onPrem-send-*.txt