Como configurar VMs para casos de uso de rede

Nesta página, descrevemos as configurações especiais de rede das instâncias de máquina virtual (VM) do Compute Engine, como as seguintes:

  • Como configurar uma conexão HTTP externa com uma VM
  • Como configurar uma VM como um proxy de rede
  • Como configurar uma VM como um gateway de VPN
  • Como configurar uma VM como um gateway NAT
  • Como criar gateways NAT de alta disponibilidade e grande largura de banda

Como configurar uma conexão HTTP externa com uma VM

As regras de firewall padrão não permitem conexões HTTP ou HTTPS com suas instâncias. No entanto, é muito simples adicionar uma regra que as permita. Observe que uma VM precisa ter um endereço IP externo (estático ou efêmero) antes de receber tráfego de fora da rede da nuvem privada virtual (VPC).

Adicione uma regra de firewall para permitir conexões HTTP ou HTTPS usando a gcloud ferramenta de linha de comando ou Console do Google Cloud. Você também pode adicionar uma regra de firewall por meio da API.

Console

É possível usar o Console do Cloud para criar uma regra de firewall geral para todas as instâncias na rede VPC ou pode permitir que instâncias individuais acessem conexões HTTP e HTTPS selecionando a respectiva opção ao criar essa instância. Essa última opção é descrita primeiro, já que oferece mais controle sobre as instâncias individuais.

  1. No Console do GCP, acesse a página Instâncias de VMs.

    Acessar a página "Instâncias de VMs"

  2. Clique em Criar instância.
  3. Na seção Firewall, selecione Permitir tráfego HTTP e Permitir tráfego HTTPS.
  4. Clique em Criar para criar a instância.

Ao marcar essas caixas de seleção, a rede VPC cria automaticamente uma regra default-http ou default-https que se aplica a todas as instâncias com as tags http-server ou https-server. A nova instância também será marcada com a devida tag, de acordo com a caixa de seleção marcada.

Se você já tem regras de firewall default-http e default-https, aplique a regra de firewall a instâncias existentes ativando as opções Permitir HTTP ou Permitir HTTPS na página de detalhes da instância.

  1. Acesse a página "Instâncias de VMs".
  2. Clique no nome da instância desejada.
  3. Clique no botão Editar na parte superior da página.
  4. Role para baixo até a seção Firewalls.
  5. Marque as opções Permitir HTTP ou Permitir HTTPS na rede VPC que quiser.
  6. Clique em Salvar.

De maneira semelhante, você também pode desativar o acesso HTTP ou HTTPS externo para uma VM desmarcando uma ou ambas as caixas de seleção.

Ao permitir que instâncias específicas sejam codificadas para tráfego HTTP e HTTPS em vez de criar uma regra de firewall geral aplicável a todas as instâncias, o Google Cloud limita as possíveis implicações de segurança de permitir tráfego externo para todas as máquinas virtuais em um projeto. Mas, se quiser criar uma regra de firewall que permita tráfego HTTP ou HTTPS em todas as instâncias de máquina virtual, crie sua própria regra de firewall:

  1. Acesse a página "Redes VPC".
  2. Selecione a rede VPC na qual você aplicará a regra de firewall.
  3. Na seção Regras de firewall, clique em Adicionar regra de firewall.
  4. Nomeie sua regra de firewall e adicione tcp:80 na caixa Protocolos e portas ou tcp:443 para tráfego HTTPS.
  5. Clique em Criar.
Ferramenta de linha de comando gcloud

Se você quiser permitir tráfego HTTP e HTTPS em todas as máquinas virtuais de um projeto, o comando a seguir cria um firewall que permite a entrada de solicitações HTTP e HTTPS de qualquer lugar em qualquer instância conectada a essa rede VPC.

gcloud compute firewall-rules create FIREWALL_RULE --allow tcp:80,tcp:443

**Exemplo**

gcloud compute firewall-rules create sample-http \
 --description "Incoming http and https allowed." \
 --allow tcp:80,tcp:443
gcloud compute firewall-rules describe sample-http
allowed:
- IPProtocol: tcp
  ports:
  - '80'
  - '443'
