Créer un service à équilibrage de charge

Ce tutoriel explique comment un producteur de services peut créer un service simple qui utilise un équilibreur de charge réseau passthrough interne. Par défaut, un équilibreur de charge réseau passthrough interne n'est disponible que depuis le réseau VPC qui l'héberge.

Ce tutoriel est destiné aux architectes cloud, aux architectes réseau, aux administrateurs réseau et aux administrateurs informatiques.

Objectifs

• Configurer la mise en réseau pour les ressources du producteur de services
• Créer des ressources de VM pour le backend de l'équilibreur de charge
• Configurer les composants de l'équilibreur de charge
• Tester l'accès à l'équilibreur de charge

Coûts

Dans ce document, vous utilisez les composants facturables de Google Cloudsuivants :

• Cloud Load Balancing
• Compute Engine

Vous pouvez obtenir une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût.

Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai sans frais.

Une fois que vous avez terminé les tâches décrites dans ce document, supprimez les ressources que vous avez créées pour éviter que des frais vous soient facturés. Pour en savoir plus, consultez la section Effectuer un nettoyage.

Avant de commencer

1. Créez ou sélectionnez un projet à utiliser pour les ressources du producteur de services. Dans les tutoriels suivants, ce projet est appelé PRODUCER_PROJECT.

1. In the Google Cloud console, go to the project selector page.

   Go to project selector

2. Select or create a Google Cloud project.

   Roles required to select or create a project

   • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
   • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.
   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

2. Enable the Compute Engine API.

   Roles required to enable APIs

   To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

   Enable the API

3. Make sure that you have the following role or roles on the project: Compute Engine > Compute Network Admin, Compute Engine > Compute Security Admin, Compute Engine > Compute Instance Admin

   Check for the roles

   1. In the Google Cloud console, go to the IAM page.

      Go to IAM
   2. Select the project.

   3. In the Principal column, find all rows that identify you or a group that you're included in. To learn which groups you're included in, contact your administrator.

   4. For all rows that specify or include you, check the Role column to see whether the list of roles includes the required roles.

   Grant the roles

   1. In the Google Cloud console, go to the IAM page.

      Accéder à IAM
   2. Sélectionnez le projet.
   3. Cliquez sur  Accorder l'accès.

   4. Dans le champ Nouveaux comptes principaux, saisissez votre identifiant utilisateur. Il s'agit généralement de l'adresse e-mail d'un compte Google.

   5. Cliquez sur Sélectionner un rôle, puis recherchez le rôle.
   6. Pour attribuer des rôles supplémentaires, cliquez sur  Ajouter un autre rôle et ajoutez tous les rôles supplémentaires.
   7. Cliquez sur Enregistrer.

Configurer la mise en réseau

Les sections suivantes expliquent comment créer un réseau, un sous-réseau et des règles de pare-feu pour le service.

Configurer un réseau et un sous-réseau

Pour créer le réseau et le sous-réseau de service pour l'équilibreur de charge, suivez les étapes décrites dans les sections suivantes.

Console

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 service-network.

4. Dans le champ Mode de création de sous-réseau, sélectionnez Personnalisé.

5. Dans la section Nouveau sous-réseau, saisissez les informations suivantes.

   1. Dans le champ Nom, saisissez service-subnet.
   2. Dans le champ Région, sélectionnez la région que vous souhaitez utiliser.
   3. Pour Type de pile d'adresses IP, sélectionnez IPv4 (pile simple).
   4. Dans Plage IPv4, saisissez 10.10.10.0/24.
   5. Cliquez sur OK.

6. Cliquez sur Créer.

gcloud

1. Créez un réseau VPC en mode personnalisé :

   gcloud compute networks create service-network --subnet-mode=custom
   

2. Dans le réseau service-network, créez un sous-réseau.

   gcloud compute networks subnets create service-subnet \
       --network=service-network \
       --range=10.10.10.0/24 \
       --region=REGION
   

   Remplacez REGION par la région que vous souhaitez utiliser.

