Codelab de balanceadores de cargas de HTTP(S) externos con administración avanzada de tráfico (Envoy)

1. Introducción

Te damos la bienvenida al codelab de balanceadores de cargas de HTTP(S) externos con administración avanzada de tráfico (Envoy).

La versión más reciente del balanceador de cargas HTTP(S) externo con administración avanzada de tráfico contiene todas las funciones de nuestro balanceador de cargas HTTP(S) externo clásico, pero con una lista creciente de capacidades de administración avanzada de tráfico. Algunas de estas funciones son nuevas para nuestros balanceadores de cargas y otras proporcionan funciones mejoradas a las capacidades existentes. Una lista parcial de estas capacidades incluye:

• División del tráfico ponderada
• Solicitar duplicación
• Detección de valores atípicos
• Solicitar reintentos
• Inyección de errores
• Opciones adicionales de afinidad de la sesión de backend
• Opciones adicionales de transformación del encabezado
• Uso compartido de recursos entre dominios (CORS)
• Nuevos algoritmos de balanceo de cargas

Qué aprenderás

• Cómo configurar un grupo de instancias administrado y las reglas de firewall y VPC asociadas
• Cómo usar las funciones avanzadas de administración de tráfico del nuevo balanceador de cargas
• Cómo validar que las funciones de administración avanzada de tráfico se ejecutan según lo previsto.

Requisitos

• Herramientas de redes básicas y conocimiento de HTTP
• Conocimiento básico de la línea de comandos de Unix/Linux

Topología del codelab y caso de uso

Figura 1: Topología de enrutamiento del balanceador de cargas HTTP

Durante este codelab, configurarás tres grupos de instancias administrados: uno en el este, el oeste y el central. Crearás un balanceador de cargas HTTPS externo global. El balanceador de cargas usará varias funciones de la lista de capacidades avanzadas que admite el balanceador de cargas basado en Envoy. Luego de la implementación, generarás una carga simulada y verificarás que la configuración que estableciste funcione correctamente.

2. Configuración y requisitos

Configuración del entorno de autoaprendizaje

1. Accede a Google Cloud Console 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.

• El Nombre del proyecto es el nombre visible de los participantes de este proyecto. Es una string de caracteres que no se utiliza en las API de Google y se puede actualizar en cualquier momento.
• El ID del proyecto debe ser único en todos los proyectos de Google Cloud y es inmutable (no se puede cambiar después de configurarlo). Cloud Console genera automáticamente una string única, que, por lo general, no importa cuál sea. En la mayoría de los codelabs, debes hacer referencia al ID del proyecto (suele ser PROJECT_ID). Por lo tanto, si no te gusta, genera otro aleatorio o prueba con uno propio y comprueba si está disponible. Después de crear el proyecto, este ID se “congela” y no se puede cambiar.
• Además, hay un tercer valor, el Número de proyecto, que usan algunas API. Obtén más información sobre estos tres valores en la documentación.

Precaución: El ID de un proyecto debe ser único a nivel global y ninguna otra persona puede usarlo después de seleccionarlo. 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 Cloud Console para usar las API o los recursos de Cloud. Ejecutar este codelab no debería costar mucho, tal vez nada. Si quieres cerrar los recursos para no se te facture más allá de este instructivo, sigue las instrucciones de “limpieza” que se encuentran al final del codelab. 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.

Antes de comenzar

En Cloud Shell, asegúrate de que el ID del proyecto esté configurado

gcloud config list project

gcloud config set project [YOUR-PROJECT-NAME]

PROJECT_ID=[YOUR-PROJECT-NAME]

echo $PROJECT_ID

Habilita las APIs

Habilita todos los servicios necesarios

gcloud services enable compute.googleapis.com
gcloud services enable logging.googleapis.com
gcloud services enable monitoring.googleapis.com

3. Crea la red de VPC

Crear red de VPC

Desde Cloud Shell

gcloud compute networks create httplbs --subnet-mode=auto

Salida

Created [https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/httplbs].
NAME: httplbs
SUBNET_MODE: AUTO
BGP_ROUTING_MODE: REGIONAL
IPV4_RANGE:
GATEWAY_IPV4:

Crea reglas de firewall de VPC

