Configura la administración del tráfico en los balanceadores de cargas de aplicaciones externos globales

En este documento, se muestran ejemplos de cómo usar la administración del tráfico en algunos casos de uso específicos. Muchos otros casos de uso son posibles.

El documento contiene ejemplos de balanceadores de cargas de aplicaciones externos globales. Los balanceadores de cargas de aplicaciones externos globales usan el esquema de balanceo de cargas EXTERNAL_MANAGED y los componentes de balanceo de cargas global, como la regla de reenvío, el mapa de URL y el servicio de backend.

Para obtener información sobre la administración del tráfico con un balanceador de cargas de aplicaciones clásico, consulta Descripción general de la administración del tráfico en un balanceador de cargas de aplicaciones clásico.

Para obtener información sobre la administración del tráfico con balanceadores de cargas de aplicaciones externos regionales, consulta Descripción general de la administración del tráfico en los balanceadores de cargas de aplicaciones externos regionales.

Además de las funciones avanzadas de enrutamiento descritas en esta página, los balanceadores de cargas de aplicaciones compatibles se integran con las extensiones de servicio para que puedas insertar lógica personalizada en la ruta de datos del balanceo de cargas.

Antes de comenzar

Asegúrate de comprender cómo funciona la administración del tráfico. Para obtener más información, consulta Descripción general de la administración del tráfico en los balanceadores de cargas de aplicaciones externos globales.

Configura y prueba la administración del tráfico

En el entorno de configuración elegido, configura la administración del tráfico mediante opciones de configuración YAML. Un mapa de URL y un servicio de backend tienen cada uno su archivo YAML. Según la función elegida, debes escribir un archivo YAML de mapa de URL, un archivo YAML de servicio de backend o ambos.

Si necesitas ayuda para escribir estos archivos YAML, puedes usar los ejemplos de esta página y la documentación de la API de Cloud Load Balancing.

La consola de Google Cloud no es compatible.

En la documentación de la API de mapas de URL globales y la API del servicio de backend global, se proporciona una lista completa de campos, incluida la semántica sobre las relaciones, las restricciones y la cardinalidad.

Puedes agregar pruebas de configuración a un mapa de URL para asegurarte de que enrute las solicitudes según lo previsto. Puedes experimentar con diferentes reglas de asignación de URL y ejecutar tantas pruebas como sea necesario para asegurarte de que el mapa enrute el tráfico al servicio de backend o al bucket de backend adecuado. Para obtener detalles, consulta Agrega pruebas a un mapa de URL. Si quieres probar nuevos cambios en un mapa de URL sin implementar el mapa, consulta Valida la configuración del mapa de URL.

Asigna tráfico a un solo servicio

Envía todo el tráfico a un solo servicio. Asegúrate de reemplazar los marcadores de posición.

    defaultService: projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_1
    hostRules:
    - hosts:
      - '*'
      pathMatcher: matcher1
    name: URL_MAP_NAME
    pathMatchers:
    - defaultService: projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_1
      name: matcher1
      routeRules:
      - matchRules:
        - prefixMatch: /PREFIX
        priority: PRIORITY  # 0 is highest
        routeAction:
          weightedBackendServices:
          - backendService: projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_1
            weight: 100

Divide el tráfico entre dos servicios

Divide el tráfico entre dos o entre varios servicios. Asegúrate de reemplazar los marcadores de posición.

   defaultService: projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_1
   hostRules:
   - hosts:
     - '*'
     pathMatcher: matcher1
   name: URL_MAP_NAME
   pathMatchers:
   - defaultService: projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_1
     name: matcher1
     routeRules:
     - matchRules:
       - prefixMatch: /PREFIX
       priority: 2
       routeAction:
         weightedBackendServices:
         - backendService: projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_1
           weight: 95
         - backendService: projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_2
           weight: 5

Configura un redireccionamiento de la URL