Configurer des règles de pare-feu

Créez des règles de pare-feu pour autoriser le trafic suivant :

• fw-allow-subnet : permet au trafic provenant de 10.10.10.0/24 d'accéder à d'autres ressources dans 10.10.10.0/24.
• fw-allow-ssh : permet au trafic SSH provenant de 0.0.0.0/0 d'atteindre les VM qui possèdent le tag réseau allow-ssh.

• fw-allow-healthcheck : permet au trafic des systèmes de vérification de l'état Google Cloudd'atteindre les VM qui possèdent le tag réseau allow-healthcheck.

Console

1. Dans la console Google Cloud , accédez à la page Règles de pare-feu.

   Accéder à la page Règles de pare-feu

2. Pour autoriser le trafic de sous-réseau, cliquez sur Créer une règle de pare-feu, puis utilisez les paramètres suivants :

   • Dans le champ Nom, saisissez fw-allow-subnet.
   • Pour Réseau, sélectionnez service-network.
   • Dans le champ Priorité, saisissez 1000.
   • Pour le Sens du trafic, sélectionnez Entrée.
   • Pour l'option Action en cas de correspondance, sélectionnez Autoriser.
   • Pour les Cibles, sélectionnez Toutes les instances du réseau.
   • Dans la section Filtre source, sélectionnez Plages IPv4.
   • Dans le champ Plages IPv4 sources, saisissez 10.10.10.0/24.
   • Pour Protocoles et ports, sélectionnez Tout autoriser.

3. Cliquez sur Créer.

4. Pour autoriser les connexions SSH entrantes, cliquez sur Créer une règle de pare-feu et utilisez les paramètres suivants :

   • Dans le champ Nom, saisissez fw-allow-ssh.
   • Pour Réseau, sélectionnez service-network.
   • Dans le champ Priorité, saisissez 1000.
   • Pour le Sens du trafic, sélectionnez Entrée.
   • Pour l'option Action en cas de correspondance, sélectionnez Autoriser.
   • Pour Cibles, sélectionnez Specified target tags (Tags cibles spécifiés).
   • Pour Tags cibles, saisissez allow-ssh.
   • Dans la section Filtre source, sélectionnez Plages IPv4.
   • Dans le champ Plages IPv4 sources, saisissez 0.0.0.0/0.
   • Dans Protocoles et ports, sélectionnez Protocoles et ports spécifiés, puis cochez la case TCP. Pour Ports, saisissez 22.

5. Cliquez sur Créer.

6. Pour autoriser les vérifications d'état Google Cloud , cliquez sur Créer une règle de pare-feu et utilisez les paramètres suivants :

   • Dans le champ Nom, saisissez fw-allow-healthcheck.
   • Pour Réseau, sélectionnez service-network.
   • Dans le champ Priorité, saisissez 1000.
   • Pour le Sens du trafic, sélectionnez Entrée.
   • Pour l'option Action en cas de correspondance, sélectionnez Autoriser.
   • Pour Cibles, sélectionnez Specified target tags (Tags cibles spécifiés).
   • Pour Tags cibles, saisissez allow-healthcheck.
   • Dans la section Filtre source, sélectionnez Plages IPv4.
   • Dans le champ Plages IPv4 sources, saisissez 130.211.0.0/22 et 35.191.0.0/16.
   • Pour Protocoles et ports, sélectionnez Tout autoriser.

7. Cliquez sur Créer.

gcloud

1. Créez la règle de pare-feu fw-allow-subnet pour autoriser la communication depuis le sous-réseau :

   gcloud compute firewall-rules create fw-allow-subnet \
       --network=service-network \
       --action=allow \
       --direction=ingress \
       --source-ranges=10.10.10.0/24 \
       --rules=tcp,udp,icmp
   