creationTimestamp: '2014-06-13T13:27:12.206-07:00'
id: '5057780722612413546'
kind: compute#firewall
name: sample-http
network: https://www.googleapis.com/compute/v1/projects/[PROJECT_ID]/global/networks/default
selfLink: https://www.googleapis.com/compute/v1/projects/[PROJECT_ID]/global/firewalls/samplehttp
sourceRanges:
- 0.0.0.0/0

Como configurar uma VM como um proxy de rede

Projete sua rede VPC para que apenas uma instância tenha acesso externo e todas as outras usem essa instância como um servidor proxy para comunicação externa. Isso será útil para controlar o acesso de entrada ou saída da rede VPC ou para reduzir o custo de pagamento de vários endereços IP externos.

Esse exemplo específico trata da configuração de um proxy de rede nas instâncias de VM que usam uma imagem Debian. Ele usa uma instância de gateway como um servidor proxy Squid, mas esse é apenas um modo de configurar um servidor proxy.

Para configurar um servidor proxy Squid:

  1. Configure uma instância com um endereço IP externo estático ou temporário. Para este exemplo, nomeie sua instância gateway-instance.
  2. Configure uma ou mais instâncias sem endereços IP externos especificando gcloud compute instances create ... --no-address. Para este exemplo, chame esta instância hidden-instance.
  3. Aprenda a conectar-se de uma instância à outra, visto que não é possível conectar-se diretamente às suas instâncias somente internas.
  4. Adicione um firewall para permitir o tráfego TCP na porta 3128:

    gcloud compute firewall-rules create [FIREWALL_RULE] --network [NETWORK] --allow tcp:3128
    
  5. Instale Squid em gateway-instance e configure-o para permitir acesso a partir de qualquer máquina na rede VPC (espaços de IP RFC 1918, RFC 4193 e RFC 4291). Isso pressupõe que gateway-instance e hidden-instance estejam conectados à mesma rede VPC, o que permite que eles se conectem uns aos outros.

    user@gateway-instance:~$ sudo apt-get install squid3
    

    Ative todas as máquinas da rede local para usar o servidor Squid3. Os seguintes comandos sed descompactam e ativam as entradas acl localnet src nos arquivos de configuração do Squid para redes e máquinas locais.

    user@gateway-instance:~$ sudo sed -i 's:#\(http_access allow localnet\):\1:' /etc/squid/squid.conf
    
    user@gateway-instance:~$ sudo sed -i 's:#\(http_access deny to_localhost\):\1:' /etc/squid/squid.conf
    
    user@gateway-instance:~$ sudo sed -i 's:#\(acl localnet src 10.0.0.0/8.*\):\1:' /etc/squid/squid.conf
    
    user@gateway-instance:~$ sudo sed -i 's:#\(acl localnet src 172.16.0.0/12.*\):\1:' /etc/squid/squid.conf
    
    user@gateway-instance:~$ sudo sed -i 's:#\(acl localnet src 192.168.0.0/16.*\):\1:' /etc/squid/squid.conf
    
    user@gateway-instance:~$ sudo sed -i 's:#\(acl localnet src fc00\:\:/7.*\):\1:' /etc/squid/squid.conf
    
    user@gateway-instance:~$ sudo sed -i 's:#\(acl localnet src fe80\:\:/10.*\):\1:' /etc/squid/squid.conf
    
    # Prevent proxy access to metadata server
    user@gateway-instance:~$ sudo tee -a /etc/squid/squid.conf <<'EOF'
    acl to_metadata dst 169.254.169.254
    http_access deny to_metadata
    EOF
    
    # Start Squid
    user@gateway:~$ sudo service squid start
    
  6. Configure hidden-instance para usar gateway-instance como proxy. Use SSH para se conectar a hidden-instance e defina seus endereços URL do proxy que apontem para gateway-instance na porta 3128 (a configuração padrão do Squid) como mostrado aqui:

    user@gateway-instance:~$ ssh hidden-instance
    
    user@hidden-instance:~$ sudo -s
    
    root@hidden-instance:~# echo "export http_proxy=\"http://gateway-instance.$(dnsdomainname):3128\"" >> /etc/profile.d/proxy.sh
    
    root@hidden-instance:~# echo "export https_proxy=\"http://gateway-instance.$(dnsdomainname):3128\"" >> /etc/profile.d/proxy.sh
    
    root@hidden-instance:~# echo "export ftp_proxy=\"http://gateway-instance.$(dnsdomainname):3128\"" >> /etc/profile.d/proxy.sh
    
    root@hidden-instance:~# echo "export no_proxy=169.254.169.254,metadata,metadata.google.internal" >> /etc/profile.d/proxy.sh
    

    Atualize o sudoers para transmitir estas variáveis env:

    root@hidden-instance:~# cp /etc/sudoers /tmp/sudoers.new
    
    root@hidden-instance:~# chmod 640 /tmp/sudoers.new
    
    root@hidden-instance:~# echo "Defaults env_keep += \"ftp_proxy http_proxy https_proxy no_proxy"\" >>/tmp/sudoers.new
    
    root@hidden-instance:~# chmod 440 /tmp/sudoers.new
    
    root@hidden-instance:~# visudo -c -f /tmp/sudoers.new && cp /tmp/sudoers.new /etc/sudoers
    
  7. Saia de sudo, carregue as variáveis e execute apt-get em hidden-instance. Agora, isso funcionará usando o gateway como um proxy. Se o gateway não estiver sendo exibido como um proxy, apt-get não funcionará porque hidden-instance não tem conexão direta com a Internet.

    root@hidden-instance:~# exit
    
    user@hidden-instance:~$ source ~/.profile
    
    user@hidden-instance:~$ sudo apt-get update
    

