Configurer un équilibreur de charge réseau proxy externe régional avec des backends de groupes d'instances de VM

Un équilibreur de charge réseau proxy externe régional est un équilibreur de charge régional de couche 4 basé sur un proxy qui vous permet d'exécuter et d'effectuer le scaling de votre trafic de service TCP dans une seule région derrière une adresse IP régionale externe. Ces équilibreurs de charge distribuent le trafic TCP externe depuis Internet vers les backends de la même région.

Avant de commencer, consultez la présentation de l'équilibreur de charge réseau proxy externe.

Ce guide contient des instructions pour configurer un équilibreur de charge réseau proxy externe régional avec un backend de groupe d'instances géré (MIG). Pour cet exemple, vous configurez le déploiement présenté dans le schéma suivant.

Exemple de configuration d'équilibreur de charge réseau proxy externe avec des backends de groupe d'instances.
Exemple de configuration d'équilibreur de charge réseau proxy externe avec des backends de groupe d'instances.

Dans cet exemple, nous allons utiliser l'équilibreur de charge pour répartir le trafic TCP entre les VM de backend de deux groupes d'instances gérés zonaux dans la région A. Pour les besoins de cet exemple, le service est un ensemble de serveurs Apache configurés pour répondre sur le port 110. De nombreux navigateurs n'autorisent pas le port 110. La section consacrée aux tests utilise donc curl.

Un équilibreur de charge réseau proxy externe régional est un équilibreur de charge régional. Tous les composants de l'équilibreur de charge doivent se trouver dans la même région que l'équilibreur de charge.

Autorisations

Pour suivre ce guide, vous devez savoir comment créer des instances et modifier un réseau dans un projet. Vous devez être propriétaire ou éditeur du projet, ou disposer de tous les rôles IAM Compute Engine suivants.

Tâche Rôle requis
Créer des réseaux, des sous-réseaux et des composants de l'équilibreur de charge Administrateur de réseaux Compute (roles/compute.networkAdmin)
Ajouter et supprimer des règles de pare-feu Administrateur de sécurité de Compute (roles/compute.securityAdmin)
Créer des instances Administrateur d'instances Compute (roles/compute.instanceAdmin)

Pour en savoir plus, consultez les guides suivants :

Facultatif : Utiliser des adresses BYOIP

L'option BYOIP (Bring your own IP) vous permet d'importer vos propres adresses publiques dansGoogle Cloud pour les utiliser avec les ressources Google Cloud . Par exemple, si vous importez vos propres adresses IPv4, vous pouvez en attribuer une à la règle de transfert lorsque vous configurez votre équilibreur de charge. Lorsque vous suivez les instructions de ce document pour configurer l'équilibreur de charge, indiquez l'adresse BYOIP comme adresse IP.

Pour en savoir plus sur l'utilisation de BYOIP, consultez Adresses BYOIP (Bring your own IP).

Configurer le réseau et les sous-réseaux

Vous avez besoin d'un réseau VPC avec deux sous-réseaux : un pour les backends de l'équilibreur de charge et l'autre pour les proxys de l'équilibreur de charge. Cet équilibreur de charge est régional. Le trafic au sein du réseau VPC est acheminé vers l'équilibreur de charge si la source du trafic se trouve dans un sous-réseau dans la même région que l'équilibreur de charge.

Cet exemple utilise le réseau VPC, la région et les sous-réseaux suivants :

  • Réseau : un réseau VPC en mode personnalisé nommé lb-network

  • Sous-réseau pour les backends : un sous-réseau nommé backend-subnet dans la région A qui utilise 10.1.2.0/24 pour sa plage d'adresses IP principale

  • Sous-réseau pour les proxys : un sous-réseau nommé proxy-only-subnet dans la région B qui utilise 10.129.0.0/23 pour sa plage d'adresses IP principale

Créer le réseau et les sous-réseaux

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

  4. Dans la section Sous-réseaux, définissez le Mode de création du sous-réseau sur Personnalisé.

  5. Créez un sous-réseau pour les backends de l'équilibreur de charge. Dans la section Nouveau sous-réseau, saisissez les informations suivantes :

    • Nom : backend-subnet
    • Région : REGION_A
    • Plage d'adresses IP : 10.1.2.0/24

  6. Cliquez sur OK.

  7. Cliquez sur Créer.

