Configura el balanceo de cargas basado en la utilización para los servicios de GKE

En esta página, se describe cómo configurar el balanceo de cargas basado en el uso para los servicios de GKE. Esta página está destinada a los equipos de infraestructura y aplicaciones, y a los administradores de GKE que se encargan de configurar y administrar la distribución del tráfico para sus servicios de GKE.

Puedes usar balanceadores de cargas basados en el uso para optimizar el rendimiento y la disponibilidad de las aplicaciones mediante la distribución inteligente del tráfico en función del uso de recursos en tiempo real de tus pods de GKE.

Antes de leer esta página, asegúrate de estar familiarizado con el balanceo de cargas basado en el uso para los servicios de GKE y cómo funciona el balanceo de cargas basado en el uso.

Precios

El balanceo de cargas basado en el uso es una capacidad de la puerta de enlace de GKE que está disponible sin costo adicional. Aún se aplican los precios de GKE y GKE.

Cuotas

El balanceo de cargas basado en el uso no introduce cuotas nuevas, aunque se siguen aplicando todas las cuotas de Cloud Load Balancing y otros servicios dependientes.

Antes de comenzar

Antes de comenzar, asegúrate de haber realizado las siguientes tareas:

  • Habilita la API de Google Kubernetes Engine.
    • Habilitar la API de Google Kubernetes Engine
  • Si deseas usar Google Cloud CLI para esta tarea, instala y, luego, inicializa gcloud CLI. Si ya instalaste gcloud CLI, ejecuta el comando gcloud components update para obtener la versión más reciente. Es posible que las versiones anteriores de gcloud CLI no admitan la ejecución de los comandos de este documento.

Requisitos del controlador de la puerta de enlace de GKE

El balanceo de cargas basado en el uso para los servicios de GKE requiere lo siguiente:

El balanceo de cargas basado en el uso para los servicios de GKE admite lo siguiente:

  • Servicios de GKE de un solo clúster y de varios clústeres que actúan como backends para un Google Cloud-balanceador de cargas administrado.
  • Todas las ediciones de GKE (Standard, Autopilot y Enterprise).
  • Todos los Google Cloud balanceadores de cargas de aplicaciones, excepto los balanceadores de cargas de aplicaciones clásicos.

Limitaciones

El balanceo de cargas basado en el uso para los servicios de GKE tiene las siguientes limitaciones.

  • Las métricas de uso de recursos admitidas son las siguientes:
  • No se admiten los balanceadores de cargas de red de proxy ni de transferencia.
  • Solo se admite la API de Gateway; no se admiten las APIs de Service ni de Ingress.
  • El balanceo de cargas basado en el uso no funciona bien si tu tráfico es muy irregular. El reequilibrio del tráfico tarda hasta 30 segundos cuando los pods alcanzan su uso máximo. Se espera que el indicador de uso aumente con el tráfico entrante, pero esta demora significa que el balanceo de cargas basado en el uso necesita tiempo para ajustarse. Para un rendimiento óptimo, el balanceo de cargas basado en el uso funciona mejor en entornos con flujos de tráfico fluidos y predecibles.
  • El balanceo de cargas basado en el uso puede tardar hasta 30 segundos en actualizar y ajustar la distribución del tráfico después de los cambios de configuración, como modificar o quitar el campo dryRun en una GCPBackendPolicy. Esta demora es un comportamiento conocido en todo el sistema. Como resultado, esta función es más adecuada para aplicaciones con patrones de tráfico relativamente estables que pueden tolerar esta latencia de actualización.

De forma predeterminada, el balanceo de cargas basado en el uso está inhabilitado para tus servicios de GKE. Debes habilitarlo de forma explícita. Si no estableces un umbral de uso máximo, el sistema usará de forma predeterminada el 80% de uso por extremo.