Como configurar uma VM como um gateway de VPN

É possível usar o software de VPN strongSwan para configurar um gateway VPN em uma de suas instâncias. Para a maioria dos usuários, recomendamos o uso do Cloud VPN em vez do strongSwan. Com o Cloud VPN, você não precisa criar e configurar uma VM para executar um software de VPN. Use o strongSwan nos casos em que o Google Cloud VPN não oferece a funcionalidade necessária.

  1. Crie uma rede VPC que se conectará com sua rede local.

    gcloud compute networks create vpn-network --subnet-mode custom
    
  2. Crie uma sub-rede com um intervalo de IP que não se sobreponha à sua sub-rede local.

    gcloud compute networks subnets create vpn-subnet \
        --network vpn-network \
        --region us-central1 \
        --range 10.0.0.0/24 \
    
  3. Crie uma instância de VM na sub-rede vpn-subnet. Essa instância será seu gateway de VPN.

    gcloud compute instances create vpn-gateway --can-ip-forward \
        --subnet vpn-subnet \
        --zone us-central1-a \
        --tags vpn-gateway
    
  4. Procure e grave o endereço IP interno e externo do seu gateway de VPN.

    gcloud compute instances describe --zone us-central1-a vpn-gateway
    

    O endereço IP externo é o valor do campo natIP. O endereço IP interno é o valor do campo networkIP, como 10.0.0.2.

  5. Crie uma instância de VM que se comunique com os clientes na sua rede local por meio do gateway da VPN.

    gcloud compute instances create test-vpn \
        --subnet vpn-subnet \
        --tags vpn \
        --zone us-central1-a
    
  6. Crie uma rota na rede vpn-network para rotear o tráfego por meio do vpn-gateway se ele for destinado à sua rede local.

    gcloud compute routes create vpnnetwork-to-gateway \
        --destination-range [ON_PREM_IP_RANGE] \
        --next-hop-address [VPN_GATEWAY_INTERNAL_IP] \
        --network vpn-network \
        --tags vpn
    

    O valor [VPN_GATEWAY_INTERNAL_IP] é o endereço IP interno do gateway da VPN (o valor do campo networkIP).

  7. Adicione as regras de firewall a seguir à sua rede VPC para aceitar o tráfego de entrada.

    gcloud compute firewall-rules create ssh --source-ranges 0.0.0.0/0 \
        --allow tcp:22 \
        --network vpn-network
    
    gcloud compute firewall-rules create  allow-internal \
        --source-ranges 10.0.0.0/24 \
        --allow tcp:1-65535,udp:1-65535,icmp \
        --network vpn-network
    
    gcloud compute firewall-rules create allow-ipsec-nat \
        --source-ranges [ON_PREM_VPN_GATEWAY_EXTERNAL_IP]/32 \
        --allow udp:4500,udp:500 \
        --network vpn-network \
        --target-tags vpn-gateway
    
    gcloud compute firewall-rules create from-onprem \
        --source-ranges [ON_PREM_NETWORK_ADDRESS_SPACE] \
        --allow tcp:1-65535,udp:1-65535,icmp \
        --network vpn-network \
        --target-tags vpn
    

    Crie regras de firewall na sua rede local para aceitar o tráfego de entrada da rede VPC.

  8. Conecte-se à sua instância de gateway de VPN.

  9. Instale e configure o software de VPN, strongSwan.

    No diretório principal, crie um arquivo chamado ipsec.conf. Preencha-o com o seguinte conteúdo, substituindo os marcadores de posição pelos valores do ambiente:

    conn myconn
      authby=psk
      auto=start
      dpdaction=hold
      esp=aes128-sha1-modp2048!
      forceencaps=yes
      ike=aes128-sha1-modp2048!
      keyexchange=ikev2
      mobike=no
      type=tunnel
      left=%any
      leftid=[VPN_GATEWAY_EXTERNAL_IP_ADDRESS]
      leftsubnet=10.0.0.0/24
      leftauth=psk
      leftikeport=4500
      right=[ON_PREM_EXTERNAL_IP_ADDRESS]
      rightsubnet=[ON_PREM_ADDRESS_SPACE]
      rightauth=psk
      rightikeport=4500
    

    Em seguida, execute os seguintes comandos, substituindo [secret-key] por uma chave secreta (um valor de string):

    $ sudo apt-get update
    
    $ sudo apt-get install strongswan -y
    
    $ echo "%any : PSK \"[secret-key]\"" | sudo tee /etc/ipsec.secrets > /dev/null
    
    $ sudo sysctl -w net.ipv4.ip_forward=1
    
    $ sudo sed -i 's/#net.ipv4.ip_forward=1/net.ipv4.ip_forward=1/g' /etc/sysctl.conf
    
    $ sudo cp ipsec.conf /etc
    
    $ sudo ipsec restart
    

    Também é necessário configurar o gateway de VPN local para que um túnel de VPN seja estabelecido com sucesso.

    Se sua máquina de gateway local está executando um sistema operacional baseado em Debian, é possível seguir as mesmas etapas para instalar e configurar o strongSwan. Por exemplo, faça uma cópia do seu arquivo ipsec.conf e alterne os IDs e as sub-redes da esquerda e da direita.

  10. Teste seu túnel VPN fazendo ping em uma máquina local a partir da instância test-vpn:

    gcloud compute ssh test-vpn --command 'ping -c 3 [ON_PREM_INTERNAL_ADDRESS]'
    

