Esta página foi traduzida pela API Cloud Translation.

Calcule o débito da rede através da interligação

Este tutorial descreve como calcular a taxa de transferência da rede, tanto dentro Google Cloud como para as suas localizações no local ou na nuvem de terceiros que estão ligadas através do Cloud Interconnect. Este documento descreve como analisar os resultados, enumera as variáveis que podem afetar o desempenho da rede e fornece algumas dicas de resolução de problemas.

Limitações e considerações

Aplicam-se limitações do Cloud Interconnect. Para mais informações, consulte as cotas do Cloud Interconnect.
Limites da NIC: Google Cloud tem em conta a largura de banda de cada instância de máquina virtual (VM) e não de cada interface de rede (NIC) ou endereço IP. O tipo de máquina de uma VM define a respetiva taxa de saída máxima. No entanto, essa taxa só pode ser alcançada em situações específicas. Consulte esta tabela para ver o número de vCPUs por tipo de máquina.
Aplicam-se outros dispositivos no caminho (firewall, comutadores com pequenos buffers e dispositivos de outros fornecedores) e as respetivas limitações. Realize as seguintes tarefas para mitigar essas limitações.
- Recolher estatísticas de rede em firewalls e comutadores no caminho.
- Para os testes do Cloud Interconnect, contorne o maior número possível de dispositivos entre o anfitrião nas instalações e o dispositivo de limite da Google.
- Identifique e valide todos os dispositivos no caminho entre a rede no local e a VM se puderem ser a origem de problemas de débito. Google Cloud

Vista geral das ferramentas para medir a taxa de transferência da rede

Este tutorial demonstra a utilização das seguintes ferramentas para calcular a taxa de transferência da rede:

iPerf3: uma ferramenta de teste de rede que pode criar fluxos de dados TCP/UDP (de um ou vários processos) e medir a taxa de transferência da rede que os transporta.

Nota: o iPerf3 é recomendado apenas para máquinas com uma única CPU.
Netperf: uma ferramenta semelhante ao iPerf3, mas adequada para testes de débito em instâncias com várias CPUs que estão limitadas pela CPU numa única CPU.
tcpdump: um analisador de pacotes de linha de comandos que captura detalhes dos pacotes e comunicações TCP/IP para uma resolução de problemas mais avançada. A ferramenta tcpdump é compatível com outras ferramentas, como o Wireshark.
Netstat: um utilitário de rede de linha de comandos que apresenta ligações de rede para o Protocolo de controlo de transmissão (tanto de entrada como de saída), tabelas de encaminhamento e várias estatísticas de protocolos de rede e de interface de rede (controlador de interface de rede ou interface de rede definida por software).
mtr: uma ferramenta de diagnóstico de rede que executa as funções traceroute e ping. Sonda os routers no caminho do trajeto limitando o número de saltos que os pacotes individuais podem atravessar e ouve as respostas da respetiva expiração.

Meça a taxa de transferência com o iPerf3

Siga este procedimento para medir a taxa de transferência de uma única instância de VM.

Escolha um tipo de máquina grande

Para realizar testes de débito, use um tipo de máquina grande, como n1-standard-8. Este tipo de máquina oferece um limite máximo de débito de saída de 16 Gbps, pelo que o débito de saída por VM não interfere com os testes.

Instale as ferramentas

Instale o iPerf3, o mtr, o netstat e o tcpdump numa instância de VM do Linux

Para distribuições baseadas em Debian, execute os seguintes comandos:

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

Para distribuições baseadas no Redhat, execute os seguintes comandos:

    yum update
    yum install iperf3 tcpdump mtr netstat

Instale o netperf

Para distribuições baseadas em Debian, execute os seguintes comandos:

    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

Para distribuições baseadas no Redhat, execute os seguintes comandos:

    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

Execute os testes de pré-requisitos

Certifique-se de que os tamanhos das associações de VLAN estão configurados corretamente. Para mais informações, consulte o artigo Modificar associações de VLANs.
Em ambas as extremidades da ligação (cada terminal), execute o comando top ou htop para monitorizar a utilização da CPU.
Recolha estatísticas da rede através do comando netstat antes de executar quaisquer testes.
```
netstat -s >> netstat.log
```
Noutro terminal, execute o comando tcpdump antes de qualquer captura com o valor do parâmetro snaplen de 128.

Execute este comando em ambos os pontos finais.
```
sudo /usr/sbin/tcpdump -s 128 -i [DEVICE_INTERFACE] host [IP_ADDRESS of remote side] -w mycap.pcap
```

Obtenha o tamanho da memória de leitura e escrita nos anfitriões de origem e de destino.

$ 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

Execute os testes iperf3

Devido à limitação de 3 Gbps para cada fluxo, recomendamos que execute vários fluxos paralelos de testes iperf3. Recomendamos que execute, no mínimo, quatro testes e, no máximo, dez testes para compensar as limitações de largura de banda e obter resultados úteis.

Noutro terminal, execute o servidor iperf3 numa extremidade da ligação (uma VM ou uma máquina no local). Vários streams requerem vários iperf3 servidores.
Execute a ferramenta iPerf3 com a flag udp para testar o Cloud Interconnect. Se a taxa de transferência pretendida com UDP for alcançada, tem de executar passos de resolução de problemas adicionais.
Para executar os vários servidores iperf3 a partir da linha de comandos, execute os seguintes comandos:
```
$ iperf3 -s -p 5101&; iperf3 -s -t 30 -p 5102&; iperf3 -s  -p 5103 &
```

Use o seguinte script bash para executar vários servidores 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

Por predefinição, o iperf3 client é executado durante 10 segundos, o que pode não ser suficiente para o TCP atingir o débito máximo. Defina o valor de DURATION para, pelo menos, 30 segundos para alcançar resultados mais fiáveis.

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

Script Bash para executar várias streams 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 para executar várias streams 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

Enquanto o teste iperf3 estiver em execução, monitorize a carga da CPU em ambos os dispositivos. Se a carga da CPU estiver perto de 100%, a CPU é um gargalo para um segmento do iperf3. Neste caso, use a ferramenta Netperf, porque suporta várias CPUs.

Se não conseguir executar o Netperf, pode iniciar vários servidores e clientes iPerf3 em diferentes terminais e portas em simultâneo.

Analise os resultados do teste

Execute os seguintes passos.

Verifique os resultados do cliente iperf3 quanto à largura de banda e à perda de pacotes.
Verifique os resultados do servidor iperf3 para ver se existem pacotes desordenados.
Realizar a análise de captura de pacotes. Execute o seguinte comando para converter o ficheiro pcap num ficheiro de texto.
```
tcpdump -A -[PCAP-FILENAME].pcap > [TXT-FILENAME].txt
```

Execute o seguinte comando para obter o total de pacotes e pacotes fora de ordem.

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

O resultado é o seguinte:

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

A análise seguinte mostra a perda de pacotes durante um teste de desempenho:

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