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 zones via une adresse IP unique, empêchant ainsi les utilisateurs d'être dirigés vers une zone où votre application n'est pas disponible. 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 perturbation 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.

Objectifs

  • Lancer une application Web de démonstration sur un groupe d'instances géré régional.
  • Configurer un équilibreur de charge global qui dirige le trafic HTTP sur plusieurs zones.
  • Observer les effets de l'équilibreur de charge en simulant une panne de zone.

Coûts

Ce tutoriel fait appel à des composants payants de GCP tels que :

  • Compute Engine

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de GCP peuvent bénéficier d'un essai gratuit.

Avant de commencer

  1. Connectez-vous à votre compte Google.

    Si vous n'en possédez pas déjà un, vous devez en créer un.

  2. Sélectionnez ou créez un projet Google Cloud Platform.

    Accéder à la page "Gérer les ressources"

  3. Assurez-vous que la facturation est activée pour votre projet Google Cloud Platform.

    Découvrir comment activer la facturation

Architecture de l'application

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

  • Réseau VPC : réseau virtuel au sein de GCP pouvant fournir une connectivité globale via ses propres routes et règles de pare-feu.
  • Règle de pare-feu : pare-feu GCP permettant d'autoriser ou de refuser le trafic sur 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 : application qui dirige le trafic sur plusieurs zones via une seule adresse IP (globale). Cet équilibreur de charge est conçu pour empêcher les utilisateurs d’être dirigés vers une zone où votre application est indisponible.
  • 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 la documentation sur le dépôt GitHub de Google Cloud Platform.

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. Accédez à la page Réseaux VPC dans la console GCP.
    Accéder à la page "Réseaux VPC"
  2. Cliquez sur Créer un réseau VPC.
  3. Sous Nom, entrez web-app-vpc.
  4. Définissez le paramètre Mode de création du sous-réseau sur Automatique.

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

Attendez la fin de la création du réseau VPC 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. Accédez à la page Pare-feu de la console GCP.
    Accéder à la page "Pare-feu"
  2. Cliquez sur Créer une règle de pare-feu.
  3. Sous Nom, entrez allow-web-app-http.
  4. Définissez le champ Réseau sur web-app-vpc.
  5. Sous Cibles, sélectionnez Toutes les instances du réseau.
  6. Définissez le filtre source sur IP ranges.
  7. Sous Plages d'adresses IP sources, entrez 0.0.0.0/0 afin d'autoriser l'accès pour toutes les adresses IP.
  8. Sous Ports et protocoles, sélectionnez Protocoles et ports spécifiés.
    Vérifiez tcp et saisissez 80 pour autoriser l'accès du trafic HTTP.
  9. 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 via un script de démarrage.

  1. Accédez à la page Modèles d'instances dans la console GCP.
    Accéder à la page "Modèles d'instance"
  2. Cliquez sur Créer un modèle d'instance.
  3. Sous Nom, entrez load-balancing-web-app-template.
  4. Sous Configuration de la machine, définissez le type de machine sur f1-micro.
  5. Sous Disque de démarrage, définissez l’image sur Debian GNU/Linux 9 (stretch).
  6. Sous Pare-feu, sélectionnez Autoriser le trafic HTTP.
  7. Cliquez sur Gestion, sécurité, disques, réseau et location unique pour afficher les paramètres avancés.
  8. Cliquez sur l'onglet Gestion. Sous Automatisation, saisissez le script de démarrage suivant :

    sudo apt-get update && sudo apt-get install git gunicorn3 python3-pip -y
    git clone https://github.com/GoogleCloudPlatform/python-docs-samples.git
    cd python-docs-samples/compute/managed-instances/demo
    sudo pip3 install -r requirements.txt
    sudo gunicorn3 --bind 0.0.0.0:80 app:app --daemon
    

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

  9. Cliquez sur l'onglet Mise en réseau. Sous Réseau, sélectionnez web-app-vpc. Cela force chaque instance créée avec ce modèle à s'exécuter sur le réseau créé précédemment.

  10. Cliquez sur Créer.