Como resolver problemas

Se você tiver problemas com a configuração da VPN, mesmo seguindo as instruções acima, tente estas dicas para solucioná-los:

  1. Verifique o status da conexão:

    $ sudo ipsec status
    

    Se myconn não estiver listado, inicie a conexão:

    $ sudo ipsec up myconn
    
  2. Determine se os dois endpoints da VPN conseguem se comunicar.

    Use netcat para enviar o tráfego como VPN (UDP, porta 4500). Execute o seguinte comando no endpoint da VPN local:

    $ echo | nc -u [vpn-vm-gateway-external-address] 4500
    

    Executar tcpdump na extremidade de recebimento para determinar se sua instância de VM pode receber o pacote na porta 4500:

    $ tcpdump -nn -n host [public-ip-of-local-VPN-gateway-machine] -i any
    
  3. Ative a geração de registros mais detalhados adicionando as linhas a seguir aos seus arquivos ipsec.conf:

    config setup
      charondebug="ike 3, mgr 3, chd 3, net 3"
    
    conn myconn
      authby=psk
      auto=start
      ...
    

    Depois teste a conexão novamente. Se ainda houver falha na conexão, verifique o registro de erros. O arquivo de registro deve estar localizado em /var/log/charon.log na instância da VM.

Como configurar uma VM como um gateway NAT

