Usa reglas de NAT de Cloud NAT

1. Descripción general

Cloud NAT es una herramienta potente: 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 ellas al acceso externo a través de IPs externas.

Cloud NAT cuenta con un diseño sin proxy, ya que implementa NAT directamente en la capa de SDN de Andromeda. Por lo tanto, no hay impacto en el rendimiento de tu carga de trabajo, y se puede escalar sin esfuerzo a muchas VMs, regiones y VPCs.

Las reglas NAT son una extensión de Cloud NAT. La función de reglas 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 NAT de origen según la dirección de destino.

Sin reglas 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 requiere que Cloud NAT 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 especifiques las reglas de NAT, el paquete coincidirá con cada regla de NAT. Si se encuentra una coincidencia con una regla, se lleva a cabo la acción correspondiente 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 NAT
• Cómo probar reglas de NAT desde una instancia
• Cómo actualizar las reglas de una puerta de enlace NAT
• Cómo borrar reglas de NAT y revertir 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 redes en GCP, como el lab de Networking in Google Cloud.
• Comprensión de los conceptos básicos de Cloud NAT

2. Usa la consola de Google Cloud y Cloud Shell

Para interactuar con GCP, usaremos Google Cloud Console 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 que sigas sus convenciones de nomenclatura, puedes usar lo que quieras 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 importa cuál sea. En la mayoría de los codelabs, deberás hacer referencia al ID del proyecto (suele identificarse como PROJECT_ID), por lo que, si no te gusta, genera otro aleatorio o puedes probar con uno propio y ver si está disponible. Después de crear el proyecto, este ID se “congela” y no se puede cambiar.

Precaución: El ID de un proyecto debe ser único a nivel global y ninguna otra persona puede usarlo después de seleccionarlo. Serás 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 que no se te facture más allá de este instructivo. Los usuarios nuevos de Google Cloud son aptos para participar en el programa Prueba gratuita de USD 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: Usaremos Cloud Shell y los comandos de gcloud para configurar este lab.

Descripción general de la arquitectura de redes:

4. Reserva direcciones IP externas

Reservaremos todas las direcciones IP externas que se usarán en este lab. Esto te ayudará a escribir todas las reglas de NAT y de firewall pertinentes en la VPC del consumidor y del productor.

En Cloud Shell, ingresa lo siguiente:

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 se puede confirmar que las direcciones se completaron correctamente. Generemos 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 la VPC y las instancias 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 con dos IPs públicas: "producer-address-1" y "producer-address-2" .

Primero, creemos la VPC. En Cloud Shell, ingresa lo siguiente:

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. En Cloud Shell, ingresa lo siguiente:

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, haz lo siguiente:

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 necesario, 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. En Cloud Shell, ingresa lo siguiente:

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. En Cloud Shell, ingresa lo siguiente:

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 del 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 los rangos de IP de origen de IAP para TCP. Esto nos permitirá acceder a las instancias de consumidor directamente con SSH a través de gcloud.

Luego, crearemos una puerta de enlace de Cloud NAT simple en el modo de asignación manual y la dirección reservada "nat-address-1" asociada a ella. En las siguientes partes del codelab, actualizaremos la configuración de la puerta de enlace para agregar reglas personalizadas. .

Primero, creemos la VPC. En Cloud Shell, ingresa lo siguiente:

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. En Cloud Shell, ingresa lo siguiente:

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 reglas de firewall de VPC para permitir que los rangos de direcciones 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 de NAT, primero debemos crear una instancia de Cloud Router (usamos un número de ASN privado, pero es irrelevante para las actividades de este lab). En Cloud Shell, ingresa lo siguiente:

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. En Cloud Shell, ingresa lo siguiente:

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 del consumidor. Aquí completamos las IPs de los productores reservadas para poder consultarlas más adelante en la instancia. En Cloud Shell, ingresa lo siguiente:

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 usa la misma IP reservada "nat-address-1" para comunicarse con todas las direcciones externas.

Primero, 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. En Cloud Shell, ingresa lo siguiente:

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

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

Resultado de muestra (el resultado completo se truncó para mayor brevedad)

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 recuperemos las IPs del productor y propaguémoslas 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 usar curl en ambas instancias de productor y observa la dirección IP de origen que se devolvió.

<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 la misma dirección IP que se devolvió para ambos extremos, que es igual al valor de la IP externa reservada "nat-address-1".

Del mismo modo, un curl a cualquier servicio externo de 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