Después de crear la VPC, crearás una regla de firewall. Se usará la regla de firewall para permitir que todas las IP accedan a la IP externa del sitio web de la aplicación de prueba en el puerto 80 para el tráfico HTTP.

Desde Cloud Shell

gcloud compute firewall-rules create httplb-allow-http-rule \
--allow tcp:80 \
--network httplbs \
--source-ranges 0.0.0.0/0 \
--priority 700

Salida

Creating firewall...working..Created [https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls/httplb-allow-http-rule].
Creating firewall...done.
NAME: httplb-allow-http-rule
NETWORK: httplbs
DIRECTION: INGRESS
PRIORITY: 700
ALLOW: tcp:80
DENY:
DISABLED: False

4. Configura los grupos de instancias administrados

Debes configurar grupos de instancias administrados que incluyan los patrones de los recursos de backend que usa el balanceador de cargas HTTP. Primero, crearemos plantillas de instancias que definan la configuración de las VMs que se crearán para cada región. A continuación, para un backend en cada región, crearemos un grupo de instancias administrado que haga referencia a una plantilla de instancias.

Los grupos de instancias administrados pueden tener un permiso zonal o regional. Para este ejercicio de lab, crearemos tres grupos de instancias administrados regionales: uno en us-east1, uno en us-west1 y otro en us-central1.

En esta sección, puedes ver una secuencia de comandos de inicio creada previamente a la que se hará referencia cuando se cree la instancia. Esta secuencia de comandos de inicio instala y habilita las capacidades del servidor web que usaremos para simular una aplicación web. Siéntete libre de explorar esta secuencia de comandos.

Crea plantillas de instancias este, oeste y central

El primer paso es crear la plantilla de instancias us-east-1.

Desde Cloud Shell

gcloud compute instance-templates create us-east1-template \
   --region=us-east1 \
   --network=httplbs \
   --tags=http-server, \
   --image-family=debian-9 \
   --image-project=debian-cloud \
   --metadata=startup-script='#! /bin/bash
     apt-get update
     apt-get install apache2 -y
     a2ensite default-ssl
     a2enmod ssl
     vm_hostname="$(curl -H "Metadata-Flavor:Google" \
     http://169.254.169.254/computeMetadata/v1/instance/name)"
     echo "Page served from: $vm_hostname" | \
     tee /var/www/html/index.html
     systemctl restart apache2'

Salida

Created [https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/instanceTemplates/us-east1-template].
NAME: us-east1-template
MACHINE_TYPE: n1-standard-1
PREEMPTIBLE:
CREATION_TIMESTAMP: 2021-11-11T11:02:37.511-08:00

El siguiente paso es crear la plantilla de instancias us-west-1.

Desde Cloud Shell

gcloud compute instance-templates create us-west1-template \
   --region=us-west1 \
   --network=httplbs \
   --tags=http-server, \
   --image-family=debian-9 \
   --image-project=debian-cloud \
   --metadata=startup-script='#! /bin/bash
     apt-get update
     apt-get install apache2 -y
     a2ensite default-ssl
     a2enmod ssl
     vm_hostname="$(curl -H "Metadata-Flavor:Google" \
     http://169.254.169.254/computeMetadata/v1/instance/name)"
     echo "Page served from: $vm_hostname" | \
     tee /var/www/html/index.html
     systemctl restart apache2'

Salida

Created [https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/instanceTemplates/us-west1-template].
NAME: us-west1-template
MACHINE_TYPE: n1-standard-1
PREEMPTIBLE:
CREATION_TIMESTAMP: 2021-11-11T11:03:08.577-08:00

El siguiente paso es crear la plantilla de instancias us-central-1.

Desde Cloud Shell

gcloud compute instance-templates create us-central1-template \
   --region=us-central1 \
   --network=httplbs \
   --tags=http-server, \
   --image-family=debian-9 \
   --image-project=debian-cloud \
   --metadata=startup-script='#! /bin/bash
     apt-get update
     apt-get install apache2 -y
     a2ensite default-ssl
     a2enmod ssl
     vm_hostname="$(curl -H "Metadata-Flavor:Google" \
     http://169.254.169.254/computeMetadata/v1/instance/name)"
     echo "Page served from: $vm_hostname" | \
     tee /var/www/html/index.html
     systemctl restart apache2'