gcloud

  1. Pour créer un réseau VPC personnalisé, utilisez la commande gcloud compute networks create :

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

  2. Pour créer un sous-réseau sur le réseau lb-network, dans la région REGION_A, utilisez la commande gcloud compute networks subnets create :

    gcloud compute networks subnets create backend-subnet \
    --network=lb-network \
    --range=10.1.2.0/24 \
    --region=REGION_A

Créer le sous-réseau proxy réservé

Un sous-réseau proxy réservé fournit un ensemble d'adresses IP utilisées par Google pour exécuter des proxys Envoy en votre nom. Les proxys interrompent les connexions du client et créent de nouvelles connexions vers les backends.

Ce sous-réseau proxy réservé est utilisé par tous les équilibreurs de charge basés sur Envoy dans la région A du réseau VPC lb-network.

Console

Si vous utilisez la console Google Cloud , vous pouvez créer le sous-réseau proxy réservé ultérieurement sur la page Équilibrage de charge.

Si vous souhaitez créer le sous-réseau proxy réservé maintenant, 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 le nom du réseau VPC partagé : lb-network.

  3. Cliquez sur Ajouter un sous-réseau.

  4. Dans le champ Nom, saisissez proxy-only-subnet.

  5. Pour Région, sélectionnez REGION_A.

  6. Définissez le champ Objectif sur Proxy géré régional.

  7. Dans Plage d'adresses IP, saisissez 10.129.0.0/23.

  8. Cliquez sur Ajouter.

gcloud

Pour créer le sous-réseau proxy réservé, utilisez la commande gcloud compute networks subnets create :

gcloud compute networks subnets create proxy-only-subnet \
    --purpose=REGIONAL_MANAGED_PROXY \
    --role=ACTIVE \
    --region=REGION_A \
    --network=lb-network \
    --range=10.129.0.0/23

Créer des règles de pare-feu

Dans cet exemple, vous devez créer les règles de pare-feu suivantes :

  • fw-allow-ssh : règle d'entrée, applicable aux instances faisant l'objet d'un équilibrage de charge, qui autorise la connectivité SSH entrante sur le port TCP 22 à partir de n'importe quelle adresse. Vous pouvez choisir une plage d'adresses IP sources plus restrictive pour cette règle. Par exemple, vous pouvez spécifier uniquement les plages d'adresses IP du système à partir duquel vous souhaitez lancer des sessions SSH. Cet exemple utilise le tag cible allow-ssh.

  • fw-allow-health-check : règle d'entrée, applicable aux instances faisant l'objet d'un équilibrage de charge, qui autorise tout le trafic TCP provenant des plages de vérification d'étatGoogle Cloud . Cet exemple utilise le tag cible allow-health-check.

  • fw-allow-proxy-only-subnet : règle d'entrée qui autorise les connexions provenant du sous-réseau proxy réservé à accéder aux backends.

Sans ces règles de pare-feu, la règle d'entrée interdite par défaut bloque le trafic entrant vers les instances backend.

Les tags cibles définissent les instances backend. Sans les tags cibles, les règles de pare-feu s'appliquent à toutes les instances backend du réseau VPC. Lorsque vous créez les VM de backend, veillez à inclure les tags cibles spécifiés, comme décrit dans la section Créer un groupe d'instances géré.

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. Cliquez de nouveau sur Créer une règle de pare-feu pour créer la règle autorisant les connexions SSH entrantes. Remplissez les champs suivants :

    • Nom : fw-allow-ssh
    • Réseau : lb-network
    • Sens du trafic : entrée
    • Action en cas de correspondance : autoriser
    • Cibles : Tags cibles spécifiés
    • Tags cibles : allow-ssh
    • Filtre source : Plages IPv4
    • Plages IPv4 sources : 0.0.0.0/0
    • Protocoles et ports :
      • Choisissez Protocoles et ports spécifiés.
      • Cochez la case TCP, puis saisissez 22 pour le numéro de port.

  3. Cliquez sur Créer.

  4. Cliquez une deuxième fois sur Créer une règle de pare-feu pour créer la règle autorisant les vérifications de l'étatGoogle Cloud  :

    • Nom : fw-allow-health-check
    • Réseau : lb-network
    • Sens du trafic : entrée
    • Action en cas de correspondance : autoriser
    • Cibles : Tags cibles spécifiés
    • Tags cibles : allow-health-check
    • Filtre source : Plages IPv4
    • Plages IPv4 sources : 35.191.0.0/16,130.211.0.0/22

    • Protocoles et ports :

      • Choisissez Protocoles et ports spécifiés.
      • Cochez la case TCP, puis saisissez 80 pour le numéro de port.

      Nous vous recommandons de limiter cette règle aux seuls protocoles et ports qui correspondent à ceux utilisés par votre vérification de l'état. Si vous utilisez tcp:80 pour le protocole et le port, Google Cloud peut contacter vos VM via HTTP sur le port 80, mais pas via HTTPS sur le port 443.

  5. Cliquez sur Créer.

  6. Cliquez une troisième fois sur Créer une règle de pare-feu pour créer la règle autorisant les serveurs proxy de l'équilibreur de charge à se connecter aux backends :

    • Nom : fw-allow-proxy-only-subnet
    • Réseau : lb-network
    • Sens du trafic : entrée
    • Action en cas de correspondance : autoriser
    • Cibles : Tags cibles spécifiés
    • Tags cibles : allow-proxy-only-subnet
    • Filtre source : Plages IPv4
    • Plages IPv4 sources : 10.129.0.0/23
    • Protocoles et ports :
      • Choisissez Protocoles et ports spécifiés.
      • Cochez la case TCP, puis saisissez 80 comme numéro de port.

  7. Cliquez sur Créer.

