Configurer l'équilibrage de charge basé sur l'utilisation pour les services GKE

Cette page explique comment configurer l'équilibrage de charge basé sur l'utilisation pour les services GKE. Cette page s'adresse aux équipes d'infrastructure et d'applications, ainsi qu'aux administrateurs GKE chargés de configurer et de gérer la distribution du trafic pour leurs services GKE.

Vous pouvez utiliser des équilibreurs de charge basés sur l'utilisation pour optimiser les performances et la disponibilité des applications en distribuant intelligemment le trafic en fonction de l'utilisation des ressources en temps réel de vos pods GKE.

Avant de lire cette page, assurez-vous de bien connaître l'équilibrage de charge basé sur l'utilisation pour les services GKE et de comprendre son fonctionnement.

Tarifs

L'équilibrage de charge basé sur l'utilisation est une fonctionnalité de GKE Gateway disponible sans frais supplémentaires. Les tarifs de Cloud Load Balancing et de GKE continuent de s'appliquer.

Quotas

L'équilibrage de charge basé sur l'utilisation n'introduit aucun nouveau quota, mais tous les quotas de Cloud Load Balancing et des autres services dépendants s'appliquent toujours.

Avant de commencer

Avant de commencer, effectuez les tâches suivantes :

  • Activez l'API Google Kubernetes Engine.
    • Activer l'API Google Kubernetes Engine
  • Si vous souhaitez utiliser Google Cloud CLI pour cette tâche, installez puis initialisez gcloud CLI. Si vous avez déjà installé gcloud CLI, assurez-vous de disposer de la dernière version en exécutant la commande gcloud components update.

Conditions requises pour le contrôleur GKE Gateway

L'équilibrage de charge basé sur l'utilisation pour les services GKE nécessite les éléments suivants :

L'équilibrage de charge basé sur l'utilisation pour les services GKE est compatible avec les éléments suivants :

  • Services GKE mono et multiclusters qui servent de backends à un équilibreur de charge géré par Google Cloud.
  • Toutes les éditions GKE (Standard, Autopilot et Enterprise).
  • Tous les équilibreurs de charge d'application, à l'exception des équilibreurs de charge d'application classiques. Google Cloud

Limites

L'équilibrage de charge basé sur l'utilisation pour les services GKE présente les limites suivantes.

  • La seule métrique d'utilisation des ressources acceptée est celle du processeur.
  • Les équilibreurs de charge réseau passthrough ou proxy ne sont pas compatibles.
  • Seule l'API Gateway est compatible. Les API Service et Ingress ne le sont pas.
  • L'équilibrage de charge basé sur l'utilisation ne fonctionne pas bien si votre trafic est très irrégulier. Le rééquilibrage du trafic prend jusqu'à 30 secondes lorsque les pods atteignent leur utilisation maximale. Le signal d'utilisation devrait augmenter avec le trafic entrant, mais ce délai signifie que l'équilibrage de charge basé sur l'utilisation a besoin de temps pour s'adapter. Pour des performances optimales, l'équilibrage de charge basé sur l'utilisation fonctionne mieux dans les environnements où le trafic est fluide et prévisible.
  • Les clusters à double pile (clusters avec une adresse IPv4 et une adresse IPv6) ne sont pas acceptés.
  • L'équilibrage de charge basé sur l'utilisation peut prendre jusqu'à 30 secondes pour mettre à jour et ajuster la répartition du trafic après des modifications de configuration, comme la modification ou la suppression du champ dryRun dans un GCPBackendPolicy. Ce délai est un comportement connu à l'échelle du système. Cette fonctionnalité est donc particulièrement adaptée aux applications dont les modèles de trafic sont relativement stables et qui peuvent tolérer cette latence de mise à jour.

Par défaut, l'équilibrage de charge basé sur l'utilisation est désactivé pour vos services GKE. Vous devez l'activer explicitement. Si vous ne définissez pas de seuil d'utilisation maximal, le système utilise par défaut 80 % d'utilisation par point de terminaison.

Lorsque vous configurez l'équilibrage de charge basé sur l'utilisation, votre objectif est d'optimiser la répartition du trafic afin que les pods de backend puissent gérer efficacement leur charge de travail, ce qui améliore les performances des applications et l'utilisation des ressources.

