Utiliser l'équilibrage de charge pour les applications à disponibilité élevée

Ce tutoriel explique comment utiliser l'équilibrage de charge avec un groupe d'instances géré régional pour détourner le trafic des instances de VM occupées ou indisponibles, ce qui permet de fournir une haute disponibilité même pendant une panne de zone.

Un groupe d'instances géré régional distribue une application sur plusieurs instances dans plusieurs zones. Un équilibreur de charge global dirige le trafic sur plusieurs régions via une adresse IP unique. En utilisant ces deux services pour distribuer votre application sur plusieurs zones, vous vous assurez que votre application est disponible même dans des cas extrêmes, comme lors d'une interruption de zone.

Les équilibreurs de charge peuvent être utilisés pour diriger divers types de trafic. Ce tutoriel explique comment créer un équilibreur de charge global qui dirige le trafic HTTP externe. La majeure partie de son contenu reste toutefois pertinente pour les autres types d'équilibreurs de charge. Pour en savoir plus sur les autres types de trafic pouvant être dirigés avec un équilibreur de charge, consultez la section sur les types d'équilibrage de charge cloud.

Ce tutoriel comprend des étapes détaillées sur le lancement d'une application Web sur un groupe d'instances géré régional, la configuration de l'accès au réseau, la création d'un équilibreur de charge pour diriger le trafic vers l'application Web et l'observation de l'équilibreur de charge en simulant une panne de zone. En fonction de vos connaissances sur ces fonctionnalités, il vous faudra environ 45 minutes pour terminer ce tutoriel.

Architecture de l'application

L'application inclut les composants Compute Engine ci-dessous.

  • Réseau VPC : réseau virtuel au sein de Google Cloud pouvant fournir une connectivité globale à l'aide de ses propres routes et règles de pare-feu.
  • Règle de pare-feu : un pare-feu Google Cloudvous permet d'autoriser ou de refuser le trafic vers vos instances.
  • Modèle d'instance : modèle utilisé pour créer chaque instance de VM dans le groupe d'instances géré.
  • Groupe d'instances géré régional : groupe d'instances de VM exécutant la même application sur plusieurs zones.
  • Adresse IP externe statique globale : adresse IP statique accessible sur des réseaux externes et pouvant être associée à une ressource globale.
  • Équilibreur de charge global : un équilibreur de charge qui permet de répartir les instances backend sur plusieurs régions. Utilisez l'équilibrage de charge global lorsque vos utilisateurs doivent accéder aux mêmes applications et contenus, et que vous souhaitez fournir un accès via une seule adresse IP Anycast.
  • Vérification d'état : règles utilisées par l'équilibreur de charge pour évaluer la réactivité de l'application sur chaque instance de VM.

Lancer l'application Web

Ce tutoriel utilise une application Web stockée sur GitHub. Si vous souhaitez en savoir plus sur la mise en œuvre de l'application, consultez le dépôt GoogleCloudPlatform/python-docs-samples sur GitHub.

Lancez l'application Web sur chaque VM d'un groupe d'instances en incluant un script de démarrage dans un modèle d'instance. Exécutez également le groupe d'instances dans un réseau VPC dédié pour empêcher les règles de pare-feu de ce tutoriel d'interférer avec les ressources existantes de votre projet.

Créer un réseau VPC

L'utilisation d'un réseau VPC empêche les ressources existantes de votre projet d'être affectées par les ressources que vous allez créer pour ce tutoriel. Un réseau VPC est également nécessaire pour limiter le trafic entrant afin qu'il passe obligatoirement par l'équilibreur de charge.