En el siguiente ejemplo, se muestra un código de respuesta MOVED_PERMANENTLY_DEFAULT 301 configurable. También establece el encabezado de respuesta Location con el URI apropiado, lo que reemplaza el host y la ruta de acceso como se especifica en la acción de redireccionamiento.

Para crear un redireccionamiento para un bucket de backend, usa projects/PROJECT_ID/global/backendBuckets/BACKEND_BUCKET para el campo defaultService.

   defaultService: projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_1
   name: <var>URL_MAP_NAME</var>
   hostRules:
   - hosts:
     - "HOST TO REDIRECT FROM" # Use * for all hosts
     pathMatcher: matcher1
   pathMatchers:
   - defaultService: projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_1
     name: matcher1
     defaultUrlRedirect:
       hostRedirect: "HOST TO REDIRECT TO" # Omit to keep the requested host
       pathRedirect: "PATH TO REDIRECT TO" # Omit to keep the requested path
       redirectResponseCode: MOVED_PERMANENTLY_DEFAULT
       stripQuery: True

Duplica el tráfico

Además de reenviar la solicitud al servicio de backend seleccionado, envía una solicitud idéntica al servicio de backend duplicado y configurado en una base de enviar y olvidar. Esto significa que el balanceador de cargas no espera una respuesta del backend al que envía la solicitud duplicada. La duplicación de solicitudes es útil para probar una versión nueva de un servicio de backend. También puedes usarla para depurar errores de producción en una versión de depuración de tu servicio de backend, en lugar de hacerlo en la versión de producción.

De forma predeterminada, el servicio de backend duplicado recibe todas las solicitudes, incluso si el tráfico original se divide entre varios servicios de backend ponderados. Puedes configurar el servicio de backend reflejado para que reciba solo un porcentaje de las solicitudes con la marca opcional mirrorPercent para especificar el porcentaje de solicitudes que se reflejarán, expresado como un valor entre 0 y 100.0. La duplicación de solicitudes basada en porcentajes se encuentra en Versión preliminar.

   defaultService: projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_1
   name: global-lb-map
   hostRules:
   - hosts:
     - '*'
     pathMatcher: matcher1
   pathMatchers:
   - defaultService: projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_1
     name: matcher1
     routeRules:
       - matchRules:
           - prefixMatch: /PREFIX
         priority: PRIORITY  # 0 is highest
         routeAction:
           weightedBackendServices:
             - backendService: projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_1
               weight: 100
           requestMirrorPolicy:
             backendService: projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_2
             mirrorPercent: 50.0

Si tienes varios servicios de backend ponderados y deseas registrar qué servicio de backend se usó para entregar la solicitud original, puedes agregar un encabezado personalizado que incluya esta información a todas las solicitudes. En el siguiente ejemplo, se agrega un encabezado personalizado llamado x-weighted-picked-backend a todas las solicitudes de clientes. Para el valor del encabezado, usa el nombre del servicio de backend que entregó la solicitud original.

   defaultService: projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_1
   name: global-lb-map
   hostRules:
   - hosts:
     - '*'
     pathMatcher: matcher1
   pathMatchers:
   - defaultService: projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_1
     name: matcher1
     routeRules:
       - matchRules:
           - prefixMatch: /PREFIX
         priority: PRIORITY  # 0 is highest
         routeAction:
           weightedBackendServices:
            - backendService: projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_1
              weight: 95
              headerAction:
                requestHeadersToAdd:
                - headerName: x-weighted-picked-backend
                  headerValue: BACKEND_SERVICE_1
                  replace: True
            - backendService: projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_2
              weight: 5
              headerAction:
                requestHeadersToAdd:
                - headerName: x-weighted-picked-backend
                  headerValue: BACKEND_SERVICE_2
                  replace: True
           requestMirrorPolicy:
             backendService: projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_3

Ten en cuenta las siguientes limitaciones cuando uses el reflejo de tráfico:

