Configuraciones especiales para instancias de máquinas virtuales

En esta página se explican las configuraciones de redes especiales de instancias de máquina virtual de Compute Engine, como las siguientes:

Configurar una instancia como proxy de red.
Configurar una instancia como pasarela de NAT.
Configurar una instancia como pasarela de VPN.
Crear pasarelas de NAT de alta disponibilidad y ancho de banda elevado.

Configurar una instancia como proxy de red

Puedes diseñar tu red de VPC de modo que solo una instancia de esa red tenga acceso externo y las demás utilicen dicha instancia como servidor proxy para el mundo exterior. Se trata de una manera de controlar el acceso de entrada o de salida a tu red de VPC o de reducir el coste que supone contar con varias direcciones IP externas.

En este ejemplo concreto se explica cómo configurar un proxy de red en instancias de máquina virtual que utilizan una imagen Debian. Utiliza una instancia de pasarela como un servidor proxy Squid, pero es la única manera de configurar un servidor proxy.

Para configurar un servidor proxy Squid, efectúa los pasos siguientes:

Configura una instancia con una dirección IP externa (estática o efímera). Para este ejemplo, ponle el siguiente nombre a la instancia: gateway-instance.
Configura una o varias instancias sin direcciones IP externas mediante gcloud compute instances create ... --no-address. Para este ejemplo, llama a esta instancia hidden-instance.
Aprende a conectar de una instancia a otra porque no podrás conectar directamente con tus instancias que sean solo internas.

Añade un cortafuegos para permitir el tráfico TCP en el puerto 3128:

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

Instala Squid en gateway-instance y configúralo de modo que permita el acceso desde cualquier máquina de la red de VPC (espacios IP RFC1918, RFC4193 y RFC4291). Para esto se supone que gateway-instance y hidden-instance están conectadas a la misma red de VPC, lo cual les permite conectarse entre sí.

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

Habilita cualquier máquina en la red local para que utilice el servidor Squid3. Los siguientes comandos sed eliminan los comentarios y permiten las entradas de acl localnet src en los archivos de configuración de Squid para máquinas y redes locales.

user@gateway-instance:~$ sudo sed -i 's:#\(http_access allow localnet\):\1:' /etc/squid3/squid.conf

user@gateway-instance:~$ sudo sed -i 's:#\(http_access deny to_localhost\):\1:' /etc/squid3/squid.conf

user@gateway-instance:~$ sudo sed -i 's:#\(acl localnet src 10.0.0.0/8.*\):\1:' /etc/squid3/squid.conf

user@gateway-instance:~$ sudo sed -i 's:#\(acl localnet src 172.16.0.0/12.*\):\1:' /etc/squid3/squid.conf

user@gateway-instance:~$ sudo sed -i 's:#\(acl localnet src 192.168.0.0/16.*\):\1:' /etc/squid3/squid.conf

user@gateway-instance:~$ sudo sed -i 's:#\(acl localnet src fc00\:\:/7.*\):\1:' /etc/squid3/squid.conf

user@gateway-instance:~$ sudo sed -i 's:#\(acl localnet src fe80\:\:/10.*\):\1:' /etc/squid3/squid.conf

# Prevent proxy access to metadata server
user@gateway-instance:~$ sudo cat <<EOF >>/etc/squid3/squid.conf
acl to_metadata dst 169.254.169.254
http_access deny to_metadata
EOF

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

Configura hidden-instance para utilizar gateway-instance como su proxy. Utiliza ssh para conectar con hidden-instance y definir sus direcciones URL de proxy para señalar a gateway-instance en el puerto 3128 (la configuración de Squid predeterminada), tal y como se muestra a continuación:

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

Actualiza los sudoers para transferir estas variables 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

Sal de sudo, carga las variables y ejecuta apt-get en hidden-instance. Ahora debería funcionar utilizando la pasarela como un proxy. Si la pasarela no funciona como proxy, apt-get no funcionaría porque hidden-instance no tiene conexión directa a Internet.
```
root@hidden-instance:~# exit
```
```
user@hidden-instance:~$ source ~/.profile
```
```
user@hidden-instance:~$ sudo apt-get update
```

Configurar conexiones HTTP externas a instancias

Las reglas de cortafuegos predeterminadas no permiten conexiones HTTP o HTTPS con tus instancias. Sin embargo, es bastante sencillo añadir una regla que las permita. Ten en cuenta que una instancia debe tener una dirección IP externa antes de que pueda recibir tráfico desde fuera de su red de VPC.