El objetivo de configurar el balanceo de cargas basado en el uso es optimizar la distribución del tráfico para que los pods de backend puedan administrar de manera eficiente su carga de trabajo, lo que mejora el rendimiento de las aplicaciones y el uso de los recursos.

Habilita el balanceo de cargas basado en el uso y el perfil de HPA de rendimiento

Antes de configurar el balanceo de cargas basado en el uso, asegúrate de que tu clúster de GKE admita las funciones requeridas. El balanceo de cargas basado en el uso utiliza métricas personalizadas, como la CPU, para tomar decisiones de enrutamiento más inteligentes. Estas decisiones dependen de lo siguiente:

  • La API de Gateway, que permite políticas a nivel de servicio a través de GCPBackendPolicy.
  • El perfil de HPA de rendimiento, que permite que las cargas de trabajo se escalen más rápido y de forma más agresiva mediante el uso de indicadores de CPU.

Habilita la API de Gateway y el perfil de HPA de rendimiento

Autopilot

La API de Gateway y el perfil de HPA de rendimiento están disponibles de forma predeterminada en un clúster de Autopilot.

Standard

Para crear un nuevo clúster Standard con el perfil de HPA de rendimiento y la API de Gateway habilitados, ejecuta el siguiente comando:

gcloud container clusters create CLUSTER_NAME \
    --location=LOCATION \
    --project=PROJECT_ID \
    --cluster-version=CLUSTER_VERSION \
    --gateway-api=standard \
    --hpa-profile=performance \
    --release-channel=rapid

Reemplaza lo siguiente:

  • CLUSTER_NAME por el nombre de tu clúster nuevo
  • LOCATION por la región o zona de Compute Engine de tu clúster
  • PROJECT_ID por el ID del proyecto
  • CLUSTER_VERSION por la versión de GKE, que debe ser 1.33.1-gke.1918000 o posterior

Para habilitar el perfil de HPA de rendimiento y la API de Gateway en un clúster de GKE Standard existente, usa lo siguiente:

gcloud container clusters update CLUSTER_NAME \
    --location=LOCATION \
    --project=PROJECT_ID \
    --gateway-api=standard \
    --hpa-profile=performance \
    --release-channel=rapid

Reemplaza lo siguiente:

Para obtener más información sobre el perfil de HPA de rendimiento, consulta Configura el perfil de HPA de rendimiento.

Configura el balanceo de cargas basado en el uso

Una vez que tu clúster esté listo, define una política que indique cómo se enruta el tráfico en función del uso del backend. Debes usar la API de Gateway de Kubernetes a través de GCPBackendPolicy para la configuración.

Requisitos previos

Antes de configurar el balanceo de cargas basado en el uso con la API de Gateway, asegúrate de que tu clúster de GKE cumpla con los siguientes requisitos:

  1. Implementa una aplicación: Asegúrate de implementar una aplicación de Kubernetes con un recurso de Deployment. Para obtener más información, consulta Implementa una aplicación en un clúster de GKE.

    Por ejemplo, un manifiesto de implementación típico podría incluir una sección de recursos como esta:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: store-v1
spec:
  # ... other deployment configurations ...
  template:
    # ... other template configurations ...
    spec:
      containers:
        - name: your-container-name
          image: your-image
          ports:
            - containerPort: 8080
          resources:
            limits:
              cpu: 100m
              memory: 45Mi
            requests:
              cpu: 100m
              memory: 45Mi

  2. Expón la aplicación con un Service: Debes exponer la aplicación con un servicio de Kubernetes. Para obtener más información sobre cómo funcionan los servicios y cómo configurarlos, consulta Comprende los servicios de Kubernetes Services.

  3. Usa un balanceador de cargas de aplicaciones basado en la API de Gateway: Expón el Service con un balanceador de cargas de aplicaciones administrado por GKE que esté configurado a través de la API de Gateway. Para obtener más información, consulta Implementa puertas de enlace.

Crea una GCPBackendPolicy para el balanceo de cargas basado en CPU