Attendez la fin de la création du modèle 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. Accédez à la page Groupes d'instances dans la console GCP.
    Accéder à la page Groupes d'instances
  2. Cliquez sur Créer un groupe d'instances.
  3. Sous Nom, entrez load-balancing-web-app-group.
  4. Sous Emplacement, sélectionnez Plusieurs zones.

  5. Sous Région, sélectionnez us-central1.

  6. Cliquez sur le menu déroulant Configurer les zones pour afficher les zones. Sélectionnez les zones suivantes :

    • us-central1-b
    • us-central1-c
    • us-central1-f
  7. Sous Modèle d'instance, sélectionnez load-balancing-web-app-template.

  8. Sous Autoscaling, sélectionnez Désactivé.

  9. Définissez le nombre d'instances sur 6.

  10. Sous Redistribution des instances, sélectionnez Activée.

  11. Sous Autoréparation et Vérification de l'état, sélectionnez Aucune vérification d'état.

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

  13. Pour vérifier que vos instances exécutent correctement l'application Web de démonstration, procédez comme suit :

    1. Sur la page Groupes d'instances, cliquez sur load-balancing-web-app-group pour afficher les instances de ce groupe.
    2. Sous Adresse IP externe, cliquez sur une adresse IP pour connecter cette instance. Un nouvel onglet de navigateur s'ouvre et affiche l'application Web de démonstration :

      Capture d'écran de l'application Web de démonstration, qui répertorie les informations sur l'instance et comporte des boutons d'action.

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

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 GCP 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. Accédez à la page Adresses IP externes de la console GCP.
    Accéder à la page "Adresses IP externes"
  2. Cliquez sur Réserver une adresse statique.
  3. Sous Nom, entrez web-app-ipv4.
  4. Définissez la 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 plusieurs parties :

  • Configuration du backend
  • Configuration de l'interface
  • Vérification et finalisation

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

  1. Accédez à la page Créer un équilibreur de charge dans la console GCP.
    Accéder à la page "Créer un équilibreur de charge"
  2. Dans la section Équilibrage de charge HTTP(S), cliquez sur Démarrer la configuration.
  3. Sous Web ou interne uniquement, sélectionnez D'Internet vers mes VM. Cliquez ensuite sur Continuer.
  4. Pour le nom de l'équilibreur de charge, saisissez web-app-load-balancer.

Configuration du backend

  1. Dans le panneau de gauche de la page Nouvel équilibreur de charge HTTP(S), cliquez sur Configuration du backend.
  2. Cliquez sur Créer ou sélectionner des services backend et des buckets backend pour ouvrir un menu déroulant. Cliquez sur Services backend, puis sur Créer un service backend.
  3. Dans la nouvelle fenêtre, pour le nom de l'application backend, saisissez web-app-backend.
  4. Définissez Groupe d'instances sur load-balancing-web-app-group.
  5. Définissez Numéros de port sur 80. Cela autorise le trafic HTTP entre l'équilibreur de charge et le groupe d'instances.
  6. Sous Mode d'équilibrage, sélectionnez Utilisation.
  7. Cliquez sur Terminé pour créer le backend.
  8. Créez la vérification d'état pour le backend de l'équilibreur de charge.

    1. Sous Vérification de l'état, sélectionnez Créer une vérification d'état (ou Créer une autre vérification d'état) dans le menu déroulant. Une nouvelle fenêtre 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. Ceci définit la durée pendant laquelle GCP 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 Enregistrer et continuer pour créer la vérification d'état.

  9. Cliquez sur Créer pour créer le service backend.

Configuration de l'interface

  1. Dans le panneau de gauche de la page Nouvel équilibreur de charge HTTP(S), cliquez sur Configuration du frontend.
  2. Sur la page Configuration du frontend, sous Nom, saisissez web-app-ipv4-frontend.
  3. Définissez Protocole sur HTTP.
  4. Définissez Version IP sur IPv4.
  5. Définissez Adresse IP sur web-app-ipv4.
  6. Définissez Port sur 80.
  7. Cliquez sur Terminé pour créer l'interface.

Vérification et finalisation

  1. 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 Nouvel équilibreur de charge HTTP(S), cliquez sur Vérification et finalisation.
    2. Sur la page Vérification et finalisation, vérifiez les paramètres de backend suivants :

      • Le service 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,
    3. Sur la même page, vérifiez que le frontend utilise une adresse IP dont le protocole est défini sur HTTP.

  2. Dans le panneau de gauche de la page Nouvel équilibreur de charge HTTP(S), 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é.

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 relative à 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. Ouvrez un terminal à l'aide de Cloud Shell à partir de la console GCP.

      Ouvrir Cloud Shell

      Cloud Shell s'ouvre au bas de la console GCP. 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 entrant la commande suivante dans votre terminal :

        gcloud compute forwarding-rules list | grep web-app-ipv4-frontend
        

        Copiez EXTERNAl_IP_ADDRESS à partir de la sortie :

        web-server-ipv4-frontend    EXTERNAl_IP_ADDRESS    TCP    web-app-load-balancer-target-proxy
        
      2. Créez une variable bash locale :

        export LOAD_BALANCER_IP=EXTERNAl_IP_ADDRESS
        

        EXTERNAl_IP_ADDRESS est 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
      done
      

      Ce script tente en permanence de se connecter à l'application Web via l'adresse IP de l'interface de l'équilibreur de charge et affiche la zone à partir de laquelle l'application Web est en cours d'exécution 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
      

      PROJECT_ID correspond à l'ID de projet de votre projet actuel, qui s'affiche à chaque nouvelle 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é.

(Facultatif) Restreindre le trafic entrant

Lorsque vous avez créé le groupe d'instances géré régional, vous pouvez accéder à chaque instance directement via son adresse IP externe éphémère. Cependant, maintenant que vous avez préparé un équilibreur de charge et l'adresse IP externe statique, vous voudrez peut-être modifier le pare-feu du réseau afin que le trafic entrant soit forcé de passer par l'équilibreur de charge.

Si vous souhaitez limiter le trafic entrant à l'équilibreur de charge, modifiez le pare-feu du réseau pour désactiver l'adresse IP externe éphémère de chaque instance.

  1. Modifiez la règle de pare-feu pour limiter le trafic HTTP afin que l'application Web ne soit accessible que via l'équilibreur de charge. Procédez comme suit :

    1. Accédez à la page Pare-feu de la console GCP.
      Accéder à la page "Pare-feu"
    2. Sous Nom, cliquez sur allow-web-app-http.
    3. Cliquez sur Modifier.
    4. Modifiez les plages d'adresses IP sources pour n'autoriser que les tests de vérification d'état :

      1. Supprimez 0.0.0.0/0.
      2. Sur la même ligne, saisissez 130.211.0.0/22 et appuyez sur la touche Tab.
      3. Sur la même ligne, saisissez 35.191.0.0/16 et appuyez sur la touche Tab.
    5. Cliquez sur Enregistrer.

  2. Vérifiez que vous ne pouvez pas vous connecter à l'application Web via l'adresse IP externe éphémère pour une instance spécifique :

    1. Accédez à la page Groupes d'instances dans la console GCP.
      Accéder à la page "Groupes d'instances"
    2. Cliquez sur load-balancing-web-app-group pour afficher les instances de ce groupe.
    3. Sous Adresse IP externe, cliquez sur une adresse IP pour connecter cette instance. Un nouvel onglet de navigation s'ouvre, mais l'application Web ne s'ouvre pas. (Et la page affiche une erreur de délai d'attente.)

      Lorsque vous avez terminé, fermez l'onglet de navigation de l'instance.

  3. Vérifiez que vous pouvez vous connecter à l'application Web via l'équilibreur de charge :

    1. Accédez à la page Équilibrage de charge dans la console GCP.
      Accéder à la page "Équilibrage de charge"
    2. Sous 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 via les adresses IP statiques externes, recherchez sous Frontend et IP:Port, puis copiez l'adresse IP. Ensuite, ouvrez un onglet de navigation et collez l'adresse IP dans la barre d'adresse. Cela devrait afficher l'application Web de démonstration :

      Capture d'écran de l'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 navigation de l'application Web de démonstration.

