Configura un balanceador de cargas de red de transferencia interno como próximo salto (con etiquetas)

En este instructivo, se usa un ejemplo en el que se muestra cómo implementar un balanceador de cargas de red de transferencia interno como próximo salto al que se reenvían los paquetes en la ruta a su destino final. Usarás etiquetas de red para configurar las instancias de cliente específicas a las que se aplica la ruta.

En esta guía, se da por sentado que estás familiarizado con el funcionamiento de un balanceador de cargas de red de transferencia interno, sus componentes relacionados, como reglas de firewall y verificaciones de estado, y cómo se usan los balanceadores de cargas de red de transferencia internos como siguientes saltos para reenviar paquetes en una ruta.

Con el balanceador de cargas de red de transferencia interno como función de próximo salto, puedes integrar dispositivos de terceros con alta disponibilidad y escalamiento horizontal. Para hacerlo, debes configurar una ruta estática personalizada y establecer el siguiente salto en el balanceador de cargas, que distribuirá el tráfico del prefijo de destino al grupo de dispositivos de VM de terceros con verificación de estado. Tendrás varias opciones cuando selecciones los siguientes saltos para admitir la alta disponibilidad de estos dispositivos de terceros:

• Especificar una dirección IP como siguiente salto: Usa la dirección IP interna asociada con la regla de reenvío como siguiente salto. La dirección IP virtual del balanceador de cargas se puede aprender entre apps similares sin tener que exportar la ruta personalizada a través de ellas.
• Usa etiquetas de red: Puedes especificar una etiqueta de red para que el balanceador de cargas de red de transferencia interno como ruta de siguiente salto solo se aplique a las instancias de cliente que se configuraron con la etiqueta. Esto te permite seleccionar qué instancias de cliente se propagan con qué balanceador de cargas de red de transferencia interno con etiquetas como ruta de próximos saltos y a qué conjunto de dispositivos debe enrutar el tráfico. No es necesario segregar las diferentes instancias de cliente a VPC independientes, ya que cada una apunta a su balanceador de cargas de red de transferencia interno preferido, que realiza un frontend de un conjunto de dispositivos. Las rutas etiquetadas no se exportan ni importan a través del intercambio de tráfico entre redes de VPC.
• Configurar varias rutas para el mismo prefijo de destino: Con etiquetas, puedes especificar varias rutas al mismo destino con diferentes balanceadores de cargas internos como siguientes saltos. Aunque ECMP no es compatible (el mismo prefijo de destino, las mismas etiquetas, pero diferentes saltos siguientes), puedes usar distintas etiquetas o prioridades para las mismas rutas de destino.

Descripción general de la configuración

Los grupos de instancias administrados que usan VM con un solo NIC se definen en diferentes regiones, con instancias de Linux configuradas para que ejecuten SNAT-translate en todo el tráfico saliente a Internet (flujo de tráfico saliente de norte a sur). La conmutación por error regional se activa de forma manual. En este instructivo, también se muestra la conectividad este-oeste con hash simétrico mediante un balanceador de cargas de red de transferencia interno como próximo salto.

En esta sección, se explica cómo configurar los siguientes puntos:

1. Redes de VPC de muestra con subredes personalizadas
2. Reglas de firewall que permiten conexiones entrantes a VM de backend
3. Grupos de instancias administrados de backend que implementan puertas de enlace NAT
4. VM cliente para probar conexiones
5. Los siguientes componentes del balanceador de cargas de red de transferencia interno:
   • Una verificación de estado del servicio de backend
   • Un servicio de backend interno
   • Una regla de reenvío interno y una dirección IP interna para el frontend del balanceador de cargas

Así se ve la arquitectura de este ejemplo:

Balanceador de cargas de red de transferencia interno como configuración de próximo salto (haz clic para ampliar)

Sigue los pasos de este instructivo y reemplaza REGION_A y REGION_B por las regiones respectivas que deseas usar para este ejemplo.