gcloud

  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. Lorsque vous omettez source-ranges,Google Cloud interprète la règle comme désignant n'importe quelle source.

    gcloud compute firewall-rules create fw-allow-ssh \
    --network=lb-network \
    --action=allow \
    --direction=ingress \
    --target-tags=allow-ssh \
    --rules=tcp:22

  2. Créez la règle fw-allow-health-check pour autoriser les vérifications d'état Google Cloud. Cet exemple autorise tout le trafic TCP provenant des tests de vérification d'état. Toutefois, vous pouvez configurer un ensemble de ports plus restreint en fonction de vos besoins.

    gcloud compute firewall-rules create fw-allow-health-check \
    --network=lb-network \
    --action=allow \
    --direction=ingress \
    --source-ranges=35.191.0.0/16,130.211.0.0/22 \
    --target-tags=allow-health-check \
    --rules=tcp:80

  3. Créez la règle fw-allow-proxy-only-subnet pour autoriser les proxys Envoy de la région à se connecter à vos backends. Définissez --source-ranges sur les plages allouées de votre sous-réseau proxy réservé, dans cet exemple, 10.129.0.0/23.

    gcloud compute firewall-rules create fw-allow-proxy-only-subnet \
    --network=lb-network \
    --action=allow \
    --direction=ingress \
    --source-ranges=10.129.0.0/23 \
    --target-tags=allow-proxy-only-subnet \
    --rules=tcp:80

Réserver l'adresse IP de l'équilibreur de charge

Réservez une adresse IP statique pour l'équilibreur de charge.

Console

  1. Dans la console Google Cloud , accédez à la page Réserver une adresse statique.

    Accédez à la page "Réserver une adresse statique"

  2. Choisissez un nom pour la nouvelle adresse.

  3. Définissez le Niveau de service réseau sur Standard.

  4. Pour Version IP, sélectionnez IPv4. Les adresses IPv6 ne sont pas compatibles.

  5. Pour le Type, sélectionnez Régional.

  6. Pour Région, sélectionnez REGION_A.

  7. Laissez l'option Associé à définie sur Aucun. Une fois l'équilibreur de charge créé, cette adresse IP sera associée à la règle de transfert de l'équilibreur de charge.

  8. Cliquez sur Réserver pour réserver l'adresse IP.

gcloud

  1. Pour réserver une adresse IP externe statique, utilisez la commande gcloud compute addresses create :

    gcloud compute addresses create ADDRESS_NAME  \
    --region=REGION_A \
    --network-tier=STANDARD

    Remplacez ADDRESS_NAME par le nom que vous souhaitez donner à cette adresse.

  2. Pour afficher le résultat, utilisez la commande gcloud compute addresses describe :

    gcloud compute addresses describe ADDRESS_NAME

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

Cette section explique comment créer deux backends de groupe d'instances géré (MIG) dans la région A pour l'équilibreur de charge. Le MIG fournit des instances de VM exécutant les serveurs de backend Apache pour cet exemple. En règle générale, un équilibreur de charge réseau proxy externe régional n'est pas utilisé pour le trafic HTTP. Néanmoins, le logiciel Apache est couramment utilisé pour les tests.