1. Créez la règle de pare-feu fw-allow-ssh pour autoriser la connectivité SSH aux VM avec le tag réseau allow-ssh.

   gcloud compute firewall-rules create fw-allow-ssh \
       --network=service-network \
       --action=allow \
       --direction=ingress \
       --source-ranges=0.0.0.0/0 \
       --target-tags=allow-ssh \
       --rules=tcp:22
   

1. Créez la règle fw-allow-healthcheck pour autoriser les vérifications d'état Google Cloud.

   gcloud compute firewall-rules create fw-allow-healthcheck \
       --network=service-network \
       --action=allow \
       --direction=ingress \
       --target-tags=allow-healthcheck \
       --source-ranges=130.211.0.0/22,35.191.0.0/16 \
       --rules=tcp,udp,icmp
   

Créer des ressources de VM pour le backend de l'équilibreur de charge

Créez les VM et le groupe d'instances à utiliser avec l'équilibreur de charge.

Créer des VM de backend

Le service que vous créez s'exécute sur deux VM pour une disponibilité accrue : vm-1 et vm-2. Les VM se trouvent dans la même zone, mais dans un environnement de production, nous vous recommandons d'utiliser plusieurs zones.

En plus de créer les VM, les étapes suivantes permettent d'accomplir les tâches suivantes :

• Configure les VM pour qu'elles utilisent les tags réseau que vous avez configurés comme cibles dans les règles de pare-feu et un tag réseau supplémentaire (allow-nat) qui sera utilisé ultérieurement.

• Installe, configure et démarre le service Apache.

Console

1. Dans la console Google Cloud , accédez à la page Instances de VM.

   Accéder à la page Instances de VM

2. Cliquez sur Créer une instance.

3. Dans le champ Nom, saisissez vm-1.

4. Pour Région et Zone, sélectionnez une région et une zone dans cette région.

5. Dans le menu de navigation, accédez à OS et stockage.

6. Dans le volet Système d'exploitation et espace de stockage, assurez-vous que Debian GNU/Linux 12 (bookworm) est sélectionné pour le disque de démarrage. Si vous devez sélectionner une autre image, cliquez sur Modifier.

7. Dans le menu de navigation, accédez à Mise en réseau.

8. Pour Tags réseau, saisissez allow-ssh, allow-healthcheck et allow-nat.

9. Pour Interfaces réseau, sélectionnez les éléments suivants :

   • Pour Réseau, sélectionnez service-network.
   • Pour Sous-réseau, sélectionnez service-subnet.
   • Pour Type de pile d'adresses IP, sélectionnez IPv4 (pile simple).
   • Pour Adresse IPv4 interne principale, sélectionnez Éphémère (automatique).
   • Pour Adresse IPv4 externe, sélectionnez Éphémère.

10. Dans le menu de navigation, accédez à Avancé.

11. Dans la section Automatisation, dans le champ Script de démarrage, saisissez le script suivant.

    
    #! /bin/bash
    if [ -f /etc/startup_script_completed ]; then
    exit 0
    fi
    apt-get update
    apt-get install apache2 -y
    a2ensite default-ssl
    a2enmod ssl
    file_ports="/etc/apache2/ports.conf"
    file_http_site="/etc/apache2/sites-available/000-default.conf"
    file_https_site="/etc/apache2/sites-available/default-ssl.conf"
    http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
    http_vh_prts="*:80 *:8008 *:8080 *:8088"
    https_listen_prts="Listen 443\nListen 8443"
    https_vh_prts="*:443 *:8443"
    vm_hostname="$(curl -H "Metadata-Flavor:Google" \
    http://metadata.google.internal/computeMetadata/v1/instance/name)"
    echo "Page served from: $vm_hostname" | \
    tee /var/www/html/index.html
    prt_conf="$(cat "$file_ports")"
    prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
    prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
    echo "$prt_conf" | tee "$file_ports"
    http_site_conf="$(cat "$file_http_site")"
    http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
    echo "$http_site_conf_2" | tee "$file_http_site"
    https_site_conf="$(cat "$file_https_site")"
    https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
    echo "$https_site_conf_2" | tee "$file_https_site"
    systemctl restart apache2
    touch /etc/startup_script_completed
    

