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

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 de enrutamiento avanzadas que se describen en esta página, ciertos balanceadores de cargas de aplicaciones se integran en las extensiones de servicio a fin de que puedas incorporar lógica personalizada en la ruta de acceso de los datos de balanceo de cargas mediante lo siguiente:configurar textos destacados de extensiones de servicio.

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 funcionalidad que desees, 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: global/backendServices/BACKEND_SERVICE_1
    hostRules:
    - hosts:
      - '*'
      pathMatcher: matcher1
    name: URL_MAP_NAME
    pathMatchers:
    - defaultService: global/backendServices/BACKEND_SERVICE_1
      name: matcher1
      routeRules:
      - matchRules:
        - prefixMatch: /PREFIX
        priority: PRIORITY  # 0 is highest
        routeAction:
          weightedBackendServices:
          - backendService: 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: global/backendServices/BACKEND_SERVICE_1
   hostRules:
   - hosts:
     - '*'
     pathMatcher: matcher1
   name: URL_MAP_NAME
   pathMatchers:
   - defaultService: global/backendServices/BACKEND_SERVICE_1
     name: matcher1
     routeRules:
     - matchRules:
       - prefixMatch: /PREFIX
       priority: 2
       routeAction:
         weightedBackendServices:
         - backendService: global/backendServices/BACKEND_SERVICE_1
           weight: 95
         - backendService: global/backendServices/BACKEND_SERVICE_2
           weight: 5

Configura un redireccionamiento de la URL

En el ejemplo siguiente, se muestra un código de respuesta 3xx 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.

   defaultService: global/backendServices/BACKEND_SERVICE_1
   name: global-lb-map
   hostRules:
   - hosts:
     - '*'
     pathMatcher: matcher1
   pathMatchers:
   - defaultService: global/backendServices/BACKEND_SERVICE_1
     name: matcher1
     routeRules:
       - matchRules:
           - prefixMatch: /PREFIX
         priority: PRIORITY  # 0 is highest
         urlRedirect:
           hostRedirect: "new-host-name.com" # Omit to keep the requested host
           pathRedirect: "/new-path" # Omit to keep the requested path; mutually exclusive to prefixRedirect
           prefixRedirect: "/newPrefix" # Omit to keep the requested path; mutually exclusive to pathRedirect
           redirectResponseCode: FOUND
           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. El balanceador de cargas no espera una respuesta del backend al que envía la solicitud duplicada. La duplicación 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.

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

La duplicación de tráfico solo es compatible en los siguientes casos:

  • Ambos servicios de backend tienen backends de grupo de instancias. No se admiten otros tipos de backend.
  • Las solicitudes HTTP no tienen cuerpos.

La duplicación no se puede configurar para una parte específica de las solicitudes. Incluso si divides el tráfico entre varios servicios de backend ponderados, el servicio de backend duplicado recibe todas las solicitudes. Sin embargo, puedes usar encabezados personalizados para registrar qué servicio de backend se usó a fin de entregar la solicitud original. 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: global/backendServices/BACKEND_SERVICE_1
   name: global-lb-map
   hostRules:
   - hosts:
     - '*'
     pathMatcher: matcher1
   pathMatchers:
   - defaultService: global/backendServices/BACKEND_SERVICE_1
     name: matcher1
     routeRules:
       - matchRules:
           - prefixMatch: /PREFIX
         priority: PRIORITY  # 0 is highest
         routeAction:
           weightedBackendServices:
            - backendService: global/backendServices/BACKEND_SERVICE_1
              weight: 95
              headerAction:
                requestHeadersToAdd:
                - headerName: x-weighted-picked-backend
                  headerValue: BACKEND_SERVICE_1
                  replace: True
            - backendService: global/backendServices/BACKEND_SERVICE_2
              weight: 5
              headerAction:
                requestHeadersToAdd:
                - headerName: x-weighted-picked-backend
                  headerValue: BACKEND_SERVICE_2
                  replace: True
           requestMirrorPolicy:
             backendService: global/backendServices/BACKEND_SERVICE_3

Vuelve a escribir la URL solicitada

Vuelve a escribir 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: global/backendServices/BACKEND_SERVICE_1
   name: global-lb-map
   hostRules:
   - hosts:
     - '*'
     pathMatcher: matcher1
   pathMatchers:
   - defaultService: global/backendServices/BACKEND_SERVICE_1
     name: matcher1
     routeRules:
       - matchRules:
           - prefixMatch: /PREFIX
         priority: PRIORITY  # 0 is highest
         routeAction:
           weightedBackendServices:
             - backendService: 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: global/backendServices/BACKEND_SERVICE_1
   name: global-lb-map
   hostRules:
   - hosts:
     - '*'
     pathMatcher: matcher1
   pathMatchers:
   - defaultService: global/backendServices/BACKEND_SERVICE_1
     name: matcher1
     routeRules:
       - matchRules:
           - prefixMatch: /PREFIX
         priority: PRIORITY  # 0 is highest
         routeAction:
           weightedBackendServices:
             - backendService: 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: global/backendServices/BACKEND_SERVICE_1
   name: global-lb-map
   hostRules:
   - hosts:
     - '*'
     pathMatcher: matcher1
   pathMatchers:
   - defaultService: global/backendServices/BACKEND_SERVICE_1
     name: matcher1
     routeRules:
       - matchRules:
           - prefixMatch: /PREFIX
         priority: PRIORITY  # 0 is highest
         routeAction:
           weightedBackendServices:
             - backendService: 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: global/backendServices/BACKEND_SERVICE_1
   name: global-lb-map
   hostRules:
   - hosts:
     - '*'
     pathMatcher: matcher1
   pathMatchers:
   - defaultService: global/backendServices/BACKEND_SERVICE_1
     name: matcher1
     routeRules:
       - matchRules:
           - prefixMatch: /PREFIX
         priority: PRIORITY  # 0 is highest
         routeAction:
           weightedBackendServices:
             - backendService: 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: global/backendServices/BACKEND_SERVICE_1
   name: global-lb-map
   hostRules:
   - hosts:
     - '*'
     pathMatcher: matcher1
   pathMatchers:
   - defaultService: global/backendServices/BACKEND_SERVICE_1
     name: matcher1
     routeRules:
       - matchRules:
           - prefixMatch: /PREFIX
         priority: PRIORITY  # 0 is highest
         routeAction:
           weightedBackendServices:
             - backendService: 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

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: global/backendServices/BACKEND_SERVICE_1
   name: global-lb-map
   hostRules:
   - hosts:
     - '*'
     pathMatcher: matcher1
   pathMatchers:
   - defaultService: global/backendServices/BACKEND_SERVICE_1
     name: matcher1
     routeRules:
       - matchRules:
           - prefixMatch: /PREFIX
         priority: PRIORITY  # 0 is highest
         routeAction:
           weightedBackendServices:
             - backendService: 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: 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

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:

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-10 \
    --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: global/backendServices/red-service
name: matcher1
routeRules:
- priority: 2
  matchRules:
    - prefixMatch: /PREFIX
  routeAction:
    weightedBackendServices:
      - backendService: global/backendServices/green-service
        weight: 95
      - backendService: global/backendServices/blue-service
        weight: 5

  7. Haz clic en Listo.

  8. Haz clic en Actualizar.

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: global/backendServices/red-service
  name: matcher1
  routeRules:
  - priority: 2
    matchRules:
      - prefixMatch: /PREFIX
    routeAction:
      weightedBackendServices:
        - backendService: global/backendServices/green-service
          weight: 95
        - backendService: 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.

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?