Console

Créer un modèle d'instance

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

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

  2. Cliquez sur Créer un modèle d'instance.

  3. Dans le champ Nom, saisissez ext-reg-tcp-proxy-backend-template.

  4. Assurez-vous que le disque de démarrage est défini sur une image Debian, telle que Debian GNU/Linux 12 (bookworm). Ces instructions utilisent des commandes uniquement disponibles dans Debian, comme apt-get.

  5. Cliquez sur Options avancées.

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

    1. Pour Tags réseau, saisissez allow-ssh, allow-health-check et allow-proxy-only-subnet.
    2. Pour Interfaces réseau, sélectionnez l'option suivante :
      • Réseau : lb-network
      • Sous-réseau : backend-subnet

  7. Cliquez sur Gestion. Saisissez le script suivant dans le champ Script de démarrage :

     #! /bin/bash
 apt-get update
 apt-get install apache2 -y
 a2ensite default-ssl
 a2enmod ssl
 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
 systemctl restart apache2

  8. Cliquez sur Créer.

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

  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. Sélectionnez Nouveau groupe d'instances géré (sans état). Pour en savoir plus, consultez la page Créer un MIG avec des disques avec état.

  4. Dans le champ Nom, saisissez mig-a.

  5. Pour Emplacement, sélectionnez Zone unique.

  6. Pour Région, sélectionnez REGION_A.

  7. Pour Zone, sélectionnez ZONE_A.

  8. Pour Modèle d'instance, sélectionnez ext-reg-tcp-proxy-backend-template.

  9. Spécifiez le nombre d'instances que vous souhaitez créer au sein du groupe.

    Pour cet exemple, spécifiez les options suivantes sous Autoscaling :

    • Dans le champ Mode autoscaling, sélectionnez Off:do not autoscale.
    • Dans le champ Nombre maximal d'instances, saisissez 2.

  10. Pour Mappage des ports, cliquez sur Ajouter un port.

    • Pour nom du port, saisissez tcp80.
    • Pour Numéro de port, saisissez 80.

  11. Cliquez sur Créer.

  12. Pour créer un deuxième groupe d'instances géré, répétez la procédure de création d'un groupe d'instances géré et utilisez les paramètres suivants :

    • Nom : mig-b
    • Zone : ZONE_B

    Ne modifiez aucun autre paramètre.

gcloud

Les instructions Google Cloud CLI du présent guide supposent que vous utilisez Cloud Shell ou un autre environnement avec bash installé.

  1. Pour créer un modèle d'instance de VM avec le serveur HTTP, utilisez la commande gcloud compute instance-templates create :

    gcloud compute instance-templates create ext-reg-tcp-proxy-backend-template \
    --region=REGION_A \
    --network=lb-network \
    --subnet=backend-subnet \
    --tags=allow-ssh,allow-health-check,allow-proxy-only-subnet \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --metadata=startup-script='#! /bin/bash
       apt-get update
       apt-get install apache2 -y
       a2ensite default-ssl
       a2enmod ssl
       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
       systemctl restart apache2'

  2. Créez un groupe d'instances géré dans la zone ZONE_A :

    gcloud compute instance-groups managed create mig-a \
    --zone=ZONE_A \
    --size=2 \
    --template=ext-reg-tcp-proxy-backend-template

  3. Créez un groupe d'instances géré dans la zone ZONE_B :

    gcloud compute instance-groups managed create mig-b \
    --zone=ZONE_B \
    --size=2 \
    --template=ext-reg-tcp-proxy-backend-template

Configurer l'équilibreur de charge

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 proxy, puis cliquez sur Suivant.
  5. Pour Public ou interne, sélectionnez Public (externe), puis cliquez sur Suivant.
  6. Pour Déploiement mondial ou dans une seule région, sélectionnez Recommandé pour les charges de travail à l'échelle régionale, puis cliquez sur Suivant.
  7. Cliquez sur Configurer.

Configuration de base

  1. Dans le champ Nom, saisissez my-ext-tcp-lb.
  2. Pour Région, sélectionnez REGION_A.
  3. Pour Réseau, sélectionnez lb-network.

Réserver un sous-réseau proxy réservé

  1. Cliquez sur Réserver.
  2. Dans le champ Nom, saisissez proxy-only-subnet.
  3. Dans le champ Plage d'adresses IP, saisissez 10.129.0.0/23.
  4. Cliquez sur Ajouter.