Activer l'équilibrage de charge basé sur l'utilisation et le profil HPA de performances

Avant de configurer l'équilibrage de charge basé sur l'utilisation, assurez-vous que votre cluster GKE est compatible avec les fonctionnalités requises. L'équilibrage de charge basé sur l'utilisation utilise des métriques personnalisées, comme le processeur, pour prendre des décisions de routage plus intelligentes. Ces décisions dépendent des éléments suivants :

  • L'API Gateway, qui permet d'appliquer des règles au niveau du service via GCPBackendPolicy.
  • Le profil HPA "Performances", qui permet aux charges de travail de s'adapter plus rapidement et de manière plus agressive en utilisant les signaux du processeur.

Activer l'API Gateway et le profil HPA des performances

Autopilot

L'API Gateway et le profil HPA de performances sont disponibles par défaut dans un cluster Autopilot.

Standard

Pour créer un cluster standard avec le profil HPA "Performances" et l'API Gateway activée, exécutez la commande suivante :

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

Remplacez les éléments suivants :

  • Remplacez CLUSTER_NAME par le nom de votre nouveau cluster.
  • LOCATION par la région ou la zone Compute Engine de votre cluster.
  • PROJECT_ID par votre ID de projet.
  • CLUSTER_VERSION avec la version de GKE, qui doit être 1.33.1-gke.1918000 ou ultérieure.

Pour activer le profil HPA "Performance" et l'API Gateway dans un cluster GKE Standard existant, utilisez la commande suivante :

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

Remplacez les éléments suivants :

Pour en savoir plus sur le profil HPA "Performances", consultez Configurer le profil HPA "Performances".

Configurer l'équilibrage de charge basé sur l'utilisation

Une fois votre cluster prêt, définissez une règle qui indique comment le trafic est acheminé en fonction de l'utilisation du backend. Vous devez utiliser l'API Kubernetes Gateway via GCPBackendPolicy pour la configuration.

Prérequis

Avant de configurer l'équilibrage de charge basé sur l'utilisation à l'aide de l'API Gateway, assurez-vous que votre cluster GKE répond aux exigences suivantes :

  1. Déployez une application : assurez-vous de déployer une application Kubernetes à l'aide d'une ressource de déploiement. Pour en savoir plus, consultez Déployer une application sur un cluster GKE.

    Par exemple, un fichier manifeste de déploiement type peut inclure une section de ressources comme celle-ci :

    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. Exposez l'application à l'aide d'un service : vous devez exposer l'application à l'aide d'un service Kubernetes. Pour en savoir plus sur le fonctionnement des services et sur leur configuration, consultez Comprendre les services Kubernetes.

  3. Utilisez un équilibreur de charge d'application basé sur l'API Gateway : exposez le service à l'aide d'un équilibreur de charge d'application géré par GKE et configuré via l'API Gateway. Pour en savoir plus, consultez Déployer des passerelles.

Créer un GCPBackendPolicy pour l'équilibrage de charge basé sur le processeur

Cette configuration permet à GKE de distribuer le trafic de manière dynamique en fonction de l'utilisation du processeur en temps réel de chaque pod de backend.

Pour activer l'équilibrage de charge basé sur l'utilisation pour les services GKE, utilisez la ressource personnalisée GCPBackendPolicy de l'API Kubernetes Gateway.

La ressource personnalisée GCPBackendPolicy vous permet de définir de manière déclarative le comportement d'équilibrage de charge dans votre cluster Kubernetes. En spécifiant des métriques d'utilisation du processeur, vous contrôlez la façon dont le trafic est réparti entre les backends en fonction de leur utilisation actuelle des ressources. Cette approche permet de maintenir les performances de l'application, d'empêcher la surcharge des pods individuels et d'améliorer la fiabilité et l'expérience utilisateur de l'application.

  1. Enregistrez l'exemple de fichier manifeste suivant sous le nom 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

    Veuillez noter les points suivants :

    • spec.targetRef.kind: Service : cible un service Kubernetes standard au sein du même cluster.
    • spec.targetRef.kind: ServiceImport : cible un service d'un autre cluster dans une configuration multicluster.
    • balancingMode: CUSTOM_METRICS : permet l'équilibrage de charge basé sur des métriques personnalisées.
    • name: gke.cpu : spécifie l'utilisation du processeur comme métrique pour la distribution du trafic.

    Si le champ maxUtilizationPercent n'est pas spécifié, le seuil d'utilisation par défaut est de 80 %. Le trafic est rééquilibré lorsqu'un backend dépasse 80 % d'utilisation du processeur.

  2. Appliquez l'exemple de fichier manifeste à votre cluster :

    kubectl apply -f my-backend-policy.yaml

