Configurer un équilibreur de charge réseau interne interrégional avec une connectivité hybride

Cette page explique comment déployer un équilibreur de charge réseau proxy interne interrégional pour équilibrer le trafic sur les points de terminaison du réseau se trouvant sur site ou dans d'autres clouds publics, et qui sont accessibles à l'aide de Connectivité hybride.

Si vous ne l'avez pas déjà fait, consultez la page Présentation des NEG de connectivité hybride pour comprendre la configuration réseau requise pour mettre en œuvre l'équilibrage de charge hybride.

Vue d'ensemble de la configuration

L'exemple configure un équilibreur de charge réseau proxy interne interrégional pour des backends de NEG de connectivité zonale et hybride, comme illustré dans la figure suivante :

Exemple d'équilibreur de charge réseau proxy interrégional pour des backends de NEG de connectivité zonale et hybride.
Exemple d'équilibreur de charge réseau proxy interrégional pour des backends de NEG de connectivité zonale et hybride (cliquez pour agrandir).

Vous devez configurer la connectivité hybride avant de tenter de mettre en œuvre un déploiement d'équilibrage de charge hybride. Selon votre choix de produit de connectivité hybride, utilisez Cloud VPN ou Cloud Interconnect (interconnexion dédiée ou partenaire).

Autorisations

Pour configurer l'équilibrage de charge hybride, vous devez disposer des autorisations suivantes :

  • Sur Google Cloud

  • Sur votre environnement sur site ou sur un environnement cloud différent de Google Cloud

    • Autorisation permettant de configurer des points de terminaison du réseau pour accéder depuis Google Cloud aux services situés dans votre environnement sur site ou d'autres environnements cloud, à l'aide d'une combinaison IP:Port. Pour en savoir plus, contactez l'administrateur réseau de votre environnement.
    • Autorisations permettant de créer des règles de pare-feu dans votre environnement sur site ou d'autres environnements cloud afin de permettre aux vérifications d'état de Google d'atteindre les points de terminaison.

En outre, pour suivre les instructions de cette page, vous devez créer un NEG de connectivité hybride, un équilibreur de charge et des NEG zonaux (et leurs points de terminaison), qui vont constituer les backends basés sur Google Cloud pour l'équilibreur de charge.

Vous devez être Propriétaire ou Éditeur du projet, ou disposer des 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)

Établir une connectivité hybride

Votre environnement Google Cloud, ainsi que votre environnement sur site ou d'autres environnements cloud, doivent être connectés via une connectivité hybride, en utilisant des rattachements de VLAN Cloud Interconnect ou des tunnels Cloud VPN avec Cloud Router. Nous vous recommandons d'utiliser une connexion à haute disponibilité.

Lorsque le routage dynamique global est activé, le routeur Cloud Router apprend le point de terminaison spécifique par l'intermédiaire du protocole Border Gateway Protocol (BGP) et le programme dans votre réseau VPC Google Cloud. Le routage dynamique régional n'est pas pris en charge. De même, les routes statiques ne sont pas prises en charge.

Le réseau VPC que vous utilisez pour configurer Cloud Interconnect ou Cloud VPN est le même que celui que vous utilisez pour configurer le déploiement de l'équilibrage de charge hybride. Assurez-vous que les plages CIDR de sous-réseau de votre réseau VPC n'entrent pas en conflit avec vos plages CIDR distantes. Lorsque les adresses IP se chevauchent, les routes de sous-réseau sont prioritaires sur la connectivité à distance.

Pour savoir comment procéder, consultez la documentation suivante :

Configurer votre environnement situé en dehors de Google Cloud

Pour configurer l'équilibrage de charge hybride dans votre environnement sur site ou dans un autre environnement cloud, procédez comme suit :

  • Configurez les points de terminaison du réseau pour exposer les services sur site à Google Cloud (IP:Port).
  • Configurez des règles de pare-feu dans votre environnement sur site ou dans un autre environnement cloud.
  • Configurez Cloud Router pour annoncer les routes requises vers votre environnement privé.

Configurer des points de terminaison du réseau

Une fois que vous avez configuré la connectivité hybride, vous configurez un ou plusieurs points de terminaison du réseau dans votre environnement sur site ou dans d'autres environnements cloud accessibles via Cloud Interconnect ou Cloud VPN, en utilisant une combinaison IP:port. Cette combinaison IP:port est configurée comme un ou plusieurs points de terminaison pour le NEG de connectivité hybride qui sera créé ultérieurement dans Google Cloud au cours de cette procédure.