Configurer les backends

  1. Cliquez sur Configuration du backend.
  2. Dans la liste Type de backend, sélectionnez Groupe d'instances.
  3. Dans la liste Protocole, sélectionnez TCP.
  4. Dans le champ Port nommé, saisissez tcp80.
  5. Configurez la vérification d'état :
    1. Dans la liste Vérification d'état, sélectionnez Créer une vérification d'état.
    2. Dans le champ Nom, saisissez tcp-health-check.
    3. Dans la liste Protocole, sélectionnez TCP.
    4. Dans le champ Port, saisissez 80.
    5. Cliquez sur Créer.
  6. Configurez le premier backend :
    1. Dans le champ Nouveau backend, sélectionnez le groupe d'instances mig-a.
    2. Pour Numéros de ports, saisissez 80.
    3. Conservez les valeurs par défaut restantes, puis cliquez sur OK.
  7. Configurez le deuxième backend :
    1. Cliquez sur Ajouter un backend.
    2. Dans le champ Nouveau backend, sélectionnez le groupe d'instances mig-b.
    3. Pour Numéros de ports, saisissez 80.
    4. Conservez les valeurs par défaut restantes, puis cliquez sur OK.
  8. Conservez les valeurs par défaut restantes, puis cliquez sur Enregistrer.
  9. Dans la console Google Cloud , vérifiez qu'une coche apparaît à côté de Configuration du backend. Si ce n'est pas le cas, vérifiez que vous avez bien suivi la procédure ci-dessous dans son intégralité.

Configurer l'interface

  1. Cliquez sur Configuration de l'interface.
  2. Dans le champ Nom, saisissez ext-reg-tcp-forwarding-rule.
  3. Définissez le Niveau de service réseau sur Standard.
  4. Pour Adresse IP, sélectionnez l'adresse IP réservée précédemment : LB_IP_ADDRESS
  5. Pour Numéro de port, saisissez 110. La règle de transfert transfère les paquets avec un port de destination correspondant.
  6. Dans le champ Protocole de proxy, sélectionnez Désactivé, car le protocole PROXY ne fonctionne pas avec le logiciel Apache HTTP Server. Pour en savoir plus, consultez la section Protocole de PROXY.
  7. Cliquez sur OK.
  8. Dans la console Google Cloud , vérifiez qu'une coche apparaît à côté de Configuration du frontend. Dans le cas contraire, vérifiez que vous avez bien suivi la procédure ci-dessus dans son intégralité.

Vérifier et finaliser

  1. Cliquez sur Vérifier et finaliser.
  2. Vérifiez les paramètres de configuration de votre équilibreur de charge.
  3. Facultatif : cliquez sur Code équivalent pour afficher la requête API REST qui est utilisée pour créer l'équilibreur de charge.
  4. Cliquez sur Créer.

gcloud

  1. Créez une vérification d'état régionale :

    gcloud compute health-checks create tcp tcp-health-check \
    --region=REGION_A \
    --use-serving-port

  2. Créez un service de backend :

    gcloud compute backend-services create ext-reg-tcp-proxy-bs \
    --load-balancing-scheme=EXTERNAL_MANAGED \
    --protocol=TCP \
    --port-name=tcp80 \
    --region=REGION_A \
    --health-checks=tcp-health-check \
    --health-checks-region=REGION_A

  3. Ajoutez des groupes d'instances au service de backend :

    gcloud compute backend-services add-backend ext-reg-tcp-proxy-bs \
    --region=REGION_A \
    --instance-group=mig-a \
    --instance-group-zone=ZONE_A \
    --balancing-mode=UTILIZATION \
    --max-utilization=0.8
 
    gcloud compute backend-services add-backend ext-reg-tcp-proxy-bs \
    --region=REGION_A \
    --instance-group=mig-b \
    --instance-group-zone=ZONE_B \
    --balancing-mode=UTILIZATION \
    --max-utilization=0.8

  4. Créez un proxy TCP cible :

    gcloud compute target-tcp-proxies create ext-reg-tcp-target-proxy \
    --backend-service=ext-reg-tcp-proxy-bs \
    --proxy-header=NONE \
    --region=REGION_A

    Si vous souhaitez activer l'en-tête de proxy, définissez le paramètre --proxy-header sur PROXY_V1 au lieu de NONE. Dans cet exemple, n'activez pas le protocole PROXY, car il ne fonctionne pas avec le logiciel Apache HTTP Server. Pour en savoir plus, consultez la section Protocole de PROXY.

  5. Créez la règle de transfert. Pour --ports, spécifiez un seul numéro de port compris entre 1 et 65 535. Cet exemple utilise le port 110. La règle de transfert transfère les paquets avec un port de destination correspondant.

    gcloud compute forwarding-rules create ext-reg-tcp-forwarding-rule \
    --load-balancing-scheme=EXTERNAL_MANAGED \
    --network-tier=STANDARD \
    --network=lb-network \
    --region=REGION_A \
    --target-tcp-proxy=ext-reg-tcp-target-proxy \
    --target-tcp-proxy-region=REGION_A \
    --address=LB_IP_ADDRESS \
    --ports=110