• La duplicación de tráfico es compatible cuando ambos servicios de backend tienen grupos de instancias administrados, NEG zonales o backends de NEG híbridos. No es compatible con NEG de Internet, NEG sin servidores ni Private Service Connect.
• Las solicitudes al servicio de backend reflejado no generan registros ni métricas para Cloud Logging ni Cloud Monitoring.

Vuelve a escribir la URL solicitada

Reescribe la parte del nombre de host de la URL, la parte de la ruta de la URL o ambas antes de enviar una solicitud al servicio de backend seleccionado. Asegúrate de reemplazar los marcadores de posición.

   defaultService: projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_1
   name: global-lb-map
   hostRules:
   - hosts:
     - '*'
     pathMatcher: matcher1
   pathMatchers:
   - defaultService: projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_1
     name: matcher1
     routeRules:
       - matchRules:
           - prefixMatch: /PREFIX
         priority: PRIORITY  # 0 is highest
         routeAction:
           weightedBackendServices:
             - backendService: projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_1
               weight: 100
           urlRewrite:
             hostRewrite: "new-host-name.com" # Omit to keep the requested host
             pathPrefixRewrite: "/new-path/" # Omit to keep the requested path

Reintentar una solicitud

Configura las condiciones en las que el balanceador de cargas reintenta enviar solicitudes con errores, cuánto espera el balanceador de cargas hasta volver a intentarlo y la cantidad máxima de reintentos permitidos.

   defaultService: projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_1
   name: global-lb-map
   hostRules:
   - hosts:
     - '*'
     pathMatcher: matcher1
   pathMatchers:
   - defaultService: projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_1
     name: matcher1
     routeRules:
       - matchRules:
           - prefixMatch: /PREFIX
         priority: PRIORITY  # 0 is highest
         routeAction:
           weightedBackendServices:
             - backendService: projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_1
               weight: 100
           retryPolicy:
             retryConditions: 502, 504
             numRetries: 3
             perTryTimeout:
               seconds: 1
               nanos: 500000000

Especifica el tiempo de espera de la ruta

Especifica el tiempo de espera para la ruta seleccionada. El tiempo de espera se calcula desde el momento en que la solicitud se procesa por completo hasta que la respuesta hace lo mismo. El tiempo de espera incluye todos los reintentos. Asegúrate de reemplazar los marcadores de posición:

   defaultService: projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_1
   name: global-lb-map
   hostRules:
   - hosts:
     - '*'
     pathMatcher: matcher1
   pathMatchers:
   - defaultService: projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_1
     name: matcher1
     routeRules:
       - matchRules:
           - prefixMatch: /PREFIX
         priority: PRIORITY  # 0 is highest
         routeAction:
           weightedBackendServices:
             - backendService: projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_1
               weight: 100
           timeout:
             seconds: 30
             nanos: 0

Configura la inserción de errores

Presenta errores cuando se entregan solicitudes para simular fallas, incluida la latencia alta, la sobrecarga del servicio, las fallas del servicio y la partición de la red. Esta característica es útil a fin de probar la resistencia de un servicio ante fallas simuladas.

   defaultService: projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_1
   name: global-lb-map
   hostRules:
   - hosts:
     - '*'
     pathMatcher: matcher1
   pathMatchers:
   - defaultService: projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_1
     name: matcher1
     routeRules:
       - matchRules:
           - prefixMatch: /PREFIX
         priority: PRIORITY  # 0 is highest
         routeAction:
           weightedBackendServices:
             - backendService: projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_1
               weight: 100
           faultInjectionPolicy:
             delay:
               fixedDelay:
                 seconds: 10
                 nanos: 0
               percentage: 25
             abort:
               httpStatus: 503
               percentage: 50

Configurar CORS