En basant la distribution du trafic sur l'utilisation du processeur en temps réel, vous optimisez automatiquement les performances. Cette action permet d'éviter la surcharge des pods individuels.

Remarques importantes sur dryRun et balancingMode

Lorsque vous configurez GCPBackendPolicy avec des métriques personnalisées, tenez compte de l'interaction entre balancingMode et le champ dryRun dans la définition de votre customMetrics. Cette interaction détermine la façon dont l'équilibreur de charge utilise vos métriques personnalisées. Pour en savoir plus sur les métriques personnalisées et leurs restrictions, y compris celles liées aux modes d'équilibrage, consultez Métriques personnalisées Cloud Load Balancing.

  • balancingMode: CUSTOM_METRICS

    • Pour distribuer le trafic en fonction d'une métrique personnalisée, au moins une métrique personnalisée de la liste customMetrics doit avoir la valeur dryRun définie sur false. Ce paramètre indique à l'équilibreur de charge d'utiliser activement cette métrique pour les décisions de rééquilibrage.
    • Vous pouvez inclure d'autres métriques personnalisées avec dryRun: true, ainsi que des métriques non liées aux tests. Cela vous permet de tester ou de surveiller de nouvelles métriques, telles que l'utilisation du GPU, sans qu'elles n'affectent le trafic, tandis qu'une autre métrique, telle que l'utilisation du processeur avec dryRun: false, contrôle l'équilibrage.
    • Si balancingMode est défini sur CUSTOM_METRICS et que toutes les métriques personnalisées ont dryRun défini sur true, une erreur s'affiche. Par exemple : gceSync: generic::invalid_argument: Update: Invalid value for field 'resource.backends[0]': '...'. CUSTOM_METRICS BalancingMode requires at least one non-dry-run custom metric. L'équilibreur de charge a besoin d'une métrique active pour prendre des décisions.

  • balancingMode est défini sur RATE ou sur d'autres modes non liés aux métriques personnalisées

    • Si l'équilibrage de charge est basé sur des critères autres que les métriques personnalisées, comme RATE pour les requêtes par seconde, vous pouvez définir dryRun: true pour toutes les métriques personnalisées. Cela vous permet de surveiller les métriques personnalisées sans affecter le mécanisme d'équilibrage principal. Cela est utile pour tester de nouvelles métriques personnalisées avant de passer de balancingMode à CUSTOM_METRICS.

  • Surveiller les métriques personnalisées

    • Après avoir configuré votre GCPBackendPolicy et commencé à envoyer du trafic vers votre application, il faut un certain temps pour que les métriques personnalisées, telles que gke.cpu, s'affichent dans l'explorateur de métriques.
    • Pour que les métriques personnalisées soient visibles et actives dans l'explorateur de métriques, le backend que la règle surveille doit enregistrer du trafic. S'il n'y a pas de trafic, la métrique ne sera peut-être visible que sous "Ressources inactives" dans l'explorateur de métriques.

Définir un seuil d'utilisation du processeur personnalisé

Par défaut, GKE répartit le trafic loin des backends qui dépassent 80 % d'utilisation du processeur. Toutefois, certaines charges de travail peuvent tolérer une utilisation du processeur plus ou moins élevée avant de nécessiter une redistribution du trafic. Vous pouvez personnaliser ce seuil à l'aide du champ maxUtilizationPercent dans la ressource GCPBackendPolicy.

  1. Pour configurer un service GKE afin qu'il autorise les backends à utiliser jusqu'à 70 % de processeur avant le déclenchement du rééquilibrage, enregistrez l'exemple de fichier manifeste suivant sous le nom 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

    Veuillez noter les points suivants :

    • Le champ maxUtilizationPercent accepte les valeurs comprises entre 0 et 100. Une valeur de 100 signifie qu'un backend peut utiliser toute sa capacité de processeur avant que le trafic ne soit rééquilibré.
    • Pour les charges de travail sensibles à la latence qui nécessitent un déchargement précoce, utilisez un seuil inférieur.
    • Pour les charges de travail conçues pour s'exécuter à pleine capacité, utilisez un seuil plus élevé.
    • Pour les services multiclusters, spec.targetRef.kind doit être défini sur ServiceImport et group sur net.gke.io.

  2. Appliquez l'exemple de fichier manifeste à votre cluster :

    kubectl apply -f my-backend-policy.yaml

