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 les instances backend de l'équilibreur de charge en fonction des pondérations signalées par une vérification d'état HTTP à l'aide de l'équilibrage de charge pondérée.

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 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 la 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 backend.

Si vous utilisez le même groupe d'instances en tant que backend pour plusieurs équilibreurs de charge réseau basés sur un service de backend qui utilisent l'équilibrage de charge pondérée, 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 la section 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 d'état réussissent et que l'instance backend soit considérée comme opérationnelle. Dans les cas où toutes les instances backend réussissent leurs vérifications d'état et renvoient l'objet 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 répartir les nouvelles connexions entre les backends en mauvais état. Pour en savoir plus, consultez la section Répartition du trafic.

Pour obtenir des exemples d'équilibrage de charge pondérée, consultez la page 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 si certaines connexions durent plus longtemps que d'autres, la répartition de la charge du backend risque d'être inégale. En signalant une pondération par instance plus faible, une instance à charge élevée peut réduire sa part de nouvelles connexions, tout en continuant à gérer les connexions existantes.
Si un backend est surchargé et que l'attribution d'un plus grand nombre de connexions peut interrompre les connexions existantes, ces backends s'attribuent un poids nul. En signalant un poids nul, une instance backend cesse de traiter les nouvelles connexions, mais continue à desservir les connexions existantes.
Si un backend draine des connexions existantes avant la maintenance, il s'attribue un poids égal à zéro. En signalant un poids nul, l'instance backend cesse de traiter les nouvelles connexions, mais elle continue de desservir les connexions existantes.

Points abordés

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

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. généralement, vous ne vous souciez pas de ce que c’est. Dans la plupart des ateliers de programmation, vous devrez référencer l'ID du projet (il est généralement identifié comme PROJECT_ID). Si l'ID généré ne vous convient pas, vous pouvez en générer un autre au hasard. Vous pouvez également essayer la vôtre pour voir si elle est disponible. Il ne peut pas être modifié après cette étape et restera actif pendant toute la durée du projet.
Pour votre information, il existe une troisième valeur, le numéro de projet, utilisé par certaines API. 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 arrêter les ressources afin d'éviter que des frais ne vous soient facturés au-delà de ce tutoriel, vous pouvez supprimer les ressources que vous avez créées ou l'ensemble du projet. 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 à chaque instance. Vous créez une vérification d'état HTTP pour indiquer les pondérations des instances backend. L'équilibreur de charge réseau pondéré est activé sur le service de backend avec la règle d'équilibrage de charge de localité définie sur 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 la gcloud CLI. Vous trouverez des commandes liées à l'équilibrage de charge dans la documentation de référence de l'API et de la gcloud CLI. Si vous n'avez jamais exécuté la Google Cloud CLI, commencez par exécuter 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 localité ni attribuer des pondérations aux instances de VM. Utilisez plutôt Google Cloud CLI.

Créer des règles de réseau VPC, de sous-réseaux et 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éer un réseau et un sous-réseau VPC a. 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 le trafic entrant pour permettre la distribution des paquets envoyés sur les ports TCP de destination 80 et 443 aux 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 backend pour qu'elles renvoient les pondérations dans l'en-tête X-Load-Balancing-Endpoint-Weight avec des réponses HTTP. Pour ce tutoriel, vous allez configurer une instance backend pour qu'elle indique une pondération de zéro, une deuxième instance backend pour qu'elle indique une pondération de 100 et une troisième instance backend pour qu'elle indique 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 allez fournir 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 allez fournir 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 de 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ée.

Créez un service de backend avec la vérification d'état HTTP et définissez la règle d'équilibrage de charge de 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 statique externe 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 FORWARDING_RULE : le 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 d'un backend à 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 la pondération d'un backend (ainsi que son état de fonctionnement) à partir 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