Esta configuración permite que GKE distribuya el tráfico de forma dinámica en función del uso de CPU en tiempo real de cada pod de backend.

Para habilitar el balanceo de cargas basado en el uso para los servicios de GKE, usa el recurso personalizado GCPBackendPolicy de la API de Gateway de Kubernetes.

El recurso personalizado GCPBackendPolicy te permite definir de forma declarativa el comportamiento del balanceo de cargas dentro de tu clúster de Kubernetes. Si especificas métricas de uso de CPU, controlas cómo se distribuye el tráfico entre los backends en función de su uso de recursos actual. Este enfoque ayuda a mantener el rendimiento de las aplicaciones, evita que los pods individuales se sobrecarguen y mejora la confiabilidad de las aplicaciones y la experiencia del usuario.

  1. Guarda el siguiente manifiesto de muestra como my-backend-policy.yaml:

    kind: GCPBackendPolicy
apiVersion: networking.gke.io/v1
metadata:
  name: my-backend-policy
  namespace: team-awesome
spec:
  targetRef:
    group: ""
    kind: Service
    name: super-service
  default:
    balancingMode: CUSTOM_METRICS
    customMetrics:
    - name: gke.cpu
      dryRun: false

    Ten en cuenta lo siguiente:

    • spec.targetRef.kind: Service: Se orienta a un servicio de Kubernetes estándar dentro del mismo clúster.
    • spec.targetRef.kind: ServiceImport: Se orienta a un servicio de otro clúster en una configuración de varios clústeres.
    • balancingMode: CUSTOM_METRICS: Habilita el balanceo de cargas basado en métricas personalizadas.
    • name: gke.cpu: Especifica el uso de CPU como la métrica para la distribución del tráfico.

    Si no se especifica el campo maxUtilizationPercent, el umbral de uso predeterminado es del 80%. El tráfico se reequilibra cuando un backend supera el 80% de uso de CPU.

  2. Aplica el manifiesto de muestra al clúster:

    kubectl apply -f my-backend-policy.yaml

Si basas la distribución del tráfico en el uso de CPU en tiempo real, optimizas automáticamente el rendimiento. Esta acción ayuda a evitar la sobrecarga en los pods individuales.

Consideraciones importantes de dryRun y balancingMode

Cuando configuras GCPBackendPolicy con métricas personalizadas, considera la interacción entre balancingMode y el campo dryRun en tu definición de customMetrics. Esta interacción determina cómo el balanceador de cargas usa tus métricas personalizadas. Para obtener más información sobre las métricas personalizadas y sus restricciones, incluidas las relacionadas con los modos de balanceo, consulta Métricas personalizadas de Cloud Load Balancing.

  • balancingMode: CUSTOM_METRICS

    • Para distribuir el tráfico en función de una métrica personalizada, al menos una métrica personalizada en la lista customMetrics debe tener dryRun establecida en false. Este parámetro de configuración le indica al balanceador de cargas que use esa métrica de forma activa para las decisiones de reequilibrio.
    • Puedes incluir otras métricas personalizadas con dryRun: true junto con métricas que no sean de ejecución de prueba. Esto te permite probar o supervisar métricas nuevas, como el uso de GPU, sin que afecten el tráfico, mientras que otra métrica, como el uso de CPU con dryRun: false, controla el balanceo.
    • Si balancingMode es CUSTOM_METRICS y todas las métricas personalizadas tienen dryRun establecida en true, obtendrás un error. Por ejemplo: gceSync: generic::invalid_argument: Update: Invalid value for field 'resource.backends[0]': '...'. CUSTOM_METRICS BalancingMode requires at least one non-dry-run custom metric. El balanceador de cargas necesita una métrica activa para tomar decisiones.

  • balancingMode es RATE o cualquier otro modo que no sea de métrica personalizada

    • Si el balanceo de cargas se basa en criterios distintos de las métricas personalizadas, como RATE para las solicitudes por segundo, puedes establecer dryRun: true para todas las métricas personalizadas. Esto te permite supervisar las métricas personalizadas sin afectar el mecanismo de balanceo principal. Esto es útil para probar métricas personalizadas nuevas antes de cambiar tu balancingMode a CUSTOM_METRICS.

  • Supervisa métricas personalizadas

    • Después de configurar tu GCPBackendPolicy y comenzar a enviar tráfico a tu aplicación, las métricas personalizadas, como gke.cpu, tardan un tiempo en aparecer en el Explorador de métricas.
    • Para que las métricas personalizadas sean visibles y estén activas en el Explorador de métricas, debe haber tráfico real que fluya a través del backend que supervisa la política. Si no hay tráfico, es posible que la métrica solo sea visible en "Recursos inactivos" en el Explorador de métricas.