Puedes añadir una regla de cortafuegos para permitir las conexiones HTTP o HTTPS mediante la herramienta de línea de comandos gcloud o la consola de Google Cloud Platform. También puedes añadir una regla de cortafuegos a través de la API.

Consola

Puedes utilizar la consola de GCP para crear una regla de cortafuegos general para todas las instancias de la red de VPC o puedes permitir el acceso individual por instancias a las conexiones HTTP y HTTPS mediante la selección de la opción correspondiente cuando crees la instancia. Esta última propuesta es la que primero se describe a continuación porque es la que proporciona un mayor control sobre las instancias individuales.

Al marcar estas casillas, la red de VPC crea de forma automática una regla default-http o default-https que se aplica a todas las instancias con las etiquetas http-server o https-server. Tu instancia nueva también se etiqueta según la casilla que hayas seleccionado.

Si ya cuentas con reglas de cortafuegos default-http y default-https, podrás aplicar la regla de cortafuegos a las instancias existentes activando las opciones Permitir el tráfico HTTP o Permitir el tráfico HTTPS en la página de detalles de la instancia.

Ir a la página Instancias de VM.
Haz clic en el nombre de la instancia deseada.
Haz clic en el botón Editar que verás en la parte superior de la página.
Desplázate a la sección Cortafuegos.
Marca las opciones Permitir el tráfico HTTP o Permitir el tráfico HTTPS en la red de VPC que quieras.
Haz clic en Guardar.

De una manera parecida, puedes inhabilitar el acceso HTTP o HTTPS externo para una instancia mediante la anulación de la selección de una de estas casillas o de las dos.

La ventaja de permitir el etiquetado de determinadas instancias para habilitar el tráfico HTTP y HTTPS en ellas, frente a la creación de una regla de cortafuegos general que se aplique a todas las instancias, es que GCP restringe al máximo los riesgos de seguridad que podría conllevar el tráfico externo habilitado para todas las máquinas virtuales de un proyecto. Sin embargo, si te interesa que dicho tráfico HTTP o HTTP esté habilitado para todas las instancias de máquina virtual, puedes crear tu propia regla de cortafuegos:

Accede a la página Redes VPC.
Selecciona la red de VPC donde vas a aplicar la regla.
En la sección Reglas de cortafuegos, haz clic en Añadir regla de cortafuegos.
Pon un nombre a la regla y añade tcp:80 en el cuadro Protocolos y puertos o tcp:443 para el tráfico HTTPS.
Haz clic en Crear.

Herramienta de línea de comandos gcloud

Si deseas permitir el tráfico HTTP o HTTPS a todas las máquinas virtuales de un proyecto, el siguiente comando crea un cortafuegos que permite la entrada de peticiones HTTP y HTTPS desde cualquier lugar a cualquier instancia conectada a esta red de VPC.

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

**Ejemplo**

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

Configurar una instancia como pasarela de VPN

El software de VPN strongSwan VPN facilita la configuración de una pasarela de VPN en una de tus instancias. No obstante, Google recomienda a la mayoría de los usuarios que utilicen Cloud VPN en lugar de strongSwan. Con Cloud VPN, no es necesario crear ni configurar una instancia para ejecutar el software de VPN. Puedes recurrir a strongSwan en aquellos casos en los que Cloud VPN no cuente con la funcionalidad que necesites.

Crea una red de VPC a la que se conectará tu red in situ.

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

Crea una subred con un intervalo de IPs que no se solape con tu subred in situ.

gcloud compute networks subnets create vpn-subnet \
    --network vpn-network \
    --region us-central1 \
    --range 10.0.0.0/24 \

Crea una instancia en la subred vpn-subnet. Esta instancia será tu pasarela de VPN.

gcloud compute instances create vpn-gateway --can-ip-forward \
    --subnet vpn-subnet \
    --zone us-central1-a \
    --tags vpn-gateway

Busca y registra la dirección IP interna y externa de la pasarela de VPN.
```
gcloud compute instances describe --zone us-central1-a vpn-gateway
```
La dirección IP externa es el valor del campo natIP. La interna es el valor del campo networkIP, por ejemplo 10.0.0.2.

Crea una instancia que se comunique con clientes en tu red in situ a través de la pasarela de VPN.

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

