Cette page a été traduite par l'API Cloud Translation.

Équilibrage de charge réseau pondéré par instance

1. Introduction

Vous pouvez configurer un équilibreur de charge réseau pour répartir le trafic entre ses instances backend en fonction des pondérations signalées par une vérification d'état HTTP à l'aide de l'équilibrage de charge pondéré.

L'équilibrage de charge pondéré nécessite la configuration des deux éléments suivants:

Vous devez définir la règle d'équilibrage de charge de la localité (localityLbPolicy) du service de backend sur WEIGHTED_MAGLEV.
Vous devez configurer le service de backend avec une vérification d'état HTTP/HTTP2/HTTPS. Les réponses de vérification d'état HTTP doivent contenir un champ d'en-tête de réponse HTTP personnalisé X-Load-Balancing-Endpoint-Weight pour spécifier les pondérations avec des valeurs entières comprises entre 0 et 1 000 en représentation décimale pour chaque instance de backend.

Si vous utilisez le même groupe d'instances comme backend pour plusieurs équilibreurs de charge réseau basés sur un service de backend utilisant l'équilibrage de charge pondéré, il est recommandé d'utiliser un chemin de requête unique pour chaque vérification d'état du service de backend. Pour en savoir plus, consultez Critères de réussite pour les vérifications d'état HTTP, HTTPS et HTTP/2.

La vérification de l'état HTTP doit renvoyer une réponse HTTP 200 (OK) pour que les vérifications de l'état réussissent et que l'instance de backend soit considérée comme opérationnelle. Dans les cas où toutes les instances de backend réussissent leurs vérifications de l'état et renvoient X-Load-Balancing-Endpoint-Weight avec une pondération nulle, l'équilibreur de charge répartit les nouvelles connexions entre les backends opérationnels, en les traitant avec une pondération égale. L'équilibreur de charge peut également distribuer les nouvelles connexions entre les backends non opérationnels. Pour en savoir plus, consultez Distribution du trafic.

Pour obtenir des exemples d'équilibrage de charge pondéré, consultez Sélection du backend et suivi des connexions.

L'équilibrage de charge pondéré peut être utilisé dans les scénarios suivants:

Si certaines connexions traitent plus de données que d'autres ou que certaines connexions existent plus longtemps que d'autres, la distribution de la charge du backend peut être inégale. En signalant une pondération par instance inférieure, une instance avec une charge élevée peut réduire sa part des nouvelles connexions, tout en conservant les connexions existantes.
Si un backend est surchargé et que l'attribution de connexions supplémentaires peut interrompre les connexions existantes, ces backends s'attribuent zéro pondération. En signalant une pondération nulle, une instance backend cesse de traiter les nouvelles connexions, mais continue à traiter les connexions existantes.
Si un backend draine des connexions existantes avant la maintenance, il s'attribue une pondération nulle. En signalant une pondération nulle, l'instance de backend cesse de traiter les nouvelles connexions, mais continue à traiter les connexions existantes.

Points abordés

Comment configurer un équilibreur de charge réseau pour répartir le trafic entre ses instances backend en fonction des pondérations signalées par une vérification d'état HTTP à l'aide de l'équilibrage de charge pondéré.

Configuration de l'environnement au rythme de chacun

Connectez-vous à la console Google Cloud, puis créez un projet ou réutilisez un projet existant. (Si vous ne possédez pas encore de compte Gmail ou Google Workspace, vous devez en créer un.)

Le nom du projet est le nom à afficher pour les participants au projet. Il s'agit d'une chaîne de caractères non utilisée par les API Google. Vous pouvez le modifier à tout moment.
L'ID du projet est unique parmi tous les projets Google Cloud et non modifiable une fois défini. La console Cloud génère automatiquement une chaîne unique (en général, vous n'y accordez d'importance particulière). Dans la plupart des ateliers de programmation, vous devrez indiquer l'ID du projet (généralement identifié par PROJECT_ID). Si l'ID généré ne vous convient pas, vous pouvez en générer un autre de manière aléatoire. Vous pouvez également en spécifier un et voir s'il est disponible. Après cette étape, l'ID n'est plus modifiable et restera donc le même pour toute la durée du projet.
Pour information, il existe une troisième valeur (le numéro de projet) que certaines API utilisent. Pour en savoir plus sur ces trois valeurs, consultez la documentation.