S'il existe plusieurs chemins d'accès au point de terminaison IP, le routage suit le comportement décrit dans la présentation de Cloud Router.

Configurer les règles de pare-feu

Les règles de pare-feu suivantes doivent être créées dans votre environnement sur site ou dans un autre environnement cloud :

  • Créez une règle de pare-feu autorisant le trafic entrant sur site ou dans d'autres environnements cloud pour autoriser le trafic provenant du sous-réseau proxy réservé de la région à atteindre les points de terminaison.

  • L'ajout de plages de vérification de l'état à la liste d'autorisation de Google n'est pas nécessaire pour les NEG hybrides. Toutefois, si vous utilisez à la fois des NEG hybrides et zonaux dans un service de backend, vous devez ajouter les plages de vérification de l'état Google à la liste d'autorisation pour les NEG zonaux.

Configurez Cloud Router pour annoncer les plages d'adresses IP personnalisées suivantes à votre environnement sur site ou à un autre environnement cloud :

  • Plage du sous-réseau proxy réservé de la région.

Configurer l'environnement Google Cloud

Pour les étapes suivantes, assurez-vous d'utiliser le même réseau VPC (appelé NETWORK dans cette procédure) que celui utilisé pour configurer la connectivité hybride entre les environnements.

En outre, assurez-vous que les régions utilisées (appelées REGION_A et REGION_B dans cette procédure) sont identiques à celles utilisées pour créer le tunnel Cloud VPN ou les rattachements de VLAN Cloud Interconnect.

Configurer les sous-réseaux backend

Utilisez ce sous-réseau pour créer les backends de NEG zonaux de l'équilibreur de charge :

Console

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

    Accéder aux réseaux VPC

  2. Accédez au réseau utilisé pour configurer la connectivité hybride entre les environnements.

  3. Dans la section Sous-réseaux :

    • Définissez Mode de création du sous-réseau sur Personnalisé.
    • Dans la section Nouveau sous-réseau, saisissez les informations suivantes :
      • Renseignez un Nom pour le sous-réseau.
      • Sélectionnez une région : REGION_A
      • Saisissez une plage d'adresses IP.
    • Cliquez sur OK.

  4. Cliquez sur Créer.

  5. Pour ajouter d'autres sous-réseaux dans différentes régions, cliquez sur Ajouter un sous-réseau et répétez les étapes précédentes pour REGION_B.

gcloud

  1. Créez des sous-réseaux dans le réseau utilisé pour configurer la connectivité hybride entre les environnements.

    gcloud compute networks subnets create SUBNET_A \
    --network=NETWORK \
    --range=LB_SUBNET_RANGE1 \
    --region=REGION_A

    gcloud compute networks subnets create SUBNET_B \
    --network=NETWORK \
    --range=LB_SUBNET_RANGE2 \
    --region=REGION_B

API

Envoyez une requête POST à la méthode subnetworks.insert. Remplacez PROJECT_ID par l'ID du projet.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_A/subnetworks

{
 "name": "SUBNET_A",
 "network": "projects/PROJECT_ID/global/networks/NETWORK",
 "ipCidrRange": "LB_SUBNET_RANGE1",
 "region": "projects/PROJECT_ID/regions/REGION_A",
}

Envoyez une requête POST à la méthode subnetworks.insert. Remplacez PROJECT_ID par l'ID du projet.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_B/subnetworks

{
 "name": "SUBNET_B",
 "network": "projects/PROJECT_ID/global/networks/NETWORK",
 "ipCidrRange": "LB_SUBNET_RANGE2",
 "region": "projects/PROJECT_ID/regions/REGION_B",
}

Remplacez les éléments suivants :

  • SUBNET_A et SUBNET_B : nom des sous-réseaux
  • LB_SUBNET_RANGE1 et LB_SUBNET_RANGE2 : plage d'adresses IP des sous-réseaux
  • REGION_A et REGION_B : régions dans lesquelles vous avez configuré l'équilibreur de charge.

