Configurações especiais para instâncias de VM

Nesta página, descrevemos as configurações especiais de rede das instâncias de máquina virtual (VM, na sigla em inglês) do Compute Engine. Veja alguns dos tópicos abordados:

Como configurar uma conexão HTTP externa para uma instância
Como configurar uma instância como proxy de rede
Como configurar uma instância como gateway de VPN
Como configurar uma instância como gateway NAT
Como criar gateways NAT de alta disponibilidade e grande largura de banda

Como configurar uma conexão HTTP externa para uma instância

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 instância precisa ter um endereço IP externo para receber tráfego de fora da rede VPC.

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

Console

Você pode usar o console do GCP para criar uma regra de firewall geral para todas as instâncias na rede VPC, ou pode permitir o acesso de instâncias individuais a conexões HTTP e HTTPS selecionando a opção respectiva ao criar essa instância. Essa última opção é descrita primeiro, por fornecer mais controle das instâncias individuais.

No Console do GCP, acesse a página "Instâncias de VM".
Acessar a página "Instâncias da VM"
Clique em Criar instância.
Na seção Firewall, selecione Permitir tráfego HTTP e Permitir tráfego HTTPS.
Clique em Criar para criar a instância.

Marque essas caixas de seleção para que a rede VPC crie automaticamente uma regra default-http ou default-https que se aplique 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á tiver as regras de firewall default-http e default-https, será possível aplicá-las às instâncias atuais. Para isso, ative as opções Permitir HTTP ou Permitir HTTPS na página de detalhes da instância.

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

Da mesma maneira, você pode desativar o acesso HTTP ou HTTPS externo de uma instância desmarcando uma ou ambas as caixas de seleção.

Permita que instâncias específicas sejam marcadas para tráfegos HTTP e HTTPS, em vez de criar uma regra de firewall geral que se aplique a todas as instâncias. Assim, o GCP limita as possíveis consequências de segurança relacionadas à permissão de tráfego externo a todas as máquinas virtuais de 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:

Acesse a página Redes VPC.
Selecione a rede VPC na qual você aplicará a regra de firewall.
Na seção Regras de firewall, clique em Adicionar regra de firewall.
Dê um nome à regra de firewall e adicione tcp:80 na caixa Protocolos e portas, ou tcp:443 para tráfego HTTPS.
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 instância como 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:

Configure uma instância com um endereço IP externo estático ou temporário. Neste exemplo, o nome da sua instância é gateway-instance.
Configure uma ou mais instâncias sem endereços IP externos, especificando gcloud compute instances create ... --no-address. Neste exemplo, o nome da instância é hidden-instance.
Aprenda a conectar-se de uma instância à outra, visto que não é possível conectar-se diretamente às suas instâncias somente internas.

Adicione um firewall para permitir o tráfego TCP na porta 3128:

gcloud compute firewall-rules create [FIREWALL_RULE] --network [NETWORK] --allow tcp:3128

Instale o Squid em gateway-instance e configure-o para permitir acesso de qualquer máquina na rede VPC (espaços de IP RFC 1918, RFC 4193 e RFC 4291). gateway-instance e hidden-instance devem estar conectados à mesma rede VPC, o que permite que se conectem entre si.

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

Ative todas as máquinas da rede local para usar o servidor Squid3. Os comandos sed a seguir removem comentários e ativam as entradas acl localnet src nos arquivos de configuração do Squid das máquinas e redes 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 cat <<EOF >>/etc/squid/squid.conf
acl to_metadata dst 169.254.169.254
http_access deny to_metadata
EOF

# Start Squid
user@gateway:~$ sudo service squid3 start

Configure a hidden-instance para usar a gateway-instance como o proxy. Use SSH para conectar-se à hidden-instance e defina os endereços URL do proxy que apontem para gateway-instance na porta 3128 (configuração padrão do Squid), conforme 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

Saia de sudo, carregue as variáveis e execute apt-get na hidden-instance. Agora, isso funcionará usando o gateway como um proxy. Se o gateway não estivesse servindo como um proxy, apt-get não funcionaria, 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 instância como gateway de VPN

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

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

gcloud compute networks create vpn-network --subnet-mode custom

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 \

Crie uma instância 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

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.

Crie uma instância que se comunique com os clientes em sua rede local pelo gateway de VPN.

gcloud compute instances create test-vpn \
    --subnet vpn-subnet \
    --tags vpn \
    --zone us-central1-a

Crie uma rota na rede vpn-network para direcionar o tráfego por meio do vpn-gateway, se ele estiver 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 de VPN (o valor do campo networkIP).

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 \
    --allow all

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.

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

Instale e configure o software de VPN Strongswan.