En activant un seuil d'utilisation du processeur personnalisé, vous pouvez contrôler la distribution du trafic en fonction de l'utilisation du processeur du backend.

(Facultatif) Activer le mode de simulation

Le mode simulation surveille l'utilisation des ressources de vos pods sans modifier la distribution du trafic. Lorsque le mode de simulation est activé, les métriques sont exportées vers Cloud Monitoring, mais Cloud Load Balancing les ignore et utilise le comportement d'équilibrage de charge par défaut.

  1. Pour activer le mode de simulation pour votre service GKE, enregistrez l'exemple de fichier manifeste suivant sous le nom 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. Appliquez l'exemple de fichier manifeste à votre cluster :

    kubectl apply -f my-backend-policy.yaml

Lorsque vous activez le mode de simulation, voici ce qui se produit :

  • Cloud Load Balancing ignore les métriques d'utilisation du processeur et utilise à la place le comportement d'équilibrage de charge par défaut.

  • Les métriques continuent d'être exportées vers Cloud Monitoring sous network.googleapis.com/loadbalancer/backend/lb_custom_metrics.

Après avoir examiné les métriques, supprimez le champ dryRun de votre GCPBackendPolicy et réappliquez la configuration. Si des problèmes surviennent après la désactivation du test à blanc, réactivez-le en ajoutant dryRun: true à la règle.

Valider la règle

Pour vérifier que GCPBackendPolicy est appliqué à votre service GKE et que les contrôleurs GKE reconnaissent la règle, exécutez la commande suivante :

kubectl describe gcpbackendpolicy POLICY_NAME -n NAMESPACE

Le résultat ressemble à ce qui suit :

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:
…

Configurer l'équilibrage de charge basé sur l'utilisation à l'aide des API Compute Engine

Nous vous recommandons d'utiliser l'API Kubernetes Gateway pour configurer l'équilibrage de charge basé sur l'utilisation pour vos services GKE.

Toutefois, vous préférerez peut-être utiliser les API Compute Engine ou Terraform pour gérer directement vos équilibreurs de charge. Si vous choisissez cette approche, vous devez activer l'équilibrage de charge basé sur l'utilisation au niveau BackendService.

  1. Pour un BackendService existant, activez l'équilibrage de charge basé sur l'utilisation et associez un groupe de points de terminaison du réseau (NEG), my-lb-neg, en exécutant la commande suivante :

    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'

    Remplacez les éléments suivants :

    • Remplacez MY_BACKEND_SERVICE par le nom de votre BackendService.
    • CUSTOM_METRICS correspond à CUSTOM_METRICS.

  2. Pour mettre à jour les paramètres d'équilibrage de charge basé sur l'utilisation pour une entrée de backend existante sur votre BackendService à laquelle un NEG est déjà associé, exécutez la commande suivante :

    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'

    Remplacez les éléments suivants :

    • Remplacez MY_BACKEND_SERVICE par le nom de votre BackendService.
    • CUSTOM_METRICS correspond à CUSTOM_METRICS.

Désactiver l'équilibrage de charge basé sur l'utilisation pour un service GKE

Pour désactiver l'équilibrage de charge basé sur l'utilisation sur vos services GKE, procédez comme suit :

  1. Si vous souhaitez conserver la règle pour d'autres paramètres, supprimez les champs balancingMode et customMetrics de votre GCPBackendPolicy.
  2. Si vous n'avez plus besoin de GCPBackendPolicy, vous pouvez le supprimer.
  3. Si vous utilisez les API Compute Engine, rétablissez les indicateurs --balancing-mode et --custom-metrics de votre service de backend.

Étapes suivantes