12. Cliquez sur Créer.

13. Répétez ces étapes pour créer une autre VM nommée vm-2 dans la même région et la même zone que vm-1.

gcloud

1. Créez deux VM en exécutant les commandes suivantes :

   gcloud compute instances create vm-1 \
       --zone=ZONE \
       --image-family=debian-12 \
       --image-project=debian-cloud \
       --tags=allow-ssh,allow-healthcheck,allow-nat \
       --subnet=service-subnet \
       --metadata=startup-script='#! /bin/bash
   if [ -f /etc/startup_script_completed ]; then
   exit 0
   fi
   apt-get update
   apt-get install apache2 -y
   a2ensite default-ssl
   a2enmod ssl
   file_ports="/etc/apache2/ports.conf"
   file_http_site="/etc/apache2/sites-available/000-default.conf"
   file_https_site="/etc/apache2/sites-available/default-ssl.conf"
   http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
   http_vh_prts="*:80 *:8008 *:8080 *:8088"
   https_listen_prts="Listen 443\nListen 8443"
   https_vh_prts="*:443 *:8443"
   vm_hostname="$(curl -H "Metadata-Flavor:Google" \
   http://metadata.google.internal/computeMetadata/v1/instance/name)"
   echo "Page served from: $vm_hostname" | \
   tee /var/www/html/index.html
   prt_conf="$(cat "$file_ports")"
   prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
   prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
   echo "$prt_conf" | tee "$file_ports"
   http_site_conf="$(cat "$file_http_site")"
   http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
   echo "$http_site_conf_2" | tee "$file_http_site"
   https_site_conf="$(cat "$file_https_site")"
   https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
   echo "$https_site_conf_2" | tee "$file_https_site"
   systemctl restart apache2
   touch /etc/startup_script_completed'
   

   gcloud compute instances create vm-2 \
       --zone=ZONE \
       --image-family=debian-12 \
       --image-project=debian-cloud \
       --tags=allow-ssh,allow-healthcheck,allow-nati \
       --subnet=service-subnet \
       --metadata=startup-script='#! /bin/bash
   if [ -f /etc/startup_script_completed ]; then
   exit 0
   fi
   apt-get update
   apt-get install apache2 -y
   a2ensite default-ssl
   a2enmod ssl
   file_ports="/etc/apache2/ports.conf"
   file_http_site="/etc/apache2/sites-available/000-default.conf"
   file_https_site="/etc/apache2/sites-available/default-ssl.conf"
   http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
   http_vh_prts="*:80 *:8008 *:8080 *:8088"
   https_listen_prts="Listen 443\nListen 8443"
   https_vh_prts="*:443 *:8443"
   vm_hostname="$(curl -H "Metadata-Flavor:Google" \
   http://metadata.google.internal/computeMetadata/v1/instance/name)"
   echo "Page served from: $vm_hostname" | \
   tee /var/www/html/index.html
   prt_conf="$(cat "$file_ports")"
   prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
   prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
   echo "$prt_conf" | tee "$file_ports"
   http_site_conf="$(cat "$file_http_site")"
   http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
   echo "$http_site_conf_2" | tee "$file_http_site"
   https_site_conf="$(cat "$file_https_site")"
   https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
   echo "$https_site_conf_2" | tee "$file_https_site"
   systemctl restart apache2
   touch /etc/startup_script_completed'
   

   Remplacez ZONE par la zone que vous souhaitez utiliser.

Créer un groupe d'instances

Pour utiliser les VM dans un backend d'équilibreur de charge, vous devez les ajouter à un groupe d'instances.