Crea una ruta en la red vpn-network para dirigir el tráfico a través de vpn-gateway si está destinado para tu red in situ.
```
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
```
El valor de [VPN_GATEWAY_INTERNAL_IP] es la dirección IP interna de tu pasarela de VPN (el valor del campo networkIP).

Añade las siguientes reglas de cortafuegos a tu red de VPC para aceptar el tráfico entrante.

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

Crea reglas de cortafuegos en tu red in situ para aceptar el tráfico entrante desde la red de VPC.

Conéctate con tu instancia de pasarela de VPN.

Instala y configura strongSwan, el software de VPN.

Desde el directorio de inicio, crea un archivo denominado ipsec.conf. Rellénalo con el contenido siguiente tras sustituir los marcadores de posición por los valores de tu entorno:

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

A continuación, ejecuta los comandos siguientes tras sustituir [secret-key] por una clave secreta (un valor de cadena):

$ 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

También debes configurar tu pasarela de VPN in situ para establecer correctamente un túnel VPN.

Si el sistema operativo de la máquina de la pasarela in situ está basado en Debian, puedes seguir los mismos pasos para instalar y configurar strongSwan. Por ejemplo, haz una copia de tu archivo ipsec.conf y cambia los ID de la izquierda y la derecha y las subredes.

Prueba el túnel VPN haciendo ping en una máquina in situ desde la instancia test-vpn:
```
gcloud compute ssh test-vpn --command 'ping -c 3 [ON_PREM_INTERNAL_ADDRESS]'
```

Solución de problemas

Si tienes problemas con la configuración de VPN a pesar de las instrucciones anteriores, prueba a hacer los pasos siguientes para solucionarlos:

Comprueba el estado de la conexión:
```
$ sudo ipsec status
```
Si myconn no aparece en la lista, inicia la conexión:
```
$ sudo ipsec up myconn
```
Determina si los dos puntos de conexión de VPN pueden comunicar.

Utiliza netcat para enviar tráfico como el de VPN (UDP y puerto 4500). Ejecuta el siguiente comando en el punto de conexión de VPN local:
```
$ echo | nc -u [vpn-vm-gateway-external-address] 4500
```
Ejecuta tcpdump en el extremo receptor para determinar que tu instancia de máquina virtual puede recibir el paquete en el puerto 4500:
```
$ tcpdump -nn -n host [public-ip-of-local-VPN-gateway-machine] -i any
```
Añade las siguientes líneas a tus archivos ipsec.conf para activar registros más detallados:
```
config setup
  charondebug="ike 3, mgr 3, chd 3, net 3"
conn myconn
  authby=psk
  auto=start
  ...
```
A continuación, vuelve a intentar la conexión. Aunque la conexión siga fallando, podrás consultar los errores en el registro. El archivo de registro debe estar guardado en /var/log/charon.log en tu instancia de máquina virtual.

Configurar una instancia como pasarela de NAT

En este ejemplo se muestra la configuración de la pasarela en una red antigua. Si utilizas una red de VPC, ajusta los intervalos de red.

Haz cambios en la recopilación de rutas para crear situaciones de redes más complejas. En esta sección se explica cómo configurar una instancia de pasarela de traducción de dirección de red (NAT) interna capaz de dirigir el tráfico desde instancias de máquina virtual solo internas hasta Internet. De este modo, puedes utilizar una dirección IP externa para enviar tráfico desde varias instancias de máquina virtual, pero exponer a Internet una sola máquina virtual.

Para empezar, crea una red de VPC para alojar tus instancias de máquina virtual para esta situación. En este ejemplo, el rango de redes antiguas utilizado es 10.240.0.0/16 con una pasarela de 10.240.0.1. Sin embargo, también puedes seleccionar tu propio rango IPv4 y dirección de pasarela. Si quieres, puedes crear en su lugar una red de VPC.
```
gcloud compute networks create gce-network \
    --subnet-mode legacy \
    --range 10.240.0.0/16
```

Crea reglas de cortafuegos para permitir las conexiones ssh en la red que acabas de crear.

gcloud compute firewall-rules create gce-network-allow-ssh --allow tcp:22 --network gce-network

gcloud compute firewall-rules create gce-network-allow-internal --allow tcp:1-65535,udp:1-65535,icmp \
    --source-ranges 10.240.0.0/16 --network gce-network

