Configurer un équilibreur de charge d'application interne interrégional avec une connectivité hybride

Cette page explique comment déployer un équilibreur de charge d'application 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 d'application interne interrégional pour des backends de NEG de connectivité zonale et hybride, comme illustré dans la figure suivante :

Exemple d'équilibreur de charge d'application interne interrégional pour des backends de NEG de connectivité zonale et hybride.
Exemple d'équilibreur de charge d'application interne 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).

Configurer une ressource de certificat SSL

Créez une ressource de certificat SSL pour le gestionnaire de certificats, comme décrit dans les articles suivants :

Nous vous recommandons d'utiliser un certificat géré par Google.

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 le VLAN Cloud Interconnect en pièces jointes.

Vous pouvez éventuellement configurer des règles de routage DNS de type GEO pour acheminer le trafic client vers l'adresse IP virtuelle de l'équilibreur de charge dans la région la plus proche du client en cas de panne régionale.

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 Google Cloud Console, 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 Google Cloud Console, 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 instances de machine virtuelle (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 REGION_A. Commencez par créer les VM dans la zone ZONE_A. Créez ensuite un NEG zonal dans la zone ZONE_A, puis ajoutez les points de terminaison du réseau des VM au NEG. Pour assurer la haute disponibilité, configurez un NEG zonal similaire dans la région REGION_B. 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 : ZONE_A dans la région REGION_A
      • Sous-réseau : SUBNET_A
    • Nom de vm-b1
      • Zone : ZONE_B 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 les options sélectionnées sont Debian pour le système d'exploitation et 10 (Buster) pour la version. 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.

gcloud compute instances create VM_NAME \
    --zone=GCP_NEG_ZONE \
    --image-family=debian-10 \
    --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'
  • VM_NAME sur vm-a1
    • La zone GCP_NEG_ZONE en tant que ZONE_A 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 ZONE_B dans la région REGION_B
    • Sous-réseau LB_SUBNET_NAME en tant que SUBNET_B

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 : ZONE_A dans la région REGION_A
      • Sous-réseau : SUBNET_A
    • Nom : neg-2
      • Zone : ZONE_B 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 Create (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.

    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
    • Nom : neg-1
      • Zone GCP_NEG_ZONE : ZONE_A dans la région REGION_A
      • Sous-réseau LB_SUBNET_NAME : SUBNET_A
    • Nom : neg-2
      • Zone GCP_NEG_ZONE : ZONE_B dans la région REGION_B
      • Sous-réseau LB_SUBNET_NAME : SUBNET_B

    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=ZONE_A \
    --add-endpoint='instance=vm-a1,port=80'

    gcloud compute network-endpoint-groups update neg2 \
    --zone=ZONE_B \
    --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. Par exemple, si vous hébergez un service dans un environnement sur site à Francfort, en Allemagne, vous pouvez spécifier la zone Google Cloud europe-west3-a lorsque vous créez le NEG.

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.

    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
    • 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

  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 HTTP à l'aide de la commande gcloud compute health-checks create http.

    gcloud compute health-checks create http gil7-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=HTTP \
  --enable-logging \
  --logging-sample-rate=1.0 \
  --health-checks=gil7-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=RATE \
  --max-rate-per-endpoint=MAX_REQUEST_RATE_PER_ENDPOINT \
  --network-endpoint-group=neg1 \
  --network-endpoint-group-zone=ZONE_A \
  --network-endpoint-group=neg2 \
  --network-endpoint-group-zone=ZONE_B

    Pour en savoir plus sur la configuration du mode d'équilibrage, consultez la documentation de gcloud CLI concernant l'option --max-rate-per-endpoint.

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

    gcloud compute backend-services add-backend BACKEND_SERVICE \
  --global \
  --balancing-mode=RATE \
  --max-rate-per-endpoint=MAX_REQUEST_RATE_PER_ENDPOINT \
  --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-rate-per-endpoint.

  5. Créez le mappage d'URL à l'aide de la commande gcloud compute url-maps create.

    gcloud compute url-maps create gil7-map \
  --default-service=BACKEND_SERVICE \
  --global

  6. Créez le proxy cible.

    Pour HTTP :

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

    gcloud compute target-http-proxies create gil7-http-proxy \
  --url-map=gil7-map \
  --global

    Pour HTTPS :

    Pour créer un certificat géré par Google, consultez la documentation suivante :

    Après avoir créé le certificat géré par Google, associez-le au proxy cible. Les mappages de certificats ne sont pas compatibles avec les équilibreurs de charge d'application internes interrégionaux.

    Pour créer un certificat autogéré, consultez la documentation suivante :

    Attribuez vos chemins de fichiers à des noms de variables.

    export LB_CERT=PATH_TO_PEM_FORMATTED_FILE

    export LB_PRIVATE_KEY=PATH_TO_PEM_LB_PRIVATE_FILE

    Créez un certificat SSL toutes régions à l'aide de la commande gcloud certificate-manager certificates create.

    gcloud certificate-manager certificates create gilb-certificate \
  --private-key-file=$LB_CERT \
  --certificate-file=$LB_PRIVATE_KEY \
  --scope=all-regions

    Utilisez le certificat SSL pour créer le proxy cible à l'aide de la commande gcloud compute target-https-proxies create.

    gcloud compute target-https-proxies create gil7-https-proxy \
  --url-map=gil7-map \
  --certificate-manager-certificates=gilb-certificate \
  --global

  7. Créez deux règles de transfert, l'une avec une adresse IP virtuelle IP_ADDRESS1 dans la région REGION_A et l'autre avec une adresse IP virtuelle IP_ADDRESS2 dans la région 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.

    Pour HTTP :

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

    gcloud compute forwarding-rules create FWRULE_A \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --network=NETWORK \
  --subnet=SUBNET_A \
  --subnet-region=REGION_A \
  --address=IP_ADDRESS1 \
  --ports=80 \
  --target-http-proxy=gil7-http-proxy \
  --global

    gcloud compute forwarding-rules create FWRULE_B \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --network=NETWORK \
  --subnet=SUBNET_B \
  --subnet-region=REGION_B \
  --address=IP_ADDRESS2 \
  --ports=80 \
  --target-http-proxy=gil7-http-proxy \
  --global

    Pour HTTPS :

    Créez la règle de transfert à l'aide de la commande gcloud compute forwarding-rules create avec les options appropriées.

    gcloud compute forwarding-rules create FWRULE_A \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --network=NETWORK \
  --subnet=SUBNET_A \
  --subnet-region=REGION_A \
  --address=IP_ADDRESS1 \
  --ports=443 \
  --target-https-proxy=gil7-https-proxy \
  --global

    gcloud compute forwarding-rules create FWRULE_B \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --network=NETWORK \
  --subnet=SUBNET_B \
  --subnet-region=REGION_B \
  --address=IP_ADDRESS2 \
  --ports=443 \
  --target-https-proxy=gil7-https-proxy \
  --global

Connecter un domaine à votre équilibreur de charge

Après avoir créé l'équilibreur de charge, notez l'adresse IP associée à celui-ci (par exemple, IP_ADDRESS1 et IP_ADDRESS2). Pour faire pointer votre domaine vers votre équilibreur de charge, créez un enregistrement A à l'aide de Cloud DNS ou du service d'enregistrement de domaine. Si vous avez ajouté plusieurs domaines à votre certificat SSL, vous devez ajouter un enregistrement A à chacun d'eux, tous pointant vers l'adresse IP de l'équilibreur de charge.

Tester l'équilibreur de charge

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

  1. Créer une VM cliente :

    gcloud compute instances create l7-ilb-client-a \
    --image-family=debian-10 \
    --image-project=debian-cloud \
    --network=NETWORK \
    --subnet=SUBNET_A \
    --zone=ZONE_A \
    --tags=allow-ssh

    gcloud compute instances create l7-ilb-client-b \
    --image-family=debian-10 \
    --image-project=debian-cloud \
    --network=NETWORK \
    --subnet=SUBNET_B \
    --zone=ZONE_B \
    --tags=allow-ssh

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

    gcloud compute ssh l7-ilb-client-a \
   --zone=ZONE_A

    gcloud compute ssh l7-ilb-client-b \
   --zone=ZONE_B

  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

      Pour le test HTTPS, remplacez curl par :

      curl -k -s 'https://test.example.com:443' --connect-to test.example.com:443:IP_ADDRESS1:443

      curl -k -s 'https://test.example.com:443' --connect-to test.example.com:443:IP_ADDRESS2:443

      L'option -k indique à curl d'ignorer l'étape de validation du certificat.

    • Facultatif : Utilisez l'enregistrement DNS configuré pour résoudre l'adresse IP la plus proche de la VM cliente. Par exemple, DNS_ENTRY peut être service.example.com.

      curl DNS_ENTRY

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.

Pour HTTP :

  • 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
}

Pour HTTPS :

  • 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 -k -s 'https://test.example.com:443' --connect-to test.example.com:443:IP_ADDRESS1:443)"
  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 -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
}

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=RATE \
   --network-endpoint-group=neg2 \
   --network-endpoint-group-zone=ZONE_B

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

    gcloud compute ssh l7-ilb-client-b \
   --zone=ZONE_B

  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 ressemble à ce qui suit :

    {
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
}

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.