Crea redes y subredes de VPC

1. Crea una red de VPC llamada hub-vpc.

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

2. Crea una subred en hub-vpc, en REGION_A.

   gcloud compute networks subnets create hub-subnet-a \
       --network hub-vpc \
       --range 10.0.0.0/24 \
       --region REGION_A
   

3. Crea una subred en hub-vpc, en region B.

   gcloud compute networks subnets create hub-subnet-b \
       --network hub-vpc \
       --range 10.0.1.0/24 \
       --region REGION_B
   

4. Crea una red de VPC llamada spoke1-vpc.

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

5. Crea una subred en spoke1-vpc.

   gcloud compute networks subnets create spoke1-subnet1 \
       --network spoke1-vpc \
       --range 192.168.0.0/24 \
       --region REGION_A
   

6. Crea una red de VPC llamada spoke2-vpc.

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

7. Crea una subred en spoke2-vpc.

   gcloud compute networks subnets create spoke2-subnet1 \
       --network spoke2-vpc \
       --range 192.168.1.0/24 \
       --region REGION_A
   

Configura reglas de firewall

1. Configura las siguientes reglas de firewall para permitir que el tráfico de TCP, ICMP y UDP llegue a instancias de los rangos de origen especificados.

   gcloud compute firewall-rules create hub-vpc-web-ping-dns \
       --network hub-vpc \
       --allow tcp:80,tcp:443,icmp,udp:53 \
       --source-ranges 10.0.0.0/24,10.0.1.0/24,192.168.0.0/24,192.168.1.0/24
   

   gcloud compute firewall-rules create spoke1-vpc-web-ping-dns \
       --network spoke1-vpc \
       --allow tcp:80,tcp:443,icmp,udp:53 \
       --source-ranges 10.0.0.0/24,10.0.1.0/24,192.168.0.0/24,192.168.1.0/24
   

   gcloud compute firewall-rules create spoke2-vpc-web-ping-dns \
       --network spoke2-vpc \
       --allow tcp:80,tcp:443,icmp,udp:53 \
       --source-ranges 10.0.0.0/24,10.0.1.0/24,192.168.0.0/24,192.168.1.0/24
   

2. Crea una regla de firewall para permitir que los sistemas de sondeo de verificación de estado accedan a las instancias en hub-vpc.

   gcloud compute firewall-rules create hub-vpc-health-checks \
       --network hub-vpc \
       --allow tcp:80 \
       --target-tags natgw \
       --source-ranges 130.211.0.0/22,35.191.0.0/16
   

3. Crea reglas de firewall que permitan el acceso SSH para instancias en todas las subredes. Si prefieres usar Identity-Aware Proxy para el redireccionamiento de TCP (recomendado), sigue estos pasos a fin de habilitar SSH.

   gcloud compute firewall-rules create hub-vpc-allow-ssh \
       --network hub-vpc \
       --allow tcp:22
   

   gcloud compute firewall-rules create spoke1-vpc-allow-ssh \
       --network spoke1-vpc \
       --allow tcp:22
   

   gcloud compute firewall-rules create spoke2-vpc-allow-ssh \
       --network spoke2-vpc \
       --allow tcp:22
   

Configura el intercambio de tráfico entre redes de VPC

1. Crea un intercambio de tráfico de hub-vpc a spoke1-vpc.

   gcloud compute networks peerings create hub-to-spoke1 \
       --network hub-vpc \
       --peer-network spoke1-vpc \
       --peer-project PROJECT_ID \
       --export-custom-routes
       

2. Crea un intercambio de tráfico de spoke1-vpc a hub-vpc.

   gcloud compute networks peerings create spoke1-to-hub \
       --network spoke1-vpc \
       --peer-network hub-vpc \
       --peer-project PROJECT_ID \
       --import-custom-routes
   