Salida

Created [https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/instanceTemplates/us-central1-template].
NAME: us-central1-template
MACHINE_TYPE: n1-standard-1
PREEMPTIBLE:
CREATION_TIMESTAMP: 2021-11-11T11:03:44.179-08:00

Ahora puedes verificar que nuestras plantillas de instancias se hayan creado correctamente con el siguiente comando de gcloud:

Desde Cloud Shell

gcloud compute instance-templates list

Salida

NAME                  MACHINE_TYPE   PREEMPTIBLE  CREATION_TIMESTAMP
us-central1-template   n1-standard-1         2021-11-09T09:25:37.263-08:00
us-east1-template      n1-standard-1         2021-11-09T09:24:35.275-08:00
us-west1-template      n1-standard-1         2021-11-09T09:25:08.016-08:00

Crea grupos de instancias administrados este, oeste y central

Ahora debemos crear un grupo de instancias administrado a partir de las plantillas de instancias que creamos antes.

Desde Cloud Shell

gcloud compute instance-groups managed create us-east1-mig \
--base-instance-name=us-east1-mig \
--size=1 \
--template=us-east1-template \
--zone=us-east1-b 

Salida

Created [https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-east1-b/instanceGroupManagers/us-east1-mig].
NAME: us-east1-mig
LOCATION: us-east1-b
SCOPE: zone
BASE_INSTANCE_NAME: us-east1-mig
SIZE: 0
TARGET_SIZE: 1
INSTANCE_TEMPLATE: us-east1-template
AUTOSCALED: no

Desde Cloud Shell

gcloud compute instance-groups managed create us-west1-mig \
--base-instance-name=us-west1-mig \
--size=1 \
--template=us-west1-template \
--zone=us-west1-a  

Salida

Created [https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroupManagers/us-west1-mig].
NAME: us-west1-mig
LOCATION: us-west1-a
SCOPE: zone
BASE_INSTANCE_NAME: us-west1-mig
SIZE: 0
TARGET_SIZE: 1
INSTANCE_TEMPLATE: us-west1-template
AUTOSCALED: no

Desde Cloud Shell

gcloud compute instance-groups managed create us-central1-mig \
--base-instance-name=us-central1-mig \
--size=1 \
--template=us-central1-template \
--zone=us-central1-a 

Salida

Created [https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-central1-a/instanceGroupManagers/us-central1-mig].
NAME: us-central1-mig
LOCATION: us-central1-a
SCOPE: zone
BASE_INSTANCE_NAME: us-central1-mig
SIZE: 0
TARGET_SIZE: 1
INSTANCE_TEMPLATE: us-central1-template
AUTOSCALED: no

Podemos verificar que nuestros grupos de instancias se crearon con éxito con el siguiente comando de gcloud:

Desde Cloud Shell

gcloud compute instance-groups list

Salida

NAME                  LOCATION      SCOPE   NETWORK         MANAGED INSTANCES
us-central1-mig       us-central1   zone    httplbs          Yes      1
us-west1-mig          us-west1      zone    httplbs          Yes      1
us-east1-mig          us-east1      zone    httplbs          Yes      1

Verifica la funcionalidad del servidor web

Cada instancia está configurada para ejecutar un servidor web de Apache con una secuencia de comandos PHP sencilla que procesa lo siguiente:

Para asegurarte de que tus servidores web funcionan correctamente, navega a Compute Engine -> instancias de VM. Asegúrate de que tus instancias nuevas (p.ej., us-east1-mig-xxx) se hayan creado según sus definiciones de grupo de instancias.

A continuación, realiza una solicitud web en tu navegador para asegurarte de que el servidor web se esté ejecutando (esto puede tardar un minuto en iniciarse). En la página Instancias de VM en Compute Engine, selecciona una instancia creada por tu grupo de instancias y haz clic en su IP externa (pública).

O bien, en tu navegador, navega a http://<IP_Address>

5. Configura el balanceador de cargas

Crea una verificación de estado

Primero, debemos crear una verificación de estado básica para asegurarnos de que nuestros servicios funcionen correctamente. Crearemos una verificación de estado básica; hay muchas más personalizaciones avanzadas disponibles.