Configurer 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 régionaux basés sur Envoy dans la même région que le réseau VPC. Il ne peut y avoir qu'un seul sous-réseau proxy réservé actif pour une utilisation donnée, par région et par réseau.

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.
  3. Dans l'onglet Sous-réseaux, cliquez sur Ajouter un sous-réseau.
  4. Saisissez un Nom pour le sous-réseau proxy réservé.
  5. Dans la liste Région, sélectionnez REGION_A.
  6. Dans la liste Objectif, sélectionnez Proxy géré interrégional.
  7. Dans le champ Plage d'adresses IP, saisissez 10.129.0.0/23.
  8. Cliquez sur Ajouter.

Créez le sous-réseau proxy réservé dans REGION_B.

  1. Cliquez sur Ajouter un sous-réseau.
  2. Saisissez un Nom pour le sous-réseau proxy réservé.
  3. Dans la liste Région, sélectionnez REGION_B.
  4. Dans la liste Objectif, sélectionnez Proxy géré interrégional.
  5. Dans le champ Plage d'adresses IP, saisissez 10.130.0.0/23.
  6. Cliquez sur Ajouter.

gcloud

Créez le sous-réseau proxy réservé à l'aide de la commande gcloud compute networks subnets create.

    gcloud compute networks subnets create PROXY_SN_A \
        --purpose=GLOBAL_MANAGED_PROXY \
        --role=ACTIVE \
        --region=REGION_A \
        --network=NETWORK \
        --range=PROXY_ONLY_SUBNET_RANGE1
    
    gcloud compute networks subnets create PROXY_SN_B \
        --purpose=GLOBAL_MANAGED_PROXY \
        --role=ACTIVE \
        --region=REGION_B \
        --network=NETWORK \
        --range=PROXY_ONLY_SUBNET_RANGE2

Remplacez les éléments suivants :

  • PROXY_SN_A et PROXY_SN_B : nom des sous-réseaux proxy réservés
  • PROXY_ONLY_SUBNET_RANGE1 et PROXY_ONLY_SUBNET_RANGE2 : plage d'adresses IP des sous-réseaux proxy réservés
  • REGION_A et REGION_B : régions dans lesquelles vous avez configuré l'équilibreur de charge.

API

Créez les sous-réseaux proxy réservés avec la méthode subnetworks.insert, en remplaçant PROJECT_ID par votre ID de projet.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_A/subnetworks

    {
      "name": "PROXY_SN_A",
      "ipCidrRange": "PROXY_ONLY_SUBNET_RANGE1",
      "network": "projects/PROJECT_ID/global/networks/NETWORK",
      "region": "projects/PROJECT_ID/regions/REGION_A",
      "purpose": "GLOBAL_MANAGED_PROXY",
      "role": "ACTIVE"
    }
  
    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_B/subnetworks

    {
      "name": " PROXY_SN_B",
      "ipCidrRange": "PROXY_ONLY_SUBNET_RANGE2",
      "network": "projects/PROJECT_ID/global/networks/NETWORK",
      "region": "projects/PROJECT_ID/regions/REGION_B",
      "purpose": "GLOBAL_MANAGED_PROXY",
      "role": "ACTIVE"
    }

Créer des règles de pare-feu

Dans cet exemple, vous devez créer les règles de pare-feu suivantes pour les backends de NEG zonaux sur Google Cloud :

  • fw-allow-health-check : règle d'entrée, applicable aux instances faisant l'objet d'un équilibrage de charge, qui autorise le trafic issu des systèmes de vérification d'état Google Cloud (130.211.0.0/22 et 35.191.0.0/16). Cet exemple utilise le tag cible allow-health-check pour identifier les NEG zonaux auxquels la règle doit s'appliquer.
  • fw-allow-ssh : règle d'entrée 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 pour identifier les VM auxquelles la règle doit s'appliquer.

  • 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 de NEG zonaux.