3. Crea un intercambio de tráfico de hub-vpc a spoke2-vpc.

   gcloud compute networks peerings create hub-to-spoke2 \
       --network hub-vpc \
       --peer-network spoke2-vpc \
       --peer-project PROJECT_ID \
       --export-custom-routes
   

4. Crea un intercambio de tráfico de spoke2-vpc a hub-vpc.

   gcloud compute networks peerings create spoke2-to-hub \
       --network spoke2-vpc \
       --peer-network hub-vpc \
       --peer-project PROJECT_ID \
       --import-custom-routes
   

Crea VM con puerta de enlace NAT y recursos de balanceo de cargas en la región A

Crea el backend del grupo de instancias administrado en REGION_A. Luego, crea los recursos del balanceo de cargas y las rutas de siguiente salto.

Crea un grupo de instancias administrado

1. Crea una plantilla de instancias para implementar una puerta de enlace NAT en region A.

   gcloud compute instance-templates create hub-natgw-region-a-template \
       --network hub-vpc \
       --subnet hub-subnet-a \
       --region REGION_A \
       --machine-type n1-standard-2 \
       --can-ip-forward \
       --tags natgw \
       --metadata startup-script='#! /bin/bash
   # Enable IP forwarding:
   echo 1 > /proc/sys/net/ipv4/ip_forward
   echo "net.ipv4.ip_forward=1" > /etc/sysctl.d/20-iptables.conf
   # iptables configuration
   iptables -t nat -F
   sudo iptables -t nat -A POSTROUTING ! -d 192.168.0.0/16 -j MASQUERADE
   iptables-save
   # Use a web server to pass the health check for this example.
   # You should use a more complete test in production.
   apt-get update
   apt-get install apache2 tcpdump -y
   a2ensite default-ssl
   a2enmod ssl
   echo "Example web page to pass health check" | \
   tee /var/www/html/index.html \
   systemctl restart apache2'
   

2. Crea el grupo de instancias en REGION_A.

   gcloud compute instance-groups managed create hub-natgw-region-a-mig \
       --region REGION_A \
       --size=2 \
       --template=hub-natgw-region-a-template
   

Crea el balanceador de cargas

Sigue estos pasos para crear un balanceador de cargas en REGION_A.

1. Cree una verificación de estado.

   gcloud compute health-checks create http natgw-ilbnhop-health-check \
       --port=80
   

2. Crea el servicio de backend.

   gcloud compute backend-services create hub-natgw-region-a-be \
       --load-balancing-scheme=internal \
       --protocol tcp \
       --region REGION_A\
       --health-checks=natgw-ilbnhop-health-check
   

3. Agrega el grupo de instancias administrado como backend.

   gcloud compute backend-services add-backend hub-natgw-region-a-be \
       --instance-group=hub-natgw-region-a-mig \
       --instance-group-region=REGION_A
   

4. Crea la regla de reenvío.

   gcloud compute forwarding-rules create hub-natgw-region-a \
       --load-balancing-scheme=internal \
       --network=hub-vpc \
       --subnet=hub-subnet-a \
       --address=10.0.0.10 \
       --ip-protocol=TCP \
       --ports=all \
       --allow-global-access \
       --backend-service=hub-natgw-region-a-be \
       --backend-service-region=REGION_A
   

Crea las rutas de siguiente salto

Crea el balanceador de cargas de red de transferencia interno como rutas de próximos saltos con la etiqueta de red predefinida ilbanh-region-a.

gcloud compute routes create spoke1-natgw-region-a \
    --network=spoke1-vpc \
    --destination-range=0.0.0.0/0 \
    --next-hop-ilb=10.0.0.10 \
    --tags=ilbanh-region-a \
    --priority 800

gcloud compute routes create spoke2-natgw-region-a \
    --network=spoke2-vpc \
    --destination-range=0.0.0.0/0 \
    --next-hop-ilb=10.0.0.10 \
    --tags=ilbanh-region-a \
    --priority 800