Crie cenários de rede mais complexos fazendo alterações no conjunto de rotas. Nessa seção, há informações sobre como configurar uma instância de gateway de conversão de endereço interno (NAT) que direcione o tráfego das instâncias de máquina virtual somente internas para a Internet. Use um só endereço IP externo para enviar tráfego de várias instâncias de máquina virtual, mas exponha somente uma máquina virtual na Internet.

  1. Para começar, crie uma rede VPC para hospedar as instâncias de máquina virtual desse cenário.

    gcloud compute networks create custom-network1 \
        --subnet-mode custom
    
  2. Crie uma sub-rede para a região us-central1.

    gcloud compute networks subnets create subnet-us-central \
        --network custom-network1 \
        --region us-central1 \
        --range 192.168.1.0/24
    
  3. Crie regras de firewall para permitir conexões SSH na rede recém-criada.

    gcloud compute firewall-rules create custom-network1-allow-ssh \
        --allow tcp:22 \
        --network custom-network1
    
    gcloud compute firewall-rules create custom-network1-allow-internal \
        --allow tcp:1-65535,udp:1-65535,icmp \
        --source-ranges 192.168.1.0/24 \
        --network custom-network1
    
  4. Crie uma máquina virtual para atuar como um gateway NAT em custom-network1.

    gcloud compute instances create nat-gateway --network custom-network1 \
        --subnet subnet-us-central \
        --can-ip-forward \
        --zone us-central1-a \
        --image-family debian-9 \
        --image-project debian-cloud \
        --tags nat
    
  5. Marque instâncias de máquina virtual sem um endereço IP externo que usará a instância de gateway com a tag no-ip ou crie uma nova máquina virtual sem um endereço IP externo e marque a instância com a tag no-ip.

    • Adicione tags a uma instância atual.
    gcloud compute instances add-tags existing-instance --tags no-ip
    
    • Como alternativa, crie uma máquina virtual sem endereço IP externo.
    gcloud compute instances create example-instance --network custom-network1 \
        --subnet subnet-us-central \
        --no-address \
        --zone us-central1-a \
        --image-family debian-9 \
        --image-project debian-cloud \
        --tags no-ip
    
  6. Crie uma rota para enviar o tráfego destinado à Internet por meio da instância de gateway.

    gcloud compute routes create no-ip-internet-route \
        --network custom-network1 \
        --destination-range 0.0.0.0/0 \
        --next-hop-instance nat-gateway \
        --next-hop-instance-zone us-central1-a \
        --tags no-ip --priority 800
    

    Defina a prioridade dessa rota para garantir que ela prevaleça quando há outras rotas conflitantes. A prioridade padrão é 1.000 e um valor menor que 1.000 terá precedência.

  7. Depois acesse a instância de gateway e configure o iptables como tráfego interno de NAT para a Internet.

    gcloud compute ssh nat-gateway --zone us-central1-a
    

    Na instância, configure o iptables:

    $ sudo sysctl -w net.ipv4.ip_forward=1
    
    $ sudo iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
    

    O primeiro comando sudo informa ao kernel que você quer permitir o encaminhamento de IP. O segundo comando sudo mascara os pacotes recebidos de instâncias internas como se eles tivessem sido enviados da instância do gateway NAT.

    Para inspecionar suas regras NAT do iptables, use a opção de listar:

    $ sudo iptables -v -L -t nat
    

    Verifique se a saída é semelhante ao exemplo a seguir:

    Chain PREROUTING (policy ACCEPT 5 packets, 3924 bytes)
     pkts bytes target     prot opt in     out     source               destination
    
    Chain INPUT (policy ACCEPT 5 packets, 3924 bytes)
     pkts bytes target     prot opt in     out     source               destination
    
    Chain OUTPUT (policy ACCEPT 64 packets, 4164 bytes)
     pkts bytes target     prot opt in     out     source               destination
    
    Chain POSTROUTING (policy ACCEPT 0 packets, 0 bytes)
     pkts bytes target     prot opt in     out     source               destination
    64  4164 MASQUERADE  all  --  any    eth0    anywhere             anywhere"
    
  8. (Opcional) Se você quiser que essas configurações persistam em futuras reinicializações:

    $ sudo echo "net.ipv4.ip_forward=1" > /etc/sysctl.d/20-natgw.conf
    
    $ sudo apt-get install iptables-persistent
    