Console

  1. Dans la console Google Cloud, accédez à la page Règles d'administration.

    Accéder à la page "Stratégies de pare-feu"

  2. Cliquez de nouveau sur Créer une règle de pare-feu pour créer la règle autorisant le trafic provenant des vérifications d'état :

    1. Saisissez le nom fw-allow-health-check.
    2. Pour Réseau, sélectionnez NETWORK.
    3. Pour Cibles, sélectionnez Specified target tags (Tags cibles spécifiés).
    4. Dans le champ Tags cibles, saisissez allow-health-check.
    5. Définissez Filtre source sur Plages IPv4.
    6. Définissez Plages IPv4 sources sur 130.211.0.0/22 et 35.191.0.0/16.
    7. Dans Protocoles et ports, sélectionnez Protocoles et ports spécifiés.
    8. Sélectionnez TCP, puis saisissez 80 pour le numéro de port.
    9. Cliquez sur Créer.

  3. Cliquez de nouveau sur Créer une règle de pare-feu pour créer la règle autorisant les connexions SSH entrantes :

    1. Nom : fw-allow-ssh
    2. Réseau : NETWORK
    3. Priorité : 1000
    4. Sens du trafic : entrée
    5. Action en cas de correspondance : autoriser
    6. Cibles : tags cibles spécifiés
    7. Tags cibles : allow-ssh
    8. Filtre source : Plages IPv4
    9. Plages IPv4 sources : 0.0.0.0/0
    10. Protocoles et ports : sélectionnez Protocoles et ports spécifiés.
    11. Sélectionnez TCP, puis saisissez 22 pour le numéro de port.
    12. Cliquez sur Créer.

  4. Cliquez de nouveau sur Créer une règle de pare-feu pour créer la règle autorisant les connexions entrantes à partir du sous-réseau proxy réservé :

    1. Nom : fw-allow-proxy-only-subnet
    2. Réseau : NETWORK
    3. Priorité : 1000
    4. Sens du trafic : entrée
    5. Action en cas de correspondance : autoriser
    6. Cibles : tags cibles spécifiés
    7. Tags cibles : allow-proxy-only-subnet
    8. Filtre source : Plages IPv4
    9. Plages IPv4 sources : PROXY_ONLY_SUBNET_RANGE1 et PROXY_ONLY_SUBNET_RANGE2
    10. Protocoles et ports : sélectionnez Protocoles et ports spécifiés.
    11. Sélectionnez TCP, puis saisissez 80 pour le numéro de port.
    12. Cliquez sur Créer.

gcloud

  1. Créez la règle fw-allow-health-check-and-proxy pour autoriser les vérifications d'état Google Cloud à atteindre les instances backend sur le port TCP 80 :

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

  2. 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=NETWORK \
    --action=allow \
    --direction=ingress \
    --target-tags=allow-ssh \
    --rules=tcp:22

  3. Créez une règle de pare-feu autorisant le trafic entrant pour le sous-réseau proxy réservé afin de permettre à l'équilibreur de charge de communiquer avec les instances backend sur le port TCP 80 :

    gcloud compute firewall-rules create fw-allow-proxy-only-subnet \
    --network=NETWORK \
    --action=allow \
    --direction=ingress \
    --target-tags=allow-proxy-only-subnet \
    --source-ranges=PROXY_ONLY_SUBNET_RANGE1,PROXY_ONLY_SUBNET_RANGE2 \
    --rules=tcp:80

Configurer le NEG zonal

Pour les backends basés sur Google Cloud, nous vous recommandons de configurer plusieurs NEG zonaux dans la même région que celle où vous avez configuré la connectivité hybride.

Pour cet exemple, nous avons configuré un NEG zonal (avec des points de terminaison de type GCE_VM_IP_PORT) dans la région REGION1. Commencez par créer les VM dans la zone NEG_ZONE1. Créez ensuite un NEG zonal dans la région NEG_ZONE2 et ajoutez les points de terminaison du réseau des VM au NEG. Pour assurer la haute disponibilité, nous avons configuré un NEG zonal similaire dans la région REGION2. Si les backends d'une région sont indisponibles, le trafic bascule vers l'autre région.

Créer des VM

Console

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

    Accéder à la page "Instances de VM"

  2. Répétez les étapes 3 à 8 pour chaque VM en utilisant les combinaisons de noms et de zones suivantes.

    • Nom de vm-a1
      • Zone : NEG_ZONE1 dans la région REGION_A
      • Sous-réseau : SUBNET_A
    • Nom de vm-b1
      • Zone : NEG_ZONE2 dans la région REGION_B
      • Sous-réseau : SUBNET_B

  3. Cliquez sur Créer une instance.

  4. Définissez le nom comme indiqué à l'étape précédente.

  5. Pour la Région, choisissez celle indiquée à l'étape précédente.

  6. Pour la Zone, choisissez celle indiquée à l'étape précédente.

  7. Dans la section Disque de démarrage, assurez-vous que Debian GNU/Linux 12 (bookworm) est sélectionné pour les options du disque de démarrage. Si nécessaire, cliquez sur Sélectionner pour modifier l'image.

  8. Dans la section Options avancées, développez Mise en réseau, puis procédez comme suit :

    • Ajoutez les tags réseau suivants : allow-ssh, allow-health-check et allow-proxy-only-subnet.
    • Dans la section Interfaces réseau, cliquez sur Ajouter une interface réseau, apportez les modifications suivantes, puis cliquez sur OK :
      • Réseau : NETWORK
      • Sous-réseau : comme indiqué à l'étape précédente.
      • Adresse IP interne principale : éphémère (automatique)
      • Adresse IP externe : Éphémère

    • Développez Gestion. Dans le champ Automatisation, copiez et collez le contenu de script suivant. Le contenu du script est identique pour toutes les VM :

      #! /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

  9. Cliquez sur Créer.