Configurer des règles de routage DNS

Si vos clients se trouvent dans plusieurs régions, vous pouvez rendre votre équilibreur de charge d'application interne interrégional accessible par des adresses IP virtuelles dans ces régions. Cette configuration multirégionale minimise la latence et les coûts liés au transit sur le réseau. En outre, il vous permet de configurer une solution d'équilibrage de charge mondiale, basée sur DNS, qui offre une résilience en cas de pannes régionales. Pour en savoir plus, consultez la page Gérer les règles de routage DNS et les vérifications d'état.

gcloud

Pour créer une entrée DNS avec une valeur TTL de 30 secondes, utilisez la commande gcloud dns record-sets create.

gcloud dns record-sets create DNS_ENTRY --ttl="30" \
  --type="A" --zone="service-zone" \
  --routing-policy-type="GEO" \
  --routing-policy-data="REGION_A=gil7-forwarding-rule-a@global;REGION_B=gil7-forwarding-rule-b@global" \
  --enable-health-checking

Remplacez les éléments suivants :

  • DNS_ENTRY : nom DNS ou nom de domaine du jeu d'enregistrements

    Par exemple : service.example.com

  • REGION_A et REGION_B : régions dans lesquelles vous avez configuré l'équilibreur de charge.

API

Créez l'enregistrement DNS en envoyant une requête POST à la méthode ResourceRecordSets.create. Remplacez PROJECT_ID par l'ID du projet.