Créez un réseau VPC afin d'encapsuler les règles de pare-feu pour l'application Web de démonstration. Procédez comme suit :

  1. Dans la console Google Cloud , accédez à la page Réseaux VPC.

    Accéder aux réseaux VPC

  2. Cliquez sur Créer un réseau VPC.

  3. Dans le champ Nom, saisissez web-app-vpc.

  4. Définissez le Mode de création du sous-réseau sur Personnalisé.

  5. Créez un sous-réseau :

    1. Dans la section Sous-réseaux, définissez le champ Nom sur web-app-vpc-subnet.
    2. Dans le menu déroulant Région, sélectionnez us-central1.
    3. Assurez-vous que l'option Type de pile d'adresses IP est définie sur IPv4.
    4. Dans la section Plage IPv4 principale, saisissez la plage IPv4 10.2.0.0/24.

  6. Au bas de la page, cliquez sur Créer.

Attendez que le réseau VPC soit créé avant de continuer.

Créer une règle de pare-feu

Une fois le réseau VPC créé, configurez une règle de pare-feu pour autoriser le trafic HTTP vers le réseau VPC.

  1. Dans la console Google Cloud , accédez à la page Pare-feu.

    Accéder à la page Pare-feu

  2. Cliquez sur Créer une règle de pare-feu.

  3. Dans le champ Nom, saisissez allow-web-app-http.

  4. Définissez le paramètre Réseau sur web-app-vpc.

  5. Assurez-vous que les options suivantes sont définies comme indiqué :

    • L'option Sens du trafic est définie sur Entrée.
    • L'option Action en cas de correspondance est définie sur Autoriser.

  6. Dans le menu déroulant Cibles, sélectionnez Toutes les instances du réseau.

  7. Définissez Filtre source sur IPv4 ranges.

  8. Dans le champ Plages d'adresses IP sources, saisissez 130.211.0.0/22, 35.191.0.0/16 pour autoriser les vérifications d'état de l'équilibreur de charge.

  9. Sous Protocoles et ports, procédez comme suit :

    1. Sélectionnez Protocoles et ports spécifiés.
    2. Sélectionnez TCP.
    3. Dans le champ Ports, saisissez 80 pour autoriser l'accès du trafic HTTP.

  10. Cliquez sur Créer.

Créer un modèle d'instance