gcloud

Créez les VM en exécutant la commande suivante, en utilisant ces combinaisons pour le nom de la VM et sa zone. Le contenu du script est identique pour les deux VM.

  • VM_NAME sur vm-a1
    • La zone GCP_NEG_ZONE en tant que NEG_ZONE1 dans la région REGION_A
    • Le sous-réseau LB_SUBNET_NAME en tant que SUBNET_A

  • VM_NAME sur vm-b1

    • Zone GCP_NEG_ZONE en tant que NEG_ZONE2 dans la région REGION_B
    • Sous-réseau LB_SUBNET_NAME en tant que SUBNET_B
    gcloud compute instances create VM_NAME \
    --zone=GCP_NEG_ZONE \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --tags=allow-ssh,allow-health-check,allow-proxy-only-subnet \
    --subnet=LB_SUBNET_NAME \
    --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'

Créer le NEG zonal

Console

Pour créer un groupe de points de terminaison de réseau zonal :

  1. Dans la console Google Cloud, accédez à la page Groupes de points de terminaison du réseau.

    Accéder à la page "Groupes de points de terminaison du réseau"

  2. Répétez les étapes 3 à 8 pour chaque NEG zonal, en utilisant les combinaisons de nom et de zone suivantes :

    • Nom : neg-1
      • Zone : NEG_ZONE1 dans la région REGION_A
      • Sous-réseau : SUBNET_A
    • Nom : neg-2
      • Zone : NEG_ZONE2 dans la région REGION_B
      • Sous-réseau : SUBNET_B

  3. Cliquez sur Créer un groupe de points de terminaison du réseau.

  4. Définissez le nom comme indiqué à l'étape précédente.

  5. Sélectionnez le type de groupe de points de terminaison du réseau : Groupe de points de terminaison du réseau (zonal).

  6. Sélectionnez le réseau : NETWORK.

  7. Sélectionnez le Sous-réseau comme indiqué à l'étape précédente.

  8. Sélectionnez la zone comme indiqué à l'étape précédente.

  9. Saisissez le port par défaut : 80.

  10. Cliquez sur Créer.

Ajoutez des points de terminaison au NEG zonal :

  1. Dans la console Google Cloud, accédez à la page Groupes de points de terminaison du réseau.

    Accéder à la page Groupes de points de terminaison du réseau

  2. Cliquez sur le Nom du groupe de points de terminaison du réseau créé à l'étape précédente. La page Détails du groupe de points de terminaison du réseau s'affiche.

  3. Dans la section Points de terminaison du réseau de ce groupe, cliquez sur Ajouter un point de terminaison du réseau. La page Ajouter un point de terminaison du réseau s'affiche.

  4. Sélectionnez une instance de VM pour ajouter ses adresses IP internes en tant que points de terminaison du réseau. Dans la section Interface réseau, le nom, la zone et le sous-réseau de la VM s'affichent.

  5. Saisissez l'adresse IP du nouveau point de terminaison du réseau.

  6. Sélectionnez le type de port.

    1. Si vous sélectionnez Par défaut, le point de terminaison utilise le port par défaut 80 pour tous les points de terminaison du groupe de points de terminaison du réseau. Cela est suffisant pour notre exemple, car le serveur Apache diffuse les requêtes au port 80.
    2. Si vous sélectionnez Personnalisé, saisissez le numéro de port du point de terminaison à utiliser.

  7. Pour ajouter d'autres points de terminaison, cliquez sur Ajouter un point de terminaison du réseau, puis répétez les étapes précédentes.

  8. Après avoir ajouté tous les points de terminaison, cliquez sur Créer.