Pruebe la conectividad

Crea instancias de clientes para probar la conectividad.

1. Crea una instancia de cliente de prueba en spoke1-vpc.

   gcloud compute instances create spoke1-client \
       --subnet=spoke1-subnet1 --no-address --zone ZONE_A \
       --tags=ilbanh-region-a \
       --metadata startup-script='#! /bin/bash
   apt-get update
   apt-get install tcpdump -y'
   

2. Crea una instancia de cliente de prueba en spoke2-vpc.

   gcloud compute instances create spoke2-client \
       --subnet=spoke2-subnet1 --no-address --zone ZONE_A \
       --tags=ilbanh-region-a \
       --metadata startup-script='#! /bin/bash
   apt-get update
   apt-get install tcpdump -y'
   

Valida los flujos de tráfico de norte a sur y de este a oeste

1. Asegúrate de que las VM de la puerta de enlace NAT se estén ejecutando y escribe las direcciones IP externas asignadas:

   gcloud compute instances list --filter="status:RUNNING AND name~natgw"
   

2. Confirma que el balanceador de cargas esté en buen estado y que las rutas se hayan creado como se esperaba:

   gcloud compute backend-services get-health hub-natgw-region-a-be --region REGION_A
   

   backend: https://www.googleapis.com/compute/v1/projects/<PROJECT_ID>/regions/us-central1/instanceGroups/hub-natgw-region-a-mig
   status:
     healthStatus:
     - forwardingRule: https://www.googleapis.com/compute/v1/projects/<PROJECT_ID>/regions/us-central1/forwardingRules/hub-natgw-region-a
       forwardingRuleIp: 10.0.0.10
       healthState: HEALTHY
       instance: https://www.googleapis.com/compute/v1/projects/<PROJECT_ID>/zones/us-central1-b/instances/<INSTANCE_NAME>
       ipAddress: 10.0.0.5
       port: 80
     - forwardingRule: https://www.googleapis.com/compute/v1/projects/<PROJECT_ID>/regions/us-central1/forwardingRules/hub-natgw-region-a
       forwardingRuleIp: 10.0.0.10
       healthState: HEALTHY
       instance: https://www.googleapis.com/compute/v1/projects/<PROJECT_ID>/zones/us-central1-f/instances/<INSTANCE_NAME>
       ipAddress: 10.0.0.6
       port: 80
     kind: compute#backendServiceGroupHealth
   

3. Verifica que el balanceador de cargas de red de transferencia interno como rutas de próximos saltos se agregue a las VPC de radio con la prioridad esperada y que apunte a la dirección IP del balanceador de cargas de red de transferencia interno:

   gcloud compute routes list --filter="name~natgw"
   

4. Ve a la consola de Google Cloud y establece conexiones SSH con las VM de la puerta de enlace NAT en diferentes pestañas.

5. Inicia tcpdump en cada una de esas sesiones de SSH con el siguiente comando:

   sudo tcpdump -n net 192.168.0.0/16
   

6. Ve a la consola de Google Cloud y establece una conexión SSH nueva a la VM spoke1-client. Luego, usa el siguiente comando para hacer ping a la dirección IP interna spoke2-client.

   ping SPOKE2_CLIENT_INTERNAL_IP
   

7. Cambia a las ventanas de SSH de la puerta de enlace NAT y verifica que puedas ver los paquetes ICMP de la siguiente manera:

   16:51:28.411260 IP 192.168.0.2 > 192.168.1.2: ICMP echo request, id 1684, seq 492, length 64
   16:51:28.411676 IP 192.168.1.2 > 192.168.0.2: ICMP echo reply, id 1684, seq 492, length 64
   

   Deberías poder hacer ping a la VM del cliente con éxito, lo que demuestra lo siguiente:

   • El tráfico este-oeste se habilita a través de las puertas de enlace NAT. Ten en cuenta que el intercambio de tráfico transitivo no es compatible entre las VPC de radio.
   • El hash simétrico está habilitado y funciona como se espera, ya que los clientes pueden comunicarse mediante sus direcciones IP de origen sin necesidad de traducción de SNAT.
   • Todos los protocolos son compatibles con el balanceador de cargas de red de transferencia interno como próximo salto.

