Usa reglas de NAT de Cloud NAT

1. Descripción general

Cloud NAT es una herramienta poderosa: con ella, las cargas de trabajo de Compute Engine y Google Kubernetes Engine (GKE) pueden acceder a los recursos de Internet de forma escalable y segura, sin exponer las cargas de trabajo que se ejecutan en ellos al acceso externo por medio de IP externas.

Cloud NAT tiene un diseño sin proxy que implementa la NAT directamente en la capa de SDN de Andromeda. Por lo tanto, no se verá afectado el rendimiento de tu carga de trabajo y se escala sin esfuerzo a muchas VMs, regiones y VPC.

Las reglas de NAT son una extensión de Cloud NAT. La función de reglas de NAT en Cloud NAT te permite crear reglas de acceso que definen cómo se usa Cloud NAT para conectarse a Internet. Actualmente, las reglas de NAT admiten la selección de direcciones de NAT de origen según la dirección de destino.

Sin las reglas de NAT, una VM con Cloud NAT habilitado usa el mismo conjunto de direcciones IP de NAT para llegar a todas las direcciones de Internet.

A veces, un caso de uso de NAT llama a Cloud NAT para que use diferentes direcciones IP de origen para destinos específicos. Una regla de NAT define una coincidencia y una acción correspondiente. Una vez que especificas las reglas de NAT, el paquete se hace coincidir con cada regla de NAT. Si se establece una coincidencia con una regla, se realiza la acción que corresponde a esa coincidencia.

Para obtener más información, consulta la sección de documentación sobre las reglas de NAT .

Qué aprenderás

• Cómo configurar una puerta de enlace de Cloud NAT en preparación para las reglas de NAT
• Cómo diseñar reglas de NAT con Common Expression Language (CEL)
• Cómo crear reglas de NAT y adjuntarlas a una puerta de enlace de NAT
• Cómo probar las reglas de NAT desde una instancia
• Cómo actualizar las reglas de una puerta de enlace NAT
• Cómo borrar reglas de NAT y volver al comportamiento predeterminado de Cloud NAT

Requisitos

• Conocimiento básico de Google Compute Engine
• Conocimiento básico de herramientas de redes y TCP/IP
• Conocimiento básico de la línea de comandos de Unix/Linux
• Es útil haber completado un recorrido por las herramientas de redes en GCP, como el lab Networking in Google Cloud.
• Comprender los conceptos básicos de Cloud NAT

2. Usa la consola de Google Cloud y Cloud Shell

Para interactuar con GCP, usaremos la consola de Google Cloud y Cloud Shell a lo largo de este lab.

Google Cloud Console

Puedes acceder a la consola de Cloud en https://console.cloud.google.com.

Configuración del entorno de autoaprendizaje

1. Accede a la consola de Cloud y crea un proyecto nuevo o reutiliza uno existente. Si aún no tienes una cuenta de Gmail o de Google Workspace, debes crear una.

Nota: Para acceder a la consola de Cloud con facilidad, memoriza su URL, que es console.cloud.google.com.

• El Nombre del proyecto es tu identificador personal para este proyecto. Siempre y cuando sigas sus convenciones de nomenclatura, puedes usar lo que desees y actualizarlo en cualquier momento.
• El ID del proyecto debe ser único en todos los proyectos de Google Cloud y es inmutable (no se puede cambiar una vez que se configura). La consola de Cloud genera automáticamente una cadena única. por lo general, no te importa qué es. En la mayoría de los codelabs, deberás hacer referencia al ID del proyecto (que suele identificarse como PROJECT_ID). Por lo tanto, si no te gusta, genera otro aleatorio, o bien puedes probar el tuyo y ver si está disponible. Luego, se “congela” una vez creado el proyecto.

Precaución: El ID de un proyecto debe ser único a nivel global y no lo puede usar nadie más una vez que lo selecciones. Eres el único usuario de ese ID. por lo que, si se borra un proyecto, ese ID no se puede volver a utilizar.

Nota: Si usas una cuenta de Gmail, puedes configurar la ubicación predeterminada como Sin organización. Si usas una cuenta de Google Workspace, elige una ubicación adecuada para tu organización.

