Codelab sobre el balanceador de cargas externo de HTTPS con administración avanzada del tráfico (Envoy)
Acerca de este codelab
1. Introducción
Te damos la bienvenida al codelab del balanceador de cargas HTTPS externo 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 del tráfico contiene todas las funciones de nuestro balanceador de cargas HTTP(S) externo global clásico existente, pero con una lista cada vez mayor de capacidades de administración avanzada del tráfico. Algunas de estas capacidades son nuevas en nuestros balanceadores de cargas, y otras proporcionan funciones mejoradas a las capacidades existentes. A continuación, se incluye una lista parcial de estas capacidades:
- División del tráfico ponderado
- Duplicación de solicitudes
- Detección de valores atípicos
- Solicitudes de reintento
- Inyección de fallas
- Opciones adicionales de afinidad de sesión de backend
- Opciones adicionales de transformación de encabezados
- 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 la VPC asociadas
- Cómo usar las funciones avanzadas de administración del tráfico del nuevo balanceador de cargas
- Cómo validar que las funciones avanzadas de administración del tráfico funcionen según lo previsto
Requisitos
- Conocimientos básicos de redes y HTTP
- Conocimiento básico de la línea de comandos de Unix/Linux
Topología y caso de uso del codelab
Figura 1: Topología de enrutamiento del balanceador de cargas HTTP
Durante este lab de programación, configurarás tres grupos de instancias administrados, uno en el este, uno en el oeste y uno en el centro. Crearás un balanceador de cargas de HTTPS externo global. El balanceador de cargas utilizará varias funciones de la lista de capacidades avanzadas que admite el balanceador de cargas basado en Envoy. Una vez que se implemente, generarás una carga simulada y verificarás que los parámetros de configuración que estableciste funcionen correctamente.
2. Configuración y requisitos
Configuración del entorno de autoaprendizaje
- 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 cadena de caracteres que no se utiliza en las APIs de Google. Puedes actualizarla cuando quieras.
- El ID del proyecto es único en todos los proyectos de Google Cloud y es inmutable (no se puede cambiar después de configurarlo). 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 de tu proyecto (suele identificarse como
PROJECT_ID). Si no te gusta el ID que se generó, podrías generar otro aleatorio. También puedes probar uno propio y ver si está disponible. No se puede cambiar después de este paso y se usa el mismo durante todo el proyecto. - Recuerda que hay un tercer valor, un número de proyecto, que usan algunas APIs. Obtén más información sobre estos tres valores en la documentación.
- A continuación, deberás habilitar la facturación en la consola de Cloud para usar las APIs o los recursos de Cloud. Ejecutar este codelab no costará mucho, tal vez nada. Para cerrar recursos y evitar que se generen cobros más allá de este instructivo, puedes borrar los recursos que creaste o borrar el proyecto. 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 Google Cloud Console, haz clic en el ícono de Cloud Shell en la barra de herramientas en la parte 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. Todo tu trabajo en este codelab se puede hacer en un navegador. No es necesario que instales nada.
Antes de comenzar
En Cloud Shell, asegúrate de que tu 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 reglas de firewall. La regla de firewall se usará para permitir que todas las IPs 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 para 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 ser zonales o regionales. Para este ejercicio de lab, crearemos tres grupos de instancias administrados regionales: uno en us-east1, uno en us-west1 y uno 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. Puedes explorar esta secuencia de comandos.
Crea las 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-12 \
--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-12 \
--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-central1.
Desde Cloud Shell
gcloud compute instance-templates create us-central1-template \
--region=us-central1 \
--network=httplbs \
--tags=http-server, \
--image-family=debian-12 \
--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 los grupos de instancias administrados East, West 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 correctamente 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 Apache con una secuencia de comandos PHP simple que renderiza lo siguiente:
Para asegurarte de que tus servidores web funcionen 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 las definiciones de su grupo de instancias.
Ahora, haz una solicitud web en tu navegador para asegurarte de que el servidor web se esté ejecutando (puede tardar un minuto en iniciarse). En la página Instancias de VM de 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, ve a http://<IP_Address>.
5. Configura el balanceador de cargas
Crear verificación de estado
Primero, debemos crear una verificación de estado básica para asegurarnos de que nuestros servicios estén en funcionamiento correctamente. Crearemos una verificación de estado básica, pero hay muchas más personalizaciones avanzadas disponibles.
Desde Cloud Shell
gcloud compute health-checks create http http-basic-check \
--port 80
Reserva una dirección IP externa
Para este paso, deberás reservar una dirección IP estática disponible a nivel global que se adjuntará al balanceador de cargas más adelante.
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 el este, el oeste y el centro.
Crea un servicio de backend para el grupo de instancias administrado de East.
Desde Cloud Shell
gcloud compute backend-services create east-backend-service \
--load-balancing-scheme=EXTERNAL_MANAGED \
--protocol=HTTP \
--port-name=http \
--health-checks=http-basic-check \
--global
Se crea un servicio de backend para el grupo de instancias administrado de Oeste.
Desde Cloud Shell
gcloud compute backend-services create west-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 central.
Desde Cloud Shell
gcloud compute backend-services create central-backend-service \
--load-balancing-scheme=EXTERNAL_MANAGED \
--protocol=HTTP \
--port-name=http \
--health-checks=http-basic-check \
--global
Agrega MIGs a los servicios de backend
Ahora que creamos los servicios de backend respectivos para cada clúster de aplicaciones, debemos agregar los grupos de instancias administrados que creamos anteriormente a cada servicio de backend.
Agrega el MIG de East al servicio de backend.
Desde Cloud Shell
gcloud 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 de West al servicio de backend.
Desde Cloud Shell
gcloud 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 central al servicio de backend.
Desde Cloud Shell
gcloud 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 encontrarán las funciones avanzadas de administración del tráfico para este lab. Debemos crear un archivo .yaml que contenga 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 estas configuraciones. Especificamos que el 50% del tráfico debe dirigirse a east-backend-service y el 50% 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 el servicio central-backend-service. El tráfico se duplica y se envía aquí solo con fines de prueba.
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 la fuente será diferente según dónde guardes el archivo .yaml.
Desde Cloud Shell
gcloud compute url-maps import web-map-http \ --source /Users/[USERNAME]/Documents/Codelab/lbconfig.yaml \ --global
Crea un frontend de HTTP
El último paso para crear el balanceador de cargas es crear el frontend. Esto asignará la dirección IP que reservaste anteriormente al mapa de URL del balanceador de cargas que creaste.
Desde Cloud Shell
gcloud 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 asigne la dirección IP reservada anteriormente al proxy HTTP.
Desde Cloud Shell
gcloud 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 de Tráfico avanzado funcionen
Para verificar que la función de división del tráfico implementada funcione, debes generar algo de carga. Para ello, crearemos una VM nueva para simular la carga.
Crea una regla de firewall para permitir 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 la VM de Siege que usarás para generar 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 que se cree, haz clic en SSH para iniciar una terminal y conectarte.
Una vez que te conectes, ejecuta el siguiente comando para generar carga. Usa la dirección IP que reservaste antes para el balanceador de cargas 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...
Verificar la distribución de la carga
Ahora que Siege se está ejecutando, es momento de verificar que el tráfico se distribuya de manera equitativa entre los grupos de instancias administrados del este y el oeste. Además, puedes verificar que la duplicación del tráfico funcione y que el tráfico se envíe al grupo de instancias administrado central.
En el menú de navegación de la consola de Cloud, haz clic en Servicios de red > Balanceo de cargas. Selecciona el balanceador de cargas web-map-http. Navega a la pestaña Supervisión y podrás ver el siguiente gráfico.
Podrás ver la división del tráfico en tiempo real hacia este MIG. El tráfico se divide de manera uniforme, ya que configuraste una división round robin 50/50.
Para verificar que la política de duplicación de tráfico que creaste funcione, debes verificar la utilización del grupo de instancias administrado central-backend-service. Para ello, navega a Compute, Compute Engine, grupos de instancias y selecciona us-central1-mig. A continuación, navega a la pestaña Supervisión.
Verás que los gráficos se completan, lo que demuestra 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 ataque. Para ello, regresa a la terminal SSH de siege-vm y presiona CTRL + C para detener la ejecución de siege.
Cómo validar el encabezado de respuesta que se envía
Antes de limpiar, puedes validar rápidamente que el balanceador de cargas de HTTP envíe el encabezado de respuesta adecuado. Lo habías configurado para enviar la prueba de encabezado con el valor de contenido. Si ejecutas el comando curl desde Cloud Shell, obtendrás 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. Borra el lab
Ahora que terminamos con el entorno del lab, es momento de desmantelarlo. Ejecuta los siguientes comandos para borrar el entorno de prueba.
Desde Cloud Shell
gcloud compute instances delete siege-vm --zone=us-east4-c gcloud compute forwarding-rules delete http-content-rule --global gcloud compute target-http-proxies delete http-lb-proxy-adv gcloud compute url-maps delete web-map-http gcloud compute backend-services delete east-backend-service --global gcloud compute backend-services delete west-backend-service --global gcloud 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 sobre el balanceador de cargas de HTTP(S) externo con administración avanzada del tráfico (Envoy).
Temas abordados
- Cómo configurar un grupo de instancias administrado y las reglas de firewall y la VPC asociadas
- Cómo usar las funciones avanzadas de administración del tráfico del nuevo balanceador de cargas
- Cómo validar que las funciones avanzadas de administración del tráfico funcionen según lo previsto
Próximos pasos
- Prueba algunas de las otras funciones de enrutamiento avanzadas, como la reescritura de URLs, la adición de encabezados de CORS y muchas más ( vínculo).