Por ahora, sal de la sesión SSH de la instancia. Volveremos a acceder a ella a través de 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 regla, consulta Lenguaje de expresión de regla.

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

Primero, crearemos un archivo YAML de regla de NAT.

En Cloud Shell, ingresa lo siguiente:

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. En Cloud Shell, ingresa lo siguiente:

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

Deberías obtener el siguiente resultado :

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

Valida que la regla se haya configurado correctamente. En Cloud Shell, ingresa lo siguiente:

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

Deberías obtener el siguiente resultado :

RULE_NUMBER  MATCH
100          destination.ip == '35.192.142.134'

Intentemos volver a crear la misma regla solo con comandos de gcloud. Primero, borra la regla existente. En Cloud Shell, ingresa lo siguiente:

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

Deberías obtener 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. En Cloud Shell, ingresa lo siguiente:

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 obtener el siguiente resultado :

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

Nuevamente, para validar que la regla se creó correctamente, repite el comando anterior. Esta vez, agregaremos el parámetro de formato YAML para ver todos los detalles de la regla.

En Cloud Shell, ingresa lo siguiente:

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

Deberías obtener 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 las direcciones externas "nat-address1" y "nat-address-2" se muestran como "IN_USE". Para ver eso, ejecuta este comando desde Cloud Shell:

$ gcloud compute addresses list

Deberías ver el siguiente resultado (las direcciones IP reales deben coincidir con las 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 y comunicarse con producer-address-2.

Validemos este comportamiento. Establece una conexión SSH a la instancia del consumidor. En Cloud Shell, ingresa lo siguiente:

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

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

Resultado de muestra (el resultado completo se truncó para mayor brevedad)

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 recuperemos las IPs del productor y propaguémoslas 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 usar curl en ambas instancias de productor y observa la dirección IP de origen que se devolvió.

<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 devuelve una dirección IP diferente para ambos extremos. La primera dirección IP debería ser la misma que la del 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 de 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

Por ahora, sal de la sesión SSH de la instancia. Volveremos a establecer la conexión SSH para probar el agotamiento de direcciones.

10. Actualiza y borra reglas de Cloud NAT

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

Actualicemos el archivo de reglas NAT de la siguiente manera:

En Cloud Shell, ingresa lo siguiente:

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

Lo que hace este nuevo archivo es colocar "nat-address-2" en un estado de vaciado. Y agrega "nat-address-3" en el estado activo. Esto debería permitir que las conexiones existentes que usan nat-address-2 finalicen correctamente, mientras que las conexiones nuevas solo usan nat-address-3.

Luego, actualicemos nuestra puerta de enlace NAT existente con este archivo de reglas. En Cloud Shell, ingresa lo siguiente:

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

Deberías obtener el siguiente resultado :

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

Valida que la regla se haya configurado correctamente. En Cloud Shell, ingresa lo siguiente:

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

Deberías obtener 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 cómo "nat-address-2" ahora se encuentra en un estado de vaciado. Te dejamos como ejercicio validar que las nuevas conexiones de la VPC del consumidor ahora usen las IPs de NAT correctas.

Por último, para borrar las reglas de NAT de tu puerta de enlace de Cloud NAT y volver al comportamiento predeterminado. Puedes usar el siguiente comando de gcloud. En Cloud Shell, ingresa lo siguiente:

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

Deberías obtener 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 de NAT.

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

Deberías obtener 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 sección "rules:" en el YAML de salida. Indica que no hay reglas de NAT configuradas.

11. Pasos para la limpieza

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

Primero, borra todas las instancias.

En Cloud Shell, ingresa lo siguiente:

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. En Cloud Shell, ingresa lo siguiente:

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

Deberías obtener el siguiente resultado :

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

Liberar todas las direcciones IP externas En Cloud Shell, ingresa lo siguiente:

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 obtener 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 reglas de firewall de VPC. En Cloud Shell, ingresa lo siguiente:

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

Deberías obtener 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 subredes. En Cloud Shell, ingresa lo siguiente:

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

Deberías obtener 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. En Cloud Shell, ingresa lo siguiente:

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

Deberías obtener 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 NAT
• Cómo probar reglas de NAT desde una instancia
• Cómo actualizar las reglas de una puerta de enlace NAT
• Cómo borrar reglas de NAT y revertir al comportamiento predeterminado de Cloud NAT

Próximos pasos

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

©Google LLC o sus afiliados. Todos los derechos reservados. Do not distribute.