Crea una máquina virtual para que funcione como una pasarela de NAT en gce-network.

gcloud compute instances create nat-gateway --network gce-network --can-ip-forward \
    --zone us-central1-a \
    --image-family debian-8 \
    --image-project debian-cloud \
    --tags nat

Etiqueta cualquier instancia de máquina virtual sin una dirección IP externa que utilizará la instancia de pasarela con la etiqueta no-ip. O bien, crea una máquina virtual nueva sin una dirección IP externa y etiqueta la instancia con no-ip.
- Añade etiquetas a una instancia que ya exista.
```
gcloud compute instances add-tags existing-instance --tags no-ip
```
- También puedes crear una máquina virtual nueva sin una dirección IP externa.
```
gcloud compute instances create example-instance --network gce-network --no-address \
        --zone us-central1-a \
        --image-family debian-8 \
        --image-project debian-cloud \
        --tags no-ip
```
Crea una ruta para enviar tráfico destinado a Internet a través de la instancia de la pasarela.
```
gcloud compute routes create no-ip-internet-route --network gce-network \
    --destination-range 0.0.0.0/0 \
    --next-hop-instance nat-gateway \
    --next-hop-instance-zone us-central1-a \
    --tags no-ip --priority 800
```
Establecer la prioridad de esta ruta garantiza que se elige esta en caso de conflicto con otras. La prioridad predeterminada es 1000 y un valor inferior tendrá preferencia.
Después, inicia sesión en la instancia de pasarela y configura iptables para el tráfico interno de NAT a Internet.
```
gcloud compute ssh nat-gateway --zone us-central1-a
```
En tu instancia, configura iptables:
```
$ sudo sysctl -w net.ipv4.ip_forward=1
```
```
$ sudo iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
```
El primer comando sudo indica el kernel al que vas a permitir el reenvío de IP. El segundo comando sudo suplanta los paquetes recibidos desde instancias internas como si se hubieran enviado desde la instancia de pasarela de NAT.

(Opcional) Si deseas que esta configuración permanezca en futuros reinicios:

$ echo "net.ipv4.ip_forward=1" | sudo tee -a /etc/sysctl.conf > /dev/null

$ sudo apt-get install iptables-persistent

Crear pasarelas de NAT de alta disponibilidad y ancho de banda elevado

En esta sección se explica cómo configurar pasarelas de NAT con enrutamiento ECMP y reparación automática habilitados para un despliegue de banda ancha alta y más resistente.

GCP utiliza direcciones IP privadas RFC 1918 para máquinas virtuales. Si estas máquinas virtuales necesitan acceder a recursos en la Internet pública, es obligatorio contar con una NAT. Basta una arquitectura de pasarela de NAT única para las situaciones más sencillas. Sin embargo, un rendimiento o una disponibilidad superiores necesitan una arquitectura más resistente.

Configurar las pasarelas

En las instancias donde varias rutas tienen la misma prioridad, GCP utiliza el enrutamiento de ECMP para distribuir el tráfico. En este caso, se crean varias pasarelas de NAT para recibir partes del tráfico a través de ECMP. Estas pasarelas reenvían después el tráfico a hosts externos con sus direcciones IP públicas.

En el siguiente diagrama se muestra esta configuración.

configuración de pasarela múltiple

Para obtener una mayor resistencia, hay que situar cada pasarela en un grupo de instancias administradas aparte con el tamaño 1 y vincular una comprobación de estado sencilla para que las pasarelas se reinicien de forma automática en caso de fallo. Las pasarelas se encuentran en grupos de instancias aparte, de modo que tendrán una IP externa estática vinculada a la plantilla de instancia. En este ejemplo, se aprovisionan tres pasarelas de NAT n1-standard-2, pero pueden utilizar cualquier otro número o tamaño de pasarelas. Por ejemplo, las instancias n1-standard-2 están limitadas a 4 Gbps de tráfico de red; si necesitas controlar un volumen de tráfico mayor, podrías elegir n1-standard-8s.