Créez un modèle que vous utiliserez pour créer un groupe d'instances de VM. Chaque instance créée à partir du modèle lance une application Web de démonstration à l'aide d'un script de démarrage.

  1. Dans la Google Cloud console, accédez à la page Modèles d'instances.

    Accéder à la page Modèles d'instances

  2. Cliquez sur Create instance template (Créer un modèle d'instance).

  3. Dans le champ Nom, saisissez load-balancing-web-app-template.

  4. Sous Configuration de la machine, définissez le type de machine sur e2-medium.

  5. Cliquez sur la section Options avancées pour la développer.

  6. Cliquez sur la section Mise en réseau, puis procédez comme suit :

    1. Dans la section Interfaces réseau, supprimez les interfaces réseau existantes en cliquant sur l'icône  à côté de chacune d'elles.
    2. Cliquez sur Ajouter une interface réseau, puis sélectionnez le réseau web-app-vpc. Cela force chaque instance créée avec ce modèle à s'exécuter sur le réseau créé précédemment.
    3. Dans le menu déroulant Sous-réseau, sélectionnez web-app-vpc-subnet.
    4. Cliquez sur OK.

  7. Cliquez sur la section Gestion, puis procédez comme suit :

    1. Dans le champ Automatisation, saisissez le script de démarrage suivant :

      apt-get update
apt-get -y install git python3-pip python3-venv
git clone https://github.com/GoogleCloudPlatform/python-docs-samples.git
python3 -m venv venv
./venv/bin/pip3 install -Ur ./python-docs-samples/compute/managed-instances/demo/requirements.txt
./venv/bin/pip3 install gunicorn
./venv/bin/gunicorn --bind 0.0.0.0:80 app:app --daemon --chdir ./python-docs-samples/compute/managed-instances/demo

      Le script récupère, installe et lance l'application Web au démarrage d'une instance de VM.

  8. Conservez les valeurs par défaut des autres options.

  9. Cliquez sur Créer.

Attendez que le modèle soit créé avant de continuer.

Créer un groupe d'instances géré régional

Pour exécuter l'application Web, utilisez le modèle d'instance pour créer un groupe d'instances géré régional. Procédez comme suit :

  1. Dans la console Google Cloud , accédez à la page Groupes d'instances.

    Accéder à la page Groupes d'instances

  2. Cliquez sur Créer un groupe d'instances.

  3. Dans le champ Nom, saisissez load-balancing-web-app-group.

  4. Pour Modèle d'instance, sélectionnez load-balancing-web-app-template.

  5. Définissez Nombre d'instances sur 6. Si ce champ est désactivé, désactivez d'abord l'autoscaling.

    Pour désactiver l'autoscaling, accédez à la section Autoscaling. Dans le menu déroulant Mode autoscaling, sélectionnez Désactivé : ne pas effectuer d'autoscaling.

  6. Pour Emplacement, sélectionnez Plusieurs zones.

  7. Dans le champ Region (Région), sélectionnez us-central1.

  8. Pour Zones, sélectionnez les zones suivantes dans la liste déroulante :

    • us-central1-b
    • us-central1-c
    • us-central1-f

  9. Conservez les valeurs par défaut des autres options.

  10. Cliquez sur Créer. Cela vous redirige vers la page Groupes d'instances.

    Il peut s'écouler quelques minutes avant que toutes les instances du groupe soient en cours d'exécution.

Configurer l'équilibreur de charge

Pour utiliser un équilibreur de charge afin de diriger le trafic sur votre application Web, vous devez réserver une adresse IP externe pour la réception de tout le trafic entrant. Créez ensuite un équilibreur de charge qui accepte le trafic de cette adresse IP et le redirige vers le groupe d'instances.

Réserver une adresse IP statique

Utilisez une adresse IP externe statique globale pour fournir à l'équilibreur de charge un point d'entrée unique pour recevoir tout le trafic des utilisateurs. Compute Engine conserve les adresses IP statiques même si vous modifiez ou supprimez des ressources Google Cloud affiliées. Cela permet à l'application Web d'avoir toujours le même point d'entrée, même si d'autres parties de l'application Web changent.

  1. Dans la console Google Cloud , accédez à la page Adresses IP.

    Accéder à la page "Adresses IP"

  2. Cliquez sur Réserver une adresse IP statique externe.

  3. Dans le champ Nom, saisissez web-app-ipv4.

  4. Définissez Version IP sur IPv4.

  5. Définissez Type sur Global.

  6. Cliquez sur Réserver.

Créer un équilibreur de charge

Cette section explique les étapes requises pour créer un équilibreur de charge global qui dirige le trafic HTTP.

Cet équilibreur de charge utilise une interface pour recevoir le trafic entrant et un backend pour le distribuer aux instances opérationnelles. Étant donné que l'équilibreur de charge comporte plusieurs composants, cette tâche est divisée en cinq parties :

  • Sélectionner le type d'équilibreur de charge
  • Attribuer un nom à l'équilibreur de charge
  • Configurer l'interface
  • Configurer le backend
  • Vérifier et finaliser

Effectuez toutes les étapes pour créer l'équilibreur de charge.

Sélectionner le type d'équilibreur de charge

  1. Dans la console Google Cloud , accédez à la page Équilibrage de charge.

    Accéder à la page Équilibrage de charge

  2. Cliquez sur Créer un équilibreur de charge.
  3. Pour Type d'équilibreur de charge, sélectionnez Équilibreur de charge d'application (HTTP/HTTPS), puis cliquez sur Suivant.
  4. Pour Public ou interne, sélectionnez Public (externe), puis cliquez sur Suivant.
  5. Pour Déploiement mondial ou dans une seule région, sélectionnez Recommandé pour les charges de travail à l'échelle mondiale, puis cliquez sur Suivant.
  6. Pour Génération de l'équilibreur de charge, sélectionnez Équilibreur de charge d'application externe global, puis cliquez sur Suivant.
  7. Cliquez sur Configurer.

Attribuer un nom à l'équilibreur de charge

  1. Dans le panneau de gauche, saisissez web-app-load-balancer dans le champ Nom de l'équilibreur de charge.

Configurer l'interface

  1. Sur la page Configuration du frontend, sous Nom, saisissez web-app-ipv4-frontend.
  2. Définissez le paramètre Protocole sur HTTP.
  3. Définissez le paramètre Version IP sur IPv4.
  4. Définissez l'adresse IP sur web-app-ipv4.
  5. Définissez le paramètre Port sur 80.
  6. Cliquez sur Terminé pour créer l'interface.

Configurer le backend

  1. Dans le panneau de gauche, cliquez sur Configuration du backend.
  2. Cliquez sur le menu déroulant Services de backend et buckets backend, puis sur Créer un service de backend.
  3. Dans la nouvelle fenêtre, pour le nom du service de backend, saisissez web-app-backend.
  4. Dans la section Backends, procédez comme suit :
    1. Définissez le paramètre Groupe d'instances sur load-balancing-web-app-group.
    2. Définissez le paramètre Numéros de ports sur 80. Cela autorise le trafic HTTP entre l'équilibreur de charge et le groupe d'instances.
    3. Sous Mode d'équilibrage, sélectionnez Utilisation.
    4. Cliquez sur OK.

  5. Créez la vérification de l'état pour le backend de l'équilibreur de charge comme suit :

    1. Cliquez sur le menu déroulant Vérification d'état, puis sur Créer une vérification d'état. Dans la fenêtre qui s'ouvre,
    2. Dans la nouvelle fenêtre, sous Nom, saisissez web-app-load-balancer-check.
    3. Définissez le protocole sur HTTP.
    4. Sous Port, saisissez 80.
    5. Pour ce tutoriel, définissez le chemin de requête sur /health, qui est le chemin de réponse configuré pour l'application Web de démonstration.

    6. Définissez les critères de vérification suivants :

      1. Définissez Intervalle entre deux tests sur 3 secondes. Ce champ définit la durée entre le début d'un test et le début du suivant.
      2. Définissez Délai avant expiration sur 3 secondes. Ce champ définit la durée pendant laquelle Google Cloud attend une réponse à une vérification. Sa valeur doit être inférieure ou égale à l'intervalle entre deux tests.
      3. Définissez Seuil sanitaire sur 2 succès consécutifs. Ce champ définit le nombre de vérifications séquentielles qui doivent réussir pour que l'instance soit considérée comme opérationnelle.
      4. Définissez Seuil non sanitaire sur 2 échecs consécutifs. Ce champ définit le nombre de vérifications séquentielles qui doivent échouer pour que l'instance soit considérée comme non opérationnelle.

    7. Cliquez sur Créer pour créer la vérification d'état.

  6. Conservez les valeurs par défaut des autres options.

  7. Cliquez sur Créer pour créer le service de backend.

Vérifier et finaliser

Vérifiez vos paramètres d'équilibrage de charge avant de créer l'équilibreur de charge. Procédez comme suit :

  1. Dans le panneau de gauche de la page Créer un équilibreur de charge d'application externe global, cliquez sur Vérification et finalisation.

  2. Sur la page Vérification et finalisation, vérifiez que l'interface utilise une adresse IP dont le protocole est défini sur HTTP.

  3. Sur la même page, vérifiez les paramètres de backend suivants :

    • Le service de backend est défini sur web-app-backend.
    • Le protocole du point de terminaison est défini sur HTTP.
    • La vérification d'état est définie sur web-app-load-balancer-check.
    • Le groupe d'instances est défini sur load-balancing-web-app-group.

  4. Cliquez sur Créer pour terminer la création de l'équilibreur de charge.

Vous devrez peut-être attendre quelques minutes pour que l'équilibrage de charge soit terminé.

Tester l'équilibreur de charge

Vérifiez que vous pouvez vous connecter à l'application Web à l'aide de l'équilibreur de charge comme suit :

  1. Dans la console Google Cloud , accédez à la page Équilibrage de charge.

    Accéder à la page Équilibrage de charge

  2. Dans la colonne Nom, cliquez sur web-app-load-balancer pour développer l'équilibreur de charge que vous venez de créer.

  3. Pour vous connecter à l'application Web à l'aide des adresses IP externes statiques, procédez comme suit :

    1. Dans la section Frontend, copiez l'adresse IP affichée dans la colonne IP:Port.

    2. Ouvrez un onglet de navigateur et collez l'adresse IP dans la barre d'adresse. Cela devrait afficher l'application Web de démonstration :

      Application Web de démonstration

    Notez que, chaque fois que vous actualisez la page, l'équilibreur de charge se connecte à différentes instances dans différentes zones. Cela se produit parce que vous ne vous connectez pas directement à une instance : vous vous connectez à l'équilibreur de charge, qui sélectionne l'instance vers laquelle vous êtes redirigé.

    Lorsque vous avez terminé, fermez l'onglet de l'application Web de démonstration.

Simuler une panne de zone

Vous pouvez observer la fonctionnalité de l'équilibreur de charge en simulant l'indisponibilité généralisée d'une panne de zone. Cette simulation consiste à forcer toutes les instances situées dans une zone spécifiée à signaler un état non opérationnel sur le chemin de requête /health. Lorsque ces instances signalent un état non opérationnel, elles échouent à la vérification d'état liée à l'équilibrage de charge, invitant ainsi l'équilibreur de charge à arrêter de diriger le trafic vers ces instances.

  1. Surveillez les zones vers lesquelles l’équilibreur de charge dirige le trafic.

    1. Dans la console Google Cloud , accédez à Cloud Shell.

      Ouvrir Cloud Shell

      Cloud Shell s'ouvre dans un volet de la consoleGoogle Cloud . L'initialisation de la session peut prendre quelques secondes.

    2. Enregistrez l'adresse IP externe statique de votre équilibreur de charge comme suit :

      1. Obtenez l'adresse IP externe à partir de la règle de transfert de l'interface de l'équilibreur de charge en saisissant la commande suivante dans votre terminal :

        gcloud compute forwarding-rules describe web-app-ipv4-frontend --global

        Le résultat est semblable à ce qui suit. Copiez EXTERNAl_IP_ADDRESS à partir du résultat.

        IPAddress: EXTERNAl_IP_ADDRESS
...

      2. Créez une variable bash locale :

        export LOAD_BALANCER_IP=EXTERNAl_IP_ADDRESS

        Remplacez EXTERNAl_IP_ADDRESS par l'adresse IP externe que vous avez copiée.

    3. Pour surveiller les zones vers lesquelles l'équilibreur de charge dirige le trafic, exécutez le script bash suivant :

      while true
do
    BODY=$(curl -s "$LOAD_BALANCER_IP")
    NAME=$(echo -n "$BODY" | grep "load-balancing-web-app-group" | perl -pe 's/.+?load-balancing-web-app-group-(.+?)<.+/\1/')
    ZONE=$(echo -n "$BODY" | grep "us-" | perl -pe 's/.+?(us-.+?)<.+/\1/')
    echo $ZONE
    sleep 2 # Wait for 2 seconds
done

      Ce script tente en permanence de se connecter à l'application Web en utilisant l'adresse IP de l'interface de l'équilibreur de charge et génère la zone à partir de laquelle l'application Web s'exécute pour chaque connexion.

      Le résultat obtenu doit inclure les zones us-central1-b, us-central1-c et us-central1-f :

      us-central1-f
us-central1-b
us-central1-c
us-central1-f
us-central1-f
us-central1-c
us-central1-f
us-central1-c
us-central1-c

      Gardez ce terminal ouvert.

  2. Pendant que le contrôle de surveillance est en cours d'exécution, commencez à simuler la panne de zone.

    1. Dans Cloud Shell, ouvrez une deuxième session de terminal en cliquant sur le bouton Ajouter.

    2. Créez une variable bash locale pour l'ID de projet :

      export PROJECT_ID=PROJECT_ID

      où PROJECT_ID correspond à l'ID du projet en cours, et est affiché sur chaque ligne dans Cloud Shell :

      user@cloudshell:~ (PROJECT_ID)$

    3. Créez une variable bash locale pour la zone que vous souhaitez désactiver. Pour simuler une défaillance de la zone us-central1-f, utilisez la commande suivante :

      export DISABLE_ZONE=us-central1-f

      Exécutez ensuite le script bash suivant. Ce script force les instances de l'application Web de démonstration de la zone désactivée à générer des réponses non opérationnelles à la vérification de l'état de l'équilibreur de charge. Les réponses non opérationnelles invitent l'équilibreur de charge à détourner le trafic de ces instances.

      export MACHINES=$(gcloud --project=$PROJECT_ID compute instances list --filter="zone:($DISABLE_ZONE)" --format="csv(name,networkInterfaces[0].accessConfigs[0].natIP)" | grep "load-balancing-web-app-group")
for i in $MACHINES;
do
  NAME=$(echo "$i" | cut -f1 -d,)
  IP=$(echo "$i" | cut -f2 -d,)
  echo "Simulating zonal failure for zone $DISABLE_ZONE, instance $NAME"
  curl -q -s "http://$IP/makeUnhealthy" >/dev/null --retry 2
done

      Après un court délai, l'équilibreur de charge arrête de diriger le trafic vers les zones non opérationnelles. Par conséquent, le résultat de la première fenêtre de terminal cesse de répertorier la zone us-central1-f :

      us-central1-c
us-central1-c
us-central1-c
us-central1-b
us-central1-b
us-central1-c
us-central1-b
us-central1-c
us-central1-c

      Cela indique que l'équilibreur de charge ne dirige le trafic que vers les instances opérationnelles et réactives.

      Gardez les deux terminaux ouverts.

    4. Dans le deuxième terminal, créez une variable bash locale pour la zone que vous souhaitez restaurer. Pour restaurer le trafic sur la zone us-central1-f, utilisez la commande suivante :

      export ENABLE_ZONE=us-central1-f

      Exécutez ensuite le script bash suivant. Ce script force les instances de l'application Web de démonstration de la zone activée à générer des réponses opérationnelles à la vérification de l'état de l'équilibreur de charge. Des réponses opérationnelles invitent l'équilibreur de charge à commencer à répartir le trafic vers ces instances.

      export MACHINES=$(gcloud --project=$PROJECT_ID compute instances list --filter="zone:($ENABLE_ZONE)" --format="csv(name,networkInterfaces[0].accessConfigs[0].natIP)" | grep "load-balancing-web-app-group")
for i in $MACHINES;
do
  NAME=$(echo "$i" | cut -f1 -d,)
  IP=$(echo "$i" | cut -f2 -d,)
  echo "Simulating zonal restoration for zone $ENABLE_ZONE, instance $NAME"
  curl -q -s "http://$IP/makeHealthy" >/dev/null --retry 2
done

      Après quelques minutes, le résultat de la première fenêtre de terminal commence à nouveau à répertorier la zone us-central1-f :

      us-central1-b
us-central1-b
us-central1-c
us-central1-f
us-central1-c
us-central1-c
us-central1-b
us-central1-c
us-central1-f

      Cela indique que l'équilibreur de charge dirige à nouveau le trafic entrant vers toutes les zones.

      Fermez les deux terminaux lorsque vous avez terminé.