GSP045

Visão geral

Neste laboratório prático você verá alguns cenários reais, recriará os ambientes e trabalhará para aprimorar o desempenho de redes problemáticas.

Será interessante comparar as diferentes instâncias, assim como o caso de uso da solução de problemas. Assim, será possível testar os resultados e conhecer as etapas usadas para melhorar o desempenho dos seus próprios sistemas.

Este laboratório é uma adaptação das postagens de Colt McAnlis: Core Count and the Egress problem e Internal IP vs External IP. O blog do Colt no Medium trata do desempenho de redes no Google Cloud.

Objetivos

• Como testar o desempenho e a conectividade da rede usando ferramentas de código aberto
• Como inspecionar o tráfego de rede usando ferramentas de código aberto
• Como o tamanho da máquina pode afetar o desempenho da rede

Pré-requisitos

• Conhecimento básico sobre os serviços do Google Cloud (recomendamos fazer os laboratórios da Quest Google Cloud Essentials)
• Conhecimento básico de TCP/IP e rede do Google Cloud (recomendamos fazer os laboratórios da Quest Networking in the Google Cloud)
• Conhecimento básico de linha de comando do Unix/Linux

Configuração e requisitos

Antes de clicar no botão Start Lab

Leia estas instruções. Os laboratórios são cronometrados e não podem ser pausados. O timer é iniciado quando você clica em Começar o laboratório e mostra por quanto tempo os recursos do Google Cloud vão ficar disponíveis.

Este laboratório prático permite que você realize as atividades em um ambiente real de nuvem, não em uma simulação ou demonstração. Você vai receber novas credenciais temporárias para fazer login e acessar o Google Cloud durante o laboratório.

Confira os requisitos para concluir o laboratório:

• Acesso a um navegador de Internet padrão (recomendamos o Chrome).

Observação: para executar este laboratório, use o modo de navegação anônima ou uma janela anônima do navegador. Isso evita conflitos entre sua conta pessoal e a conta de estudante, o que poderia causar cobranças extras na sua conta pessoal.

• Tempo para concluir o laboratório---não se esqueça: depois de começar, não será possível pausar o laboratório.

Observação: não use seu projeto ou conta do Google Cloud neste laboratório para evitar cobranças extras na sua conta.

Como iniciar seu laboratório e fazer login no console do Google Cloud

1. Clique no botão Começar o laboratório. Se for preciso pagar, você verá um pop-up para selecionar a forma de pagamento. No painel Detalhes do laboratório à esquerda, você verá o seguinte:

   • O botão Abrir Console do Cloud
   • Tempo restante
   • As credenciais temporárias que você vai usar neste laboratório
   • Outras informações se forem necessárias

2. Clique em Abrir Console do Google. O laboratório ativa recursos e depois abre outra guia com a página Fazer login.

   Dica: coloque as guias em janelas separadas lado a lado.

   Observação: se aparecer a caixa de diálogo Escolher uma conta, clique em Usar outra conta.

3. Caso seja preciso, copie o Nome de usuário no painel Detalhes do laboratório e cole esse nome na caixa de diálogo Fazer login. Clique em Avançar.

4. Copie a Senha no painel Detalhes do laboratório e a cole na caixa de diálogo Olá. Clique em Avançar.

   Importante: você precisa usar as credenciais do painel à esquerda. Não use suas credenciais do Google Cloud Ensina. Observação: se você usar sua própria conta do Google Cloud neste laboratório, é possível que receba cobranças adicionais.

5. Acesse as próximas páginas:

   • Aceite os Termos e Condições.
   • Não adicione opções de recuperação nem autenticação de dois fatores (porque essa é uma conta temporária).
   • Não se inscreva em testes gratuitos.

Depois de alguns instantes, o console do GCP vai ser aberto nesta guia.

Observação: para ver uma lista dos produtos e serviços do Google Cloud, clique no Menu de navegação no canto superior esquerdo.

O objetivo deste laboratório é mostrar a você a relação entre a quantidade de núcleos e a capacidade de processamento. Para isso, ele inclui seis instâncias já integradas. Elas são criadas quando você inicia o laboratório.

