Configurer l'équilibrage de charge pondéré

Ce guide fournit des instructions pour créer un déploiement d'équilibreurs de charge externes pondérés à stratégie directe pour chaque instance de machine virtuelle (VM) à l'aide d'un service de backend régional.

Dans ce tutoriel, vous créez un groupe d'instances avec trois instances de VM et vous attribuez des pondérations à chaque instance. Vous créez une vérification d'état HTTP pour signaler les pondérations des instances backend. L'équilibrage de charge 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'équilibreur de charge réseau externe à stratégie directe 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

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 :

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 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'

Create an instance group

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 et 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éez 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 de 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 : 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 BACKEND_SERVICE_NAME \
  --region=us-central1
```

Le résultat est le suivant :

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