Crea una red de VPC (si fuera necesario). Si no vas a añadir estas pasarelas a una VPC existente, crea una red de VPC y una subred para ellas. Si las vas a añadir a una VPC existente, continúa en el segundo paso y modifica las regiones como corresponda para tu entorno.
1. Con Cloud Shell, crea una VPC personalizada que esté asociada a tu proyecto de GCP. Esta VPC te permite utilizar direcciones IP no predeterminadas, pero no incluye reglas de cortafuegos predeterminadas:
```
gcloud compute networks create example-vpc --mode custom
```
2. Crea una subred dentro de esta VPC y especifica una región y un intervalo de IPs. Para este tutorial, utiliza 10.0.1.0/24 y la región us-east1:
```
gcloud compute networks subnets create example-east \
    --network example-vpc --range 10.0.1.0/24 --region us-east1
```

Reserva y almacena tres direcciones IP estáticas.

Reserva y almacena una dirección denominada nat-1 en la región 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)')

Reserva y almacena una dirección denominada nat-2 en 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)')

Reserva y almacena una dirección denominada nat-3 en 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)')

Crea tres plantillas de instancia con direcciones IP reservadas.

Copia la configuración de inicio:
```
gsutil cp gs://nat-gw-template/startup.sh .
```
Si no puedes acceder a la secuencia de comandos de inicio, cópiala desde la sección de secuencia de comandos de inicio.

Crea una plantilla de instancia 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

Crea una plantilla de instancia 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

Crea una plantilla de instancia 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
```
El tipo de máquina n1-standard-2 tiene dos vCPU y puede consumir hasta 4 Gbps de ancho de banda de la red. Si necesitas más ancho de banda, podrías elegir un host diferente. El ancho de banda escala a 2 Gbps por vCPU y hasta 16 Gbps en un host de 8vCPU.

Crea una comprobación del estado para supervisar la capacidad de respuesta:

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 "209.85.152.0/22","209.85.204.0/22","35.191.0.0/16"

Si un sistema falla y no puede responder al tráfico de HTTP, se reiniciará. En este caso, y dado que necesitas un proyecto, puedes utilizar uno que ya exista o crear uno nuevo.

Crea un grupo de instancias para cada pasarela de 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

Configura la reparación automática para reiniciar pasarelas de NAT que no responden:

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 }')

Añade rutas predeterminadas a tus instancias:

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

Etiqueta las instancias en las que quieres utilizar el traductor NAT:
```
gcloud compute instances add-tags natted-servers --tags no-ip
```

Prueba la funcionalidad de NAT. Una vez que las pasarelas están configuradas y las máquinas virtuales invitadas etiquetadas, haz ping en los host externos sin dar tus IP externos de máquinas virtuales, como en este ejemplo:

ping 8.8.8.8

Ejemplo:

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

Aspectos que se deben tener en cuenta

Esta configuración proporciona tres pasarelas de NAT en la región us-east1, cada una con capacidad de 2 Gbps. No obstante, el balanceo de carga de ECMP no es perfecto y no se extiende un flujo individual por varios enlaces.

También hay disponible un módulo de Terraform para esta configuración que permite automatizar los despliegues.
Se recomienda esta configuración para enlaces de salida efímeros o sin reconocimiento del estado. Si cambia el tamaño del grupo de pasarelas de NAT, podrían reequilibrarse las conexiones TCP, de modo que se restablecería una conexión ya establecida.
Los nodos no se actualizan de forma automática, por lo que si una instalación predeterminada de Debian presenta una amenaza, tendrás que actualizar de forma manual.
Estas instancias están todas en la región us-east1. Si tus máquinas virtuales se encuentran en otras zonas, acerca las pasarelas a esas zonas para que mejorar el rendimiento.
El ancho de banda por pasarela consume hasta 2 Gbps por núcleo unidireccional. En caso de fallo de una pasarela, el tráfico se distribuye a las pasarelas restantes, pero como no se reprograman los flujos de ejecución, el tráfico no se restablece de forma inmediata cuando la pasarela vuelve a estar operativa. Así que se recomienda asegurarse de tener la sobrecarga suficiente cuando se calcule el tamaño.
Para recibir una alerta cuando los resultados no sean los previstos, utiliza Stackdriver que supervisa los grupos de instancias administradas y el tráfico de la red.

Secuencia de comandos de inicio: startup.sh

Secuencia de comandos de inicio a la que se hace referencia en el paso 3a:

#!/bin/bash
echo 1 > /proc/sys/net/ipv4/ip_forward
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 &

Siguientes pasos

Consulta la descripción general de las VPC para obtener más información sobre este tipo de redes.
Consulta cómo usar las redes de VPC para obtener instrucciones sobre cómo crearlas y modificarlas.