• No console do Cloud, acesse o Menu de navegação > Compute Engine > Instâncias de VMs para conferir suas instâncias:

Observação: talvez a região e a zona das suas instâncias sejam diferentes daquelas que aparecem na captura de tela.

Teste de conexão

Faça um teste de conexão rápido para verificar se tudo está funcionando.

1. Clique no botão "SSH" ao lado do nome instance-1 no console para acessar a instância por SSH.

2. Na nova janela de shell, dê um ping em uma das outras instâncias e execute o comando abaixo (substitua <external ip address of instance-2> pelo endereço IP externo de instance-2):

ping -c 5 <external ip address of instance-2>

Exemplo de saída:

student-00-aafd1bd9c185@instance-1:~$ ping -c 5 35.194.158.169 PING 35.194.158.169 (35.194.158.169) 56(84) bytes of data. 64 bytes from 35.194.158.169: icmp_seq=1 ttl=76 time=1.89 ms 64 bytes from 35.194.158.169: icmp_seq=2 ttl=76 time=0.409 ms 64 bytes from 35.194.158.169: icmp_seq=3 ttl=76 time=0.542 ms 64 bytes from 35.194.158.169: icmp_seq=4 ttl=76 time=0.557 ms 64 bytes from 35.194.158.169: icmp_seq=5 ttl=76 time=0.559 ms --- 35.194.158.169 ping statistics --- 5 packets transmitted, 5 received, 0% packet loss, time 4001ms rtt min/avg/max/mdev = 0.409/0.792/1.894/0.554 ms

3. Dê ping em outra instância. Substitua <external ip address of instance-3> pelo endereço IP externo de instance-3 e dê um ping nela.

ping -c 5 <external ip address of instance-3>

Exemplo de saída:

student-00-aafd1bd9c185@instance-1:~$ ping -c 5 35.194.187.75 PING 35.194.187.75 (35.194.187.75) 56(84) bytes of data. 64 bytes from 35.194.187.75: icmp_seq=1 ttl=64 time=1.59 ms 64 bytes from 35.194.187.75: icmp_seq=2 ttl=64 time=0.336 ms 64 bytes from 35.194.187.75: icmp_seq=3 ttl=64 time=0.338 ms 64 bytes from 35.194.187.75: icmp_seq=4 ttl=64 time=0.302 ms 64 bytes from 35.194.187.75: icmp_seq=5 ttl=64 time=0.270 ms --- 35.194.187.75 ping statistics --- 5 packets transmitted, 5 received, 0% packet loss, time 3999ms rtt min/avg/max/mdev = 0.270/0.568/1.596/0.514 ms

Até aqui tudo certo, vamos em frente!

Analise as regras de firewall

As regras de firewall também foram criadas para este laboratório.

• Para conhecê-las, acesse o Menu de navegação -> Rede -> Redes VPC -> Firewall e clique no firewall iperftesting.

A regra de firewall iperftesting usa a configuração a seguir:

Campo	Valor	Comentários
Nome	iperftesting	Nome da nova regra
Alvos	Todas as instâncias na rede
Intervalos de IPs de origem	0.0.0.0/0	Abriremos o firewall para qualquer endereço IP da Internet.
Protocolos e portas	tcp:5001; udp:5001
Direção do tráfego	Entrada
Ação se houver correspondência	Permitir

Agora está tudo pronto para você começar a usar o laboratório.

Caso de uso 1: rede e contagem de núcleos do Compute Engine

Neste primeiro cenário, você vai entender como o tamanho das máquinas usadas afeta a capacidade medida.

O Dobermanifesto é uma rede microblog de vídeos exclusivamente para animais de estimação. Vídeos de animais podem ser enviados de qualquer lugar do mundo.

Apesar da transferência de dados ter como origem e destino os back-ends do Compute Engine do microblog, a largura de banda não era tão alta quanto o esperado:

Tarefa 1: Como reproduzir o comportamento

Para reproduzir esse comportamento, duas instâncias na mesma zona foram criadas, e o iperf foi executado entre elas cem vezes.

Esse desempenho foi ainda pior. Está claro que algo deu errado no teste. Precisamos de mais informações e de instruções mais detalhadas da empresa para a reprodução.