POST https://www.googleapis.com/dns/v1/projects/PROJECT_ID/managedZones/SERVICE_ZONE/rrsets
{
  "name": "DNS_ENTRY",
  "type": "A",
  "ttl": 30,
  "routingPolicy": {
    "geo": {
      "items": [
        {
          "location": "REGION_A",
          "healthCheckedTargets": {
            "internalLoadBalancers": [
              {
                "loadBalancerType": "globalL7ilb",
                "ipAddress": "gil7-forwarding-rule-a",
                "port": "80",
                "ipProtocol": "tcp",
                "networkUrl": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
                "project": "PROJECT_ID"
              }
            ]
          }
        },
        {
          "location": "REGION_B",
          "healthCheckedTargets": {
            "internalLoadBalancers": [
              {
                "loadBalancerType": "globalL7ilb",
                "ipAddress": "gil7-forwarding-rule-b",
                "port": "80",
                "ipProtocol": "tcp",
                "networkUrl": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
                "project": "PROJECT_ID"
              }
            ]
          }
        }
      ]
    }
  }
}

Activer la détection des anomalies

Vous pouvez activer la détection des anomalies sur les services de backend globaux pour identifier les NEG sans serveur non opérationnels et réduire le nombre de requêtes envoyées aux NEG sans serveur non opérationnels.

La détection des anomalies est activée sur le service de backend à l'aide de l'une des méthodes suivantes :

  • La méthode consecutiveErrors (outlierDetection.consecutiveErrors), dans laquelle un code d'état HTTP de la série 5xx est considéré comme une erreur.
  • La méthode consecutiveGatewayFailure (outlierDetection.consecutiveGatewayFailure), dans laquelle seuls les codes d'état HTTP 502, 503 et 504 sont considérés comme des erreurs.

Procédez comme suit pour activer la détection des anomalies pour un service de backend existant. Sachez que même après l'activation de la détection des anomalies, certaines requêtes peuvent être envoyées au service non opérationnel et renvoyer un code d'état 5xx aux clients. Pour réduire davantage le taux d'erreur, vous pouvez configurer des valeurs plus agressives pour les paramètres de détection des anomalies. Pour en savoir plus, consultez le champ outlierDetection.