Como criar gateways NAT de alta disponibilidade e grande largura de banda

Nesta seção, descrevemos como configurar vários gateways NAT com o roteamento de vários caminhos de custo igual (ECMP) e recuperação automática ativados para uma implantação mais resiliente e de grande largura de banda.

O Google Cloud usa endereços IP privados RFC 1918 para máquinas virtuais. Se essas VMs precisarem acessar recursos na Internet pública, será necessário uma NAT. Uma única arquitetura de gateway NAT é suficiente para cenários simples. No entanto, uma capacidade maior ou disponibilidade mais alta exigem uma arquitetura mais resiliente.

Como configurar os gateways

Em instâncias em que várias rotas têm a mesma prioridade, o Google Cloud usa o roteamento ECMP para distribuir o tráfego. Nesse caso, você cria vários gateways NAT para receber partes do tráfego por meio do ECMP. Os gateways NAT encaminham o tráfego para hosts externos com seus endereços IP públicos.

O diagrama a seguir mostra essa configuração.

configuração de vários gateways

Para maior resiliência, coloque cada gateway em um grupo separado de instâncias gerenciadas com tamanho 1 e anexe uma verificação de integridade simples para garantir que os gateways vão reiniciar automaticamente se falharem. Os gateways estão em grupos de instâncias separados para que tenham um IP externo estático anexado ao modelo de instância. Você aprovisiona três gateways NAT n1-standard-2 neste exemplo, mas é possível usar qualquer outro número ou tamanho de gateway que quiser. Por exemplo, instâncias n1-standard-2 são limitadas a 4 Gbps de tráfego de rede. Se você precisar lidar com um volume maior de tráfego, escolha n1-standard-8.

  1. Crie uma rede VPC (se necessário). Se você não está adicionando esses gateways a uma VPC atual, crie uma rede VPC e uma sub-rede para eles. Se você está adicionando-os a uma VPC atual, passe para a segunda etapa e modifique as regiões conforme apropriado para o ambiente.

    1. Usando o Cloud Shell, crie uma VPC personalizada associada ao seu projeto do Google Cloud. Ele permitirá que você use o endereçamento IP não padrão, mas não incluirá regras de firewall padrão:

      gcloud compute networks create example-vpc --subnet-mode custom
      
    2. Crie uma sub-rede dentro da VPC e especifique uma região e um intervalo de IP. Para este tutorial, use 10.0.1.0/24 e a região us-east1:

      gcloud compute networks subnets create example-east \
          --network example-vpc --range 10.0.1.0/24 --region us-east1
      
  2. Reserve e armazene três endereços IP estáticos.

    1. Reserve e armazene um endereço chamado nat-1 na região us-east1:

      gcloud compute addresses create nat-1 --region us-east1
      
      nat_1_ip=$(gcloud compute addresses describe nat-1 \
          --region us-east1 --format='value(address)')
      
    2. Reserve e armazene um endereço com o nome nat-2 em us-east1:

      gcloud compute addresses create nat-2 --region us-east1
      
      nat_2_ip=$(gcloud compute addresses describe nat-2 \
          --region us-east1 --format='value(address)')
      
    3. Reserve e armazene um endereço com o nome nat-3 em us-east1:

      gcloud compute addresses create nat-3 --region us-east1
      nat_3_ip=$(gcloud compute addresses describe nat-3 \
          --region us-east1 --format='value(address)')
      
  3. Crie três modelos de instância com IPs reservados.

    1. Copie a configuração de inicialização:

      gsutil cp gs://nat-gw-template/startup.sh .
      

      Se você não conseguir acessar o script de inicialização, copie-o da seção Script de inicialização.

    2. Crie um modelo de instância nat-1:

      gcloud compute instance-templates create nat-1 \
          --machine-type n1-standard-2 --can-ip-forward --tags natgw \
          --metadata-from-file=startup-script=startup.sh --address $nat_1_ip
      
    3. Crie um modelo de instância nat-2:

      gcloud compute instance-templates create nat-2 \
          --machine-type n1-standard-2 --can-ip-forward --tags natgw \
          --metadata-from-file=startup-script=startup.sh  --address $nat_2_ip
      
    4. Crie um modelo de instância nat-3:

      gcloud compute instance-templates create nat-3 \
          --machine-type n1-standard-2 --can-ip-forward --tags natgw \
          --metadata-from-file=startup-script=startup.sh --address $nat_3_ip
      

      O tipo de máquina n1-standard-2 tem duas vCPUs e pode usar até 4 Gbps de largura de banda de rede. Se você precisar de mais largura de banda, convém escolher um host diferente. A largura de banda pode ser escalonada em 2 Gbps por vCPU, até 16 Gbps em um host 8vCPU.

  4. Crie uma verificação de integridade para monitorar a capacidade de resposta:

    gcloud compute health-checks create http nat-health-check --check-interval 30 \
        --healthy-threshold 1 --unhealthy-threshold 5 --request-path /health-check
    
    gcloud compute firewall-rules create "natfirewall" \
        --allow tcp:80 --target-tags natgw \
        --source-ranges "130.211.0.0/22","35.191.0.0/16"
    

    Se um sistema falhar e não conseguir responder ao tráfego HTTP, ele será reiniciado. Nesse caso, por precisar de um projeto, é possível usar um projeto existente ou criar um novo.

  5. Crie um grupo de instâncias de VM para cada gateway NAT:

    gcloud compute instance-groups managed create nat-1 --size=1 --template=nat-1 --zone=us-east1-b
    gcloud compute instance-groups managed create nat-2 --size=1 --template=nat-2 --zone=us-east1-c
    gcloud compute instance-groups managed create nat-3 --size=1 --template=nat-3 --zone=us-east1-d
    
  6. Configure a autocorreção para reiniciar os gateways NAT que não respondem:

    gcloud compute instance-groups managed update nat-1 \
        --health-check nat-health-check --initial-delay 120 --zone us-east1-b
    nat_1_instance=$(gcloud compute instances list --format='value(name)' --filter='name ~nat-1')
    gcloud compute instance-groups managed update nat-2 \
        --health-check nat-health-check --initial-delay 120 --zone us-east1-c
    nat_2_instance=$(gcloud compute instances list --format='value(name)' --filter='name ~nat-2')
    gcloud compute instance-groups managed update nat-3 \
        --health-check nat-health-check --initial-delay 120 --zone us-east1-d
    nat_3_instance=$(gcloud compute instances list --format='value(name)' --filter='name ~nat-3')
    
  7. Adicione rotas padrão à rede VPC, que se aplicam a instâncias que usam o NAT:

    gcloud compute routes create natroute1 --destination-range 0.0.0.0/0 \
        --tags no-ip --priority 800 --next-hop-instance-zone us-east1-b \
        --next-hop-instance $nat_1_instance
    gcloud compute routes create natroute2 --destination-range 0.0.0.0/0 \
        --tags no-ip --priority 800 --next-hop-instance-zone us-east1-c \
        --next-hop-instance $nat_2_instance
    gcloud compute routes create natroute3 --destination-range 0.0.0.0/0 \
        --tags no-ip --priority 800 --next-hop-instance-zone us-east1-d \
        --next-hop-instance $nat_3_instance
    
  8. Marque as instâncias que usarão a NAT:

    gcloud compute instances add-tags natted-servers --tags no-ip
    
  9. Teste a funcionalidade da NAT. Com os gateways configurados e as VMs convidadas marcadas, dê um ping em hosts externos sem fornecer os IPs externos das suas VMs, como neste exemplo:

    ping 8.8.8.8

    Exemplo de saída:

    PING 8.8.8.8 (8.8.8.8): 56 data bytes
    64 bytes from 8.8.8.8: icmp_seq=0 ttl=52 time=0.618 ms
    64 bytes from 8.8.8.8: icmp_seq=1 ttl=52 time=0.325 ms
    64 bytes from 8.8.8.8: icmp_seq=2 ttl=52 time=0.443 ms
    64 bytes from 8.8.8.8: icmp_seq=3 ttl=52 time=0.314 ms
    64 bytes from 8.8.8.8: icmp_seq=4 ttl=52 time=0.386 ms
    