Configura las políticas de uso compartido de recursos entre dominios (CORS) a fin de controlar la configuración para aplicar las solicitudes de CORS.

   defaultService: projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_1
   name: global-lb-map
   hostRules:
   - hosts:
     - '*'
     pathMatcher: matcher1
   pathMatchers:
   - defaultService: projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_1
     name: matcher1
     routeRules:
       - matchRules:
           - prefixMatch: /PREFIX
         priority: PRIORITY  # 0 is highest
         routeAction:
           weightedBackendServices:
             - backendService: projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_1
               weight: 100
           corsPolicy:
               allowOrigins: [ "http://my-domain.com" ]
               allowMethods: [ "GET", "POST" ]
               allowHeaders: [ "Authorization", "Content-Type" ]
               maxAge: 1200
               allowCredentials: true

Agrega y quita encabezados de solicitud y respuesta

Nota: Anunciamos un cambio en el comportamiento de los encabezados personalizados configurados en mapas de URL y servicios de backend. Este cambio no afecta a los proyectos que tenían tráfico existente que usaba encabezados personalizados antes del 14 de noviembre de 2022. Para obtener más información, consulta la nota de la versión del 14 de noviembre de 2022.

Agrega y quita encabezados de solicitud antes de enviar una solicitud al servicio de backend. Además, agrega y quita los encabezados de respuesta después de recibir una respuesta del servicio de backend.

Hay restricciones para los valores válidos de headerName y headerValue. Para obtener más información, consulta Cómo funcionan los encabezados personalizados.

   defaultService: projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_1
   name: global-lb-map
   hostRules:
   - hosts:
     - '*'
     pathMatcher: matcher1
   pathMatchers:
   - defaultService: projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_1
     name: matcher1
     routeRules:
       - matchRules:
           - prefixMatch: /PREFIX
         priority: PRIORITY  # 0 is highest
         routeAction:
           weightedBackendServices:
             - backendService: projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_1
               headerAction:
                 requestHeadersToAdd:
                 - headerName: header-1-name
                   headerValue: header-1-value
                   replace: True
                 requestHeadersToRemove:
                 - header-2-name
                 - header-3-name
                 responseHeadersToAdd:
                 - headerName: header-4-name
                   headerValue: header-4-value
                   replace: True
                responseHeadersToRemove:
                - header-5-name
                - header-6-name

Configura la detección de valores atípicos

Especifica los criterios para la expulsión de las VM de backend o extremos en mal estado en los NEG, junto con criterios que definan cuándo un backend o extremo tiene un estado lo suficientemente bueno como para recibir tráfico otra vez. Asegúrate de reemplazar los marcadores de posición:

    loadBalancingScheme: EXTERNAL_MANAGED
    localityLbPolicy: RANDOM
    name: projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_1
    outlierDetection:
      baseEjectionTime:
        nanos: 0
        seconds: 30
      consecutiveErrors: 5
      consecutiveGatewayFailure: 3
      enforcingConsecutiveErrors: 2
      enforcingConsecutiveGatewayFailure: 100
      enforcingSuccessRate: 100
      interval:
        nanos: 0
        seconds: 1
      maxEjectionPercent: 50
      successRateMinimumHosts: 5
      successRateRequestVolume: 100
      successRateStdevFactor: 1900

Configura la división de tráfico: pasos detallados

Nota: No configures la afinidad de sesión si usas la división de tráfico ponderada. Si lo haces, la configuración de división de tráfico ponderada tiene prioridad.

En este ejemplo, se muestran los siguientes pasos:

1. Crear plantillas distintas para servicios diferentes

2. Crear grupos de instancias para esas plantillas

3. Crea reglas de enrutamiento que configuren una división del tráfico del 95% / 5%.

4. Envía los comandos curl que muestren que los porcentajes de división del tráfico coinciden de forma aproximada con la configuración.

En estas instrucciones, se supone lo siguiente:

• Se creó un proxy de destino y una regla de reenvío, junto con un mapa de URL llamado global-lb-map.

• El mapa de URL envía todo el tráfico a un servicio de backend llamado red-service, que es el servicio de backend predeterminado.