Agora você vai montar o cenário.

Ambiente do Dobermanifesto

1. Volte à lista de instâncias de VMs no console do Compute Engine.

2. Acesse a instance-1 (1 vCPU, 3,75 GB) por SSH e execute este comando, configurando um "recebedor" iperf:

iperf -s

3. Acesse a instance-2 (1 vCPU, 3,75 GB) por SSH e gere tráfego iperf apontando para instance-1:

iperf -c <external ip address of instance-1>

Exemplo de saída:

student-00-aafd1bd9c185@instance-2:~$ iperf -c 35.225.180.44 ------------------------------------------------------------ Client connecting to 35.225.180.44, TCP port 5001 TCP window size: 45.0 KByte (default) ------------------------------------------------------------ [ 3] local 10.20.0.4 port 56330 connected with 35.225.180.44 port 5001 [ ID] Interval Transfer Bandwidth [ 3] 0.0000-10.0010 sec 4.66 GBytes 4.00 Gbits/sec

4. Volte para a instance-1 e digite CTRL + C para encerrar o recebedor.

Ambiente de teste

1. Volte ao console do Compute Engine e abra outra janela de SSH com a instance-6 (1 vCPU e2-micro, 0,6 GB).

2. Execute este comando, configurando a instância como "recebedor":

iperf -s

Exemplo de saída:

student-00-aafd1bd9c185@instance-6:~$ iperf -s ------------------------------------------------------------ Server listening on TCP port 5001 TCP window size: 128 KByte (default) ------------------------------------------------------------

3. Na janela SSH de instance-2, teste a conexão com instance-6:

iperf -c <internal ip address of instance-6>

Exemplo de saída:

student-00-aafd1bd9c185@instance-2:~$ iperf -c 10.40.0.7 ------------------------------------------------------------ Client connecting to 10.40.0.7, TCP port 5001 TCP window size: 45.0 KByte (default) ------------------------------------------------------------ [ 3] local 10.40.0.5 port 54029 connected with 10.40.0.7 port 5001 [ ID] Interval Transfer Bandwidth [ 3] 0.0-10.0 sec 2.29 GBytes 1.96 Gbits/sec

4. Volte para a instance-6 e digite CTRL + C para encerrar o recebedor.

O que aconteceu? A largura de banda parece ter aumentado. Isso também pode ter ocorrido no seu caso. Pode ter sido menor.

Na próxima seção, você vai aprender que o número total de núcleos limita a largura de banda. Com números pequenos como esse (apenas um núcleo), a largura de banda nunca vai exceder cerca de 2 Gbits/s. Por isso, a velocidade de rede é baixa e a largura de banda é limitada, como aconteceu com o Dobermanifesto. Quando você fizer o teste com quatro CPUs em breve, o resultado será maior.

O número de núcleos está correlacionado ao Gb/segundo

Por que os resultados não são muito diferentes? Segundo a documentação do Compute Engine:

O tráfego de saída de uma máquina virtual está sujeito aos limites máximos de capacidade de saída da rede. Esses limites dependem do número de vCPUs que uma instância de máquina virtual tem. Cada núcleo está sujeito a um limite de 2 Gbits/segundo (Gbps) de desempenho máximo. Os núcleos acrescentados aumentam o limite de rede até um máximo teórico de 16 Gbps para cada máquina virtual.

Isso significa que, quanto maior o número de CPUs virtuais na rede, maior será a capacidade dela.

Para mostrar como isso funciona na prática, grupos com quantidades diferentes de núcleos foram configurados na mesma zona e o iperf foi executado entre eles mil vezes.

Conforme a contagem de núcleos aumenta, o mesmo ocorre com a capacidade média e máxima. Mesmo com esse teste simples, é possível perceber o limite máximo de 16 Gbps em máquinas superiores.

Observação: se você executar iperf com vários processadores lógicos (por volta de oito), será possível passar dos 10 Gbps e chegar a cerca de 16 Gbps usando uma máquina e2-standard-16 ou superior. Não temos uma máquina desse porte no ambiente do laboratório, mas vamos fazer o teste com vários processadores lógicos a seguir. Também há VMs de maior custo nas séries N2, N2D, C2 ou C2D com a opção de configuração Nível 1 de alta largura de banda, que alcança 50 a 100 Gbps.