Problemas a considerar

Essa configuração fornece três gateways NAT na região us-east1, cada um com capacidade de 2 Gbps. Porém, o balanceamento de carga ECMP não é perfeito. O fluxo individual não é distribuído por vários links.

  • Um módulo Terraform para esta configuração também está disponível para automatizar implantações.
  • Essa configuração é melhor para links de saída efêmeros ou sem estado. Se o tamanho do pool de gateways NAT mudar, as conexões TCP poderão ser rebalanceadas, o que pode acarretar a redefinição de uma conexão estabelecida.
  • Os nós não são atualizados automaticamente. Portanto, se uma instalação padrão do Debian apresentar uma ameaça, você precisará atualizar manualmente.
  • Essas instâncias estão todas na região us-east1. Se as VMs estiverem em outras zonas, será possível ter melhor desempenho movendo os gateways mais próximos dessas zonas.
  • A largura de banda por gateway é de até 2 Gbps por núcleo unidirecional. Durante uma falha de gateway, o tráfego é distribuído para os gateways restantes, mas, como os fluxos em execução não são reprogramados, o tráfego não se restabelece imediatamente quando o gateway volta a ficar on-line. Portanto, permita uma sobrecarga suficiente ao dimensionar.
  • Para ser avisado sobre resultados inesperados, use o Stackdriver para monitorar os grupos de instâncias gerenciadas e o tráfego de rede.