Vous devez ensuite activer la facturation dans la console Cloud pour utiliser les ressources/API Cloud. L'exécution de cet atelier de programmation est très peu coûteuse, voire sans frais. Pour désactiver les ressources et éviter ainsi que des frais ne vous soient facturés après ce tutoriel, vous pouvez supprimer le projet ou les ressources que vous avez créées. Les nouveaux utilisateurs de Google Cloud peuvent participer au programme d'essai gratuit pour bénéficier d'un crédit de 300 $.

Démarrer Cloud Shell

Bien que Google Cloud puisse être utilisé à distance depuis votre ordinateur portable, nous allons nous servir de Google Cloud Shell pour cet atelier de programmation, un environnement de ligne de commande exécuté dans le cloud.

Dans la console Google Cloud, cliquez sur l'icône Cloud Shell dans la barre d'outils supérieure :

Le provisionnement et la connexion à l'environnement prennent quelques instants seulement. Une fois l'opération terminée, le résultat devrait ressembler à ceci :

Cette machine virtuelle contient tous les outils de développement nécessaires. Elle comprend un répertoire d'accueil persistant de 5 Go et s'exécute sur Google Cloud, ce qui améliore nettement les performances du réseau et l'authentification. Vous pouvez effectuer toutes les tâches de cet atelier de programmation dans un navigateur. Vous n'avez rien à installer.

2. Démarrer la configuration

L'atelier de programmation nécessite un seul projet.

Dans ce tutoriel, vous allez créer un groupe d'instances avec trois instances de VM et attribuer des pondérations à chacune d'elles. Vous créez une vérification d'état HTTP pour signaler les pondérations des instances de backend. L'équilibreur de charge réseau pondéré est activé sur le service de backend avec la règle d'équilibreur de charge de la localité WEIGHTED_MAGLEV.

Avant de commencer

Consultez la présentation de l'équilibrage de charge réseau externe basé sur un service de backend.
Installez Google Cloud CLI. Pour une présentation complète de l'outil, consultez la présentation de gcloud CLI. Vous trouverez des commandes liées à l'équilibrage de charge dans la documentation de référence de l'API et de gcloud CLI. Si vous n'avez pas encore utilisé Google Cloud CLI, exécutez d'abord gcloud init pour vous authentifier.
Activez l'API Compute.

gcloud services enable compute.googleapis.com

Remarque : Vous ne pouvez pas utiliser la console Google Cloud pour configurer la règle d'équilibrage de charge de la zone et attribuer des pondérations aux instances de VM. Utilisez plutôt Google Cloud CLI.

Créer un réseau VPC, des sous-réseaux et des règles de pare-feu

Créez un réseau VPC, un sous-réseau et des règles de pare-feu autorisant les entrées afin d'autoriser les connexions aux VM de backend de votre équilibreur de charge.

Créez un réseau et un sous-réseau VPC : Pour créer le réseau VPC, exécutez la commande gcloud compute networks create .:

gcloud compute networks create NETWORK_NAME --subnet-mode custom

b. Dans cet exemple, la plage d'adresses IPv4 principale du sous-réseau est 10.10.0.0/24.

Pour créer le sous-réseau, exécutez la commande gcloud compute networks subnets create :

gcloud compute networks subnets create SUBNET_NAME \
  --network=NETWORK_NAME \
  --range=10.10.0.0/24 \
  --region=us-central1

Remplacez les éléments suivants :

NETWORK_NAME : nom du réseau VPC à créer.
SUBNET_NAME: nom du sous-réseau à créer.

Créez une règle de pare-feu autorisant les entrées pour autoriser la distribution des paquets envoyés aux ports TCP de destination 80 et 443 vers les VM de backend. Dans cet exemple, la règle de pare-feu autorise les connexions à partir de n'importe quelle adresse IP source. La règle de pare-feu s'applique aux VM avec le tag réseau network-lb-tag. Pour créer la règle de pare-feu, exécutez la commande gcloud compute firewall-rules create :

gcloud compute firewall-rules create FIREWALL_RULE_NAME \
   --direction=INGRESS \
   --priority=1000 \
   --network=NETWORK_NAME \
   --action=ALLOW \
   --rules=tcp:80,tcp:443 \
   --source-ranges=0.0.0.0/0 \
   --target-tags=network-lb-tag

