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

Ce document fournit des instructions de configuration d'un équilibreur de charge d'application externe régional pour vos services exécutés sur des VM Compute Engine.

Étant donné que les équilibreurs de charge d'application externes régionaux vous permettent de créer des équilibreurs de charge dans des régions spécifiques, ils sont souvent utilisés pour les charges de travail qui présentent des exigences de conformité juridictionnelle. Les charges de travail nécessitant un accès au trafic sortant de niveau de réseau Standard constituent un autre cas d'utilisation courant des équilibreurs de charge d'application externes régionaux, car les équilibreurs de charge d'application externes régionaux sont compatibles avec le niveau de service réseau Standard.

Avant de suivre ce guide, familiarisez-vous avec les points suivants :

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 réseau
Ajouter et supprimer des règles de pare-feu Administrateur de sécurité
Créer des instances Administrateur d'instances

Pour en savoir plus, consultez les guides suivants :

Vue d'ensemble de la configuration

Vous pouvez configurer un équilibreur de charge d'application externe régional, comme décrit dans le flux de configuration de haut niveau suivant. Les étapes numérotées font référence aux numéros du diagramme.

Composants numérotés de l'équilibreur de charge d'application externe régional
Composants numérotés de l'équilibreur de charge d'application externe régional (cliquez pour agrandir)

Comme le montre le schéma, cet exemple crée un équilibreur de charge d'application externe régional dans un réseau VPC dans la région us-west1, avec un service de backend et deux groupes d'instances backend.