Tester l'équilibreur de charge

Maintenant que vous avez configuré votre équilibreur de charge, vous pouvez commencer à envoyer du trafic vers son adresse IP.

  1. Obtenez l'adresse IP de l'équilibreur de charge.

    Pour obtenir l'adresse IPv4, exécutez la commande suivante :

    gcloud compute addresses describe ADDRESS_NAME

  2. Envoyez du trafic à votre équilibreur de charge en exécutant la commande suivante. Remplacez LB_IP_ADDRESS par l'adresse IPv4 de votre équilibreur de charge.

    curl -m1 LB_IP_ADDRESS:9090

Options de configuration supplémentaires

Cette section développe l'exemple de configuration et propose d'autres options de configuration. Toutes les tâches décrites ici sont facultatives. Vous pouvez les exécuter dans n'importe quel ordre.

Créer un équilibreur de charge avec des routes TLS

Cette section vous explique comment créer un équilibreur de charge pouvant utiliser le routage basé sur SNI. Le routage basé sur SNI permet à vos équilibreurs de charge réseau proxy d'acheminer le trafic vers des services de backend spécifiques en fonction du nom d'hôte SNI (Server Name Indication) fourni lors du handshake TLS.

Pour créer cet équilibreur de charge, nous utilisons les mêmes réseaux, sous-réseaux et règles de pare-feu que ceux créés précédemment sur cette page. Vous configurez le déploiement présenté dans le schéma suivant :

Configuration d'un équilibreur de charge réseau proxy externe régional avec des routes TLS.
Configuration d'un équilibreur de charge réseau proxy externe régional avec des routes TLS.

Créer un backend de groupe d'instances géré

Cette section explique comment créer des backends de groupe d'instances géré (MIG) pour l'équilibreur de charge. Le MIG fournit des instances de VM exécutant les serveurs de backend pour cet exemple.

Les instructions Google Cloud CLI du présent guide supposent que vous utilisez Cloud Shell ou un autre environnement avec bash installé.

  1. Créez un modèle d'instance avec un service HTTPS "echo" exposé sur le port 443.

    gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME \
--region=REGION_A \
--network=NETWORK \
--subnet=SUBNET_A \
--stack-type=IPv4_ONLY \
--tags=allow-ssh,allow-health-check,allow-proxy-only-subnet \
--image-family=debian-12 \
--image-project=debian-cloud \
--metadata=startup-script='#! /bin/bash
sudo sed -i "s/^#DNS=.*/DNS=8.8.8.8 8.8.4.4/" /etc/systemd/resolved.conf
sudo systemctl restart systemd-resolved
sudo rm -rf /var/lib/apt/lists/*
sudo apt-get -y clean
sudo apt-get -y update
sudo apt-get -y install ca-certificates curl gnupg software-properties-common
sudo curl -fsSL https://download.docker.com/linux/debian/gpg | sudo apt-key add -
sudo add-apt-repository -y "deb [arch=amd64] https://download.docker.com/linux/debian $(lsb_release -cs) stable"
sudo apt-get -y update
sudo apt-get -y install docker-ce
sudo which docker
echo "{ \"registry-mirrors\": [\"https://mirror.gcr.io\"] }" | sudo tee -a /etc/docker/daemon.json
sudo service docker restart
sudo docker run -e HTTPS_PORT=9999 -p 443:9999 --rm -dt mendhak/http-https-echo:22'

    Remplacez les éléments suivants :

    • INSTANCE_TEMPLATE_NAME : nom du modèle d'instance.
    • REGION_A : région du modèle d'instance.
    • NETWORK : nom du réseau.
    • SUBNET_A : nom du sous-réseau.

  2. Créez un groupe d'instances géré basé sur le modèle d'instance :

    gcloud compute instance-groups managed create INSTANCE_GROUP_NAME \
  --zone=ZONE_A \
  --size=2 \
  --template=INSTANCE_TEMPLATE_NAME

    Remplacez ZONE_A par la zone du groupe d'instances.

  3. Définissez le nom du port de diffusion du groupe d'instances géré :

    gcloud compute instance-groups managed set-named-ports INSTANCE_GROUP_NAME \
  --named-ports=PORT_NAME:PORT_NUMBER \
  --zone=ZONE_A

    Remplacez les éléments suivants :

    • PORT_NAME : nom du port de diffusion, par exemple tcp443.
    • PORT_NUMBER : numéro de port pour le port de diffusion (par exemple, 443).

Configurer le pare-feu

Configurez une règle de pare-feu pour autoriser le trafic provenant de l'équilibreur de charge et des vérifications d'état à accéder aux instances de backend.

gcloud compute firewall-rules create FIREWALL_RULE_NAME \
    --network=NETWORK \
    --action=allow \
    --direction=ingress \
    --source-ranges=35.191.0.0/16,130.211.0.0/22 \
    --target-tags=allow-health-check \
    --rules=tcp:443

Remplacez FIREWALL_RULE_NAME par le nom de la règle de pare-feu.

Configurer l'équilibreur de charge

  1. Créez une vérification de l'état HTTPS :

    gcloud compute health-checks create http HTTPS_HEALTH_CHECK_NAME \
    --region=REGION_A \
    --port=HC_PORT

    Remplacez les éléments suivants :

    • HTTPS_HEALTH_CHECK_NAME : nom de la vérification de l'état.
    • HC_PORT : port de la vérification de l'état (par exemple, 443).
    • REGION_A : région de la vérification de l'état.

  2. Créez un service de backend :

    gcloud compute backend-services create BACKEND_SERVICE_NAME \
    --load-balancing-scheme=EXTERNAL_MANAGED \
    --protocol=TCP \
    --port-name=PORT_NAME \
    --health-checks=HTTPS_HEALTH_CHECK_NAME \
    --health-checks-region=REGION_A \
    --region=REGION_A

    Remplacez les éléments suivants :

    • BACKEND_SERVICE_NAME : nom du service de backend.
    • PORT_NAME : nom du port pour le service de backend. Utilisez le même port nommé que celui configuré sur le groupe d'instances (par exemple, tcp443).
    • HTTPS_HEALTH_CHECK_NAME : nom de la vérification de l'état HTTPS.

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

    gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
    --balancing-mode=UTILIZATION \
    --max-utilization=0.8
    --instance-group=INSTANCE_GROUP_NAME \
    --instance-group-zone=ZONE_A \
    --region=REGION_A

    Remplacez les éléments suivants :

    • INSTANCE_GROUP_NAME : nom du groupe d'instances backend.
    • ZONE_A : zone du groupe d'instances.

  4. Créez un proxy TCP cible.

    gcloud beta compute target-tcp-proxies create TARGET_TCP_PROXY_NAME \
    --load-balancing-scheme=EXTERNAL_MANAGED \
    --proxy-header=NONE \
    --region=REGION_A

    Remplacez TARGET_TCP_PROXY_NAME par le nom du proxy TCP cible.

  5. Créez une spécification de route TLS et enregistrez-la dans un fichier YAML.

    cat <<EOF | tee YAML_FILE_NAME
name: TLS_ROUTE_NAME
targetProxies:
- projects/PROJECT_NUMBER/locations/REGION_A/targetTcpProxies/TARGET_TCP_PROXY
rules:
- matches:
  - sniHost:
    - example.com
  action:
  destinations:
  - serviceName: projects/PROJECT_NUMBER/locations/REGION_A/backendServices/BACKEND_SERVICE_NAME
EOF

    Remplacez les éléments suivants :

    • YAML_FILE_NAME : nom du fichier YAML (par exemple, tls-route.yaml).
    • TLS_ROUTE_NAME : nom de la route TLS.
    • PROJECT_NUMBER : numéro du projet.

  6. Utilisez le fichier de spécification YAML pour créer la ressource de route TLS.

    gcloud network-services tls-routes import TLS_ROUTE_NAME \
  --source=YAML_FILE_NAME \
  --location=REGION_A

  7. Créez la règle de transfert.

    gcloud compute forwarding-rules create FORWARDING_RULE_NAME \
  --load-balancing-scheme=EXTERNAL_MANAGED \
  --network-tier=STANDARD \
  --network=NETWORK \
  --region=REGION_A \
  --target-tcp-proxy=TARGET_TCP_PROXY_NAME \
  --target-tcp-proxy-region=REGION_A \
  --address=IP_ADDRESS \
  --ports=PORT_NUMBER

    Remplacez les éléments suivants :

    • FORWARDING_RULE_NAME : nom de la règle de transfert.
    • NETWORK : nom du réseau.
    • SUBNET_A : nom du sous-réseau dans la même région que l'équilibreur de charge.
    • IP_ADDRESS : adresse IP de l'équilibreur de charge.
    • PORT_NUMBER : port utilisé par la règle de transfert, par exemple 443.

Tester l'équilibreur de charge

Maintenant que vous avez configuré votre équilibreur de charge, vous pouvez commencer à envoyer du trafic vers son adresse IP.

  1. Vérifiez que vous pouvez accéder au service HTTPS via l'équilibreur de charge.

    curl https://example.com --resolve example.com:443:IP_ADDRESS -k

    La commande renvoie une réponse de l'une des VM du groupe d'instances géré, avec les informations suivantes imprimées sur la console.

    "path": "/",
"headers": {
  "host": "example.com",
  "user-agent": "curl/7.81.0",
  "accept": "*/*"
},
"method": "GET",
"body": "",
"fresh": false,
"hostname": "example.com",
"ip": "::ffff:10.142.0.2",
"ips": [],
"protocol": "https",
"query": {},
"subdomains": [],
"xhr": false,
"os": {
  "hostname": "0cd3aec9b351"
},
"connection": {
  "servername": "example.com"
}

    Vous pouvez vérifier que si vous fournissez un autre nom d'hôte SNI qui ne correspond pas à une route TLS, ou si vous ne fournissez pas de nom d'hôte SNI du tout, la requête est abandonnée.

    • Exécutez un test avec un nom d'hôte SNI qui ne correspond pas à example.com pour vous assurer que la connexion est refusée.
    curl https://unknown.com --resolve unknown.com:443:IP_ADDRESS -k
    • Effectuez un test avec une connexion en texte brut sans TLS pour vous assurer que la connexion est refusée.
    curl example.com:443 --resolve example.com:443:IP_ADDRESS -k

    Ces commandes renvoient l'erreur suivante.

    curl: (35) OpenSSL SSL_connect: Connection reset by peer in connection

    Le code d'erreur connection_refused s'affiche dans les journaux proxyStatus lorsque l'équilibreur de charge refuse ces connexions non valides.