Establece un umbral de uso de CPU personalizado

De forma predeterminada, GKE distribuye el tráfico lejos de los backends que superan el 80% de uso de CPU. Sin embargo, ciertas cargas de trabajo pueden tolerar un uso de CPU más alto o más bajo antes de que requieran la redistribución del tráfico. Puedes personalizar este umbral con el campo maxUtilizationPercent en el recurso GCPBackendPolicy.

  1. Para configurar un servicio de GKE de modo que permita que los backends utilicen hasta el 70% de la CPU antes de que se active el reequilibrio, guarda el siguiente manifiesto de muestra como my-backend-policy.yaml:

    kind: GCPBackendPolicy
apiVersion: networking.gke.io/v1
metadata:
  name: my-backend-policy
  namespace: team-awesome
spec:
  targetRef:
    group: ""
    kind: Service
    name: super-service
  default:
    balancingMode: CUSTOM_METRICS
    customMetrics:
    - name: gke.cpu
      maxUtilizationPercent: 70

    Ten en cuenta lo siguiente:

    • El campo maxUtilizationPercent acepta valores de 0 a 100. Un valor de 100 significa que un backend puede usar su capacidad total de CPU antes de que se reequilibre el tráfico.
    • Para las cargas de trabajo sensibles a la latencia que requieren una descarga temprana, usa un umbral más bajo.
    • Para las cargas de trabajo diseñadas para ejecutarse cerca de la capacidad total, usa un umbral más alto.
    • Para los servicios de varios clústeres, spec.targetRef.kind debe ser ServiceImport y group debe ser net.gke.io.

  2. Aplica el manifiesto de muestra al clúster:

    kubectl apply -f my-backend-policy.yaml

Si habilitas un umbral de uso de CPU personalizado, puedes controlar la distribución del tráfico en función del uso de CPU del backend.

(Opcional) Habilita el modo de ejecución de prueba

El modo de ejecución de prueba supervisa el uso de recursos de tus pods sin cambiar la distribución del tráfico. Cuando se habilita el modo de ejecución de prueba, las métricas se exportan a Cloud Monitoring, pero Cloud Load Balancing las ignora y usa el comportamiento predeterminado del balanceo de cargas.

  1. Para habilitar el modo de ejecución de prueba para tu servicio de GKE, guarda el siguiente manifiesto de muestra como my-backend-policy.yaml:

    kind: GCPBackendPolicy
apiVersion: networking.gke.io/v1
metadata:
  name: my-backend-policy
spec:
  targetRef:
    group: ""
    kind: Service
    name: store-v1
  default:
    balancingMode: RATE
    maxRatePerEndpoint: 10
    customMetrics:
    - name: gke.cpu
      dryRun: true

  2. Aplica el manifiesto de muestra al clúster:

    kubectl apply -f my-backend-policy.yaml