Remplacez FIREWALL_RULE_NAME par le nom de la règle de pare-feu à créer.

Créer des instances de VM et attribuer des pondérations

Créez trois instances de VM et attribuez des pondérations:

Configurez trois instances de VM de backend pour renvoyer les pondérations dans l'en-tête X-Load-Balancing-Endpoint-Weight avec les réponses HTTP. Dans ce tutoriel, vous configurez une instance backend pour indiquer une pondération de zéro, une deuxième instance backend pour signaler une pondération de 100, et une troisième instance backend pour indiquer une pondération de 900. Pour créer les instances, exécutez la commande gcloud compute instances create :

gcloud compute instances create instance-0 \
  --zone=us-central1-a \
  --tags=network-lb-tag \
  --image-family=debian-10 \
  --image-project=debian-cloud \
  --subnet=
SUBNET_NAME
\
  --metadata=load-balancing-weight=0,startup-script='#! /bin/bash
  apt-get update
  apt-get install apache2 -y
  ln -sr /etc/apache2/mods-available/headers.load /etc/apache2/mods-enabled/headers.load
  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
  lb_weight="$(curl -H "Metadata-Flavor:Google" \
  http://169.254.169.254/computeMetadata/v1/instance/attributes/load-balancing-weight)"
  echo "Header set X-Load-Balancing-Endpoint-Weight \"$lb_weight\"" | \
  tee /etc/apache2/conf-enabled/headers.conf
  systemctl restart apache2'

gcloud compute instances create instance-100 \
  --zone=us-central1-a \
  --tags=network-lb-tag \
  --image-family=debian-10 \
  --image-project=debian-cloud \
  --subnet=SUBNET_NAME \
  --metadata=load-balancing-weight=100,startup-script='#! /bin/bash
  apt-get update
  apt-get install apache2 -y
  ln -sr /etc/apache2/mods-available/headers.load /etc/apache2/mods-enabled/headers.load
  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
  lb_weight="$(curl -H "Metadata-Flavor:Google" \
  http://169.254.169.254/computeMetadata/v1/instance/attributes/load-balancing-weight)"
  echo "Header set X-Load-Balancing-Endpoint-Weight \"$lb_weight\"" | \
  tee /etc/apache2/conf-enabled/headers.conf
  systemctl restart apache2'

gcloud compute instances create instance-900 \
  --zone=us-central1-a \
  --tags=network-lb-tag \
  --image-family=debian-10 \
  --image-project=debian-cloud \
  --subnet=
SUBNET_NAME
\
  --metadata=load-balancing-weight=900,startup-script='#! /bin/bash
    apt-get update
    apt-get install apache2 -y
    ln -sr /etc/apache2/mods-available/headers.load /etc/apache2/mods-enabled/headers.load
    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
    lb_weight="$(curl -H "Metadata-Flavor:Google" \
    http://169.254.169.254/computeMetadata/v1/instance/attributes/load-balancing-weight)"
    echo "Header set X-Load-Balancing-Endpoint-Weight \"$lb_weight\"" | \
    tee /etc/apache2/conf-enabled/headers.conf
    systemctl restart apache2'

Créer un groupe d'instances

Dans ce tutoriel, vous fournissez des instructions pour créer un groupe d'instances non géré contenant les trois instances de VM(instance-0, instance-100, and instance-900).

Pour créer le groupe d'instances, exécutez la commande gcloud compute instance-groups unmanaged create :

gcloud compute instance-groups unmanaged create
INSTANCE_GROUP --zone=us-central1-a

gcloud compute instance-groups unmanaged add-instances INSTANCE_GROUP \
  --zone=us-central1-a \
  --instances=instance-0,instance-100,instance-900

Remplacez INSTANCE_GROUP par le nom du groupe d'instances à créer.

Créer une vérification d'état HTTP

Dans ce tutoriel, vous fournissez des instructions pour créer une vérification d'état HTTP afin de lire la réponse HTTP contenant la pondération de la VM backend."

Pour créer la vérification d'état HTTP, exécutez la commande gcloud compute health-checks create :

gcloud compute health-checks create http HTTP_HEALTH_CHECK_NAME \
  --region=us-central1