gcloud

  1. Créez des NEG zonaux (avec des points de terminaison GCE_VM_IP_PORT) à l'aide des combinaisons de noms, de zones et de sous-réseaux. Exécutez la commande gcloud compute network-endpoint-groups create.

    • Nom : neg-1
      • Zone GCP_NEG_ZONE : NEG_ZONE1 dans la région REGION_A
      • Sous-réseau LB_SUBNET_NAME : SUBNET_A
    • Nom : neg-2
      • Zone GCP_NEG_ZONE : NEG_ZONE2 dans la région REGION_B
      • Sous-réseau LB_SUBNET_NAME : SUBNET_B
    gcloud compute network-endpoint-groups create GCP_NEG_NAME \
    --network-endpoint-type=GCE_VM_IP_PORT \
    --zone=GCP_NEG_ZONE \
    --network=NETWORK \
    --subnet=LB_SUBNET_NAME

    Vous pouvez spécifier un port à l'aide de l'option --default-port lors de la création du NEG ou spécifier un numéro de port pour chaque point de terminaison, comme indiqué à l'étape suivante.

  2. Ajoutez des points de terminaison à neg1 et neg2.

    gcloud compute network-endpoint-groups update neg1 \
    --zone=NEG_ZONE1 \
    --add-endpoint='instance=vm-a1,port=80'

    gcloud compute network-endpoint-groups update neg2 \
    --zone=NEG_ZONE2 \
    --add-endpoint='instance=vm-b1,port=80'

Configurer le NEG de connectivité hybride

Lorsque vous créez le NEG, utilisez une zone qui réduit la distance géographique entre Google Cloud et votre environnement sur site ou autre environnement cloud.

De plus, si vous utilisez Cloud Interconnect, la zone utilisée pour créer le NEG se trouve dans la même région que le rattachement Cloud Interconnect.

Les NEG hybrides ne sont compatibles qu'avec les vérifications d'état Envoy distribuées.

Console

Pour créer un groupe de points de terminaison du réseau de connectivité hybride :

  1. Dans la console Google Cloud, accédez à la page Groupes de points de terminaison du réseau.

    Accéder à la page Groupes de points de terminaison du réseau

  2. Cliquez sur Créer un groupe de points de terminaison du réseau.

  3. Répétez les étapes 4 à 9 pour chaque NEG hybride, en utilisant les combinaisons de noms et de zones suivantes.

    • Nom ON_PREM_NEG_NAME : hybrid-1
      • Zone : ON_PREM_NEG_ZONE1
      • Sous-réseau : SUBNET_A
    • Nom ON_PREM_NEG_NAME : hybrid-2
      • Zone : ON_PREM_NEG_ZONE2
      • Sous-réseau : SUBNET_B

  4. Définissez le nom comme indiqué à l'étape précédente.

  5. Sélectionnez le type de groupe de points de terminaison du réseau : Groupe de points de terminaison du réseau de connectivité hybride (zonal).

  6. Sélectionnez le réseau : NETWORK.

  7. Pour le sous-réseau, choisissez la valeur indiquée à l'étape précédente.

  8. Pour la zone, choisissez la valeur indiquée à l'étape précédente.

  9. Saisissez le port par défaut.

  10. Cliquez sur Créer.

Ajoutez des points de terminaison au NEG de connectivité hybride :

  1. Dans la console Google Cloud, accédez à la page Groupes de points de terminaison du réseau.

    Accéder à la page Groupes de points de terminaison du réseau

  2. Cliquez sur le nom du groupe de points de terminaison du réseau créé à l'étape précédente. La page Détails du groupe de points de terminaison du réseau s'affiche.

  3. Dans la section Points de terminaison du réseau de ce groupe, cliquez sur Ajouter un point de terminaison du réseau. La page Ajouter un point de terminaison du réseau s'affiche.

  4. Saisissez l'adresse IP du nouveau point de terminaison du réseau.

  5. Sélectionnez le type de port.

    1. Si vous sélectionnez Par défaut, le point de terminaison utilise le port par défaut pour tous les points de terminaison du groupe de points de terminaison du réseau.
    2. Si vous sélectionnez Personnalisé, vous pouvez saisir un numéro de port différent à utiliser par le point de terminaison.

  6. Pour ajouter d'autres points de terminaison, cliquez sur Ajouter un point de terminaison du réseau, puis répétez les étapes précédentes.

  7. Après avoir ajouté tous les points de terminaison autres que Google Cloud, cliquez sur Créer.