Effectuer un nettoyage

Une fois que vous avez terminé le tutoriel sur l'équilibrage de charge, vous pouvez procéder au nettoyage des ressources que vous avez créées sur GCP afin qu'elles ne soient plus comptabilisées dans votre quota et qu'elles ne vous soient plus facturées. Dans les sections suivantes, nous allons voir comment supprimer ou désactiver ces ressources.

Si vous avez créé un projet distinct pour ce tutoriel, supprimez-le entièrement. Ou bien, si le projet contient des ressources que vous souhaitez conserver, ne supprimez que les ressources créées spécifiquement pour ce tutoriel.

Supprimer le projet

  1. Dans la console GCP, accédez à la page "Projets".

    Accéder à la page Projets

  2. Dans la liste des projets, sélectionnez celui que vous souhaitez supprimer, puis cliquez sur Supprimer.
  3. Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Supprimer des ressources spécifiques

Supprimer l'équilibreur de charge

  1. Accédez à la page Équilibrage de charge dans la console GCP.
    Accéder à la page "Équilibrage de charge"
  2. Cochez la case en regard de web-app-load-balancer.
  3. Cliquez sur Supprimer en haut de la page.
  4. Dans la nouvelle fenêtre, cochez toutes les cases. Cliquez ensuite sur Supprimer l’équilibreur de charge et les ressources sélectionnées pour confirmer la suppression.

Supprimer l'adresse IP externe statique

  1. Accédez à la page Adresses IP externes dans la console GCP.
    Accéder à la page "Adresses IP externes"
  2. Cochez la case en regard de web-app-ipv4.
  3. Cliquez sur Libérer l'adresse statique en haut de la page. Dans la nouvelle fenêtre, cliquez sur Supprimer pour confirmer la suppression.

Supprimer le groupe d'instances

  1. Dans la console GCP, accédez à la page "Groupes d'instances".

    Accéder à la page Groupes d'instances

  2. Cochez la case à côté de votre groupe d'instances load-balancing-web-app-group.
  3. Cliquez sur le bouton Supprimer en haut de la page pour supprimer le groupe d'instances.

Supprimer le modèle d'instance

  1. Accédez à la page Modèles d'instances dans la console GCP.

    Accéder à la page "Modèles d'instance"

  2. Cochez la case en regard de load-balancing-web-app-template.

  3. Cliquez sur Supprimer en haut de la page. Dans la nouvelle fenêtre, cliquez sur Supprimer pour confirmer la suppression.

Supprimer le réseau VPC

  1. Accédez à la page Réseaux VPC dans la console GCP.

    Accéder à la page "Réseaux VPC"

  2. Cliquez sur web-app-vpc.

  3. Cliquez sur Supprimer en haut de la page. Dans la nouvelle fenêtre, cliquez sur Supprimer pour confirmer la suppression.

Étapes suivantes

Cette page vous a-t-elle été utile ? Évaluez-la :

Envoyer des commentaires concernant…

Documentation Compute Engine