Console

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 volet de navigation, cliquez sur Nouveau groupe d'instances non géré.

4. Dans le champ Nom, saisissez ig-1.

5. Dans la section Emplacement, sélectionnez la même région et la même zone que vos VM.

6. Pour Réseau, sélectionnez service-network.

7. Pour Sous-réseau, sélectionnez service-subnet.

8. Dans la section Instances de VM, ajoutez vm-1 et vm-2 au groupe d'instances.

9. Cliquez sur Créer.

gcloud

1. Créez un groupe d'instances non géré :

   gcloud compute instance-groups unmanaged create ig-1 \
       --zone=ZONE
   

   Remplacez ZONE par la zone qui contient les VM.

2. Ajoutez les VM au groupe d'instances :

   gcloud compute instance-groups unmanaged add-instances ig-1 \
       --zone=ZONE \
       --instances=vm-1,vm-2
   

Configurer les composants de l'équilibreur de charge

Configurez tous les composants de l'équilibreur de charge réseau passthrough interne, en commençant par la vérification de l'état d'état et le service de backend, puis les composants d'interface :

• Vérification de l'état : Vous utilisez une vérification de l'état HTTP qui recherche un code d'état HTTP 200 OK.

• Service de backend Étant donné que vous devez transmettre le trafic HTTP via l'équilibreur de charge interne, vous devez utiliser TCP, et non UDP.

• Règle de transfert Vous créez une seule règle de transfert interne, service-rule.

• Adresse IP interne : Vous spécifiez une adresse IP interne, 10.10.10.99, lorsque vous créez la règle de transfert.

Console

Démarrer la configuration

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. Sous Type d'équilibreur de charge, sélectionnez Équilibreur de charge réseau (TCP/UDP/SSL), puis cliquez sur Suivant.
4. Pour Proxy ou passthrough, sélectionnez Équilibreur de charge passthrough, puis cliquez sur Suivant.
5. Pour Public ou interne, sélectionnez Interne, puis cliquez sur Suivant.
6. Cliquez sur Configurer.

Configuration de base

Sur la page Créer un équilibreur de charge réseau passthrough interne, saisissez les informations suivantes :

• Dans le champ Nom de l'équilibreur de charge, saisissez service-lb.
• Pour Région, sélectionnez la même région que celle de vos VM.
• Pour Réseau, sélectionnez service-network.

Configurer les backends

1. Cliquez sur Configuration du backend.
2. Dans la liste Vérification d'état, cliquez sur Créer une vérification d'état, puis saisissez les informations suivantes :
   • Pour Nom, saisissez hc-http-80.
   • Pour Protocole, sélectionnez HTTP.
   • Pour Port, saisissez 80.
   • Pour Protocole de proxy, sélectionnez NONE.
   • Dans le champ Chemin de requête, saisissez /.
3. Cliquez sur Créer.
4. Dans la section Nouveau backend de Backends, sélectionnez IPv4 (pile unique).
5. Dans Groupe d'instances, sélectionnez le groupe d'instances ig-1 puis cliquez sur OK.
6. Vérifiez qu'une coche bleue apparaît à côté de Configuration du backend avant de continuer.

Configurer l'interface

1. Cliquez sur Configuration de l'interface.
2. Dans la section Nouveaux IP et port frontend, procédez comme suit :
   1. Dans le champ Nom, saisissez service-rule.
   2. Pour Sous-réseau, sélectionnez service-subnet.
   3. Dans la section Objectif de l'adresse IP interne, dans la liste Adresse IP, sélectionnez Créer une adresse IP, puis saisissez les informations suivantes :
      • Dans le champ Nom, saisissez service-rule-ip.
      • Pour Version IP, sélectionnez IPv4.
      • Sous Adresse IP statique, sélectionnez Let me choose.
      • Sous Adresse IP personnalisée, saisissez 10.10.10.99.
   4. Cliquez sur Réserver.
   5. Pour Ports, sélectionnez Unique, puis dans Numéros de ports, saisissez 80.
   6. Cliquez sur OK.
   7. Vérifiez qu'une coche bleue apparaît à côté de Configuration de l'interface avant de continuer.