Remplacez HTTP_HEALTH_CHECK_NAME par le nom de la vérification d'état HTTP à créer.

Créer un service backend

L'exemple suivant fournit des instructions pour créer un service de backend externe régional configuré pour utiliser l'équilibrage de charge pondéré.

Créez un service de backend avec la vérification d'état HTTP et définissez la règle d'équilibrage de charge de la localité sur WEIGHTED_MAGLEV.

Pour créer le service de backend, exécutez la commande gcloud compute backend-services create :

gcloud compute backend-services create BACKEND_SERVICE_NAME \
  --load-balancing-scheme=external \
  --protocol=tcp \
  --region=us-central1 \
  --health-checks=HTTP_HEALTH_CHECK_NAME \
  --health-checks-region=us-central1 \
  --locality-lb-policy=WEIGHTED_MAGLEV

Remplacez BACKEND_SERVICE_NAME par le nom du service de backend à créer.

Ajoutez le groupe d'instances backend au service de backend.

Pour ajouter le groupe d'instances, exécutez la commande gcloud compute backend-services add-backend :

gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
  --instance-group=INSTANCE_GROUP \
  --instance-group-zone=us-central1-a \
  --region=us-central1

Réservez une adresse IP externe régionale pour l'équilibreur de charge.

Pour réserver une ou plusieurs adresses IP, exécutez la commande gcloud compute addresses create :

gcloud compute addresses create ADDRESS_NAME \
 --region us-central1

Remplacez ADDRESS_NAME par le nom de l'adresse IP à créer. Utilisez la commande compute addresses describe pour afficher le résultat. Notez l'adresse IP externe statique réservée (IP_ADDRESS').

gcloud compute addresses describe ADDRESS_NAME

Créez une règle de transfert à l'aide de l'adresse IP externe régionale réservée "IP_ADDRESS". Connectez la règle de transfert au service de backend.

Pour créer la règle de transfert, exécutez la commande gcloud compute forwarding-rules create :

gcloud compute forwarding-rules create FORWARDING_RULE \
  --region=us-central1 \
  --ports=80 \
  --address=IP_ADDRESS \
  --backend-service=BACKEND_SERVICE_NAME

Remplacez les éléments suivants : FORWARDING_RULE : nom de la règle de transfert à créer. IP_ADDRESS: est l'adresse IP à attribuer à l'instance. Utilisez l'adresse IP externe statique réservée plutôt que le nom d'adresse.

Vérifier les pondérations des backends à l'aide de l'API du service de backend

Vérifiez que les pondérations du backend sont correctement signalées à la vérification d'état HTTP.

Pour obtenir les pondérations du backend (ainsi que l'état de fonctionnement) d'un service de backend, exécutez la commande gcloud compute backend-services get-health :

gcloud compute backend-services get-health HTTP_HEALTH_CHECK_NAME \
  --region=us-central1

Le résultat doit se présenter comme suit :

backend: https://www.googleapis.com/compute/projects/project-name/{project}/zones/us-central1-a/instanceGroups/{instance-group-name}
status:
  healthStatus:
  - forwardingRule: https://www.googleapis.com/compute/projects/{project}/regions/us-central1/forwardingRules/{firewall-rule-name}
    forwardingRuleIp: 34.135.46.66
    healthState: HEALTHY
    instance: https://www.googleapis.com/compute/projects/{project}/zones/us-central1-a/instances/instance-0
    ipAddress: 10.10.0.5
    port: 80
    weight: '0'
  - forwardingRule: https://www.googleapis.com/compute/projects/{project}/regions/us-central1/forwardingRules/{firewall-rule-name}
    forwardingRuleIp: 34.135.46.66
    healthState: HEALTHY
    instance: https://www.googleapis.com/compute/projects/{project}/zones/us-central1-a/instances/instance-100
    ipAddress: 10.10.0.6
    port: 80
    weight: '100'
  - forwardingRule: https://www.googleapis.com/compute/projects/{project}/regions/us-central1/forwardingRules/{firewall-rule-name}
    forwardingRuleIp: 34.135.46.66
    healthState: HEALTHY
    instance: https://www.googleapis.com/compute/projects/{project}/zones/us-central1-a/instances/instance-900
    ipAddress: 10.10.0.7
    port: 80
    weight: '900'
  kind: compute#backendServiceGroupHealth