8. Detén los resultados de tcpdump en las VM de la puerta de enlace NAT y mira las estadísticas de iptables:

   watch sudo iptables -t nat -nvL
   

9. Vuelve a la VM spoke1-client y ejecuta el siguiente comando varias veces. En el resultado, se muestra la dirección IP de origen pública que se usa para conectarse al sitio web.

   curl ifconfig.io
   

   Deberías ver las direcciones IP de las VM de puerta de enlace NAT como direcciones IP de origen. Esto demuestra que el balanceador de cargas de red de transferencia interno distribuye el tráfico según la afinidad predeterminada (hash de 5 tuplas).

10. Regresa a la VM de la puerta de enlace NAT para confirmar que aumentaron los contadores de paquetes.

    Chain PREROUTING (policy ACCEPT 0 packets, 0 bytes)
     pkts bytes target     prot opt in     out     source               destination
    
    Chain INPUT (policy ACCEPT 0 packets, 0 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
      105 11442 MASQUERADE  all  --  *      *       0.0.0.0/0           !192.168.0.0/16
    
    Chain OUTPUT (policy ACCEPT 0 packets, 0 bytes)
     pkts bytes target     prot opt in     out     source               destination
    

Crea VM de puerta de enlace NAT y recursos de balanceo de cargas en la región B

Crea el backend del grupo de instancias administrado en region B. Luego, crea los recursos del balanceo de cargas y las rutas de siguiente salto.

Crea un grupo de instancias administrado

1. Crea una plantilla de instancias para implementar una puerta de enlace NAT en region B.

   gcloud compute instance-templates create hub-natgw-region-b-template \
       --network hub-vpc \
       --subnet hub-subnet-b --region REGION_B \
       --machine-type n1-standard-2 --can-ip-forward \
       --tags natgw \
       --metadata startup-script='#! /bin/bash
   # Enable IP forwarding:
   echo 1 > /proc/sys/net/ipv4/ip_forward
   echo "net.ipv4.ip_forward=1" > /etc/sysctl.d/20-iptables.conf
   # iptables configuration
   iptables -t nat -F
   sudo iptables -t nat -A POSTROUTING ! -d 192.168.0.0/16 -j MASQUERADE
   iptables-save
   # Use a web server to pass the health check for this example.
   # You should use a more complete test in production.
   apt-get update
   apt-get install apache2 tcpdump -y
   a2ensite default-ssl
   a2enmod ssl
   echo "Example web page to pass health check" | \
   tee /var/www/html/index.html \
   systemctl restart apache2'
   

2. Crea el grupo de instancias en region B.

   gcloud compute instance-groups managed create hub-natgw-region-b-mig \
       --region REGION_B \
       --size=2 \
       --template=hub-natgw-region-b-template
   

Crea el balanceador de cargas

Realiza los siguientes pasos para crear un balanceador de cargas en la región B.

1. Crea el servicio de backend.

   gcloud compute backend-services create hub-natgw-region-b-be \
       --load-balancing-scheme=internal \
       --protocol tcp \
       --region REGION_B\
       --health-checks=natgw-ilbnhop-health-check
   

2. Agrega el grupo de instancias administrado como backend.

   gcloud compute backend-services add-backend hub-natgw-region-b-be \
       --instance-group=hub-natgw-region-b-mig \
       --instance-group-region=REGION_B
   

3. Crea la regla de reenvío.

   gcloud compute forwarding-rules create hub-natgw-region-b \
       --load-balancing-scheme=internal \
       --network=hub-vpc \
       --subnet=hub-subnet-b \
       --address=10.0.1.10 \
       --ip-protocol=TCP \
       --ports=all \
       --allow-global-access \
       --backend-service=hub-natgw-region-b-be \
       --backend-service-region=REGION_B
   

Crea las rutas de siguiente salto

Crea el balanceador de cargas de red de transferencia interno como rutas de próximos saltos con la etiqueta de red predefinida ilbanh-region-a.

gcloud compute routes create spoke1-natgw-region-b \
    --network=spoke1-vpc \
    --destination-range=0.0.0.0/0 \
    --next-hop-ilb=10.0.1.10 \
    --tags=ilbanh-region-a \
    --priority 900

gcloud compute routes create spoke2-natgw-region-b \
    --network=spoke2-vpc \
    --destination-range=0.0.0.0/0 \
    --next-hop-ilb=10.0.1.10 \
    --tags=ilbanh-region-a \
    --priority 900

Valida la conmutación por error regional

1. Asegúrate de que las VM de la puerta de enlace NAT se estén ejecutando y escribe las IP externas asignadas:

   gcloud compute instances list --filter="status:RUNNING AND name~natgw"
   

2. Confirma que el balanceador de cargas esté en buen estado y que las rutas se creen como se espera:

   gcloud compute backend-services get-health hub-natgw-region-b-be --region REGION_B
   

   backend: https://www.googleapis.com/compute/v1/projects/<PROJECT_ID>/regions/us-west2/instanceGroups/hub-natgw-region-b-mig
   status:
     healthStatus:
     - forwardingRule: https://www.googleapis.com/compute/v1/projects/<PROJECT_ID>/regions/us-west2/forwardingRules/hub-natgw-region-b
       forwardingRuleIp: 10.0.1.10
       healthState: HEALTHY
       instance: https://www.googleapis.com/compute/v1/projects/<PROJECT_ID>/zones/us-west2-a/instances/<INSTANCE_NAME>
       ipAddress: 10.0.1.3
       port: 80
     - forwardingRule: https://www.googleapis.com/compute/v1/projects/<PROJECT_ID>/regions/us-west2/forwardingRules/hub-natgw-region-b
       forwardingRuleIp: 10.0.1.10
       healthState: HEALTHY
       instance: https://www.googleapis.com/compute/v1/projects/<PROJECT_ID>/zones/us-west2-b/instances/<INSTANCE_NAME>
       ipAddress: 10.0.1.2
       port: 80
     kind: compute#backendServiceGroupHealth
   

3. Verifica que el balanceador de cargas de red de transferencia interno como rutas de próximos saltos se agregue a las VPC de radio con la prioridad esperada y que apunte a la dirección IP del balanceador de cargas de red de transferencia interno:

   gcloud compute routes list --filter="name~natgw"
   

4. Ahora puedes validar la conmutación por error regional si borras las rutas de prioridad alta y toma nota de lo que sucede. Cambia a la VM spoke1-client y ejecuta el siguiente comando para enviar una solicitud curl cada segundo. Este comando también informa la dirección IP externa que se usa:

   while true; do echo -n `date` && echo -n ' - ' && curl ifconfig.io --connect-timeout 1; done
   

   Solo se deben mostrar las direcciones IP externas asignadas a las puertas de enlace NAT en region A, ya que es la ruta de prioridad alta. Deja el comando curl ejecutándose y cambia a Cloud Shell para borrar la ruta al balanceador de cargas de red de transferencia interno en region A a fin de verificar el resultado:

   gcloud -q compute routes delete spoke1-natgw-region-a
   

   En region B, aparecen las direcciones IP externas asignadas a las VM de la puerta de enlace NAT, con un tiempo de inactividad mínimo, lo que demuestra que la conmutación por error regional se realizó de forma correcta.

Nota: Una ruta no se quita de forma automática, incluso si todos los backends están en mal estado. Considera usar Cloud Functions para automatizar este proceso.

Limpia los recursos

1. Quita el balanceador de cargas de red de transferencia interno como rutas de próximos saltos:

   gcloud -q compute routes delete spoke1-natgw-region-b
   
   gcloud -q compute routes delete spoke2-natgw-region-a
   
   gcloud -q compute routes delete spoke2-natgw-region-b
   

2. Quita los recursos y los backends del balanceador de cargas de red de transferencia interno:

   gcloud -q compute forwarding-rules delete hub-natgw-region-a \
     --region REGION_A
   
   gcloud -q compute backend-services delete hub-natgw-region-a-be \
     --region REGION_A
   
   gcloud -q compute instance-groups managed delete hub-natgw-region-a-mig \
     --region REGION_A
   
   gcloud -q compute instance-templates delete hub-natgw-region-a-template
   
   gcloud -q compute forwarding-rules delete hub-natgw-region-b \
     --region REGION_B
   
   gcloud -q compute backend-services delete hub-natgw-region-b-be \
     --region REGION_B
   
   gcloud -q compute instance-groups managed delete hub-natgw-region-b-mig \
     --region REGION_B
   
   gcloud -q compute instance-templates delete hub-natgw-region-b-template
   
   gcloud -q compute health-checks delete natgw-ilbnhop-health-check
   

3. Borra las VM de cliente:

   gcloud -q compute instances delete spoke1-client \
     --zone=ZONE_A
   
   gcloud -q compute instances delete spoke2-client \
     --zone=ZONE_A
   

4. Borra los intercambios de tráfico de red de VPC, las reglas de firewall, las subredes y las VPC:

   gcloud -q compute networks peerings delete spoke2-to-hub \
     --network spoke2-vpc
   
   gcloud -q compute networks peerings delete spoke1-to-hub \
     --network spoke1-vpc
   
   gcloud -q compute networks peerings delete hub-to-spoke1 \
     --network hub-vpc
   
   gcloud -q compute networks peerings delete hub-to-spoke2 \
     --network hub-vpc
   
   gcloud -q compute firewall-rules delete spoke2-vpc-web-ping-dns
   
   gcloud -q compute firewall-rules delete spoke1-vpc-web-ping-dns
   
   gcloud -q compute firewall-rules delete hub-vpc-web-ping-dns
   
   gcloud -q compute firewall-rules delete hub-vpc-health-checks
   
   gcloud -q compute firewall-rules delete hub-vpc-allow-ssh
   
   gcloud -q compute firewall-rules delete spoke1-vpc-allow-ssh
   
   gcloud -q compute firewall-rules delete spoke2-vpc-allow-ssh
   
   gcloud -q compute networks subnets delete spoke1-subnet1 \
     --region REGION_A
   
   gcloud -q compute networks subnets delete spoke2-subnet1 \
     --region REGION_A
   
   gcloud -q compute networks subnets delete hub-subnet-a \
     --region REGION_A
   
   gcloud -q compute networks subnets delete hub-subnet-b \
     --region REGION_B
   
   gcloud -q compute networks delete spoke1-vpc
   
   gcloud -q compute networks delete spoke2-vpc
   
   gcloud -q compute networks delete hub-vpc
   

¿Qué sigue?

• Consulta los conceptos de la conmutación por error para balanceadores de cargas de red internos para obtener información importante sobre la conmutación por error.
• Consulta Registro y supervisión del balanceador de cargas de red de transferencia interno para información sobre cómo configurar Logging y Monitoring para el balanceador de cargas de red de transferencia interno.
• Consulta Balanceadores de cargas de red de transferencia internos y redes conectadas para obtener información sobre cómo acceder a los balanceadores de cargas de red de transferencia internos desde redes de intercambio de tráfico conectadas a tu red de VPC.
• Consulta Soluciona problemas del balanceador de cargas de red de transferencia interno para obtener información sobre cómo solucionar problemas del balanceador de cargas de red de transferencia interno.