Tarefa 2: Como melhorar os resultados

A rede do Dobermanifesto usa máquinas com 1 vCPU. Com mais núcleos, o Dobermanifesto provavelmente vai ter melhores resultados. É hora de testar essa teoria.

1. Use SSH para se conectar à instance-3 (4 vCPUs e 15 GB de memória) e execute este comando:

iperf -s

Exemplo de saída:

student-00-aafd1bd9c185@instance-3:~$ iperf -s ------------------------------------------------------------ Server listening on TCP port 5001 TCP window size: 128 KByte (default) ------------------------------------------------------------

2. Use SSH para se conectar à instance-4 (4 vCPUs e 15 GB de memória):

iperf -c <internal ip address of instance-3>

Exemplo de saída:

student-00-aafd1bd9c185@instance-4:~$ iperf -c 10.40.0.2 ------------------------------------------------------------ Client connecting to 10.40.0.2, TCP port 5001 TCP window size: 45.0 KByte (default) ------------------------------------------------------------ [ 3] local 10.40.0.4 port 54081 connected with 10.40.0.2 port 5001 [ ID] Interval Transfer Bandwidth [ 3] 0.0-10.0 sec 8.93 GBytes 7.67 Gbits/sec

3. Agora tente fazer isso com quatro processadores lógicos:

iperf -c <internal ip address of instance-3> -P4

4. E com oito processadores lógicos:

iperf -c <internal ip address of instance-3> -P8

5. Volte para a instance-3 e digite CTRL + C para encerrar o recebedor.

Nesses experimentos, tanto o servidor quanto o cliente tinham 4 vCPUs, e a velocidade aumentou bastante. A taxa de transferência aumentou em 6,64 Gbytes, e a largura de banda, em 5,71 Gbits/s. Com vários processadores lógicos, alcançamos o desempenho máximo dessa quantidade de núcleos.

6. Continue o teste com a instance-5, que é uma máquina de maior desempenho com 4 vCPUs, tipo de instância "highcpu-4".

Esse tipo de instância tem CPUs mais rápidas, porém menos memória. Você percebe alguma diferença? E com vários processadores lógicos?

Agora a equipe do Dobermanifesto precisa decidir qual caminho seguir. Depois de criar o perfil do uso de CPU e conferir os preços, eles optaram por uma máquina e2-standard-4. Ela tem quase quatro vezes mais capacidade média, com um custo menor do que as máquinas e2-standard-8.

Um dos pontos positivos de mudar para máquinas maiores é que elas são executadas com uma frequência menor. As máquinas anteriores ficavam muito tempo em estado ativo só para transferir dados. Com o tamanho da nova máquina, as instâncias têm mais tempo de inatividade. Isso permite que o balanceador de carga reduza o número total de instâncias diariamente. Se por um lado eles pagaram por uma máquina de nível mais alto, por outro, terão menos gastos mensais com horas de uso de núcleos.

Como o desempenho impacta diretamente os resultados, há muitas questões sutis de custo-benefício que devem consideradas.

Caso de uso 2: rede do Google Cloud com IPs internos

Neste próximo exemplo, você vai usar o iperf para testar a velocidade de processamento. Você configurará uma máquina como o servidor e apontará outras máquinas a ela para comparar os resultados.

A Gecko Protocol, uma empresa B2B que oferece protocolo de rede leve e personalizado criado para jogos e outros sistemas de gráficos em tempo real, estava encontrando capacidades mais baixas do que o esperado em máquinas de back-end responsáveis por transferir e transcodificar grandes arquivos de gráficos e de vídeo.

Estes são os resultados do teste iperf de referência:

------------------------------------------------------------ Client connecting to 104.155.145.79, TCP port 5001 TCP window size: 45.0 KByte (default) ------------------------------------------------------------ [ 3] local 10.128.0.3 port 53504 connected with 104.155.145.79 port 5001 [ ID] Interval Transfer Bandwidth [ 3] 0.0-10.0 sec 1.03 GBytes 884 Mbits/sec