Desde Cloud Shell

gcloud compute health-checks create http http-basic-check \
    --port 80

Reserva dirección IP externa

Para este paso, deberás reservar una dirección IP estática disponible a nivel global que luego se conectará al balanceador de cargas.

Desde Cloud Shell

gcloud compute addresses create lb-ipv4-2 \
    --ip-version=IPV4 \
    --global

Asegúrate de anotar la dirección IP que se reservó.

gcloud compute addresses describe lb-ipv4-2 \
    --format="get(address)" \
    --global

Crea servicios de backend

Ahora debemos crear un servicio de backend para cada uno de los grupos de instancias administrados que creamos antes. Una para este, oeste y centro.

Crea un servicio de backend para el grupo de instancias administrado de East.

Desde Cloud Shell

gcloud beta compute backend-services create east-backend-service \
    --load-balancing-scheme=EXTERNAL_MANAGED \
    --protocol=HTTP \
    --port-name=http \
    --health-checks=http-basic-check \
    --global

Crea un servicio de backend para el grupo de instancias administrado por el oeste.

Desde Cloud Shell

gcloud beta compute backend-services create west-backend-service \
    --load-balancing-scheme=EXTERNAL_MANAGED \
    --protocol=HTTP \
    --port-name=http \
    --health-checks=http-basic-check \
    --global

Crear un servicio de backend para el grupo de instancias administrado central.

Desde Cloud Shell

gcloud beta compute backend-services create central-backend-service \
    --load-balancing-scheme=EXTERNAL_MANAGED \
    --protocol=HTTP \
    --port-name=http \
    --health-checks=http-basic-check \
    --global

Agrega MIG a servicios de backend

Ahora que creamos los servicios de backend respectivos para cada clúster de aplicación, debemos agregar los grupos de instancias administrados que creamos antes a cada servicio de backend.

Agrega el MIG oriental al servicio de backend.

Desde Cloud Shell

gcloud beta compute backend-services add-backend east-backend-service \
    --balancing-mode='UTILIZATION' \
    --instance-group=us-east1-mig \
    --instance-group-zone=us-east1-b \
    --global

Agrega el MIG oeste al servicio de backend.

Desde Cloud Shell

gcloud beta compute backend-services add-backend west-backend-service \
    --balancing-mode='UTILIZATION' \
    --instance-group=us-west1-mig \
    --instance-group-zone=us-west1-a \
    --global

Agrega el MIG oeste al servicio de backend.

Desde Cloud Shell

gcloud beta compute backend-services add-backend central-backend-service \
    --balancing-mode='UTILIZATION' \
    --instance-group=us-central1-mig \
    --instance-group-zone=us-central1-a \
    --global

Crear mapa de URL

El mapa de URL es donde se ubicarán las funciones de administración avanzada de tráfico de este lab. Debemos crear un archivo .yaml que contendrá la configuración. En el archivo .yaml, creamos una coincidencia de prefijo en /roundrobbin, por lo que solo el tráfico que coincida con /roundrobbin se verá afectado por estos parámetros de configuración. Especificamos que el 50% del tráfico debe ir a east-backend-service y el 50% del tráfico debe ir a west-backend-service. Además, agregamos un valor de encabezado de respuesta:{test}, que estará presente en todas las respuestas. Por último, agregamos que todo el tráfico debe duplicarse en central-backend-service. El tráfico se duplica y se envía aquí solo para realizar pruebas.

Guarda el ejemplo como un archivo .yaml en tu máquina.

defaultService: https://www.googleapis.com/compute/v1/projects/[project_id]/global/backendServices/east-backend-service
kind: compute #urlMap
name: web-map-http
hostRules:
- hosts:
  - '*'
  pathMatcher: matcher1