No diretório inicial, crie um arquivo denominado 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, você pode seguir as mesmas etapas para instalar e configurar o strongSwan. Por exemplo, faça uma cópia do arquivo ipsec.conf e mude os códigos e sub-redes da esquerda e da direita.

Teste seu túnel VPN realizando um ping da instância test-vpn em uma máquina local.
```
gcloud compute ssh test-vpn --command 'ping -c 3 [ON_PREM_INTERNAL_ADDRESS]'
```

Solução de problemas

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

Verifique o status da conexão:
```
$ sudo ipsec status
```
Se myconn não estiver listado, inicie a conexão:
```
$ sudo ipsec up myconn
```
Determine se os dois pontos de extremidade da VPN conseguem se comunicar.

Use netcat para enviar o tráfego como VPN (UDP, porta 4500). Execute o seguinte comando no ponto de extremidade da VPN local:
```
$ echo | nc -u [vpn-vm-gateway-external-address] 4500
```
Execute tcpdump na extremidade de recepção para determinar se a instância de VM pode receber o pacote na porta 4500:
```
$ tcpdump -nn -n host [public-ip-of-local-VPN-gateway-machine] -i any
```
Ative a geração de registros mais detalhados adicionando as linhas a seguir aos 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 de conexão, verifique se há erros no registro. O arquivo de registros estará em /var/log/charon.log na instância de VM.

Como configurar uma instância como 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.

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
```

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

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

Crie uma máquina virtual para atuar como um gateway NAT na rede 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

Marque todas as instâncias de máquina virtual sem endereço IP externo que usarão a instância de gateway com a tag no-ip ou crie uma nova máquina virtual sem 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
```
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.

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 sua 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 indica ao kernel que é preciso permitir o encaminhamento de IP. O segundo comando sudo mascara os pacotes recebidos de instâncias internas como se fossem enviados da instância de 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"

(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, na sigla em inglês) e recuperação automática ativados para uma implantação mais resiliente e de grande largura de banda.

O GCP 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

Nos casos em que várias rotas têm a mesma prioridade, o GCP usa o roteamento ECMP para distribuir o tráfego. Neste caso, você cria vários gateways NAT para receber partes do tráfego por meio de ECMP. Os gateways NAT, por sua vez, encaminham o tráfego para hosts externos com os respectivos 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ê provisiona três gateways NAT n1-standard-2 neste exemplo, mas pode usar qualquer outro número ou tamanho de gateway. Por exemplo, as instâncias n1-standard-2 são limitadas a 4 Gbps de tráfego de rede. Se precisar lidar com um volume maior de tráfego, escolha n1-standard-8.

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 um VPC personalizado associado ao projeto do GCP. 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
```

Reserve e armazene três endereços IP estáticos.

Reserve e armazene um endereço denominado 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)')

Reserve e armazene um endereço denominado 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)')

Reserve e armazene um endereço denominado 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)')

Crie três modelos de instância com IPs reservados.

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.

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

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

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.

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, você pode usar um projeto existente ou criar um novo.

Crie um grupo de instâncias 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

Configure a autocorreção para reiniciar os gateways NAT que não respondem:

gcloud beta compute instance-groups managed set-autohealing nat-1 \
    --health-check nat-health-check --initial-delay 120 --zone us-east1-b
nat_1_instance=$(gcloud compute instances list |awk '$1 ~ /^nat-1/ { print $1 }')
gcloud beta compute instance-groups managed set-autohealing nat-2 \
    --health-check nat-health-check --initial-delay 120 --zone us-east1-c
nat_2_instance=$(gcloud compute instances list |awk '$1 ~ /^nat-2/ { print $1 }')
gcloud beta compute instance-groups managed set-autohealing nat-3 \
    --health-check nat-health-check --initial-delay 120 --zone us-east1-d
nat_3_instance=$(gcloud compute instances list |awk '$1 ~ /^nat-3/ { print $1 }')

Adicione rotas padrão às instâncias:

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

Marque as instâncias que usarão a NAT:

gcloud compute instances add-tags natted-servers --tags no-ip

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:

Configure o Cloud NAT na mesma região em que você tem o gateway baseado em instância.
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.
- Se você tiver usado o exemplo de gateway único acima, a rota se chamará no-ip-internet-route.
- Se tiver usado o exemplo de alta disponibilidade e alta largura de banda acima, as rotas se chamarão natroute1, natroute2 e natroute3.
O tráfego começará a fluir pelo Cloud NAT.
Depois de confirmar que tudo está funcionando, exclua os gateways NAT baseados em instância.

A seguir

Consulte Visão geral da VPC para saber informações sobre redes VPC.
Consulte Como usar a VPC para saber como criar e modificar redes VPC.