gcloud

  1. Créez un NEG de connectivité hybride qui utilise les combinaisons de noms suivantes. Exécutez la commande gcloud compute network-endpoint-groups create.

    • Nom ON_PREM_NEG_NAME : hybrid-1
      • Zone ON_PREM_NEG_ZONE : ON_PREM_NEG_ZONE1
    • Nom ON_PREM_NEG_NAME : hybrid-2
      • Zone GCP_NEG_ZONE : ON_PREM_NEG_ZONE2
    gcloud compute network-endpoint-groups create ON_PREM_NEG_NAME \
    --network-endpoint-type=NON_GCP_PRIVATE_IP_PORT \
    --zone=ON_PREM_NEG_ZONE \
    --network=NETWORK

  2. Ajoutez le point de terminaison de VM de backend sur site à ON_PREM_NEG_NAME :

    gcloud compute network-endpoint-groups update ON_PREM_NEG_NAME \
    --zone=ON_PREM_NEG_ZONE \
    --add-endpoint="ip=ON_PREM_IP_ADDRESS_1,port=PORT_1" \
    --add-endpoint="ip=ON_PREM_IP_ADDRESS_2,port=PORT_2"

Vous pouvez utiliser cette commande pour ajouter les points de terminaison du réseau précédemment configurés dans votre environnement situé sur site ou sur un autre cloud. Répétez --add-endpoint autant de fois que nécessaire.

Configurer l'équilibreur de charge

Console

gcloud

  1. Définissez la vérification d'état TCP à l'aide de la commande gcloud compute health-checks create tcp.

    gcloud compute health-checks create tcp gil4-basic-check \
   --use-serving-port \
   --global

  2. Créez le service de backend pour activer la journalisation avec la commande gcloud compute backend-services create.

    gcloud compute backend-services create BACKEND_SERVICE \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --protocol=TCP \
  --enable-logging \
  --logging-sample-rate=1.0 \
  --health-checks=gil4-basic-check \
  --global-health-checks \
  --global

  3. Ajoutez des backends au service de backend à l'aide de la commande gcloud compute backend-services add-backend.

    gcloud compute backend-services add-backend BACKEND_SERVICE \
  --global \
  --balancing-mode=CONNECTION \
  --max-connections-per-endpoint=MAX_CONNECTIONS \
  --network-endpoint-group=neg1 \
  --network-endpoint-group-zone=NEG_ZONE1 \
  --network-endpoint-group=neg2 \
  --network-endpoint-group-zone=NEG_ZONE2

    Pour en savoir plus sur la configuration du mode d'équilibrage, consultez la documentation de gcloud CLI concernant l'option --max-connections-per-endpoint. Pour MAX_CONNECTIONS, saisissez le nombre maximal de connexions simultanées que le backend doit gérer.

  4. Ajoutez les NEG hybrides en tant que backend au service de backend.

    gcloud compute backend-services add-backend BACKEND_SERVICE \
  --global \
  --balancing-mode=CONNECTION \
  --max-connections-per-endpoint=MAX_CONNECTIONS \
  --network-endpoint-group=hybrid1 \
  --network-endpoint-group-zone=ON_PREM_NEG_ZONE1 \
  --network-endpoint-group=hybrid2 \
  --network-endpoint-group-zone=ON_PREM_NEG_ZONE2 \

    Pour en savoir plus sur la configuration du mode d'équilibrage, consultez la documentation de gcloud CLI concernant le paramètre --max-connections-per-endpoint. Pour MAX_CONNECTIONS, saisissez le nombre maximal de connexions simultanées que le backend doit gérer.

  5. Créez le proxy cible.

    Créez le proxy cible à l'aide de la commande gcloud compute target-tcp-proxies create.

    gcloud compute target-tcp-proxies create gil4-tcp-proxy \
  --url-map=gil4-map \
  --global

  6. Créez deux règles de transfert, l'une avec une adresse IP virtuelle IP_ADDRESS1 dans REGION_A et l'autre avec une adresse IP virtuelle IP_ADDRESS2 dans REGION_B. Pour l'adresse IP de la règle de transfert, utilisez la plage d'adresses IP LB_SUBNET_RANGE1 ou LB_SUBNET_RANGE2. Si vous essayez d'utiliser le sous-réseau proxy réservé, la création de la règle de transfert échoue.

    Pour les réseaux personnalisés, vous devez faire référence au sous-réseau dans la règle de transfert. Notez qu'il s'agit du sous-réseau de VM et non du sous-réseau proxy.

    Utilisez la commande gcloud compute forwarding-rules create avec les options appropriées.

    gcloud compute forwarding-rules create gil4-forwarding-rule-a \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --network=NETWORK \
  --subnet=SUBNET_A \
  --subnet-region=REGION_A \
  --address=IP_ADDRESS1 \
  --ports=80 \
  --target-tcp-proxy=gil4-tcp-proxy \
  --global

    gcloud compute forwarding-rules create gil4-forwarding-rule-b \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --network=NETWORK \
  --subnet=SUBNET_B \
  --subnet-region=REGION_B \
  --address=IP_ADDRESS2 \
  --ports=80 \
  --target-tcp-proxy=gil4-tcp-proxy \
  --global