Ao duplicar o teste, a configuração da rede foi idêntica, mas os resultados do teste foram muito diferentes:

student-00-aafd1bd9c185@instance-2:~$ iperf -c 10.128.0.2 ------------------------------------------------------------ Client connecting to 10.128.0.2, TCP port 5001 TCP window size: 45.0 KByte (default) ------------------------------------------------------------ [ 3] local 10.128.0.3 port 38978 connected with 10.128.0.2 port 5001 [ ID] Interval Transfer Bandwidth [ 3] 0.0-10.0 sec 2.27 GBytes 1.95 Gbits/sec

O valor de 1,95 GB/segundo é muito mais alto do que os gráficos da Gecko Protocol mostravam. Então o que está acontecendo?

Agora recrie este cenário.

1. No console, use SSH para se conectar a instance-1 e configure o receptor iperf:

iperf -s

Exemplo de saída:

student-00-aafd1bd9c185@instance-1:~$ iperf -s ------------------------------------------------------------ Server listening on TCP port 5001 TCP window size: 128 KByte (default) ------------------------------------------------------------

2. Use SSH para se conectar à instance-2 e verifique a conexão do endereço IP externo:

iperf -c <external ip address of instance-1>

Exemplo de saída:

student-00-aafd1bd9c185@instance-2:~$ iperf -c 35.201.145.135 ------------------------------------------------------------ Client connecting to 35.201.145.135, TCP port 5001 TCP window size: 45.0 KByte (default) ------------------------------------------------------------ [ 3] local 10.40.0.8 port 58691 connected with 35.201.145.135 port 5001 [ ID] Interval Transfer Bandwidth [ 3] 0.0-10.0 sec 1.36 GBytes 1.16 Gbits/sec

Após mais algumas conversas com a Gecko Protocol, descobrimos que eles estavam usando IPs externos para conectar as máquinas, e o teste usava IPs internos. Quando as máquinas estão em uma rede, conectá-las com IPs internos resultará em uma capacidade mais rápida.

3. Verifique agora a conexão com o endereço interno:

iperf -c <internal ip address of instance-1>

Exemplo de saída:

student-00-aafd1bd9c185@instance-2:~$ iperf -c 10.40.0.5 ------------------------------------------------------------ Client connecting to 10.40.0.5, TCP port 5001 TCP window size: 45.0 KByte (default) ------------------------------------------------------------ [ 3] local 10.40.0.8 port 42950 connected with 10.40.0.5 port 5001 [ ID] Interval Transfer Bandwidth [ 3] 0.0-10.0 sec 2.26 GBytes 1.94 Gbits/sec

Confira as duas taxas diferentes de transferência e largura de banda. Neste exemplo, a alteração para o endereço IP interno resultou em uma melhoria de 0,9 GB na taxa de transferência e 0,78 Gbits/segundo de melhoria na largura de banda. Você acabou de provar que a conexão interna é mais rápida.

Com base no que você aprendeu resolvendo o problema do Dobermanifesto, é possível melhorar ainda mais a velocidade da rede usando uma máquina superior? A instance-2 tem apenas uma vCPU. Qual será a velocidade de conexão com um máquina um pouco melhor? E se for muito melhor? Continue a testar usando o endereço IP interno (mas teste o externo também, caso tenha tempo).

Máquina com 4 vCPUs

• Use SSH para se conectar à instance-3 e teste a conexão com o endereço IP interno:

iperf -c <internal ip address of instance-1>

Exemplo de saída (talvez seus resultados sejam diferentes):

student-00-aafd1bd9c185@instance-3:~$ iperf -c 10.40.0.5 ------------------------------------------------------------ Client connecting to 10.40.0.5, TCP port 5001 TCP window size: 45.0 KByte (default) ------------------------------------------------------------ [ 3] local 10.40.0.6 port 39115 connected with 10.40.0.5 port 5001 [ ID] Interval Transfer Bandwidth [ 3] 0.0-10.0 sec 4.53 GBytes 3.89 Gbits/sec

Máquina 4 highCPU

• Use SSH para se conectar à instance-5 e teste a conexão com o endereço IP interno:

iperf -c <internal ip address of instance-1>

Exemplo de saída:

student-00-aafd1bd9c185@instance-5:~$ iperf -c 10.40.0.5 ------------------------------------------------------------ Client connecting to 10.40.0.5, TCP port 5001 TCP window size: 45.0 KByte (default) ------------------------------------------------------------ [ 3] local 10.40.0.3 port 39736 connected with 10.40.0.5 port 5001 [ ID] Interval Transfer Bandwidth [ 3] 0.0-10.0 sec 10.3 GBytes 8.84 Gbits/sec

Isso melhora bastante a taxa de capacidade.

Parece que a Gecko Protocol também precisa pensar na quantidade ideal de núcleos. Com essa pequena depuração, a transferência de dados de vídeos e gráficos aumentou cerca de 14 vezes. Isso é algo enorme, considerando que a solução deles é criar serviços de back-end para computação de alto desempenho.

Tarefa 3. Como testar no seu próprio ambiente

Este laboratório não abrange como testar seu próprio sistema, mas incluímos aqui mais algumas informações para você. Para mais informações sobre como testar sua rede, leia Como diagnosticar a velocidade da rede com Iperf.

Se quiser e tiver tempo, configure uma VM para testar. Ao criar suas VMs, verifique se usou a regra de firewall e a tag "iperftest". Teste seu endereço IP interno e externo.

Como configurar para testar a velocidade da sua rede

1. No console, acesse menu de navegação > Redes > Redes VPC > Firewall.

2. Clique em Criar regra de firewall. Use as configurações abaixo para criar uma regra de firewall:

Campo	Valor	Comentários
Nome	iperf-testing	Nome da nova regra
Alvos	Todas as instâncias na rede
Intervalos de IPs de origem	0.0.0.0/0	Abriremos o firewall para qualquer endereço IP da Internet.
Direção do tráfego	entrada
Ação se houver correspondência	Permitir
Protocolos e portas	tcp:5001; udp:5001

3. Clique em Criar.

Clique em Verificar meu progresso para conferir o objetivo. Crie a regra de firewall

A tendência é que a carga de trabalho fique o mais próxima possível de 100%. Assim, há pouco espaço para o disco desfragmentar etc.

Entre 90 e 93% de uso é saudável, mas 98% de uso reduzirá o desempenho porque você terá muita contenção.

Ao testar, caso o desempenho de E/S tenha queda, verifique os contadores de limitação. Se o limite não estiver sendo aplicado, observe o uso da CPU. Se ele está alto, esse é o problema.

Tarefa 4: Se você tiver mais tempo

Na interface do laboratório, acesse a seção "Recursos para estudantes" à esquerda. Ela contém links para vídeos relacionados ao laboratório. Vale muito a pena assistir.

Parabéns!

Parabéns! Neste laboratório, você aprendeu a testar a conectividade da rede e o desempenho com ferramentas de código aberto, além de entender como o tamanho da máquina afeta o desempenho da rede.

Próximas etapas / Saiba mais

• Siga as etapas indicadas na postagem do Google Cloud Como usar produtos de rede de nuvem do Google: um guia para todos os guias.
• Leia a documentação de rede do Compute Engine.
• Saiba mais sobre sub-redes.
• Publique perguntas e encontre respostas no Stack Overflow com a tag google-compute-engine ou google-cloud-platform.

Treinamento e certificação do Google Cloud

Esses treinamentos ajudam você a aproveitar as tecnologias do Google Cloud ao máximo. Nossas aulas incluem habilidades técnicas e práticas recomendadas para ajudar você a alcançar rapidamente o nível esperado e continuar sua jornada de aprendizado. Oferecemos treinamentos que vão do nível básico ao avançado, com opções de aulas virtuais, sob demanda e por meio de transmissões ao vivo para que você possa encaixá-las na correria do seu dia a dia. As certificações validam sua experiência e comprovam suas habilidades com as tecnologias do Google Cloud.

Manual atualizado em 4 de outubro de 2023

Laboratório testado em 4 de outubro de 2023

Copyright 2024 Google LLC. Todos os direitos reservados. Google e o logotipo do Google são marcas registradas da Google LLC. Todos os outros nomes de produtos e empresas podem ser marcas registradas das respectivas empresas a que estão associados.