pathMatchers:
- defaultService: https://www.googleapis.com/compute/v1/projects/[project_id]/global/backendServices/east-backend-service
  name: matcher1
  routeRules:
  - matchRules:
    - prefixMatch: /roundrobbin
    priority: 2
    headerAction:
        responseHeadersToAdd:
          - headerName: test
            headerValue: value
            replace: True
    routeAction:
        weightedBackendServices:
        - backendService: https://www.googleapis.com/compute/v1/projects/[project_id]/global/backendServices/east-backend-service
          weight: 50
        - backendService: https://www.googleapis.com/compute/v1/projects/[project_id]/global/backendServices/west-backend-service
          weight: 50
        retryPolicy:
            retryConditions: ['502', '504']
            numRetries: 3
            perTryTimeout:
                seconds: 1
                nanos: 50
        requestMirrorPolicy:
          backendService: https://www.googleapis.com/compute/v1/projects/[project_id]/global/backendServices/central-backend-service

Crea el mapa de URL importando el documento desde tu máquina. Ten en cuenta que la ruta de acceso de origen será diferente según dónde hayas guardado el archivo .yaml.

Desde Cloud Shell

gcloud beta compute url-maps import web-map-http \
   --source /Users/[USERNAME]/Documents/Codelab/lbconfig.yaml \
   --global

Crea el frontend HTTP

El último paso para crear el balanceador de cargas es crear el frontend. Esto asignará la dirección IP que reservaste antes al mapa de URL del balanceador de cargas que creaste.

Desde Cloud Shell

gcloud beta compute target-http-proxies create http-lb-proxy-adv \
    --url-map=web-map-http

A continuación, debes crear una regla de reenvío global que asignará la dirección IP reservada antes al proxy HTTP.

Desde Cloud Shell

gcloud beta compute forwarding-rules create http-content-rule \
    --load-balancing-scheme EXTERNAL_MANAGED \
    --address=lb-ipv4-2 \
    --global \
    --target-http-proxy=http-lb-proxy-adv \
    --ports=80

6. Verifica que las funciones avanzadas de tráfico funcionen correctamente

Para verificar que la función de división del tráfico implementada se ejecute correctamente, debes generar algo de carga. Crearemos una VM nueva para simular la carga.

Crea una regla de firewall de permiso SSH

Para establecer una conexión SSH a la VM desde la que generaremos tráfico, primero debes crear una regla de firewall que permita el tráfico SSH a la VM.

Desde Cloud Shell

gcloud compute firewall-rules create fw-allow-ssh \
    --network=httplbs \
    --action=allow \
    --direction=ingress \
    --target-tags=allow-ssh \
    --rules=tcp:22

Salida

NAME          NETWORK  DIRECTION  PRIORITY  ALLOW   DENY  DISABLED
fw-allow-ssh  httplbs  INGRESS    1000      tcp:22        False

Crea Siege-vm

Ahora, crearás el archivo siege-vm que usarás para generar la carga

Desde Cloud Shell

gcloud compute instances create siege-vm \
    --network=httplbs \
    --zone=us-east4-c \
    --machine-type=e2-medium \
    --tags=allow-ssh,http-server \
    --metadata=startup-script='sudo apt-get -y install siege'

Salida

NAME     ZONE        MACHINE_TYPE INTERNAL_IP  EXTERNAL_IP    STATUS
siege-vm us-east4-c  e2-medium    10.150.0.3   34.85.218.119  RUNNING

A continuación, puedes establecer una conexión SSH a la VM que creaste. Una vez creada, haz clic en SSH para iniciar una terminal y conectarte.

Una vez conectado, ejecuta el siguiente comando para generar carga. Usa la dirección IP que reservaste antes para el balanceador de cargas de HTTP externo.

Desde Cloud Shell

siege -c 250 http://$lb-ipv4-2/roundrobbin

Salida

New configuration template added to /home/cloudcurriculumdeveloper/.siege
Run siege -C to view the current settings in that file
[alert] Zip encoding disabled; siege requires zlib support to enable it: No such file or directory
** SIEGE 4.0.2
** Preparing 250 concurrent users for battle.
The server is now under siege...

Verifica la distribución de la carga

Ahora que Siege se está ejecutando, es momento de verificar que el tráfico se distribuya de forma equitativa a los grupos de instancias administrados de este y oeste. Además, puedes verificar que la duplicación de tráfico funcione y que el tráfico se envíe al grupo de instancias administrado central.

En la consola de Cloud, en Menú de navegación, haz clic en Servicios de red > Balanceo de cargas Haz clic en Backends. Haz clic en el menú avanzado, como se muestra en la captura de pantalla a continuación.