Cuando habilitas el modo de ejecución de prueba, sucede lo siguiente:

  • Cloud Load Balancing ignora las métricas de uso de CPU y, en su lugar, usa el comportamiento predeterminado del balanceo de cargas.

  • Las métricas continúan exportándose a Cloud Monitoring en network.googleapis.com/loadbalancer/backend/lb_custom_metrics.

Después de revisar las métricas, quita el campo dryRun de tu GCPBackendPolicy y vuelve a aplicar la configuración. Si se producen problemas después de inhabilitar la ejecución de prueba, vuelve a habilitarla agregando dryRun: true a la política.

Verifica la política

Para confirmar que la GCPBackendPolicy se aplica a tu servicio de GKE y verificar que los controladores de GKE reconocen la política, ejecuta el siguiente comando:

kubectl describe gcpbackendpolicy POLICY_NAME -n NAMESPACE

El resultado es similar a este:

Name:         <your policy name>
Namespace:    <your namespace>
Labels:       <none>
Annotations:  <none>
API Version:  networking.gke.io/v1
Kind:         GCPBackendPolicy
Metadata:
  Creation Timestamp:  ...
  Generation:          1
  Resource Version:    …
  UID:                 …
Spec:
  Default:
    Balancing Mode:  CUSTOM_METRICS
    Custom Metrics:
      Dry Run:  false
      Name:     gke.cpu
  Target Ref:
    Group:
    Kind:   Service
    Name:   super-service
Status:
  Conditions:
    Last Transition Time:  …
    Message:
    Reason:                Attached
    Status:                True
    Type:                  Attached
Events:
…

Configura el balanceo de cargas basado en el uso con las APIs de Compute Engine

Te recomendamos que uses la API de Gateway de Kubernetes para configurar el balanceo de cargas basado en el uso para tus servicios de GKE.

Sin embargo, es posible que prefieras usar las APIs de Compute Engine o Terraform para administrar tus balanceadores de cargas directamente. Si eliges este enfoque, debes habilitar el balanceo de cargas basado en el uso en el nivel de BackendService.

  1. Para un BackendService existente, habilita el balanceo de cargas basado en el uso y adjunta un grupo de extremos de red (NEG), my-lb-neg, ejecutando el siguiente comando:

    gcloud compute backend-services add-backend MY_BACKEND_SERVICE \
  --network-endpoint-group my-lb-neg \
  --network-endpoint-group-zone=asia-southeast1-a \
  --global \
  --balancing-mode=CUSTOM_METRICS \
  --custom-metrics 'name="gke.cpu",maxUtilization=0.8'

    Reemplaza lo siguiente:

    • MY_BACKEND_SERVICE por el nombre de tu BackendService
    • CUSTOM_METRICS por CUSTOM_METRICS

  2. Para actualizar la configuración del balanceo de cargas basado en el uso para una entrada de backend existente en tu BackendService en la que ya está adjunto un NEG, ejecuta el siguiente comando:

    gcloud compute backend-services update-backend MY_BACKEND_SERVICE \
  --network-endpoint-group my-lb-neg \
  --network-endpoint-group-zone=asia-southeast1-a \
  --global \
  --balancing-mode=CUSTOM_METRICS \
  --custom-metrics 'name="gke.cpu",maxUtilization=0.8'

    Reemplaza lo siguiente:

    • MY_BACKEND_SERVICE por el nombre de tu BackendService
    • CUSTOM_METRICS por CUSTOM_METRICS

Inhabilita el balanceo de cargas basado en el uso para un servicio de GKE

Para inhabilitar el balanceo de cargas basado en el uso en tus servicios de GKE, sigue estos pasos:

  1. Si deseas conservar la política para otros parámetros de configuración, quita los campos balancingMode y customMetrics de tu GCPBackendPolicy.
  2. Si ya no necesitas GCPBackendPolicy, puedes borrarla.
  3. Si usas las APIs de Compute Engine, vuelve a cambiar las marcas --balancing-mode y --custom-metrics de tu servicio de backend.

¿Qué sigue?