Vérifier la configuration

1. Cliquez sur Vérifier et finaliser.
2. Vérifiez les paramètres de configuration de votre équilibreur de charge.
3. Cliquez sur Créer.

gcloud

1. Créez une vérification d'état HTTP régionale pour tester la connectivité HTTP aux VM sur le port 80.

   gcloud compute health-checks create http hc-http-80 \
       --region=REGION \
       --port=80
   

   Remplacez REGION par la même région que les VM de backend.

2. Créez le service de backend pour le trafic HTTP :

   gcloud compute backend-services create service-lb \
       --load-balancing-scheme=internal \
       --protocol=tcp \
       --region=REGION \
       --health-checks=hc-http-80 \
       --health-checks-region=REGION
   

   Remplacez REGION par la même région que les VM de backend.

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

   gcloud compute backend-services add-backend service-lb \
       --region=REGION \
       --instance-group=ig-1 \
       --instance-group-zone=ZONE
   

   Remplacez les éléments suivants :

   • REGION : la même région que les VM de backend.
   • ZONE : la même zone que les VM de backend.

4. Créez une règle de transfert pour le service de backend.

   gcloud compute forwarding-rules create service-rule \
       --region=REGION \
       --load-balancing-scheme=internal \
       --network=service-network \
       --subnet=service-subnet \
       --address=10.10.10.99 \
       --ip-protocol=TCP \
       --ports=80 \
       --backend-service=service-lb \
       --backend-service-region=REGION
   

   Remplacez REGION par la même région que les VM de backend.

Tester l'accès à l'équilibreur de charge

Pour vérifier que l'équilibreur de charge fonctionne, créez une VM de test et envoyez-lui une requête.

Créer une VM cliente pour les tests

Créez une VM cliente dans la même région que les VM de backend (serveur).

Console

1. Dans la console Google Cloud , accédez à la page Instances de VM.

   Accéder à la page Instances de VM

2. Cliquez sur Créer une instance.

3. Dans le champ Nom, saisissez producer-test.

4. Pour Région, sélectionnez la même région que celle des VM de backend.

5. Pour Zone, sélectionnez une zone dans cette région.

6. Cliquez sur Mise en réseau et configurez les champs suivants :

   1. Pour Tags réseau, saisissez allow-ssh.
   2. Pour Interfaces réseau, sélectionnez l'option suivante :
      • Pour Réseau, sélectionnez service-network.
      • Pour Sous-réseau, sélectionnez service-subnet.

7. Cliquez sur Créer.

gcloud

gcloud compute instances create producer-test \
    --zone=ZONE \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --tags=allow-ssh \
    --subnet=service-subnet

Remplacez ZONE par une zone située dans la même région que les VM de backend.

Tester la connectivité

Ce test contacte l'équilibreur de charge à partir d'une VM cliente. Le comportement attendu est une répartition du trafic entre les VM de backend de l'équilibreur de charge.

1. Connectez-vous à l'instance de VM cliente.

   gcloud compute ssh producer-test --zone=ZONE
   

   Remplacez ZONE par la zone de la VM cliente.
2. Envoyez une requête Web à l'équilibreur de charge à l'aide de curl pour contacter son adresse IP. Répétez la requête pour que les réponses proviennent de différentes VM de backend. Le nom de la VM qui génère la réponse est affiché dans le texte de la réponse HTML, en raison du contenu de /var/www/html/index.html sur chaque VM de backend. Par exemple, les réponses attendues ressemblent à Page served from: vm-1 et Page served from: vm-2.

   curl -s http://10.10.10.99
   

Étapes suivantes

• Rendre le service accessible depuis d'autres réseaux VPC