• Configura una ruta alternativa que envíe el 5% del tráfico a blue-service y el 95% del tráfico a green-service.

• Se usa un comparador de rutas.

• Usas Cloud Shell o algún otro entorno con bash instalada.

Define los servicios

La siguiente función bash crea un servicio de backend, lo que incluye la plantilla de instancias y el grupo de instancias administrado.

En estas instrucciones, se supone que se creó una verificación de estado de HTTP (global-lb-basic-check). Para obtener instrucciones, consulta una de las siguientes páginas:

• Configura un balanceador de cargas de aplicaciones externo global con un backend de Compute Engine
• Configura un balanceador de cargas de aplicaciones externo global con un bucket de backend
• Configura un balanceador de cargas de aplicaciones externo global con conectividad híbrida
• Configura un balanceador de cargas de aplicaciones externo global con Cloud Run, App Engine o funciones de Cloud Run

function make_service() {
  local name="$1"
  local region="$2"
  local zone="$3"
  local network="$4"
  local subnet="$5"
  local subdir="$6"

  www_dir="/var/www/html/$subdir"

  (set -x; \
  gcloud compute instance-templates create "${name}-template" \
    --region="$region" \
    --network="$network" \
    --subnet="$subnet" \
    --tags=allow-ssh,load-balanced-backend \
    --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
  sudo mkdir -p $www_dir
  /bin/hostname | sudo tee ${www_dir}index.html
  systemctl restart apache2"; \
  gcloud compute instance-groups managed create \
    "${name}-instance-group" \
    --zone="$zone" \
    --size=2 \
    --template="${name}-template"; \
  gcloud compute backend-services create "${name}-service" \
    --load-balancing-scheme=EXTERNAL_MANAGED \
    --protocol=HTTP \
    --health-checks=global-lb-basic-check \
    --global \
  gcloud compute backend-services add-backend "${name}-service" \
    --balancing-mode='UTILIZATION' \
    --instance-group="${name}-instance-group" \
    --instance-group-zone="$zone" \
    --global)
}

Crea los servicios

Llama a la función para crear tres servicios: red, green y blue. El servicio red actúa como el servicio predeterminado para las solicitudes a /. Los servicios green y blue se configuraron en /prefix para administrar el 95% y el 5% del tráfico, respectivamente.

make_service red us-west1 us-west1-a lb-network backend-subnet ""
make_service green us-west1 us-west1-a lb-network backend-subnet /prefix
make_service blue us-west1 us-west1-a lb-network backend-subnet /prefix

Crea el mapa de URL

Console

1. Ve a la página Balanceo de cargas en la consola de Google Cloud.
   Ir a Balanceo de cargas
2. Haz clic en el vínculo global-lb-map.
3. Haz clic en Editar .

Configura las reglas de enrutamiento nuevas

1. En Reglas de enrutamiento, selecciona Host avanzado, ruta de acceso y regla de enrutamiento.
2. En Nuevos hosts y comparadores de rutas de acceso, crea la acción predeterminada. Para esto, establece el Servicio en red-service.
3. Haz clic en Listo.
4. Haz clic en Agregar hosts y comparadores de rutas de acceso.
5. En el campo Hosts, ingresa la dirección IP de la regla de reenvío del balanceador de cargas.

6. Pega el siguiente contenido de YAML en el cuadro Comparador de rutas de acceso:

   defaultService: projects/PROJECT_ID/global/backendServices/red-service
   name: matcher1
   routeRules:
   - priority: 2
     matchRules:
       - prefixMatch: /PREFIX
     routeAction:
       weightedBackendServices:
         - backendService: projects/PROJECT_ID/global/backendServices/green-service
           weight: 95
         - backendService: projects/PROJECT_ID/global/backendServices/blue-service
           weight: 5
   

7. Haz clic en Listo.

8. Haz clic en Update.

gcloud

1. Exporta el mapa de URL existente con el comando gcloud compute url-maps export:

   gcloud compute url-maps export global-lb-map \
     --destination=global-lb-map-config.yaml \
     --global
   

2. Actualiza el archivo de mapa de URL global-lb-map-config.yaml. Para esto, agrega lo siguiente al final del archivo:

   hostRules:
   - hosts:
     - '*'
     pathMatcher: matcher1
   pathMatchers:
   - defaultService: projects/PROJECT_ID/global/backendServices/red-service
     name: matcher1
     routeRules:
     - priority: 2
       matchRules:
         - prefixMatch: /PREFIX
       routeAction:
         weightedBackendServices:
           - backendService: projects/PROJECT_ID/global/backendServices/green-service
             weight: 95
           - backendService: projects/PROJECT_ID/global/backendServices/blue-service
             weight: 5
   

3. Actualiza el mapa de URL con el comando gcloud compute url-maps import:

   gcloud compute url-maps import global-lb-map \
      --global \
      --source=global-lb-map-config.yaml
   

Prueba la configuración

Para probar la configuración, primero asegúrate de que las solicitudes a la dirección IP que se configuró antes en el balanceador de cargas se manejen mediante la configuración red predeterminada.

Luego, asegúrate de que las solicitudes que se enviaron a FORWARDING_RULE_IP_ADDRESS/prefix estén divididas según lo esperado.

Configura la afinidad de sesión basada en HTTP_COOKIE

El control de tráfico te permite configurar la afinidad de sesión en función de una cookie proporcionada. Si deseas configurar la afinidad de sesión basada en HTTP_COOKIE para un servicio de backend llamado red-service, sigue estas instrucciones.

1. Usa el comando gcloud compute backend_services export para obtener la configuración del servicio de backend.

   gcloud compute backend-services export red-service \
       --destination=red-service-config.yaml \
       --global
   

2. Actualiza el archivo red-service-config.yaml de la siguiente manera:

   sessionAffinity: 'HTTP_COOKIE'
   localityLbPolicy: 'RING_HASH'
   consistentHash:
    httpCookie:
     name: 'http_cookie'
     path: '/cookie_path'
     ttl:
       seconds: 100
       nanos: 0
    minimumRingSize: 10000
   

3. En el archivo red-service-config.yaml, incluye la siguiente línea:

   sessionAffinity: NONE
   

4. Actualiza el archivo de configuración del servicio de backend:

   gcloud compute backend-services import red-service \
       --source=red-service-config.yaml \
       --global
   

Soluciona problemas

Usa esta información para solucionar problemas cuando el tráfico no se enruta de acuerdo con las reglas de enrutamiento y las políticas de tráfico que configuraste.

Para obtener información sobre el registro y la supervisión, consulta la sección Registro y supervisión de HTTP(S) interno.

Síntomas:

• Mayor tráfico a los servicios en reglas que se encuentran por encima de la regla en cuestión
• Aumento inesperado en las respuestas HTTP 4xx y 5xx para una regla de enrutamiento determinada

Solución: verifica el orden de tus reglas de enrutamiento. Las reglas de enrutamiento se interpretan en el orden en que se especifican.

Las reglas de enrutamiento dentro de una asignación de URL se interpretan en el orden en que se especifican. Esto las diferencia de las reglas de ruta de acceso, que se interpretan por la coincidencia de prefijo más largo. Para una regla de ruta de acceso, el balanceador de cargas de aplicaciones global externo solo selecciona una única regla de ruta de acceso. Sin embargo, cuando usas reglas de enrutamiento, es posible que se aplique más de una.

Cuando definas reglas de enrutamiento, asegúrate de que las reglas ubicadas en la parte superior de la lista no desvíen de forma involuntaria el tráfico que, de lo contrario, se enrutaría mediante una regla de enrutamiento posterior. Es probable que el servicio que recibe tráfico mal dirigido rechace las solicitudes y el servicio en tus reglas de enrutamiento reciba poco o nada de tráfico.

¿Qué sigue?

• Limpia la configuración del balanceador de cargas.