2. A continuación, deberás habilitar la facturación en la consola de Cloud para usar los recursos de Google Cloud recursos.

Ejecutar este codelab no debería costar mucho, tal vez nada. Asegúrate de seguir las instrucciones de la sección “Realiza una limpieza” en la que se aconseja cómo cerrar recursos para no incurrir en facturación más allá de este instructivo. Los usuarios nuevos de Google Cloud son aptos para participar en el programa Prueba gratuita de$300.

Inicia Cloud Shell

Si bien Google Cloud y Spanner se pueden operar de manera remota desde tu laptop, en este codelab usarás Google Cloud Shell, un entorno de línea de comandos que se ejecuta en la nube.

En GCP Console, haga clic en el ícono de Cloud Shell en la barra de herramientas superior derecha:

El aprovisionamiento y la conexión al entorno deberían tomar solo unos minutos. Cuando termine el proceso, debería ver algo como lo siguiente:

Esta máquina virtual está cargada con todas las herramientas de desarrollo que necesitarás. Ofrece un directorio principal persistente de 5 GB y se ejecuta en Google Cloud, lo que permite mejorar considerablemente el rendimiento de la red y la autenticación. Puedes realizar todo tu trabajo en este lab usando simplemente un navegador.

3. Configuración del lab

En este lab, usarás un proyecto y crearás dos VPC con una subred en cada una. Reservarás direcciones IP externas y, luego, crearás y configurarás una puerta de enlace de Cloud NAT (con un Cloud Router), dos instancias de productor y una instancia de consumidor. Después de validar el comportamiento predeterminado de Cloud NAT, crearás reglas personalizadas de Cloud NAT y validarás su comportamiento.

Nota: Utilizaremos los comandos de Cloud Shell y gcloud para configurar este lab.

Descripción general de la arquitectura de Herramientas de redes:

4. Reservar direcciones IP externas

Reservemos todas las direcciones IP externas para usar en este lab. Esto te ayudará a escribir todas las reglas relevantes de NAT y firewall en la VPC del consumidor y del productor.

Desde Cloud Shell:

gcloud compute addresses  create nat-address-1 nat-address-2 nat-address-3 producer-address-1 producer-address-2 --region us-east4

Resultado:

Created [https://www.googleapis.com/compute/v1/projects/<Project ID>/regions/us-east4/addresses/nat-address-1].
Created [https://www.googleapis.com/compute/v1/projects/<Project ID>/regions/us-east4/addresses/nat-address-2].
Created [https://www.googleapis.com/compute/v1/projects/<Project ID>/regions/us-east4/addresses/nat-address-3].
Created [https://www.googleapis.com/compute/v1/projects/<Project ID>/regions/us-east4/addresses/producer-address-1].
Created [https://www.googleapis.com/compute/v1/projects/<Project ID>/regions/us-east4/addresses/producer-address-2].

Propaga las direcciones IP que se reservaron como variables de entorno.

export natip1=`gcloud compute addresses list --filter name:nat-address-1 --format="get(address)"`
export natip2=`gcloud compute addresses list --filter name:nat-address-2 --format="get(address)"`
export natip3=`gcloud compute addresses list --filter name:nat-address-3 --format="get(address)"`
export producerip1=`gcloud compute addresses list --filter name:producer-address-1 --format="get(address)"`
export producerip2=`gcloud compute addresses list --filter name:producer-address-2 --format="get(address)"`

No se espera ningún resultado, pero para confirmar que las direcciones se propagaron correctamente. Obtengamos el resultado de los valores de todas las variables de entorno.

$ env | egrep '^(nat|producer)ip[1-3]'

Resultado:

producerip1=<Actual Producer IP 1>
producerip2=<Actual Producer IP 2>
natip1=<NAT IP 1>
natip2=<NAT IP 2>
natip3=<NAT IP 3>

5. Configuración de instancias y VPC del productor.

Ahora, crearemos los recursos para los recursos del productor. Las instancias que se ejecutan en la VPC del productor ofrecerán el servicio orientado a Internet mediante dos IP públicas “producer-address-1” y “producer-address-2” de Google Cloud.

Primero, creemos la VPC. Desde Cloud Shell:

gcloud compute networks create producer-vpc --subnet-mode custom

Resultado:

Created [https://www.googleapis.com/compute/v1/projects/<Project-ID>/global/networks/producer-vpc].
NAME      SUBNET_MODE  BGP_ROUTING_MODE  IPV4_RANGE  GATEWAY_IPV4
producer-vpc  CUSTOM       REGIONAL

Instances on this network will not be reachable until firewall rules
are created. As an example, you can allow all internal traffic between
instances as well as SSH, RDP, and ICMP by running:

$ gcloud compute firewall-rules create <FIREWALL_NAME> --network producer-vpc --allow tcp,udp,icmp --source-ranges <IP_RANGE>
$ gcloud compute firewall-rules create <FIREWALL_NAME> --network producer-vpc --allow tcp:22,tcp:3389,icmp

A continuación, crearemos la subred en us-east4. Desde Cloud Shell:

gcloud compute networks subnets create producer-e4 \
   --network producer-vpc --range 10.0.0.0/24 --region us-east4

Resultado:

Created [https://www.googleapis.com/compute/v1/projects/<Project-ID>/regions/us-east4/subnetworks/producer-e4].
NAME              REGION       NETWORK       RANGE
producer-e4       us-east4  producer-vpc  10.0.0.0/24

A continuación, crearemos reglas de firewall de VPC para permitir que las direcciones IP de NAT lleguen a las instancias del productor en el puerto 8080.

Para la primera regla, desde Cloud Shell:

gcloud compute firewall-rules create producer-allow-8080 \
  --network producer-vpc --allow tcp:8080 \
  --source-ranges $natip1,$natip2,$natip3

Resultado:

Creating firewall...⠹Created [https://www.googleapis.com/compute/v1/projects/<Project-ID>/global/firewalls/producer-allow-8080].
Creating firewall...done.
NAME                 NETWORK       DIRECTION  PRIORITY  ALLOW     DENY  DISABLED
producer-allow-8080  producer-vpc  INGRESS    1000      tcp:8080        False

El siguiente paso es crear las dos instancias de productor.

Las instancias de productor ejecutarán un servicio de eco de IP en un contenedor de Docker disponible en Docker Hub (el código fuente está disponible en el repositorio de GitHub del autor del servicio).

Para aprovisionar rápidamente las instancias con todo el software requerido, usaremos la función Implementación de contenedores en Compute Engine.

Para poder escribir reglas de NAT, aprovisionaremos cada instancia con una dirección IP reservada diferente.

Crea la primera instancia. Desde Cloud Shell:

gcloud compute instances create-with-container producer-instance-1 \
--zone=us-east4-a --machine-type=e2-medium \
--network-interface=address=producer-address-1,network-tier=PREMIUM,subnet=producer-e4 \
--container-image=mpolden/echoip --container-restart-policy=always

Resultado:

Created [https://www.googleapis.com/compute/v1/projects/<Project-ID>/zones/us-east4-a/instances/producer-instance-1].
NAME                 ZONE           MACHINE_TYPE  PREEMPTIBLE  INTERNAL_IP  EXTERNAL_IP  STATUS
producer-instance-1  us-east4-a  e2-medium                  10.0.0.2     <producer IP 1>  RUNNING

Luego, crea la segunda instancia. Desde Cloud Shell:

gcloud compute instances create-with-container producer-instance-2 \
 --zone=us-east4-a --machine-type=e2-medium \
--network-interface=address=producer-address-2,network-tier=PREMIUM,subnet=producer-e4 \
--container-image=mpolden/echoip --container-restart-policy=always

Resultado:

Created [https://www.googleapis.com/compute/v1/projects/<Project-ID>/zones/us-east4-a/instances/producer-instance-2].
NAME                 ZONE           MACHINE_TYPE  PREEMPTIBLE  INTERNAL_IP  EXTERNAL_IP  STATUS
producer-instance-2  us-east4-a  e2-medium                  10.0.0.3     <producer IP 2>  RUNNING

6. Configura la VPC del consumidor, Cloud NAT y la instancia

Ahora que creaste el servicio de productor, es momento de crear la VPC del consumidor y su puerta de enlace de Cloud NAT.

Después de crear la VPC y la subred, agregaremos una regla de firewall de entrada simple para permitir el IAP para los rangos de IP de origen de TCP. Esto nos permitirá establecer una conexión SSH a las instancias del consumidor directamente con gcloud.

A continuación, crearemos una puerta de enlace de Cloud NAT simple en el modo de asignación manual y la dirección reservada “nat-address-1”. asociados con ella. En partes posteriores del codelab, actualizaremos la configuración de la puerta de enlace para agregar reglas personalizadas. .

Primero, creemos la VPC. Desde Cloud Shell:

gcloud compute networks create consumer-vpc --subnet-mode custom

Resultado:

Created [https://www.googleapis.com/compute/v1/projects/<Project-ID>/global/networks/consumer-vpc].
NAME      SUBNET_MODE  BGP_ROUTING_MODE  IPV4_RANGE  GATEWAY_IPV4
consumer-vpc  CUSTOM       REGIONAL

Instances on this network will not be reachable until firewall rules
are created. As an example, you can allow all internal traffic between
instances as well as SSH, RDP, and ICMP by running:

$ gcloud compute firewall-rules create <FIREWALL_NAME> --network consumer-vpc --allow tcp,udp,icmp --source-ranges <IP_RANGE>
$ gcloud compute firewall-rules create <FIREWALL_NAME> --network producer-vpc --allow tcp:22,tcp:3389,icmp

A continuación, crearemos una subred en us-east4. Desde Cloud Shell:

gcloud compute networks subnets create consumer-e4 \
   --network consumer-vpc --range 10.0.0.0/24 --region us-east4

Resultado:

Created [https://www.googleapis.com/compute/v1/projects/<Project-ID>/regions/us-east4/subnetworks/consumer-e4].
NAME              REGION       NETWORK       RANGE
consumer-e4       us-east4  consumer-vpc  10.0.0.0/24

A continuación, crearemos una regla de firewall de VPC para permitir que las direcciones de rangos de IAP lleguen a las instancias del consumidor en el puerto 22.

Para la primera regla de firewall, ejecuta lo siguiente desde Cloud Shell:

gcloud compute firewall-rules create consumer-allow-iap \
  --network consumer-vpc --allow tcp:22 \
  --source-ranges 35.235.240.0/20

Resultado:

Creating firewall...⠹Created [https://www.googleapis.com/compute/v1/projects/<Project-ID>/global/firewalls/consumer-allow-iap].
Creating firewall...done.
NAME                 NETWORK       DIRECTION  PRIORITY  ALLOW     DENY  DISABLED
consumer-allow-iap  consumer-vpc  INGRESS    1000      tcp:22        False

Antes de crear una puerta de enlace NAT, primero debemos crear una instancia de Cloud Router (usamos un número ASN privado, pero es irrelevante para las actividades de este lab). Desde Cloud Shell:

gcloud compute routers create consumer-cr \
--region=us-east4 --network=consumer-vpc \
 --asn=65501

Resultado:

Creating router [consumer-cr]...done.
NAME         REGION       NETWORK
consumer-cr  us-east4  consumer-vpc

Luego, crea la instancia de puerta de enlace NAT. Desde Cloud Shell:

gcloud compute routers nats create consumer-nat-gw \
    --router=consumer-cr \
    --router-region=us-east4 \
    --nat-all-subnet-ip-ranges \
    --nat-external-ip-pool=nat-address-1

Resultado:

Creating NAT [consumer-nat-gw] in router [consumer-cr]...done.

Crea la instancia de prueba de consumidor. Propagamos las IP de productor reservadas aquí para poder hacer referencia a ellas dentro de la instancia más adelante. Desde Cloud Shell:

gcloud compute instances create consumer-instance --zone=us-east4-a \
--machine-type=e2-medium --network-interface=subnet=consumer-e4,no-address \
--metadata=producer-service-ip1=$producerip1,producer-service-ip2=$producerip2

Resultado:

Created [https://www.googleapis.com/compute/v1/projects/<Project-ID>/zones/us-east4-a/instances/consumer-instance].
NAME               ZONE           MACHINE_TYPE  PREEMPTIBLE  INTERNAL_IP  EXTERNAL_IP  STATUS
consumer-instance  us-east4-a  e2-medium                  10.0.0.2                  RUNNING

7. Verifica el comportamiento predeterminado de Cloud NAT

En este punto, la instancia del consumidor usa el comportamiento predeterminado de Cloud NAT, que utiliza la misma IP reservada “nat-address-1” para comunicarse con todas las direcciones externas.

Validemos este comportamiento antes de usar la nueva función de reglas de NAT en Cloud NAT.

Establece una conexión SSH a la instancia del consumidor. Desde Cloud Shell:

gcloud compute ssh consumer-instance --zone=us-east4-a

Ahora deberías estar en la shell de la instancia.

Resultado de muestra (resultado completo truncado para abreviación)

No zone specified. Using zone [us-east4-a] for instance: [consumer-instance].
External IP address was not found; defaulting to using IAP tunneling.
...
...
<username>@consumer-instance:~$

Desde la instancia del consumidor, primero recuperamos ambas IP de productor y las propagamos como variables de entorno

export producerip1=`curl -s "http://metadata.google.internal/computeMetadata/v1/instance/attributes/producer-service-ip1" -H "Metadata-Flavor: Google"`

export producerip2=`curl -s "http://metadata.google.internal/computeMetadata/v1/instance/attributes/producer-service-ip2" -H "Metadata-Flavor: Google"`

Luego, intenta ejecutar el comando curl en ambas instancias de productor y observa la dirección IP de origen que se muestra.

<username>@consumer-instance:~$ curl http://$producerip1:8080
34.136.8.83
<username>@consumer-instance:~$ curl http://$producerip2:8080
34.136.8.83

Deberías ver que se muestra la misma dirección IP para ambos extremos, que es igual al valor de la IP reservada externa “nat-address-1”.

Del mismo modo, un comando curl a cualquier servicio externo reflector de IP debería mostrar la misma IP, por ejemplo:

<username>@consumer-instance:~$ curl http://ifconfig.co
34.136.8.83
<username>@consumer-instance:~$ curl http://ifconfig.me
34.136.8.83
<username>@consumer-instance:~$ curl http://ip.fyr.io
34.136.8.83

Sal de la sesión SSH de la instancia por ahora. Volveremos a establecer la conexión SSH después de configurar las reglas de NAT.

8. Crea reglas de Cloud NAT

Las reglas de NAT se escriben con la sintaxis de Common Expression Language. Para obtener más información sobre el lenguaje de expresión de reglas, consulta Lenguaje de expresión de reglas.

También puedes agregar una regla de NAT a una puerta de enlace de NAT existente con los comandos de gcloud. Exploraremos ambas opciones para crear reglas de Cloud NAT.

Primero, crearemos un archivo YAML con la regla de NAT.

Desde Cloud Shell:

export projectid=`gcloud config get-value project`

cat <<EOF >natrulesfile.txt
rules:
 - ruleNumber: 100
   match: destination.ip == '$producerip2'
   action:
     sourceNatActiveIps:
     -  /projects/$projectid/regions/us-east4/addresses/nat-address-2
EOF

Luego, actualicemos nuestra puerta de enlace NAT existente con este archivo de reglas. Desde Cloud Shell:

gcloud alpha compute routers nats update consumer-nat-gw \
    --router=consumer-cr \
    --rules=natrulesfile.txt \
    --router-region=us-east4

Deberías esperar el siguiente resultado :

Updating nat [consumer-nat-gw] in router [consumer-cr]...done.

Verifica que la regla se haya configurado correctamente. Desde Cloud Shell:

gcloud alpha compute routers nats rules list \
--nat=consumer-nat-gw --router=consumer-cr \
--router-region=us-east4

Deberías esperar el siguiente resultado :

RULE_NUMBER  MATCH
100          destination.ip == '35.192.142.134'

Intentemos recrear la misma regla solo con los comandos de gcloud. Primero, borra la regla existente. Desde Cloud Shell:

gcloud alpha compute routers nats rules delete 100 \
--nat=consumer-nat-gw --router=consumer-cr \
--router-region=us-east4 --quiet

Deberías esperar el siguiente resultado :

Updated [https://www.googleapis.com/compute/alpha/projects/ghaleb-s2/regions/us-east4/routers/consumer-cr]

Luego, vuelve a crear la regla con este comando de gcloud. Desde Cloud Shell:

gcloud alpha compute routers nats rules create 100 \
 --match='destination.ip == "'$producerip2'"' \
--source-nat-active-ips=nat-address-2 --nat=consumer-nat-gw \
 --router=consumer-cr --router-region=us-east4

Deberías esperar el siguiente resultado :

Creating Rule [100] in NAT [consumer-nat-gw]...done.

Una vez más, para validar que la regla se creó correctamente, repite el comando anterior. Esta vez, agregaremos el interruptor de formato YAML para ver todos los detalles de la regla.

Desde Cloud Shell:

gcloud alpha compute routers nats rules list\
 --nat=consumer-nat-gw --router=consumer-cr \
--router-region=us-east4  --format=yaml

Deberías esperar el siguiente resultado :

---
action:
  sourceNatActiveIps:
  - https://www.googleapis.com/compute/alpha/projects/<Project-ID>/regions/us-east4/addresses/nat-address-2
match: destination.ip == <actual IP for producer-IP 2>
ruleNumber: 100

Por último, observa que ahora tanto "nat-address1" y "nat-address-2" que las direcciones externas se muestren como “IN_USE”. Para comprobarlo, ejecuta este comando desde Cloud Shell:

$ gcloud compute addresses list

Deberías esperar el siguiente resultado (las direcciones IP reales deben coincidir con las direcciones que reservaste) :

NAME                ADDRESS/RANGE   TYPE      PURPOSE  NETWORK  REGION       SUBNET  STATUS
nat-address-1       34.136.8.83     EXTERNAL                    us-east4          IN_USE
nat-address-2       34.70.137.35    EXTERNAL                    us-east4          IN_USE
nat-address-3       34.135.103.88   EXTERNAL                    us-east4          RESERVED
producer-address-1  34.66.0.105     EXTERNAL                    us-east4          IN_USE
producer-address-2  35.192.142.134  EXTERNAL                    us-east4          IN_USE

9. Verifica el comportamiento de las reglas de Cloud NAT

En este punto, la instancia del consumidor debería usar la regla de Cloud NAT creada para usar nat-address-2 para comunicarse con producer-address-2.

Validaremos este comportamiento. Establece una conexión SSH a la instancia del consumidor. Desde Cloud Shell:

gcloud compute ssh consumer-instance --zone=us-east4-a

Ahora deberías estar en la shell de la instancia.

Resultado de muestra (resultado completo truncado para abreviación)

No zone specified. Using zone [us-east4-a] for instance: [consumer-instance].
External IP address was not found; defaulting to using IAP tunneling.
...
...
<username>@consumer-instance:~$

Desde la instancia del consumidor, primero recuperamos ambas IP de productor y las propagamos como variables de entorno

export producerip1=`curl -s "http://metadata.google.internal/computeMetadata/v1/instance/attributes/producer-service-ip1" -H "Metadata-Flavor: Google"`

export producerip2=`curl -s "http://metadata.google.internal/computeMetadata/v1/instance/attributes/producer-service-ip2" -H "Metadata-Flavor: Google"`

Luego, intenta ejecutar el comando curl en ambas instancias de productor y observa la dirección IP de origen que se muestra.

<username>@consumer-instance:~$ curl http://$producerip1:8080
34.136.8.83
<username>@consumer-instance:~$ curl http://$producerip2:8080
34.70.137.35

Ahora deberías ver que se muestra una dirección IP diferente para ambos extremos. La primera dirección IP debería ser la misma que el comportamiento predeterminado. La segunda dirección IP debe ser igual a "nat-address-2" después de agregar la nueva regla de NAT.

Un curl a cualquier servicio externo reflector de IP debería seguir mostrando la misma IP que el comportamiento predeterminado, por ejemplo:

<username>@consumer-instance:~$ curl http://ifconfig.co
34.136.8.83
<username>@consumer-instance:~$ curl http://ifconfig.me
34.136.8.83
<username>@consumer-instance:~$ curl http://ip.fyr.io
34.136.8.83

Sal de la sesión de SSH de la instancia por ahora y volveremos a establecer la conexión SSH para probar el vaciado de direcciones.

10. Actualizar y Borra las reglas de Cloud NAT

Puedes actualizar las reglas existentes de Cloud NAT. Por ejemplo, puedes asociar direcciones IP nuevas y desviar las direcciones IP existentes asociadas con reglas existentes.

Actualicemos el archivo de reglas NAT como se indica a continuación

Desde Cloud Shell:

export projectid=`gcloud config get-value project`

cat <<EOF >natrulesfile.txt
rules:
 - ruleNumber: 100
   match: destination.ip == '$producerip2'
   action:
     sourceNatDrainIps:
     -  /projects/$projectid/regions/us-east4/addresses/nat-address-2
     sourceNatActiveIps:
     -  /projects/$projectid/regions/us-east4/addresses/nat-address-3
EOF

Ahora, este archivo nuevo coloca "nat-address-2" en estado agotado. Y agrega "nat-address-3" en estado activo. Esto debería permitir que las conexiones existentes que usan nat-address-2 finalicen de forma correcta, mientras que se crean conexiones nuevas solo con nat-address-3.

Luego, actualicemos nuestra puerta de enlace NAT existente con este archivo de reglas. Desde Cloud Shell:

gcloud alpha compute routers nats update consumer-nat-gw \
    --router=consumer-cr \
    --rules=natrulesfile.txt \
    --router-region=us-east4

Deberías esperar el siguiente resultado :

Updating nat [consumer-nat-gw] in router [consumer-cr]...done.

Verifica que la regla se haya configurado correctamente. Desde Cloud Shell:

gcloud alpha compute routers nats rules list \
--nat=consumer-nat-gw --router=consumer-cr \
--router-region=us-east4 --format=yaml

Deberías esperar el siguiente resultado :

---
action:
  sourceNatActiveIps:
  - https://www.googleapis.com/compute/alpha/projects/ghaleb-s2/regions/us-east4/addresses/nat-address-3
  sourceNatDrainIps:
  - https://www.googleapis.com/compute/alpha/projects/ghaleb-s2/regions/us-east4/addresses/nat-address-2
match: destination.ip == '35.192.142.134'
ruleNumber: 100

Observa que "nat-address-2" ahora se encuentra en estado desviado. Te permitimos validar que las nuevas conexiones de la VPC del consumidor ahora usen las IP de NAT correctas.

Por último, borra las reglas de NAT de tu puerta de enlace de Cloud NAT y vuelve al comportamiento predeterminado. Puedes usar el siguiente comando de gcloud. Desde Cloud Shell:

gcloud alpha compute routers nats rules delete 100 \
 --nat=consumer-nat-gw --router=consumer-cr \
 --router-region=us-east4 --quiet

Deberías esperar el siguiente resultado :

Updated [https://www.googleapis.com/compute/alpha/projects/ghaleb-s2/regions/us-east4/routers/consumer-cr]

Para verificar que no existan más reglas de NAT, usemos el comando de descripción de la puerta de enlace NAT

gcloud alpha compute routers nats describe consumer-nat-gw \
 --router=consumer-cr --router-region=us-east4

Deberías esperar el siguiente resultado :

enableEndpointIndependentMapping: false
name: consumer-nat-gw
natIpAllocateOption: MANUAL_ONLY
natIps:
- https://www.googleapis.com/compute/alpha/projects/ghaleb-s2/regions/us-east4/addresses/nat-address-1
sourceSubnetworkIpRangesToNat: ALL_SUBNETWORKS_ALL_IP_RANGES

Observa que no hay una “reglas:” en el archivo YAML de salida. Indicar que no se configuraron reglas de NAT.

11. Pasos de limpieza

Para evitar cargos recurrentes, debes borrar todos los recursos asociados con este codelab.

Primero, borra todas las instancias.

Desde Cloud Shell:

gcloud compute instances delete consumer-instance \
producer-instance-1 producer-instance-2 \
 --zone us-east4-a --quiet

Resultado esperado :

Deleted [https://www.googleapis.com/compute/v1/projects/<Project Id>/zones/us-east4-a/instances/consumer-instance].
Deleted [https://www.googleapis.com/compute/v1/projects/<Project Id>/zones/us-east4-a/instances/producer-instance-1].
Deleted [https://www.googleapis.com/compute/v1/projects/<Project Id>/zones/us-east4-a/instances/producer-instance-2].

A continuación, borra el Cloud Router. Desde Cloud Shell:

gcloud compute routers delete consumer-cr \
--region us-east4 --quiet

Deberías esperar el siguiente resultado :

Deleted [https://www.googleapis.com/compute/v1/projects/<Project ID>/regions/us-east4/routers/consumer-cr].

Libera todas las direcciones IP externas. Desde Cloud Shell:

gcloud compute addresses delete nat-address-1 \
 nat-address-2 nat-address-3 producer-address-1 \
producer-address-2 --region us-east4 --quiet

Deberías esperar el siguiente resultado :

Deleted [https://www.googleapis.com/compute/v1/projects/<Project ID>/regions/us-east4/addresses/nat-address-1].
Deleted [https://www.googleapis.com/compute/v1/projects/<Project ID>/regions/us-east4/addresses/nat-address-2].
Deleted [https://www.googleapis.com/compute/v1/projects/<Project ID>/regions/us-east4/addresses/nat-address-3].
Deleted [https://www.googleapis.com/compute/v1/projects/<Project ID>/regions/us-east4/addresses/producer-address-1].
Deleted [https://www.googleapis.com/compute/v1/projects/<Project ID>/regions/us-east4/addresses/producer-address-2].

Borra las reglas de firewall de VPC. Desde Cloud Shell:

gcloud compute firewall-rules delete consumer-allow-iap \
 producer-allow-8080 --quiet

Deberías esperar el siguiente resultado :

Deleted [https://www.googleapis.com/compute/v1/projects/<Project ID>/global/firewalls/consumer-allow-iap].
Deleted [https://www.googleapis.com/compute/v1/projects/<Project ID>/global/firewalls/producer-allow-8080].

Borra las subredes. Desde Cloud Shell:

gcloud compute networks subnets delete consumer-e4 \
producer-e4 --region=us-east4 --quiet

Deberías esperar el siguiente resultado :

Deleted [https://www.googleapis.com/compute/v1/projects/<Project ID>/regions/us-east4/subnetworks/consumer-e4].
Deleted [https://www.googleapis.com/compute/v1/projects/<Project ID>/regions/us-east4/subnetworks/producer-e4].

Por último, borremos las VPC. Desde Cloud Shell:

gcloud compute networks delete consumer-vpc \
producer-vpc --quiet

Deberías esperar el siguiente resultado :

Deleted [https://www.googleapis.com/compute/v1/projects/<Project ID>/global/networks/consumer-vpc].
Deleted [https://www.googleapis.com/compute/v1/projects/<Project ID>/global/networks/producer-vpc].

12. ¡Felicitaciones!

Completaste el lab de reglas de Cloud NAT.

Temas abordados

• Cómo configurar una puerta de enlace de Cloud NAT en preparación para las reglas de NAT
• Cómo diseñar reglas de NAT con Common Expression Language (CEL)
• Cómo crear reglas de NAT y adjuntarlas a una puerta de enlace de NAT
• Cómo probar las reglas de NAT desde una instancia
• Cómo actualizar las reglas de una puerta de enlace NAT
• Cómo borrar reglas de NAT y volver al comportamiento predeterminado de Cloud NAT

Próximos pasos

• Experimenta con la creación de reglas de NAT más complejas, como este ejemplo.
• Explora el vaciado de direcciones IP de NAT y observa el impacto en la conexión.
• Obtenga más información sobre Herramientas de redes en Google Cloud Platform

©Google, Inc. or its affiliates. All rights reserved. Do not distribute.