Script de inicialização: startup.sh

Script de inicialização mencionado na etapa 3a:

#!/bin/bash
echo 1 > /proc/sys/net/ipv4/ip_forward
echo "net.ipv4.ip_forward=1" > /etc/sysctl.d/20-natgw.conf
iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE

cat <<EOF > /usr/local/sbin/health-check-server.py
#!/usr/bin/python
from BaseHTTPServer import BaseHTTPRequestHandler,HTTPServer
import subprocess

PORT_NUMBER = 80
PING_HOST = "www.google.com"

def connectivityCheck():
  try:
    subprocess.check_call(["ping", "-c", "1", PING_HOST])
    return True
  except subprocess.CalledProcessError as e:
    return False

#This class handles any incoming request
class myHandler(BaseHTTPRequestHandler):
  def do_GET(self):
    if self.path == '/health-check':
      if connectivityCheck():
        self.send_response(200)
      else:
        self.send_response(503)
    else:
      self.send_response(404)

try:
  server = HTTPServer(("", PORT_NUMBER), myHandler)
  print "Started httpserver on port " , PORT_NUMBER
  #Wait forever for incoming http requests
  server.serve_forever()

except KeyboardInterrupt:
  print "^C received, shutting down the web server"
  server.socket.close()
EOF

nohup python /usr/local/sbin/health-check-server.py >/dev/null 2>&1 &

Migrar um gateway NAT baseado em instância para o Cloud NAT

Se você tiver um gateway NAT baseado em instância, mas quiser migrar para o Cloud NAT, faça o seguinte:

  1. Configure o Cloud NAT na mesma região em que você tem o gateway baseado em instância.
  2. Exclua a rota estática ou direcione os pacotes de envio para o gateway NAT baseado em instância. Observe que você ainda terá uma rota de gateway padrão para sua rede.
  3. O tráfego começará a fluir pelo Cloud NAT.
  4. Depois de confirmar que tudo está funcionando, exclua os gateways NAT baseados em instância.

A seguir