Navega a la pestaña Servicios de backend y selecciona east-backend-service

Podrás ver la división del tráfico en tiempo real para este MIG. Toma nota de la tarifa, podrás compararla con west-backend-service en un momento.

Del mismo modo, navega a west-backend-service. También deberías ver que fluye el tráfico a este servicio. La tasa debería ser similar a la que viste en east-backend-service, ya que configuraste una división del tráfico mediante round robbin 50/50.

Para comprobar que la política de duplicación de tráfico que creaste está funcionando, debes verificar el uso del grupo de instancias administrado del servicio central-backend-service. Para ello, navega a Compute Engine, Compute Engine y grupos de instancias, y selecciona us-central1-mig. A continuación, navega a la pestaña Supervisión.

Verás los gráficos propagados que demuestran que el tráfico se duplicó en este grupo de instancias administrado.

Detén el asedio

Ahora que demostraste que la división avanzada del tráfico funciona, es momento de detener el asedio. Para ello, regresa a la terminal SSH de siege-vm y presiona CTRL+C para detener la ejecución de siege.

Valida el encabezado de respuesta que se envía

Antes de realizar una limpieza, puedes validar rápidamente que el balanceador de cargas HTTP envíe el encabezado de respuesta adecuado. Lo configuraste para enviar la prueba de encabezado con el valor de contenido. Ejecutar el comando curl desde Cloud Shell dará la respuesta esperada.

Desde Cloud Shell

curl -svo /dev/null http://lb-ipv4-2/roundrobbin

Salida

*   Trying lb-ipv4-2..
* TCP_NODELAY set
* Connected to  lb-ipv4-2 ( lb-ipv4-2) port 80 (#0)
> GET /roundrobbin HTTP/1.1
> Host:  lb-ipv4-2
> User-Agent: curl/7.64.1
> Accept: */*
>
< HTTP/1.1 404 Not Found
< date: Wed, 10 Nov 2021 17:05:27 GMT
< server: envoy
< Content-Length: 273
< content-type: text/html; charset=iso-8859-1
< via: 1.1 google
< test: value
<
{ [273 bytes data]
* Connection #0 to host 34.149.2.26 left intact
* Closing connection 0

7. Limpieza del lab

Ahora que terminamos el entorno del lab, es momento de eliminarlo. Ejecuta los siguientes comandos para borrar el entorno de prueba.

Desde Cloud Shell

gcloud compute instances delete siege-vm

gcloud alpha compute forwarding-rules delete http-content-rule --global
gcloud alpha compute target-http-proxies delete http-lb-proxy-adv
gcloud alpha compute url-maps delete web-map-http
gcloud alpha compute backend-services delete east-backend-service --global
gcloud alpha compute backend-services delete west-backend-service --global
gcloud alpha compute backend-services delete central-backend-service --global

gcloud compute addresses delete lb-ipv4-2 --global
gcloud compute health-checks delete http-basic-check 

gcloud compute instance-groups managed delete us-east1-mig --zone us-east1-b
gcloud compute instance-groups managed delete us-west1-mig --zone us-west1-a
gcloud compute instance-groups managed delete us-central1-mig --zone us-central1-a

gcloud compute instance-templates delete "us-east1-template" 
gcloud compute instance-templates delete "us-west1-template" 
gcloud compute instance-templates delete "us-central1-template" 

gcloud compute firewall-rules delete httplb-allow-http-rule
gcloud compute firewall-rules delete fw-allow-ssh

gcloud compute networks delete httplbs 

8. ¡Felicitaciones!

Completaste el codelab de LB de HTTP externo con el codelab de administración avanzada de tráfico (Envoy).

Temas abordados

• Cómo configurar un grupo de instancias administrado y las reglas de firewall y VPC asociadas
• Cómo usar las funciones avanzadas de administración de tráfico del nuevo balanceador de cargas
• Cómo validar que las funciones de administración avanzada de tráfico se ejecutan según lo previsto.

Próximos pasos

• Prueba algunas de las otras funciones avanzadas de enrutamiento, como la reescritura de URL, la adición de encabezados de CORS y muchas más ( vínculo).