Console

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

    Accéder à la page "Équilibrage de charge"

  2. Cliquez sur le nom de l'équilibreur de charge dont vous souhaitez modifier le service de backend.

  3. Sur la page Détails de l'équilibreur de charge, cliquez sur Modifier.

  4. Sur la page Modifier l'équilibreur de charge d'application interne interrégional, cliquez sur Configuration du backend.

  5. Sur la page Configuration du backend, cliquez sur le bouton Modifier correspondant au service de backend que vous souhaitez modifier.

  6. Faites défiler la page vers le bas et développez la section Configurations avancées.

  7. Dans la section Détection des anomalies, cochez la case Activer.

  8. Cliquez sur Modifier pour configurer la détection des anomalies.

    Vérifiez que les options suivantes sont configurées avec ces valeurs :

    Propriété Valeur
    Erreurs consécutives 5
    Intervalle 1000
    Durée d'éjection de base 30000
    Pourcentage maximal d'éjection 50
    Éjection pour erreurs consécutives 100

    Dans cet exemple, l'analyse de détection des anomalies s'exécute toutes les secondes. Si le nombre de codes d'état HTTP 5xx consécutifs reçus par un proxy Envoy est supérieur ou égal à cinq, le point de terminaison de backend est exclu du pool d'équilibrage de charge de ce proxy Envoy pendant 30 secondes. Lorsque le pourcentage d'application est défini sur 100 %, le service de backend exclut les points de terminaison non opérationnels des pools d'équilibrage de charge de ces proxys Envoy spécifiques à chaque exécution de l'analyse de détection des anomalies. Si les conditions d'exclusion sont remplies, jusqu'à 50 % des points de terminaison de backend du pool d'équilibrage de charge peuvent être exclus.

  9. Cliquez sur Enregistrer.

  10. Pour mettre à jour le service de backend, cliquez sur Mettre à jour.

  11. Pour mettre à jour l'équilibreur de charge, cliquez sur Mettre à jour sur la page Modifier l'équilibreur de charge d'application interne interrégional.

gcloud

  1. Exportez le service de backend dans un fichier YAML.

    gcloud compute backend-services export BACKEND_SERVICE_NAME \
  --destination=BACKEND_SERVICE_NAME.yaml --global

    Remplacez BACKEND_SERVICE_NAME par le nom du service de backend.

  2. Modifiez la configuration YAML du service de backend pour ajouter les champs de détection des anomalies, comme indiqué dans la configuration YAML suivante.

    Dans cet exemple, l'analyse de détection des anomalies s'exécute toutes les secondes. Si le nombre de codes d'état HTTP 5xx consécutifs reçus par un proxy Envoy est supérieur ou égal à cinq, le point de terminaison de backend est exclu du pool d'équilibrage de charge de ce proxy Envoy pendant 30 secondes. Lorsque le pourcentage d'application est défini sur 100 %, le service de backend exclut les points de terminaison non opérationnels des pools d'équilibrage de charge de ces proxys Envoy spécifiques à chaque exécution de l'analyse de détection des anomalies. Si les conditions d'exclusion sont remplies, jusqu'à 50 % des points de terminaison de backend du pool d'équilibrage de charge peuvent être exclus. 

    name: BACKEND_SERVICE_NAME
backends:
- balancingMode: UTILIZATION
  capacityScaler: 1.0
  group: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_A/networkEndpointGroups/SERVERLESS_NEG_NAME
- balancingMode: UTILIZATION
  capacityScaler: 1.0
  group: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_B/networkEndpointGroups/SERVERLESS_NEG_NAME_2
outlierDetection:
  baseEjectionTime:
    nanos: 0
    seconds: 30
  consecutiveErrors: 5
  enforcingConsecutiveErrors: 100
  interval:
    nanos: 0
    seconds: 1
  maxEjectionPercent: 50
port: 80
selfLink: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_NAME
sessionAffinity: NONE
timeoutSec: 30
...

    Remplacez les éléments suivants :

    • BACKEND_SERVICE_NAME : nom du service de backend.
    • PROJECT_ID : ID de votre projet
    • REGION_A et REGION_B : régions dans lesquelles l'équilibreur de charge a été configuré.
    • SERVERLESS_NEG_NAME : nom du premier NEG sans serveur.
    • SERVERLESS_NEG_NAME_2 : nom du deuxième NEG sans serveur.

  3. Mettez à jour le service de backend en important la dernière configuration.

    gcloud compute backend-services import BACKEND_SERVICE_NAME \
  --source=BACKEND_SERVICE_NAME.yaml --global

    La détection des anomalies est désormais activée sur le service de backend.

Étapes suivantes