Le schéma montre les éléments suivants :

  1. Un réseau VPC avec deux sous-réseaux :

    1. Un sous-réseau est utilisé pour les backends (groupes d'instances). Sa plage d'adresses IP principale est 10.1.2.0/24.

    2. Un sous-réseau est un sous-réseau proxy uniquement dans la région us-west1. Vous devez créer un sous-réseau proxy réservé dans chaque région du réseau VPC dans lequel vous utilisez des équilibreurs de charge d'application externes régionaux. Le sous-réseau proxy réservé de la région est partagé entre tous les équilibreurs de charge régionaux de la région. Les adresses sources des paquets envoyés depuis les équilibreurs de charge vers les backends de votre service sont attribuées à partir du sous-réseau proxy réservé. Dans cet exemple, le sous-réseau proxy réservé de la région possède la plage d'adresses IP principale 10.129.0.0/23, qui est la taille de sous-réseau recommandée. Pour en savoir plus, consultez la section Sous-réseaux proxy réservés.

  2. Une règle de pare-feu qui autorise les flux de trafic de sous-réseau proxy réservé dans votre réseau. Cela signifie ajouter une règle qui autorise le trafic sur le port TCP 80, 443 et 8080 à partir de 10.129.0.0/23 (la plage du sous-réseau proxy réservé dans cet exemple). Une autre règle de pare-feu pour les vérifications de l'état.

  3. Instances backend.

  4. Groupes d'instances :

    1. Groupes d'instances gérés ou non gérés pour les déploiements de VM Compute Engine
    2. NEG pour les déploiements GKE

    Dans chaque zone, vous pouvez combiner différents types de groupes de backend en fonction des exigences de votre déploiement.

  5. Une vérification d'état régionale indiquant la disponibilité de vos backends.

  6. Un service de backend régional surveillant l'utilisation et l'état des backends.

  7. Un mappage d'URL régional qui analyse l'URL des requêtes et les transfère à des services de backend spécifiques en fonction de l'hôte et du chemin d'accès de l'URL de la requête.

  8. Un proxy HTTP ou HTTPS régional cible qui reçoit la requête de l'utilisateur et la transfère au mappage d'URL. Pour le protocole HTTPS, configurez une ressource de certificat SSL régional. Le proxy cible peut utiliser le certificat SSL ou le certificat du gestionnaire de certificats pour déchiffrer le trafic SSL si vous configurez l'équilibrage de charge HTTPS. Le proxy cible peut transférer le trafic vers vos instances à l'aide du protocole HTTP ou HTTPS.

  9. Une règle de transfert, qui possède l'adresse IP externe de votre équilibreur de charge, pour transmettre chaque requête entrante au proxy cible.

    L'adresse IP externe associée à la règle de transfert est réservée à l'aide de la commande gcloud compute addresses create, comme décrit dans la section Réserver l'adresse IP de l'équilibreur de charge.

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. Les équilibreurs de charge d'application externes régionaux sont régionaux. 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 : le réseau est 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 us-west1 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 us-west1 utilise 10.129.0.0/23 pour sa plage d'adresses IP principale.

Configurer le réseau et le sous-réseau pour les backends

Console

  1. Dans Google Cloud Console, 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é.
    • Dans la section Nouveau sous-réseau, saisissez les informations suivantes :
      • Nom : backend-subnet
      • Région : us-west1
      • Plage d'adresses IP : 10.1.2.0/24
    • Cliquez sur OK.

  5. Cliquez sur Créer.

gcloud

  1. Créez le réseau VPC personnalisé à l'aide de la commande gcloud compute networks create :

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

  2. Créez un sous-réseau dans le réseau lb-network de la région us-west1 à l'aide de la commande gcloud compute networks subnets create :

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

Terraform

Pour créer le réseau VPC, utilisez la ressource google_compute_network.

resource "google_compute_network" "default" {
  name                    = "lb-network"
  auto_create_subnetworks = false
  routing_mode            = "REGIONAL"
}

Pour créer le sous-réseau VPC dans le réseau lb-network, utilisez la ressource google_compute_subnetwork.

resource "google_compute_subnetwork" "default" {
  name                       = "backend-subnet"
  ip_cidr_range              = "10.1.2.0/24"
  network                    = google_compute_network.default.id
  private_ipv6_google_access = "DISABLE_GOOGLE_ACCESS"
  purpose                    = "PRIVATE"
  region                     = "us-west1"
  stack_type                 = "IPV4_ONLY"
}

API

  1. Envoyez une requête POST à la méthode networks.insert, en remplaçant PROJECT_ID par votre ID de projet.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks
{
 "routingConfig": {
   "routingMode": "REGIONAL"
 },
 "name": "lb-network",
 "autoCreateSubnetworks": false
}

  2. Envoyez une requête POST à 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/us-west1/subnetworks
{
 "name": "backend-subnet",
 "network": "projects/PROJECT_ID/global/networks/lb-network",
 "ipCidrRange": "10.1.2.0/24",
 "region": "projects/PROJECT_ID/regions/us-west1",
}

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 du réseau VPC lb-network. Il ne peut y avoir qu'un seul sous-réseau proxy réservé actif 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 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 us-west1.

  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

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-only-subnet \
  --purpose=REGIONAL_MANAGED_PROXY \
  --role=ACTIVE \
  --region=us-west1 \
  --network=lb-network \
  --range=10.129.0.0/23

Terraform

Pour créer le sous-réseau proxy réservé VPC dans le réseau lb-network, utilisez la ressource google_compute_subnetwork.

resource "google_compute_subnetwork" "proxy_only" {
  name          = "proxy-only-subnet"
  ip_cidr_range = "10.129.0.0/23"
  network       = google_compute_network.default.id
  purpose       = "REGIONAL_MANAGED_PROXY"
  region        = "us-west1"
  role          = "ACTIVE"
}

API

Créez le sous-réseau proxy réservé 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/us-west1/subnetworks
{
  "name": "proxy-only-subnet",
  "ipCidrRange": "10.129.0.0/23",
  "network": "projects/PROJECT_ID/global/networks/lb-network",
  "region": "projects/PROJECT_ID/regions/us-west1",
  "purpose": "REGIONAL_MANAGED_PROXY",
  "role": "ACTIVE"
}

Configurer des règles de pare-feu

Cet exemple utilise les règles de pare-feu suivantes :

  • 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 issu des systèmes de vérification d'état Google Cloud (dans 130.211.0.0/22 et 35.191.0.0/16). Cet exemple utilise le tag cible load-balanced-backend pour identifier les VM auxquelles la règle de pare-feu s'applique.

  • fw-allow-proxies : règle d'entrée applicable aux instances faisant l'objet d'un équilibrage de charge, qui autorise le trafic TCP sur les ports 80, 443 et 8080 à partir des proxys gérés de l'équilibreur de charge d'application externe régional. Cet exemple utilise le tag cible load-balanced-backend pour identifier les VM auxquelles la règle de pare-feu s'applique.

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 d'administration.

    Accéder aux règles de pare-feu

  2. Cliquez sur Créer une règle de pare-feu pour créer la règle autorisant les vérifications d'état Google 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 : load-balanced-backend
    • Filtre source : Plages IPv4
    • Plages IPv4 sources : 130.211.0.0/22 et 35.191.0.0/16
    • 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.

  3. Cliquez sur Créer.

  4. Cliquez 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-proxies
    • Réseau : lb-network
    • Sens du trafic : entrée
    • Action en cas de correspondance : autoriser
    • Cibles : Tags cibles spécifiés
    • Tags cibles : load-balanced-backend
    • 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, 443, 8080 pour les numéros de port.

  5. Cliquez sur Créer.

gcloud

  1. 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=130.211.0.0/22,35.191.0.0/16 \
    --target-tags=load-balanced-backend \
    --rules=tcp

  2. Créez la règle fw-allow-proxies pour autoriser les proxys de l'équilibreur de charge d'application externe régional à se connecter à vos backends. Définissez source-ranges sur les plages allouées de votre sous-réseau proxy réservé, par exemple 10.129.0.0/23.

    gcloud compute firewall-rules create fw-allow-proxies \
  --network=lb-network \
  --action=allow \
  --direction=ingress \
  --source-ranges=source-range \
  --target-tags=load-balanced-backend \
  --rules=tcp:80,tcp:443,tcp:8080

Terraform

Pour créer les règles de pare-feu, utilisez la ressource google_compute_firewall.

resource "google_compute_firewall" "default" {
  name = "fw-allow-health-check"
  allow {
    protocol = "tcp"
  }
  direction     = "INGRESS"
  network       = google_compute_network.default.id
  priority      = 1000
  source_ranges = ["130.211.0.0/22", "35.191.0.0/16"]
  target_tags   = ["load-balanced-backend"]
}
resource "google_compute_firewall" "allow_proxy" {
  name = "fw-allow-proxies"
  allow {
    ports    = ["443"]
    protocol = "tcp"
  }
  allow {
    ports    = ["80"]
    protocol = "tcp"
  }
  allow {
    ports    = ["8080"]
    protocol = "tcp"
  }
  direction     = "INGRESS"
  network       = google_compute_network.default.id
  priority      = 1000
  source_ranges = ["10.129.0.0/23"]
  target_tags   = ["load-balanced-backend"]
}

API

Créez la règle de pare-feu fw-allow-health-check en envoyant une requête POST à la méthode firewalls.insert, en remplaçant PROJECT_ID par l'ID de votre projet.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls
{
  "name": "fw-allow-health-check",
  "network": "projects/PROJECT-ID/global/networks/lb-network",
  "sourceRanges": [
    "130.211.0.0/22",
    "35.191.0.0/16"
  ],
  "targetTags": [
    "load-balanced-backend"
  ],
  "allowed": [
    {
      "IPProtocol": "tcp"
    }
  ],
  "direction": "INGRESS"
}

Créez la règle de pare-feu fw-allow-proxies pour autoriser le trafic TCP dans le sous-réseau proxy pour la méthode firewalls.insert, en remplaçant PROJECT_ID par l'ID de votre projet.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls
{
  "name": "fw-allow-proxies",
  "network": "projects/PROJECT_ID/global/networks/lb-network",
  "sourceRanges": [
    "10.129.0.0/23"
  ],
  "targetTags": [
    "load-balanced-backend"
  ],
  "allowed": [
    {
      "IPProtocol": "tcp",
      "ports": [
        "80"
      ]
    },
    {
      "IPProtocol": "tcp",
      "ports": [
        "443"
      ]
    },
    {
      "IPProtocol": "tcp",
      "ports": [
        "8080"
      ]
    }
  ],
  "direction": "INGRESS"
}

Configurer un équilibreur de charge d'application externe régional avec un service basé sur une VM

Cette section présente la configuration requise pour les services exécutés sur des VM Compute Engine. Les VM clientes se connectent à l'adresse IP et au port que vous configurez dans la règle de transfert. Lorsque vos applications clientes envoient du trafic vers cette adresse IP et ce port, leurs requêtes sont transférées vers vos VM de backend en fonction du mappage d'URL de l'équilibreur de charge d'application externe régional.

L'exemple de cette page crée explicitement une adresse IP externe réservée pour la règle de transfert de l'équilibreur de charge d'application externe régional au lieu d'autoriser l'allocation d'une adresse IP externe éphémère. Nous vous recommandons de réserver les adresses IP pour les règles de transfert.

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

Cette section explique comment créer un modèle et un groupe d'instances géré. Le groupe d'instances géré fournit des instances de VM exécutant les serveurs de backend d'un exemple d'équilibreur de charge d'application externe régional. Le trafic des clients fait l'objet d'un équilibrage de charge par rapport à ces serveurs de backend. À des fins de démonstration, les backends diffusent leurs propres noms d'hôte.

Console

  1. Créez un modèle d'instance. Dans Google Cloud Console, accédez à la page Modèles d'instances.

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

    1. Cliquez sur Create instance template (Créer un modèle d'instance).
    2. Dans le champ Nom, saisissez l7-xlb-backend-template.
    3. Assurez-vous que le disque de démarrage est défini sur une image Debian, telle que Debian GNU/Linux 10 (Buster). Ces instructions utilisent des commandes uniquement disponibles dans Debian, comme apt-get.
    4. Cliquez sur Options avancées.
    5. Cliquez sur Mise en réseau et configurez les champs suivants :
      1. Pour Tags réseau, saisissez load-balanced-backend.
      2. Pour Interfaces réseau, sélectionnez l'option suivante :
        • Réseau : lb-network
        • Sous-réseau : backend-subnet

    6. 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

    7. Cliquez sur Créer.

  2. Créez un groupe d'instances géré. Dans Google Cloud Console, accédez à la page Groupes d'instances.

    Accéder à la page "Groupes d'instances"

    1. Cliquez sur Créer un groupe d'instances.
    2. Sélectionnez Nouveau groupe d'instances géré (sans état). Pour plus d'informations, consultez la page Groupes d'instances gérés (MIG) sans état ou avec état.
    3. Dans le champ Nom, saisissez l7-xlb-backend-example.
    4. Pour Emplacement, sélectionnez Zone unique.
    5. Pour Région, sélectionnez us-west1.
    6. Pour Zone, sélectionnez us-west1-a.
    7. Pour Modèle d'instance, sélectionnez l7-xlb-backend-template.

    8. Dans le champ Mode autoscaling, sélectionnez Activé : ajouter et supprimer des instances dans le groupe.

      Définissez le paramètre Nombre minimal d'instances sur 2 et le paramètre Nombre maximal d'instances sur 2 ou plus.

    9. Cliquez sur Créer.

gcloud

Les instructions gcloud de ce guide supposent que vous utilisez Cloud Shell ou un autre environnement avec bash installé.

  1. Créez un modèle d'instance de VM avec le serveur HTTP à l'aide de la commande gcloud compute instance-templates create.

    gcloud compute instance-templates create l7-xlb-backend-template \
--region=us-west1 \
--network=lb-network \
--subnet=backend-subnet \
--tags=load-balanced-backend \
--image-family=debian-10 \
--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 à l'aide de la commande gcloud compute instance-groups managed create.

    gcloud compute instance-groups managed create l7-xlb-backend-example \
    --zone=us-west1-a \
    --size=2 \
    --template=l7-xlb-backend-template

Terraform

Pour créer le modèle d'instance, utilisez la ressource google_compute_instance_template.

resource "google_compute_instance_template" "default" {
  name = "l7-xlb-backend-template"
  disk {
    auto_delete  = true
    boot         = true
    device_name  = "persistent-disk-0"
    mode         = "READ_WRITE"
    source_image = "projects/debian-cloud/global/images/family/debian-10"
    type         = "PERSISTENT"
  }
  labels = {
    managed-by-cnrm = "true"
  }
  machine_type = "n1-standard-1"
  metadata = {
    startup-script = <<EOF
    #! /bin/bash
    sudo apt-get update
    sudo apt-get install apache2 -y
    sudo a2ensite default-ssl
    sudo a2enmod ssl
    vm_hostname="$(curl -H "Metadata-Flavor:Google" \
    http://169.254.169.254/computeMetadata/v1/instance/name)"
    sudo echo "Page served from: $vm_hostname" | \
    tee /var/www/html/index.html
    sudo systemctl restart apache2
    EOF
  }
  network_interface {
    access_config {
      network_tier = "PREMIUM"
    }
    network    = google_compute_network.default.id
    subnetwork = google_compute_subnetwork.default.id
  }
  region = "us-west1"
  scheduling {
    automatic_restart   = true
    on_host_maintenance = "MIGRATE"
    provisioning_model  = "STANDARD"
  }
  service_account {
    email  = "default"
    scopes = ["https://www.googleapis.com/auth/devstorage.read_only", "https://www.googleapis.com/auth/logging.write", "https://www.googleapis.com/auth/monitoring.write", "https://www.googleapis.com/auth/pubsub", "https://www.googleapis.com/auth/service.management.readonly", "https://www.googleapis.com/auth/servicecontrol", "https://www.googleapis.com/auth/trace.append"]
  }
  tags = ["load-balanced-backend"]
}

Pour créer le groupe d'instances géré, utilisez la ressource google_compute_instance_group_manager.

resource "google_compute_instance_group_manager" "default" {
  name = "l7-xlb-backend-example"
  zone = "us-west1-a"
  named_port {
    name = "http"
    port = 80
  }
  version {
    instance_template = google_compute_instance_template.default.id
    name              = "primary"
  }
  base_instance_name = "vm"
  target_size        = 2
}

API

  1. Créez le modèle d'instance avec la méthode instanceTemplates.insert, en remplaçant PROJECT_ID par votre ID de projet.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/instanceTemplates
{
 "name":"l7-xlb-backend-template",
 "properties": {
   "machineType":"e2-standard-2",
   "tags": {
     "items":[
       "load-balanced-backend"
     ]
   },
   "metadata": {
     "kind":"compute#metadata",
     "items":[
       {
         "key":"startup-script",
         "value":"#! /bin/bash\napt-get update\napt-get install apache2 -y\na2ensite default-ssl\na2enmod ssl\nvm_hostname=\"$(curl -H \"Metadata-Flavor:Google\" \\\nhttp://metadata.google.internal/computeMetadata/v1/instance/name)\"\necho \"Page served from: $vm_hostname\" | \\\ntee /var/www/html/index.html\nsystemctl restart apache2"
       }
     ]
   },
   "networkInterfaces":[
     {
       "network":"projects/PROJECT_ID/global/networks/lb-network",
       "subnetwork":"regions/us-west1/subnetworks/backend-subnet",
       "accessConfigs":[
         {
           "type":"ONE_TO_ONE_NAT"
         }
       ]
     }
   ],
   "disks": [
     {
       "index":0,
       "boot":true,
       "initializeParams": {
         "sourceImage":"projects/debian-cloud/global/images/family/debian-10"
       },
       "autoDelete":true
     }
   ]
 }
}

  2. Créez un groupe d'instances géré dans chaque zone à l'aide de la méthode instanceGroupManagers.insert, en remplaçant PROJECT_ID par l'ID de votre projet.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/{zone}/instanceGroupManagers
{
 "name": "l7-xlb-backend-example",
 "zone": "projects/PROJECT_ID/zones/us-west1-a",
 "instanceTemplate": "projects/PROJECT_ID/global/instanceTemplates/l7-xlb-backend-template",
 "baseInstanceName": "l7-xlb-backend-example",
 "targetSize": 2
}

Ajouter un port nommé au groupe d'instances

Pour votre groupe d'instances, définissez un service HTTP et mappez un nom de port sur le port correspondant. Le service de backend de l'équilibreur de charge transfère le trafic vers le port nommé.

Console

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

    Accéder à la page "Groupes d'instances"

  2. Cliquez sur le nom de votre groupe d'instances (dans cet exemple l7-xlb-backend-example).

  3. Sur la page Présentation du groupe d'instances, cliquez sur Modifier .

  4. Cliquez sur Préciser le mappage des noms des ports.

  5. Cliquez sur Ajouter un élément.

  6. Pour le nom du port, saisissez http. Pour le numéro de port, saisissez 80.

  7. Cliquez sur Enregistrer.

gcloud

Exécutez la commande gcloud compute instance-groups set-named-ports.

gcloud compute instance-groups set-named-ports l7-xlb-backend-example \
    --named-ports http:80 \
    --zone us-west1-a

Terraform

L'attribut named_port est inclus dans l'exemple de groupe d'instances géré.

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

Réserver une adresse IP externe pour l'équilibreur de charge. Cette procédure crée l'adresse IP de l'équilibreur de charge au niveau Standard. Les équilibreurs de charge d'application externes régionaux sont compatibles avec les niveaux de service réseau Premium et Standard. Toutefois, la création de cet équilibreur de charge au niveau Premium n'est pas possible dans la console Google Cloud. Utilisez plutôt gcloud ou l'API REST.

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 peuvent être que globales et ne peuvent être utilisées qu'avec les équilibreurs de charge globaux.

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

  6. Pour le paramètre Région, sélectionnez us-west1.

  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 à l'aide de gcloud compute, utilisez la commande compute addresses create.

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

    Remplacez les éléments suivants :

    • ADDRESS_NAME : nom que vous souhaitez donner à cette adresse.
    • REGION : région dans laquelle vous souhaitez réserver cette adresse. Cette région doit être la même que celle de l'équilibreur de charge. Toutes les adresses IP régionales sont IPv4.

  2. Utilisez la commande compute addresses describe pour afficher le résultat :

    gcloud compute addresses describe ADDRESS_NAME

Terraform

Pour réserver l'adresse IP, utilisez la ressource google_compute_address.

resource "google_compute_address" "default" {
  name         = "address-name"
  address_type = "EXTERNAL"
  network_tier = "STANDARD"
  region       = "us-west1"
}

Pour savoir comment appliquer ou supprimer une configuration Terraform, consultez la page Commandes Terraform de base.

API

Pour créer une adresse IPv4 régionale, appelez la méthode addresses.insert régionale :

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/addresses

Le corps de votre requête doit contenir les éléments suivants :

{
  "name": "ADDRESS_NAME"
  "networkTier": "STANDARD"
  "region": "us-west1"
}

Remplacez les éléments suivants :

  • ADDRESS_NAME : nom de l'adresse
  • REGION : nom de la région pour cette requête.
  • PROJECT_ID : ID du projet pour cette requête

Configurer l'équilibreur de charge

Cet exemple vous explique comment créer les ressources suivantes pour l'équilibreur de charge d'application externe régional :

  • Vérification d'état HTTP
  • Un service de backend avec un groupe d'instances géré en tant que backend
  • Un mappage d'URL
    • Veillez à faire référence à un mappage d'URL régional si une région est définie pour le proxy HTTP(S) cible. Un mappage d'URL régional achemine les requêtes vers un service de backend régional en fonction des règles que vous définissez pour l'hôte et le chemin d'une URL entrante. Un mappage d'URL régional peut être référencé par une règle de proxy cible régionale de la même région uniquement.
  • Un certificat SSL (pour HTTPS)
  • Un proxy cible
  • Une règle de transfert

Disponibilité du proxy

Parfois, les régions Google Cloud ne disposent pas d'une capacité de proxy suffisante pour un nouvel équilibreur de charge. Dans ce cas, la console Google Cloud fournit un message d'avertissement de disponibilité du proxy lors de la création de votre équilibreur de charge. Pour résoudre ce problème, vous pouvez effectuer l'une des opérations suivantes :

  • Sélectionnez une autre région pour votre équilibreur de charge. Cette option peut être pratique si vous avez des backends dans une autre région.
  • Sélectionnez un réseau VPC comportant déjà un sous-réseau proxy réservé alloué.

  • Attendez que le problème de capacité soit résolu.

Console

Démarrer la configuration

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

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

  2. Cliquez sur Créer un équilibreur de charge.
  3. Dans le champ Type d'équilibreur de charge, sélectionnez Équilibreur de charge d'application (HTTP/HTTPS), puis cliquez sur Suivant.
  4. Pour Public ou interne, sélectionnez Public (externe), puis cliquez sur Suivant.
  5. Pour Déploiement global ou dans une seule région, sélectionnez Recommandé pour les charges de travail régionales, puis cliquez sur Suivant.
  6. Cliquez sur Configurer.

Configuration de base

  1. Pour le nom de l'équilibreur de charge, saisissez regional-l7-xlb.
  2. Pour Région, sélectionnez us-west1.
  3. Pour Réseau, sélectionnez lb-network.

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

Pour un équilibreur de charge d'application externe régional, réservez un sous-réseau proxy réservé :

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

Configurer l'interface

Pour HTTP :

  1. Cliquez sur Configuration de l'interface.
  2. Pour Nom, définissez l7-xlb-forwarding-rule.
  3. Définissez le paramètre Protocole sur HTTP.
  4. Définissez le paramètre Port sur 80.
  5. Sélectionnez l'Adresse IP que vous avez créée dans la section Réserver l'adresse IP de l'équilibreur de charge.
  6. Cliquez sur OK.

Pour HTTPS :

  1. Cliquez sur Configuration de l'interface.
  2. Dans le champ Nom, saisissez l7-xlb-forwarding-rule.
  3. Dans le champ Protocole, sélectionnez HTTPS (includes HTTP/2).
  4. Assurez-vous que le Port est défini sur la valeur 443.
  5. Sélectionnez l'Adresse IP que vous avez créée dans la section Réserver l'adresse IP de l'équilibreur de charge.
  6. Dans la liste Paramètres, procédez comme suit :
    1. Si vous possédez déjà une ressource de certificat SSL autogéré Compute Engine, sélectionnez le certificat SSL principal.
    2. Cliquez sur Créer un certificat.
      1. Dans le champ Nom, saisissez l7-xlb-cert.
      2. Dans les champs appropriés, importez vos fichiers au format PEM :
        • Certificat
        • Clé privée
      3. Cliquez sur Create (Créer).
  7. Facultatif : Pour ajouter des certificats en plus du certificat SSL principal :
    1. Cliquez sur Ajouter un certificat.
    2. Si vous disposez déjà d'un certificat, sélectionnez-le dans la liste Certificats.
    3. Facultatif : Cliquez sur Créer un certificat et suivez les instructions indiquées à l'étape précédente.
  8. Sélectionnez une règle SSL dans la liste Règle SSL. Si vous n'avez pas créé de règle SSL, une règle SSL Google Cloud par défaut est appliquée.
  9. Cliquez sur OK.

Configurer le service de backend

  1. Cliquez sur Configuration du backend.
  2. Dans le menu Créer ou sélectionner des services de backend, sélectionnez Créer un service backend.
  3. Définissez le nom du service de backend sur l7-xlb-backend-service.
  4. Pour Protocole, sélectionnez HTTP.
  5. Pour le Port nommé, saisissez http.
  6. Définissez Type de backend sur Groupe d'instances.
  7. Dans la section Nouveau backend :
    1. Définissez le paramètre Groupe d'instances sur l7-xlb-backend-example.
    2. Définissez le paramètre Numéros de ports sur 80.
    3. Définissez le Mode d'équilibrage sur Utilisation.
    4. Cliquez sur OK.
  8. Dans la section Vérification d'état, cliquez sur Créer une vérification d'état.
    1. Pour Nom, définissez l7-xlb-basic-check.
    2. Définissez le paramètre Protocole sur HTTP.
    3. Définissez le paramètre Port sur 80.
    4. Cliquez sur Save (Enregistrer).
  9. Cliquez sur Create (Créer).

Configurer les règles de routage

  1. Cliquez sur Règles de routage.
  2. Sous Mode, sélectionnez Règle d'hôte et de chemin d'accès simple.
  3. Assurez-vous que l7-xlb-backend-service est le seul service de backend pour tous les hôtes et chemins sans correspondance.

Vérifier la configuration

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

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 l7-xlb-basic-check \
   --region=us-west1 \
   --request-path='/' \
   --use-serving-port

  2. Définissez le service de backend avec la commande gcloud compute backend-services create.

    gcloud compute backend-services create l7-xlb-backend-service \
  --load-balancing-scheme=EXTERNAL_MANAGED \
  --protocol=HTTP \
  --port-name=http \
  --health-checks=l7-xlb-basic-check \
  --health-checks-region=us-west1 \
  --region=us-west1

  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 l7-xlb-backend-service \
  --balancing-mode=UTILIZATION \
  --instance-group=l7-xlb-backend-example \
  --instance-group-zone=us-west1-a \
  --region=us-west1

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

    gcloud compute url-maps create regional-l7-xlb-map \
  --default-service=l7-xlb-backend-service \
  --region=us-west1

  5. Créez le proxy cible.

    Pour HTTP :

    Pour un équilibreur de charge HTTP, créez le proxy cible à l'aide de la commande gcloud compute target-http-proxies create.

    gcloud compute target-http-proxies create l7-xlb-proxy \
  --url-map=regional-l7-xlb-map \
  --url-map-region=us-west1 \
  --region=us-west1

    Pour HTTPS :

    Vous pouvez créer des certificats Compute Engine ou du gestionnaire de certificats. Utilisez l'une des méthodes suivantes pour créer des certificats à l'aide du gestionnaire de certificats :

    • Certificats régionaux autogérés. Pour en savoir plus sur la création et l'utilisation de certificats autogérés régionaux, consultez la page Déployer un certificat régional autogéré. Les mappages de certificats ne sont pas acceptés.

    • Certificats régionaux gérés par Google. Les mappages de certificats ne sont pas acceptés.

      Les types de certificats régionaux gérés par Google suivants sont compatibles avec le gestionnaire de certificats :

      • Après avoir créé des certificats, associez-les directement au proxy cible.

      1. Attribuez vos chemins de fichiers à des noms de variables.

        export LB_CERT=path to PEM-formatted file

        export LB_PRIVATE_KEY=path to PEM-formatted file

      2. Créez un certificat SSL régional à l'aide de la commande gcloud compute ssl-certificates create.

        gcloud compute ssl-certificates create l7-xlb-cert \
 --certificate=$LB_CERT \
 --private-key=$LB_PRIVATE_KEY \
 --region=us-west1

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

        gcloud compute target-https-proxies create l7-xlb-proxy \
 --url-map=regional-l7-xlb-map \
 --region=us-west1 \
 --ssl-certificates=l7-xlb-cert

    • Créez la règle de transfert.

      Pour HTTP :

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

      gcloud compute forwarding-rules create l7-xlb-forwarding-rule \
  --load-balancing-scheme=EXTERNAL_MANAGED \
  --network-tier=STANDARD \
  --network=lb-network \
  --address=ADDRESS_NAME \
  --ports=80 \
  --region=us-west1 \
  --target-http-proxy=l7-xlb-proxy \
  --target-http-proxy-region=us-west1

      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 l7-xlb-forwarding-rule \
  --load-balancing-scheme=EXTERNAL_MANAGED \
  --network-tier=STANDARD \
  --network=lb-network \
  --address=ADDRESS_NAME \
  --ports=443 \
  --region=us-west1 \
  --target-https-proxy=l7-xlb-proxy \
  --target-https-proxy-region=us-west1

Terraform

Pour créer la vérification d'état, utilisez la ressource google_compute_region_health_check.

resource "google_compute_region_health_check" "default" {
  name               = "l7-xlb-basic-check"
  check_interval_sec = 5
  healthy_threshold  = 2
  http_health_check {
    port_specification = "USE_SERVING_PORT"
    proxy_header       = "NONE"
    request_path       = "/"
  }
  region              = "us-west1"
  timeout_sec         = 5
  unhealthy_threshold = 2
}

Pour créer le service de backend, utilisez la ressource google_compute_region_backend_service.

resource "google_compute_region_backend_service" "default" {
  name                  = "l7-xlb-backend-service"
  region                = "us-west1"
  load_balancing_scheme = "EXTERNAL_MANAGED"
  health_checks         = [google_compute_region_health_check.default.id]
  protocol              = "HTTP"
  session_affinity      = "NONE"
  timeout_sec           = 30
  backend {
    group           = google_compute_instance_group_manager.default.instance_group
    balancing_mode  = "UTILIZATION"
    capacity_scaler = 1.0
  }
}

Pour créer le mappage d'URL, utilisez la ressource google_compute_region_url_map.

resource "google_compute_region_url_map" "default" {
  name            = "regional-l7-xlb-map"
  region          = "us-west1"
  default_service = google_compute_region_backend_service.default.id
}

Pour créer le proxy HTTP cible, utilisez la ressource google_compute_region_target_http_proxy.

resource "google_compute_region_target_http_proxy" "default" {
  name    = "l7-xlb-proxy"
  region  = "us-west1"
  url_map = google_compute_region_url_map.default.id
}

Pour créer la règle de transfert, utilisez la ressource google_compute_forwarding_rule.

resource "google_compute_forwarding_rule" "default" {
  name       = "l7-xlb-forwarding-rule"
  provider   = google-beta
  depends_on = [google_compute_subnetwork.proxy_only]
  region     = "us-west1"

  ip_protocol           = "TCP"
  load_balancing_scheme = "EXTERNAL_MANAGED"
  port_range            = "80"
  target                = google_compute_region_target_http_proxy.default.id
  network               = google_compute_network.default.id
  ip_address            = google_compute_address.default.id
  network_tier          = "STANDARD"
}

Pour savoir comment appliquer ou supprimer une configuration Terraform, consultez la page Commandes Terraform de base.

API

Créez la vérification de l'état en envoyant une requête POST à la méthode regionHealthChecks.insert, en remplaçant PROJECT_ID par l'ID de votre projet.

POST https://compute.googleapis.com/compute/v1/projects/<var>PROJECT_ID</var>/regions/{region}/healthChecks
{
  "name": "l7-xlb-basic-check",
  "type": "HTTP",
  "httpHealthCheck": {
    "portSpecification": "USE_SERVING_PORT"
  }
}

Créez le service de backend régional en envoyant une requête POST à la méthode regionBackendServices.insert, en remplaçant PROJECT_ID par l'ID de votre projet.

POST https://compute.googleapis.com/compute/v1/projects/<var>PROJECT_ID</var>/regions/us-west1/backendServices
{
  "name": "l7-xlb-backend-service",
  "backends": [
    {
      "group": "projects/<var>PROJECT_ID</var>/zones/us-west1-a/instanceGroups/l7-xlb-backend-example",
      "balancingMode": "UTILIZATION"
    }
  ],
  "healthChecks": [
    "projects/<var>PROJECT_ID</var>/regions/us-west1/healthChecks/l7-xlb-basic-check"
  ],
  "loadBalancingScheme": "EXTERNAL_MANAGED"
}

Créez le mappage d'URL en envoyant une requête POST à la méthode regionUrlMaps.insert, en remplaçant PROJECT_ID par l'ID de votre projet.

POST https://compute.googleapis.com/compute/v1/projects/<var>PROJECT_ID</var>/regions/us-west1/urlMaps
{
  "name": "regional-l7-xlb-map",
  "defaultService": "projects/<var>PROJECT_ID</var>/regions/us-west1/backendServices/l7-xlb-backend-service"
}

Créez le proxy HTTP cible en envoyant une requête POST à la méthode regionTargetHttpProxies.insert, en remplaçant PROJECT_ID par l'ID de votre projet.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/targetHttpProxy
{
  "name": "l7-xlb-proxy",
  "urlMap": "projects/PROJECT_ID/global/urlMaps/regional-l7-xlb-map",
  "region": "us-west1"
}

Créez la règle de transfert en envoyant une requête POST à la méthode forwardingRules.insert, en remplaçant PROJECT_ID par l'ID de votre projet.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules
{
  "name": "l7-xlb-forwarding-rule",
  "IPAddress": "10.1.2.99",
  "IPProtocol": "TCP",
  "portRange": "80-80",
  "target": "projects/PROJECT_ID/regions/us-west1/targetHttpProxies/l7-xlb-proxy",
  "loadBalancingScheme": "EXTERNAL_MANAGED",
  "network": "projects/PROJECT_ID/global/networks/lb-network",
  "networkTier": "STANDARD",
}

Connecter un domaine à votre équilibreur de charge

Une fois l'équilibreur de charge créé, notez l'adresse IP associée à celui-ci (par exemple, 30.90.80.100). Pour faire pointer votre domaine vers votre équilibreur de charge, créez un enregistrement A à l'aide de votre 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. Par exemple, pour créer des enregistrements A pour www.example.com et example.com, utilisez le code suivant :

NAME                  TYPE     DATA
www                   A        30.90.80.100
@                     A        30.90.80.100

Si vous utilisez Cloud DNS comme fournisseur DNS, consultez la section Ajouter, modifier et supprimer des enregistrements.

Tester l'équilibreur de charge

Maintenant que le service d'équilibrage de charge est en cours d'exécution, vous pouvez envoyer le trafic vers la règle de transfert et observer la répartition du trafic entre les différentes instances.

Console

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

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

  2. Sélectionnez l'équilibreur de charge que vous venez de créer.
  3. Dans la section Backend, vérifiez que les VM sont opérationnelles. La colonne Opérationnelles doit indiquer que les deux VM sont opérationnelles (2/2). Si ce n'est pas le cas, commencez par actualiser la page. Il peut s'écouler quelques instants avant que la console Google Cloud n'indique que les VM sont opérationnelles. Si les backends ne semblent toujours pas opérationnels au bout de quelques minutes, vérifiez la configuration du pare-feu et le tag réseau attribué à vos VM de backend.
  4. Une fois que la console Google Cloud indique que les instances backend sont opérationnelles, vous pouvez tester votre équilibreur de charge à l'aide d'un navigateur Web en accédant à https://IP_ADDRESS (ou http://IP_ADDRESS). Remplacez IP_ADDRESS par l'adresse IP de l'équilibreur de charge.
  5. Si vous avez utilisé un certificat autosigné pour les tests HTTPS, votre navigateur affiche un avertissement. Vous devez explicitement lui indiquer d'accepter un certificat autosigné.
  6. Votre navigateur doit afficher une page dont le contenu indique le nom de l'instance ayant diffusé la page, ainsi que sa zone (par exemple, Page served from: lb-backend-example-xxxx). Si ce n'est pas le cas, vérifiez les paramètres de configuration décrits dans ce guide.

gcloud

Notez l'adresse IPv4 réservée :

gcloud beta compute addresses describe ADDRESS_NAME \
    --format="get(address)" \
    --region="us-west1"

Vous pouvez tester votre équilibreur de charge à l'aide d'un navigateur Web en accédant à https://IP_ADDRESS (ou http://IP_ADDRESS). Remplacez IP_ADDRESS par l'adresse IP de l'équilibreur de charge.

Si vous avez utilisé un certificat autosigné pour les tests HTTPS, votre navigateur affiche un avertissement. Vous devez explicitement lui indiquer d'accepter un certificat autosigné.

Votre navigateur doit afficher une page contenant un minimum d'informations sur l'instance backend. Si votre navigateur n'affiche pas cette page, examinez les paramètres de configuration de ce guide.

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.

Activer l'affinité de session

Ces procédures vous montrent comment mettre à jour un service de backend pour l'exemple d'équilibreur de charge d'application externe régional afin que le service de backend utilise l'affinité basée sur les cookies générés, l'affinité de champ d'en-tête ou l'affinité de cookie HTTP.

Lorsque l'affinité basée sur les cookies générés est activée, l'équilibreur de charge émet un cookie lors de la première requête. Pour chaque requête suivante présentant le même cookie, l'équilibreur de charge dirige celle-ci vers les mêmes VM ou points de terminaison backend. Pour les équilibreurs de charge d'application externes régionaux, ce cookie est nommé GCILB.

Lorsque l'affinité du champ d'en-tête est activée, l'équilibreur de charge achemine les requêtes vers les VM ou les points de terminaison de backend dans un NEG en fonction de la valeur de l'en-tête HTTP nommé dans l'option --custom-request-header. L'affinité du champ d'en-tête n'est valide que si la stratégie de localité d'équilibrage de charge est RING_HASH ou MAGLEV et que le hachage cohérent du service de backend spécifie le nom de l'en-tête HTTP.

Lorsque l'affinité basée sur les cookies HTTP est activée, l'équilibreur de charge achemine les requêtes vers les VM ou les points de terminaison de backend dans un NEG, en fonction d'un cookie HTTP nommé dans l'option HTTP_COOKIE avec l'option --affinity-cookie-ttl facultative. Si le client ne fournit pas le cookie dans sa requête HTTP, le proxy génère le cookie et le renvoie au client dans un en-tête Set-Cookie. L'affinité basée sur les cookies HTTP n'est valide que si la règle de localité d'équilibrage de charge est RING_HASH ou MAGLEV et que le hachage cohérent du service de backend spécifie le cookie HTTP.

Console

Pour activer ou modifier l'affinité de session pour un service de backend :

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

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

  2. Sélectionnez l'équilibreur de charge que vous venez de créer.

  3. Cliquez sur Backends.

  4. Cliquez sur l7-xlb-backend-service (le nom du service de backend que vous avez créé pour cet exemple) et cliquez sur Modifier.

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

  6. Sous Affinité de session, sélectionnez le type d'affinité de session souhaité dans le menu.

  7. Cliquez sur Update (Mettre à jour).

gcloud

Utilisez les commandes gcloud suivantes pour mettre à jour le service de backend l7-xlb-backend-service vers différents types d'affinité de session :

gcloud compute backend-services update l7-xlb-backend-service \
    --session-affinity=[GENERATED_COOKIE | HEADER_FIELD | HTTP_COOKIE | CLIENT_IP]
    --region=us-west1

API

Pour définir l'affinité de session, envoyez une requête PATCH à la méthode regionBackendServices/patch.

PATCH https://compute.googleapis.com/compute/v1/projects/[PROJECT_ID]/regions/us-west1/regionBackendServices/l7-xlb-backend-service
{
  "sessionAffinity": ["GENERATED_COOKIE" | "HEADER_FIELD" | "HTTP_COOKIE" | "CLIENT_IP" ]
}

Étapes suivantes