Activer l'affinité de session

L'exemple de configuration crée un service de backend sans affinité de session.

Ces procédures vous montrent comment mettre à jour un service de backend pour l'exemple d'équilibreur de charge créé précédemment afin que ce service utilise l'affinité basée sur les adresses IP client ou l'affinité basée sur les cookies générés.

Lorsque l'affinité basée sur les adresses IP client est activée, l'équilibreur de charge dirige les requêtes d'un client particulier toujours vers la même VM de backend, grâce à un hachage créé à partir de l'adresse IP du client et de l'adresse IP de l'équilibreur de charge (l'adresse IP interne d'une règle de transfert interne).

Pour activer l'affinité de session basée sur les adresses IP client, procédez comme suit :

Console

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

    Accéder à la page Équilibrage de charge

  2. Cliquez sur Backends.

  3. Cliquez sur ext-reg-tcp-proxy-bs (nom du service de backend que vous avez créé pour cet exemple), puis sur Modifier.

  4. Sur la page Détails du service backend, cliquez sur Configuration avancée.

  5. Sous Affinité de session, sélectionnez IP client.

  6. Cliquez sur Mettre à jour.

gcloud

Pour mettre à jour le service de backend ext-reg-tcp-proxy-bs et spécifier l'affinité de session basée sur les adresses IP client, utilisez la commande gcloud compute backend-services update ext-reg-tcp-proxy-bs :

gcloud compute backend-services update ext-reg-tcp-proxy-bs \
    --region=REGION_A \
    --session-affinity=CLIENT_IP

Étape suivante