Tester l'équilibreur de charge

Créer une instance de VM pour tester la connectivité

  1. Créez des VM clientes dans REGION_A, REGION_B et les régions :

    gcloud compute instances create l4-ilb-client-a \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --network=NETWORK \
    --subnet=SUBNET_A \
    --zone=NEG_ZONE1 \
    --tags=allow-ssh

    gcloud compute instances create l4-ilb-client-b \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --network=NETWORK \
    --subnet=SUBNET_B \
    --zone=NEG_ZONE2 \
    --tags=allow-ssh

  2. Utilisez SSH pour vous connecter à chaque instance cliente.

    gcloud compute ssh l4-ilb-client-a \
   --zone=NEG_ZONE1

    gcloud compute ssh l4-ilb-client-b \
   --zone=NEG_ZONE2

  3. Vérifiez que l'adresse IP diffuse son nom d'hôte.

    • Vérifiez que la VM cliente peut atteindre les deux adresses IP. La commande doit réussir et renvoyer le nom de la VM de backend qui a diffusé la requête :

      curl IP_ADDRESS1

      curl IP_ADDRESS2

Exécuter 100 requêtes

Exécutez 100 requêtes curl et vérifiez qu'elles font l'objet d'un équilibrage de charge par le biais des réponses.

  • Vérifiez que la VM cliente peut atteindre les deux adresses IP. La commande doit réussir et renvoyer le nom de la VM de backend qui a diffusé la requête :

    {
  RESULTS=
  for i in {1..100}
  do
    RESULTS="$RESULTS:$(curl --silent IP_ADDRESS1)"
  done
  echo "***"
  echo "*** Results of load-balancing to IP_ADDRESS1: "
  echo "***"
  echo "$RESULTS" | tr ':' '\n' | grep -Ev "^$" | sort | uniq -c
  echo
}

    {
  RESULTS=
  for i in {1..100}
  do
    RESULTS="$RESULTS:$(curl --silent IP_ADDRESS2)"
  done
  echo "***"
  echo "*** Results of load-balancing to IP_ADDRESS2: "
  echo "***"
  echo "$RESULTS" | tr ':' '\n' | grep -Ev "^$" | sort | uniq -c
  echo
}

Tester le basculement

  1. Vérifiez le basculement vers les backends de la région REGION_A lorsque les backends de REGION_B sont non opérationnels ou inaccessibles. Nous simulerons cela en supprimant tous les backends de REGION_B :

    gcloud compute backend-services remove-backend BACKEND_SERVICE \
   --balancing-mode=CONNECTION \
   --network-endpoint-group=neg2 \
   --network-endpoint-group-zone=NEG_ZONE2

  2. Utilisez SSH pour vous connecter à la VM cliente dans le réseau REGION_B.

    gcloud compute ssh l4-ilb-client-b \
   --zone=NEG_ZONE2

  3. Envoyez des requêtes à l'adresse IP faisant l'objet d'un équilibrage de charge dans la région REGION_B. Le résultat de la commande doit afficher les réponses des VM de backend dans REGION_A :

    {
RESULTS=
for i in {1..100}
do
  RESULTS="$RESULTS:$(curl -k -s 'https://test.example.com:443' --connect-to test.example.com:443:IP_ADDRESS2:443)"
done
echo "***"
echo "*** Results of load-balancing to IP_ADDRESS2: "
echo "***"
echo "$RESULTS" | tr ':' '\n' | grep -Ev "^$" | sort | uniq -c
echo
}

Étape suivante