Configurer un équilibreur de charge d'application interne avec un VPC partagé

Ce document présente deux exemples de configuration pour la configuration d'un équilibrage de charge d'application interne dans un environnement VPC partagé :

  • Le premier exemple crée tous les composants et les backends de l'équilibreur de charge dans un projet de service.
  • Le deuxième exemple crée les composants d'interface et le mappage d'URL de l'équilibreur de charge dans un projet de service, tandis que le service de backend et les backends de l'équilibreur de charge sont créés dans un projet de service différent. Ce type de déploiement, où le mappage d'URL fait référence à un service de backend situé dans un autre projet, est appelé Référence de services inter-projets.

Les deux exemples nécessitent la même configuration initiale pour accorder des autorisations et configurer un VPC partagé avant de pouvoir commencer à créer des équilibreurs de charge.

Ce ne sont pas les seules configurations de VPC partagé compatibles avec les équilibreurs de charge d'application internes. Pour découvrir d'autres architectures de VPC partagé valides, consultez la page Architectures de VPC partagé.

Si vous ne souhaitez pas utiliser de réseau VPC partagé, consultez la page Configurer un équilibreur de charge d'application interne.

Avant de commencer

  1. Consultez la page Présentation du VPC partagé.
  2. Consultez la page Présentation de l'équilibreur de charge d'application interne, y compris la section Architectures de VPC partagé.

les autorisations requises pour l'extension ;

La configuration d'un équilibreur de charge sur un réseau VPC partagé nécessite une configuration et un provisionnement initiaux par un administrateur. Une fois la configuration initiale terminée, un propriétaire de projet de service peut effectuer l'une des opérations suivantes :

  • Déployer tous les composants de l'équilibreur de charge et ses backends dans un projet de service.
  • Déployer les composants backend de l'équilibreur de charge (service de backend et backends) dans des projets de service pouvant être référencés par un mappage d'URL dans un autre service ou projet hôte.

Cette section récapitule les autorisations requises pour suivre ce guide afin de configurer un équilibreur de charge sur un réseau VPC partagé.

Configurer un VPC partagé

Les rôles suivants sont requis pour les tâches suivantes :

  1. effectuer des tâches d'administration ponctuelles, telles que la configuration du VPC partagé et l'activation d'un projet hôte ;
  2. effectuer des tâches d'administration qui doivent être répétées chaque fois que vous souhaitez intégrer un nouveau projet de service. Cela inclut le rattachement du projet de service, le provisionnement et la configuration des ressources réseau, ainsi que l'attribution de l'autorisation d'accès à l'administrateur du projet de service.

Ces tâches doivent être effectuées dans le projet hôte du VPC partagé. Il est préférable que l'administrateur du VPC partagé soit également le propriétaire du projet hôte du VPC partagé. Les rôles d'administrateur réseau et d'administrateur de sécurité seront ainsi attribués automatiquement.

Tâche Rôle requis
Configurer le VPC partagé, activer le projet hôte et accorder l'accès aux administrateurs de projet de service Administrateur de VPC partagé
Créer des sous-réseaux dans le projet hôte de VPC partagé et accorder l'accès aux administrateurs de projet de service Administrateur réseau
Ajouter et supprimer des règles de pare-feu Administrateur de sécurité

Une fois les sous-réseaux provisionnés, le propriétaire du projet hôte doit attribuer le rôle d'utilisateur de réseau dans le projet hôte à toute personne (généralement des administrateurs de projet de service, des développeurs ou des comptes de service) ayant besoin d'utiliser ces ressources.

Tâche Rôle requis
Utiliser des réseaux et sous-réseaux VPC appartenant au projet hôte Utilisateur du réseau

Ce rôle peut être attribué au niveau du projet ou pour des sous-réseaux individuels. Nous vous recommandons d'attribuer le rôle pour les sous-réseaux individuels. En effet, l'attribution du rôle au niveau du projet permet d'accéder à tous les sous-réseaux actuels et futurs du réseau VPC du projet hôte.

Déployer un équilibreur de charge et des backends

Les administrateurs de projet de service ont besoin des rôles suivants dans le projet de service pour créer des ressources et des backends d'équilibrage de charge. Ces autorisations sont accordées automatiquement au propriétaire ou à l'éditeur du projet de service.

Rôles attribués dans le projet de service
Tâche Rôle requis
Créer des composants pour l'équilibreur de charge Administrateur réseau
Créer des instances Administrateur d'instances
Créer et modifier des certificats SSL Administrateur de sécurité

Prérequis

Dans cette section, vous devez effectuer les étapes suivantes :

  1. Configurer le réseau et les sous-réseaux dans le projet hôte.
  2. Configurer un VPC partagé dans le projet hôte.

Il n'est pas nécessaire de suivre les étapes de cette section chaque fois que vous souhaitez créer un équilibreur de charge. Toutefois, vous devez vous assurer que vous avez accès aux ressources décrites ici avant de créer l'équilibreur de charge.

Configurer le réseau et les sous-réseaux dans le projet hôte

Vous avez besoin d'un réseau VPC partagé avec deux sous-réseaux : un pour l'interface et les backends de l'équilibreur de charge, un pour les proxys de l'équilibreur de charge.

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

  • Réseau Le réseau est nommé lb-network.

  • Sous-réseau pour l'interface et les backends de l'équilibreur de charge. Un sous-réseau nommé lb-frontend-and-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 sous-réseau pour l'interface et les backends de l'équilibreur de charge

Il n'est pas nécessaire de suivre les étapes de cette section chaque fois que vous souhaitez créer un équilibreur de charge. Vous devez simplement vous assurer que le projet de service a accès à un sous-réseau du réseau VPC partagé (en plus du sous-réseau proxy réservé).

Toutes les étapes de cette section doivent être effectuées dans le projet hôte.

Console

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

    Accéder aux réseaux VPC

  2. Cliquez sur Créer un réseau VPC.
  3. Dans le champ Nom, saisissez lb-network.

  4. Dans la section Sous-réseaux :

    1. Définissez Mode de création du sous-réseau sur Personnalisé.

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

      • Nom : lb-frontend-and-backend-subnet

      • Région : us-west1

      • Plage d'adresses IP : 10.1.2.0/24

    3. Cliquez sur OK.

  5. Cliquez sur Créer.

gcloud

  1. Créez un réseau VPC à 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 sur le réseau lb-network, dans la région us-west1 :

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

Terraform

  1. Créez un réseau VPC : 

    # Shared VPC network
resource "google_compute_network" "lb_network" {
  name                    = "lb-network"
  provider                = google-beta
  project                 = "my-host-project-id"
  auto_create_subnetworks = false
}

  2. Créez un sous-réseau dans la région us-west1 : 

    # Shared VPC network - backend subnet
resource "google_compute_subnetwork" "lb_frontend_and_backend_subnet" {
  name          = "lb-frontend-and-backend-subnet"
  provider      = google-beta
  project       = "my-host-project-id"
  region        = "us-west1"
  ip_cidr_range = "10.1.2.0/24"
  role          = "ACTIVE"
  network       = google_compute_network.lb_network.id
}

Configurer le sous-réseau proxy réservé

Le sous-réseau proxy réservé est utilisé par tous les équilibreurs de charge régionaux basés sur Envoy dans la région us-west1 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.

N'effectuez pas cette étape s'il existe déjà un sous-réseau proxy réservé dans la région us-west1 de ce réseau.

Toutes les étapes de cette section doivent être effectuées dans le projet hôte.

Console

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

    Accéder aux réseaux VPC

  2. Cliquez sur le nom du réseau VPC partagé : lb-network.
  3. Cliquez sur Ajouter un sous-réseau.
  4. Dans le champ Nom, saisissez proxy-only-subnet.
  5. Pour Région, sélectionnez 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

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

# Shared VPC network - proxy-only subnet
resource "google_compute_subnetwork" "proxy_only_subnet" {
  name          = "proxy-only-subnet"
  provider      = google-beta
  project       = "my-host-project-id"
  region        = "us-west1"
  ip_cidr_range = "10.129.0.0/23"
  role          = "ACTIVE"
  purpose       = "REGIONAL_MANAGED_PROXY"
  network       = google_compute_network.lb_network.id
}

Autoriser les administrateurs de projet de service à accéder au sous-réseau backend

Les administrateurs de projet de service ont besoin d'accéder au sous-réseau lb-frontend-and-backend-subnet pour pouvoir provisionner les backends de l'équilibreur de charge.

Un administrateur du VPC partagé doit accorder l'accès au sous-réseau backend aux administrateurs du projet de service (ou aux développeurs qui déploieront des ressources et des backends qui exploitent le sous-réseau). Pour obtenir des instructions, consultez la section Administrateurs de projet de service pour certains sous-réseaux.

Configurer des règles de pare-feu dans le projet hôte

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

Toutes les étapes de cette section doivent être effectuées dans le projet hôte.

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 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
    • Protocols and ports (Protocoles et ports) :
      • Choisissez Protocoles et ports spécifiés.
      • Vérifiez TCP et 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 vérifications d'état Google Cloud :
    • 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
    • Protocols and ports (Protocoles et ports) :
      • Choisissez Protocoles et ports spécifiés.
      • Vérifiez TCP et saisissez 80, 443, 8080 pour les numéros de port.
  5. Cliquez sur Créer.
  6. 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-ssh
    • Réseau : lb-network
    • Sens du trafic : entrée
    • Action en cas de correspondance : autoriser
    • Cibles : tags cibles spécifiés
    • Tags cibles : allow-ssh
    • Filtre source : plages IPv4
    • Plages IPv4 sources : 0.0.0.0/0
    • Protocols and ports (Protocoles et ports) :
      • Choisissez Protocoles et ports spécifiés.
      • Vérifiez TCP et saisissez 22 pour le numéro de port.
  7. Cliquez sur Créer.

gcloud

  1. Créez la règle de pare-feu fw-allow-health-check pour autoriser les vérifications d'état Google Cloud. Cet exemple autorise tout le trafic TCP provenant des vérificateurs 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 de pare-feu fw-allow-proxies pour autoriser le trafic provenant du sous-réseau proxy réservé Envoy à accéder à vos backends.

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

  3. Créez la règle de pare-feu fw-allow-ssh pour autoriser la connectivité SSH aux VM avec le tag réseau allow-ssh. Lorsque vous omettez source-ranges, Google Cloud interprète la règle comme désignant n'importe quelle source.

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

Terraform

  1. Créez une règle de pare-feu pour autoriser les vérifications d'état Google Cloud. 

    resource "google_compute_firewall" "fw_allow_health_check" {
  name          = "fw-allow-health-check"
  provider      = google-beta
  project       = "my-host-project-id"
  direction     = "INGRESS"
  network       = google_compute_network.lb_network.id
  source_ranges = ["130.211.0.0/22", "35.191.0.0/16"]
  allow {
    protocol = "tcp"
  }
  target_tags = ["load-balanced-backend"]
}

  2. Créez une règle de pare-feu pour autoriser le trafic provenant du sous-réseau proxy réservé Envoy à atteindre vos backends. 

    resource "google_compute_firewall" "fw_allow_proxies" {
  name          = "fw-allow-proxies"
  provider      = google-beta
  project       = "my-host-project-id"
  direction     = "INGRESS"
  network       = google_compute_network.lb_network.id
  source_ranges = ["10.129.0.0/23"]
  allow {
    protocol = "tcp"
    ports    = ["80", "443", "8080"]
  }
  target_tags = ["load-balanced-backend"]
}

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

    resource "google_compute_firewall" "fw_allow_ssh" {
  name          = "fw-allow-ssh"
  provider      = google-beta
  project       = "my-host-project-id"
  direction     = "INGRESS"
  network       = google_compute_network.lb_network.id
  source_ranges = ["0.0.0.0/0"]
  allow {
    protocol = "tcp"
    ports    = ["22"]
  }
  target_tags = ["allow-ssh"]
}

Configurer un VPC partagé dans le projet hôte

Cette étape consiste à activer un projet hôte de VPC partagé, à partager des sous-réseaux du projet hôte et à associer des projets de service au projet hôte afin que ces derniers puissent utiliser le réseau VPC partagé. Pour configurer un VPC partagé dans le projet hôte, consultez les pages suivantes :

Le reste de ces instructions suppose que vous avez déjà configuré un VPC partagé. Cela inclut de configurer des stratégies IAM pour votre organisation et de désigner les projets hôtes et de service.

Ne poursuivez pas tant que vous n'avez pas configuré le VPC partagé et activé les projets hôte et de service.

Après avoir suivi les étapes décrites dans cette section, vous pouvez effectuer l'une des configurations suivantes :

Configurer un équilibreur de charge dans le projet de service

Cet exemple crée un équilibreur de charge d'application interne dans lequel tous les composants d'équilibrage de charge (règle de transfert, proxy cible, mappage d'URL et service de backend) et les backends sont créés dans le projet de service.

Les ressources réseau de l'équilibreur de charge d'application interne, telles que le sous-réseau proxy réservé et le sous-réseau des instances backend, sont créées dans le projet hôte. Les règles de pare-feu des instances backend sont également créées dans le projet hôte.

Figure 1. Équilibreur de charge d'application interne sur un VPC partagé
Figure 1. Équilibreur de charge d'application interne sur un VPC partagé

Cette section vous explique comment configurer l'équilibreur de charge et les backends. Ces étapes doivent être effectuées par l'administrateur du projet de service (ou un développeur opérant dans le projet de service) et ne nécessitent aucune intervention de l'administrateur du projet hôte. Les étapes de cette section sont très semblables aux étapes standards de configuration de l'équilibreur de charge d'application interne.

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

Créer le backend du 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 interne. 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-ilb-backend-template.
    3. Assurez-vous que le disque de démarrage est défini sur une image Debian, telle que Debian GNU/Linux 12 (bookworm). Ces instructions utilisent des commandes uniquement disponibles dans Debian, comme apt-get. Si vous devez modifier le disque de démarrage, cliquez sur Modifier.
      1. Pour Système d'exploitation, sélectionnez Debian.
      2. Pour Version, sélectionnez l'une des images Debian disponibles, telles que Debian GNU/Linux 12 (bookworm).
      3. Cliquez sur Sélectionner.
    4. Cliquez sur Options avancées, puis sur Mise en réseau.
    5. Saisissez les tags réseau suivants : allow-ssh,load-balanced-backend.
    6. Dans la section Interfaces réseau, sélectionnez Réseaux partagés avec moi (depuis le projet hôte : HOST_PROJECT_ID).
    7. Sélectionnez le sous-réseau lb-frontend-and-backend-subnet dans le réseau lb-network.
    8. Cliquez sur Gestion. Pour Gestion, insérez 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
    9. Cliquez sur Créer.

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

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

    1. Cliquez sur Créer un groupe d'instances.
    2. Choisissez Nouveau groupe d'instances géré (sans état). Pour des informations plus détaillées, consultez la page Groupes d'instances gérés (MIG) sans état ou avec état.
    3. Dans le champ Nom, saisissez l7-ilb-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-ilb-backend-template.

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

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

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

      Si vous le souhaitez, dans la section Autoscaling de l'interface utilisateur, vous pouvez configurer le groupe d'instances de manière à ajouter ou supprimer automatiquement des instances en fonction de l'utilisation du processeur.

    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 un serveur HTTP à l'aide de la commande gcloud compute instance-templates create.

    gcloud compute instance-templates create l7-ilb-backend-template \
--region=us-west1 \
--network=projects/HOST_PROJECT_ID/global/networks/lb-network \
--subnet=projects/HOST_PROJECT_ID/regions/us-west1/subnetworks/lb-frontend-and-backend-subnet \
--tags=allow-ssh,load-balanced-backend \
--image-family=debian-12 \
--image-project=debian-cloud \
--metadata=startup-script='#! /bin/bash
apt-get update
apt-get install apache2 -y
a2ensite default-ssl
a2enmod ssl
vm_hostname="$(curl -H "Metadata-Flavor:Google" \
http://metadata.google.internal/computeMetadata/v1/instance/name)"
echo "Page served from: $vm_hostname" | \
tee /var/www/html/index.html
systemctl restart apache2' \
--project=SERVICE_PROJECT_ID

  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-ilb-backend-example \
    --zone=us-west1-a \
    --size=2 \
    --template=l7-ilb-backend-template \
    --project=SERVICE_PROJECT_ID

Terraform

  1. Créez un modèle d'instance de VM.

    # Instance template
resource "google_compute_instance_template" "default" {
  name     = "l7-ilb-backend-template"
  provider = google-beta
  project  = "my-service-project-id"
  region   = "us-west1"
  # For machine type, using small. For more options check https://cloud.google.com/compute/docs/machine-types
  machine_type = "e2-small"
  tags         = ["allow-ssh", "load-balanced-backend"]
  network_interface {
    network    = google_compute_network.lb_network.id
    subnetwork = google_compute_subnetwork.lb_frontend_and_backend_subnet.id
    access_config {
      # add external ip to fetch packages like apache2, ssl
    }
  }
  disk {
    source_image = "debian-cloud/debian-12"
    auto_delete  = true
    boot         = true
  }

  # install apache2 and serve a simple web page
  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://metadata.google.internal/computeMetadata/v1/instance/name)"
    sudo echo "Page served from: $vm_hostname" | \
    tee /var/www/html/index.html
    sudo systemctl restart apache2
    EOF
  }
}

  2. Créez un groupe d'instances géré.

    Pour HTTP :

    # MIG
resource "google_compute_instance_group_manager" "default" {
  name               = "l7-ilb-backend-example"
  provider           = google-beta
  project            = "my-service-project-id"
  zone               = "us-west1-a"
  base_instance_name = "vm"
  target_size        = 2
  version {
    instance_template = google_compute_instance_template.default.id
    name              = "primary"
  }
  named_port {
    name = "http"
    port = 80
  }
}

    Pour HTTPS :

    # MIG
resource "google_compute_instance_group_manager" "default" {
  name               = "l7-ilb-backend-example"
  provider           = google-beta
  project            = "my-service-project-id"
  zone               = "us-west1-a"
  base_instance_name = "vm"
  target_size        = 2
  version {
    instance_template = google_compute_instance_template.default.id
    name              = "primary"
  }
  named_port {
    name = "https"
    port = 443
  }
}

Configurer l'équilibreur de charge

Cette section vous explique comment créer les ressources suivantes pour l'équilibreur de charge d'application interne :

  • Vérification d'état HTTP
  • Un service de backend avec un groupe d'instances géré en tant que backend
  • Un mappage d'URL
  • Un certificat SSL (requis uniquement pour HTTPS)
  • Un proxy cible
  • Règle de transfert

Disponibilité du proxy

En fonction du nombre de projets de service qui utilisent le même réseau VPC partagé, vous pouvez atteindre des quotas ou des limites plus rapidement que dans le modèle de déploiement réseau où chaque projet Google Cloud héberge son propre réseau.

Parfois, les régions Google Cloud ne disposent pas d'une capacité de proxy suffisante pour un nouvel équilibreur de charge d'application interne. 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 :

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

  • Contactez l'équipe commerciale Google Cloud pour augmenter ces limites.

Console

Basculer vers le contexte du projet de service

  1. Dans la console Google Cloud, accédez à la page Tableau de bord.

    Accéder à Google Dashboard

  2. Cliquez sur la liste Sélectionner en haut de la page. Dans la fenêtre Sélectionner qui s'affiche, sélectionnez le projet de service dans lequel vous souhaitez créer l'équilibreur de charge.

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 Interne, puis cliquez sur Suivant.
  5. Pour Déploiement interrégional 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 l7-ilb-shared-vpc.
  2. Pour la région, sélectionnez us-west1.

  3. Pour le réseau, sélectionnez lb-network (dans Projet : HOST_PROJECT_ID).

    Si le message d'avertissement Sous-réseau proxy réservé obligatoire dans le réseau VPC partagé s'affiche, confirmez que l'administrateur du projet hôte a créé l'adresse proxy-only-subnet dans la région us-west1 du réseau VPC partagé lb-network. La création de l'équilibreur de charge réussit même si vous ne disposez pas des autorisations nécessaires pour afficher le sous-réseau proxy réservé sur cette page.

  4. Laissez la fenêtre ouverte pour continuer.

Configurer le 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 de backend.
  3. Définissez le paramètre Nom du service de backend sur l7-ilb-backend-service.
  4. Définissez le Type de backend sur Groupes d'instances.
  5. Dans la section Nouveau backend :
    1. Définissez le Groupe d'instances sur l7-ilb-backend-example.
    2. Définissez les numéros de port sur 80.
    3. Définissez le Mode d'équilibrage sur Utilisation.
    4. Cliquez sur OK.
  6. Dans la section Vérification d'état, sélectionnez Créer une vérification d'état avec les paramètres suivants :
    1. Nom : l7-ilb-basic-check
    2. Protocole : HTTP
    3. Port : 80
  7. Cliquez sur Enregistrer et continuer.
  8. Cliquez sur Créer.

Configurer les règles de routage

  • Cliquez sur Règles de routage. Assurez-vous que l7-ilb-backend-service est le seul service de backend pour tous les hôtes et chemins sans correspondance.

Pour en savoir plus sur la gestion du trafic, consultez la page Configurer la gestion du trafic.

Configurer l'interface

Pour HTTP :

  1. Cliquez sur Configuration du frontend.
  2. Dans le champ Nom, spécifiez l7-ilb-forwarding-rule.
  3. Définissez le paramètre Protocole sur HTTP.
  4. Définissez le paramètre Sous-réseau sur lb-frontend-and-backend-subnet. Ne sélectionnez pas le sous-réseau proxy réservé pour l'interface, même s'il s'agit d'une option de la liste déroulante.
  5. Définissez le paramètre Port sur 80.
  6. Cliquez sur le menu Adresse IP, puis sur Créer une adresse IP.
  7. Dans le panneau Réserver une adresse IP statique interne, fournissez les informations suivantes :
    1. Dans le champ Nom, saisissez ip-address-shared-vpc.
    2. Pour Adresse IP statique, cliquez sur Laissez-moi choisir. Pour Adresse IP personnalisée, saisissez 10.1.2.99.
    3. (Facultatif) Si vous souhaitez partager cette adresse IP avec différentes interfaces, définissez la section Objectif sur Partagée.
  8. Cliquez sur OK.

Pour HTTPS :

Si vous utilisez HTTPS entre le client et l'équilibreur de charge, vous devez disposer d'une ou de plusieurs ressources de certificat SSL pour configurer le proxy. Pour en savoir plus sur la création de ressources de certificat SSL, consultez la page Certificats SSL. À l'heure actuelle, les certificats gérés par Google ne sont pas compatibles avec les équilibreurs de charge d'application internes.

  1. Cliquez sur Configuration de l'interface.
  2. Dans le champ Nom, saisissez l7-ilb-forwarding-rule.
  3. Dans le champ Protocole, sélectionnez HTTPS (includes HTTP/2).
  4. Définissez le paramètre Sous-réseau sur lb-frontend-and-backend-subnet. Ne sélectionnez pas le sous-réseau proxy réservé pour l'interface, même s'il s'agit d'une option de la liste déroulante.
  5. Assurez-vous que le port est défini sur la valeur 443 pour autoriser le trafic HTTPS.
  6. Cliquez sur le menu Adresse IP, puis sur Créer une adresse IP.
  7. Dans le panneau Réserver une adresse IP statique interne, fournissez les informations suivantes :
    1. Dans le champ Nom, saisissez ip-address-shared-vpc.
    2. Pour Adresse IP statique, cliquez sur Laissez-moi choisir. Pour Adresse IP personnalisée, saisissez 10.1.2.99.
    3. (Facultatif) Si vous souhaitez partager cette adresse IP avec différentes interfaces, définissez la section Objectif sur Partagée.
  8. Cliquez sur la liste Certificat.
    1. Si vous possédez déjà une ressource de certificat SSL autogérée que vous souhaitez utiliser comme certificat SSL principal, sélectionnez-la dans le menu déroulant.
    2. Sinon, sélectionnez Créer un certificat.
      1. Pour le nom, indiquez l7-ilb-cert.
      2. Dans les champs appropriés, importez vos fichiers au format PEM :
        • Certificat de clé publique
        • Chaîne de certificats
        • Clé privée
      3. Cliquez sur Créer.
  9. Pour ajouter des ressources de certificat en plus de la ressource de certificat SSL principale, procédez comme suit :
    1. Cliquez sur Ajouter un certificat.
    2. Sélectionnez un certificat dans la liste Certificats ou cliquez sur Créer un certificat, puis suivez les instructions précédentes.
  10. Cliquez sur OK.

Vérifier et finaliser la configuration

  • 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-ilb-basic-check \
   --region=us-west1 \
   --use-serving-port \
   --project=SERVICE_PROJECT_ID

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

    gcloud compute backend-services create l7-ilb-backend-service \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --protocol=HTTP \
  --health-checks=l7-ilb-basic-check \
  --health-checks-region=us-west1 \
  --region=us-west1 \
  --project=SERVICE_PROJECT_ID

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

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

    gcloud compute url-maps create l7-ilb-map \
  --default-service=l7-ilb-backend-service \
  --region=us-west1 \
  --project=SERVICE_PROJECT_ID

  5. Créez le proxy cible.

    Pour HTTP :

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

    gcloud compute target-http-proxies create l7-ilb-proxy \
  --url-map=l7-ilb-map \
  --url-map-region=us-west1 \
  --region=us-west1 \
  --project=SERVICE_PROJECT_ID

    Pour HTTPS :

    Pour en savoir plus sur la création de ressources de certificat SSL, consultez la page Certificats SSL. À l'heure actuelle, les certificats gérés par Google ne sont pas compatibles avec les équilibreurs de charge d'application internes.

    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

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

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

    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-ilb-proxy \
  --url-map=l7-ilb-map \
  --region=us-west1 \
  --ssl-certificates=l7-ilb-cert \
  --project=SERVICE_PROJECT_ID

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

    Pour les réseaux personnalisés, vous devez faire référence au sous-réseau dans la règle de transfert.

    Pour l'adresse IP de la règle de transfert, utilisez le sous-réseau lb-frontend-and-backend-subnet. Si vous essayez d'utiliser le sous-réseau proxy réservé, la création de la règle de transfert échoue.

    Pour HTTP :

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

    gcloud compute forwarding-rules create l7-ilb-forwarding-rule \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --network=projects/HOST_PROJECT_ID/global/networks/lb-network \
  --subnet=projects/HOST_PROJECT_ID/regions/us-west1/subnetworks/lb-frontend-and-backend-subnet \
  --address=IP_ADDRESS_NAME \
  --ports=80 \
  --region=us-west1 \
  --target-http-proxy=l7-ilb-proxy \
  --target-http-proxy-region=us-west1 \
  --project=SERVICE_PROJECT_ID

    Pour HTTPS :

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

    gcloud compute forwarding-rules create l7-ilb-forwarding-rule \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --network=projects/HOST_PROJECT_ID/global/networks/lb-network \
  --subnet=projects/HOST_PROJECT_ID/regions/us-west1/subnetworks/lb-frontend-and-backend-subnet \
  --address=IP_ADDRESS_NAME \
  --ports=443 \
  --region=us-west1 \
  --target-https-proxy=l7-ilb-proxy \
  --target-https-proxy-region=us-west1 \
  --project=SERVICE_PROJECT_ID

Terraform

  1. Définissez la vérification d'état HTTP.

    Pour HTTP : 

    # health check
resource "google_compute_health_check" "default" {
  name               = "l7-ilb-basic-check"
  provider           = google-beta
  project            = "my-service-project-id"
  timeout_sec        = 1
  check_interval_sec = 1
  http_health_check {
    port = "80"
  }
}

    Pour HTTPS : 

    # health check
resource "google_compute_health_check" "default" {
  name               = "l7-ilb-basic-check"
  provider           = google-beta
  project            = "my-service-project-id"
  timeout_sec        = 1
  check_interval_sec = 1
  https_health_check {
    port = "443"
  }
}

  2. Définissez le service de backend.

    # backend service
resource "google_compute_region_backend_service" "default" {
  name                  = "l7-ilb-backend-service"
  provider              = google-beta
  project               = "my-service-project-id"
  region                = "us-west1"
  protocol              = "HTTP"
  load_balancing_scheme = "INTERNAL_MANAGED"
  timeout_sec           = 10
  health_checks         = [google_compute_health_check.default.id]
  backend {
    group           = google_compute_instance_group_manager.default.instance_group
    balancing_mode  = "UTILIZATION"
    capacity_scaler = 1.0
  }
}

  3. Créez le mappage d'URL.

    # URL map
resource "google_compute_region_url_map" "default" {
  name            = "l7-ilb-map"
  provider        = google-beta
  project         = "my-service-project-id"
  region          = "us-west1"
  default_service = google_compute_region_backend_service.default.id
}

  4. Créez le proxy cible.

    Pour HTTP : 

    # HTTP target proxy
resource "google_compute_region_target_http_proxy" "default" {
  name     = "l7-ilb-proxy"
  provider = google-beta
  project  = "my-service-project-id"
  region   = "us-west1"
  url_map  = google_compute_region_url_map.default.id
}

    Pour HTTPS : créez un certificat SSL régional.

    Pour en savoir plus sur la création de ressources de certificat SSL, consultez la page Certificats SSL. À l'heure actuelle, les certificats gérés par Google ne sont pas compatibles avec les équilibreurs de charge d'application internes.

    # Use self-signed SSL certificate
resource "google_compute_region_ssl_certificate" "default" {
  name        = "l7-ilb-cert"
  provider    = google-beta
  project     = "my-service-project-id"
  region      = "us-west1"
  private_key = file("sample-private.key") # path to PEM-formatted file
  certificate = file("sample-server.cert") # path to PEM-formatted file
}

    Utilisez le certificat SSL régional pour créer un proxy cible.

    # HTTPS target proxy
resource "google_compute_region_target_https_proxy" "default" {
  name             = "l7-ilb-proxy"
  provider         = google-beta
  project          = "my-service-project-id"
  region           = "us-west1"
  url_map          = google_compute_region_url_map.default.id
  ssl_certificates = [google_compute_region_ssl_certificate.default.id]
}

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

    Pour les réseaux personnalisés, vous devez faire référence au sous-réseau dans la règle de transfert.

    Pour HTTP : 

    # Forwarding rule
resource "google_compute_forwarding_rule" "default" {
  name                  = "l7-ilb-forwarding-rule"
  provider              = google-beta
  project               = "my-service-project-id"
  region                = "us-west1"
  ip_protocol           = "TCP"
  port_range            = "80"
  load_balancing_scheme = "INTERNAL_MANAGED"
  target                = google_compute_region_target_http_proxy.default.id
  network               = google_compute_network.lb_network.id
  subnetwork            = google_compute_subnetwork.lb_frontend_and_backend_subnet.id
  network_tier          = "PREMIUM"
  depends_on            = [google_compute_subnetwork.lb_frontend_and_backend_subnet]
}

    Pour HTTPS : 

    # Forwarding rule
resource "google_compute_forwarding_rule" "default" {
  name                  = "l7-ilb-forwarding-rule"
  provider              = google-beta
  project               = "my-service-project-id"
  region                = "us-west1"
  ip_protocol           = "TCP"
  port_range            = "443"
  load_balancing_scheme = "INTERNAL_MANAGED"
  target                = google_compute_region_target_https_proxy.default.id
  network               = google_compute_network.lb_network.id
  subnetwork            = google_compute_subnetwork.lb_frontend_and_backend_subnet.id
  network_tier          = "PREMIUM"
  depends_on            = [google_compute_subnetwork.lb_frontend_and_backend_subnet]
}

Tester l'équilibreur de charge

Pour tester l'équilibreur de charge, commencez par créer un exemple de VM cliente. Établissez ensuite une session SSH avec la VM et envoyez le trafic de cette VM à l'équilibreur de charge.

Créer une instance de VM de test

Les clients peuvent se situer dans le projet hôte ou dans n'importe quel projet de service connecté. Dans cet exemple, vous déployez une VM cliente dans un projet de service pour tester le fonctionnement de l'équilibreur de charge. Le client doit utiliser le même réseau VPC partagé et se trouver dans la même région que l'équilibreur de charge.

Console

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

    Accéder à la page "Instances de VM"

  2. Cliquez sur Créer une instance.

  3. Définissez le paramètre Nom sur client-vm.

  4. Définissez la Zone sur us-west1-a.

  5. Cliquez sur Options avancées, puis sur Mise en réseau.

  6. Saisissez les tags réseau suivants : allow-ssh,load-balanced-backend.

  7. Dans la section Interfaces réseau, sélectionnez Réseaux partagés avec moi (depuis le projet hôte : HOST_PROJECT_ID).

  8. Sélectionnez le sous-réseau lb-frontend-and-backend-subnet dans le réseau lb-network.

  9. Cliquez sur Créer.

gcloud

Créez une instance de VM de test.

gcloud compute instances create client-vm \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --subnet=projects/HOST_PROJECT_ID/regions/us-west1/subnetworks/lb-frontend-and-backend-subnet \
    --zone=us-west1-a \
    --tags=allow-ssh \
    --project=SERVICE_PROJECT_ID

Terraform

Créez une instance de VM de test.

resource "google_compute_instance" "vm_test" {
  name         = "client-vm"
  provider     = google-beta
  project      = "my-service-project-id"
  zone         = "us-west1-a"
  machine_type = "e2-small"
  tags         = ["allow-ssh"]
  network_interface {
    network    = google_compute_network.lb_network.id
    subnetwork = google_compute_subnetwork.lb_frontend_and_backend_subnet.id
  }
  boot_disk {
    initialize_params {
      image = "debian-cloud/debian-12"
    }
  }
  lifecycle {
    ignore_changes = [
      metadata["ssh-keys"]
    ]
  }
}

Envoyer du trafic vers l'équilibreur de charge

Utilisez SSH pour vous connecter à l'instance que vous venez de créer et pour vérifier que les services HTTP(S) sur les backends sont accessibles via l'adresse IP de la règle de transfert de l'équilibreur de charge d'application interne et que le trafic fait l'objet d'un équilibrage de charge sur les instances backend.

  1. Connectez-vous à l'instance cliente avec SSH.

    gcloud compute ssh client-vm \
   --zone=us-west1-a

  2. Vérifiez que l'adresse IP diffuse son nom d'hôte. Remplacez LB_IP_ADDRESS par l'adresse IP de l'équilibreur de charge.

    curl LB_IP_ADDRESS

    Pour le test HTTPS, remplacez curl par ce qui suit :

    curl -k -s 'https://LB_IP_ADDRESS:443'

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

Configurer un équilibreur de charge avec un service de backend multiprojet

L'exemple précédent de cette page vous explique comment configurer un déploiement de VPC partagé dans lequel tous les composants de l'équilibreur de charge et ses backends sont créés dans le projet de service.

Les équilibreurs de charge d'application internes vous permettent également de configurer des déploiements de VPC partagé dans lesquels un mappage d'URL d'un projet hôte ou de service peut faire référence à des services de backend (et à des backends) situés sur plusieurs projets de service dans des environnements VPC partagés. C'est ce que l'on appelle la référence du service inter-projets.

Vous pouvez utiliser les étapes de cette section comme référence pour configurer l'une des combinaisons compatibles répertoriées ici :

  • Règle de transfert, proxy cible et mappage d'URL dans le projet hôte, et service de backend dans un projet de service
  • Règle de transfert, proxy cible et mappage d'URL dans un projet de service, et service de backend dans un autre projet de service

Le référencement des services multiprojets peut être utilisé avec des groupes d'instances, des NEG sans serveur ou tout autre type de backend compatible. Si vous utilisez des NEG sans serveur, vous devez créer une VM dans le réseau VPC sur lequel vous souhaitez créer l'interface de l'équilibreur de charge. Pour obtenir un exemple, consultez la section Créer une instance de VM dans un sous-réseau spécifique sur la page Configurer un équilibreur de charge d'application interne avec Cloud Run.

Conditions à respecter

Cet exemple configure un exemple d'équilibreur de charge avec son interface et son backend dans deux projets de service différents.

Si vous ne l'avez pas déjà fait, vous devez suivre toutes les étapes préalables pour configurer le VPC partagé ainsi que les réseaux, les sous-réseaux et les règles de pare-feu requis pour cet exemple. Pour obtenir des instructions, consultez les sections suivantes :

Figure 2. Interface et backend de l&#39;équilibreur de charge dans différents projets de service
Figure 2. Interface et backend de l'équilibreur de charge dans différents projets de service

Créer les backends et le service de backend dans le projet de service B

Toutes les étapes de cette section doivent être effectuées dans le projet de service B.

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 Créer un modèle d'instance.
    2. Dans le champ Nom, saisissez le nom du modèle d'instance : cross-ref-backend-template.
    3. Assurez-vous que le disque de démarrage est défini sur une image Debian, telle que Debian GNU/Linux 12 (bookworm). Ces instructions utilisent des commandes uniquement disponibles dans Debian, comme apt-get. Si vous devez modifier le disque de démarrage, cliquez sur Modifier.
      1. Pour Système d'exploitation, sélectionnez Debian.
      2. Pour Version, sélectionnez l'une des images Debian disponibles, telles que Debian GNU/Linux 12 (bookworm).
      3. Cliquez sur Sélectionner.
    4. Cliquez sur Options avancées, puis sur Mise en réseau.
    5. Saisissez les tags réseau suivants : allow-ssh,load-balanced-backend.
    6. Dans la section Interfaces réseau, sélectionnez Réseaux partagés avec moi (depuis le projet hôte : HOST_PROJECT_ID).
    7. Sélectionnez le sous-réseau lb-frontend-and-backend-subnet dans le réseau lb-network.
    8. Cliquez sur Gestion. Pour Gestion, insérez 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
    9. Cliquez sur Créer.

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

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

    1. Cliquez sur Créer un groupe d'instances.
    2. Choisissez 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. Pour le champ Nom, saisissez le nom du groupe d'instances : cross-ref-ig-backend.
    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 cross-ref-backend-template.

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

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

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

      Si vous le souhaitez, dans la section Autoscaling de l'interface utilisateur, vous pouvez configurer le groupe d'instances de manière à ajouter ou supprimer automatiquement des instances en fonction de l'utilisation du processeur.

    9. Cliquez sur Créer.

  3. Créez un service de backend régional. Dans le cadre de cette étape, nous allons également créer la vérification de l'état et ajouter des backends au service de backend. Dans la console Google Cloud, accédez à la page Backends.

    Accéder à la page Backends

    1. Cliquez sur Créer un service de backend régional.
    2. Dans le champ Nom, saisissez le nom du service de backend : cross-ref-backend-service.
    3. Pour le paramètre Région, sélectionnez us-west1.
    4. Pour Type d'équilibreur de charge, sélectionnez Équilibreur de charge d'application interne régional (INTERNAL_MANAGED).
    5. Définissez Type de backend sur Groupes d'instances.
    6. Dans la section Backends, définissez le réseau sur lb-network.
    7. Cliquez sur Ajouter un backend et définissez les champs suivants :
      1. Définissez le Groupe d'instances sur cross-ref-ig-backend.
      2. Saisissez les numéros de port : 80.
      3. Définissez le Mode d'équilibrage sur Utilisation.
      4. Cliquez sur OK.
    8. Dans la section Vérification d'état, sélectionnez Créer une vérification d'état avec les paramètres suivants :
      1. Nom : cross-ref-http-health-check
      2. Protocole : HTTP
      3. Port : 80
      4. Cliquez sur Enregistrer.
    9. Cliquez sur Continuer.

    10. Facultatif : dans la section Ajouter des autorisations, saisissez les comptes principaux IAM (généralement une adresse e-mail) des administrateurs de l'équilibreur de charge provenant d'autres projets afin qu'ils puissent utiliser ce service de backend pour les équilibreurs de charge dans leurs propres projets. Sans cette autorisation, vous ne pouvez pas utiliser le référencement des services multiprojets.

      Si vous ne disposez pas des autorisations nécessaires pour définir des règles de contrôle des accès pour les services de backend dans ce projet, vous pouvez toujours créer le service de backend et un utilisateur autorisé effectuera cette étape ultérieurement, comme décrit dans la section Accorder des autorisations à l'administrateur de l'équilibreur de charge pour utiliser le service de backend. Cette section explique également comment accorder l'accès à tous les services de backend de ce projet, afin de ne pas avoir à le faire chaque fois que vous créez un service de backend.

    11. Cliquez sur Créer.

gcloud

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

    gcloud compute instance-templates create BACKEND_IG_TEMPLATE \
    --region=us-west1 \
    --network=projects/HOST_PROJECT_ID/global/networks/lb-network \
    --subnet=projects/HOST_PROJECT_ID/regions/us-west1/subnetworks/lb-frontend-and-backend-subnet \
    --tags=allow-ssh,load-balanced-backend \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --metadata=startup-script='#! /bin/bash
    apt-get update
    apt-get install apache2 -y
    a2ensite default-ssl
    a2enmod ssl
    vm_hostname="$(curl -H "Metadata-Flavor:Google" \
    http://metadata.google.internal/computeMetadata/v1/instance/name)"
    echo "Page served from: $vm_hostname" | \
    tee /var/www/html/index.html
    systemctl restart apache2' \
    --project=SERVICE_PROJECT_B_ID

    Remplacez les éléments suivants :

    • BACKEND_IG_TEMPLATE : nom du modèle de groupe d'instances.
    • SERVICE_PROJECT_B_ID : ID du projet de service B, dans lequel les backends de l'équilibreur de charge et le service de backend sont créés.
    • HOST_PROJECT_ID : ID du projet hôte de VPC partagé.

  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 BACKEND_MIG \
    --zone=us-west1-a \
    --size=2 \
    --template=BACKEND_IG_TEMPLATE \
    --project=SERVICE_PROJECT_B_ID

    Remplacez les éléments suivants :

    • BACKEND_MIG : nom du groupe d'instances backend.

  3. 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 HTTP_HEALTH_CHECK_NAME \
  --region=us-west1 \
  --use-serving-port \
  --project=SERVICE_PROJECT_B_ID

    Remplacez les éléments suivants :

    • HTTP_HEALTH_CHECK_NAME : nom de la vérification d'état HTTP

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

    gcloud compute backend-services create BACKEND_SERVICE_NAME \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --protocol=HTTP \
  --health-checks=HTTP_HEALTH_CHECK_NAME \
  --health-checks-region=us-west1 \
  --region=us-west1 \
  --project=SERVICE_PROJECT_B_ID

    Remplacez les éléments suivants :

    • BACKEND_SERVICE_NAME : nom du service de backend créé dans le projet de service B.

  5. 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_NAME \
  --balancing-mode=UTILIZATION \
  --instance-group=BACKEND_MIG \
  --instance-group-zone=us-west1-a \
  --region=us-west1 \
  --project=SERVICE_PROJECT_B_ID

Terraform

  1. Créez un modèle d'instance.

    # Instance template
resource "google_compute_instance_template" "default" {
  name     = "l7-ilb-backend-template"
  provider = google-beta
  project  = "my-service-project-b-id"
  region   = "us-west1"
  # For machine type, using small. For more options check https://cloud.google.com/compute/docs/machine-types
  machine_type = "e2-small"
  tags         = ["allow-ssh", "load-balanced-backend"]
  network_interface {
    network    = google_compute_network.lb_network.id
    subnetwork = google_compute_subnetwork.lb_frontend_and_backend_subnet.id
    access_config {
      # add external ip to fetch packages like apache2, ssl
    }
  }
  disk {
    source_image = "debian-cloud/debian-12"
    auto_delete  = true
    boot         = true
  }

  # install apache2 and serve a simple web page
  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://metadata.google.internal/computeMetadata/v1/instance/name)"
    sudo echo "Page served from: $vm_hostname" | \
    tee /var/www/html/index.html
    sudo systemctl restart apache2
    EOF
  }
}

  2. Créez un groupe d'instances géré.

    Pour HTTP

    # MIG
resource "google_compute_instance_group_manager" "default" {
  name               = "l7-ilb-backend-example"
  provider           = google-beta
  project            = "my-service-project-b-id"
  zone               = "us-west1-a"
  base_instance_name = "vm"
  target_size        = 2
  version {
    instance_template = google_compute_instance_template.default.id
    name              = "primary"
  }
  named_port {
    name = "http"
    port = 80
  }
}

    Pour HTTPS

    # MIG
resource "google_compute_instance_group_manager" "default" {
  name               = "l7-ilb-backend-example"
  provider           = google-beta
  project            = "my-service-project-b-id"
  zone               = "us-west1-a"
  base_instance_name = "vm"
  target_size        = 2
  version {
    instance_template = google_compute_instance_template.default.id
    name              = "primary"
  }
  named_port {
    name = "https"
    port = 443
  }
}

  3. Créez une vérification d'état pour le backend.

    Pour HTTP

    # health check
resource "google_compute_health_check" "default" {
  name               = "l7-ilb-basic-check"
  provider           = google-beta
  project            = "my-service-project-b-id"
  timeout_sec        = 1
  check_interval_sec = 1
  http_health_check {
    port = "80"
  }
}

    Pour HTTPS

    # health check
resource "google_compute_health_check" "default" {
  name               = "l7-ilb-basic-check"
  provider           = google-beta
  project            = "my-service-project-b-id"
  timeout_sec        = 1
  check_interval_sec = 1
  https_health_check {
    port = "443"
  }
}

  4. Créez un service de backend régional.

    # backend service
resource "google_compute_region_backend_service" "default" {
  name                  = "l7-ilb-backend-service"
  provider              = google-beta
  project               = "my-service-project-b-id"
  region                = "us-west1"
  protocol              = "HTTP"
  load_balancing_scheme = "INTERNAL_MANAGED"
  timeout_sec           = 10
  health_checks         = [google_compute_health_check.default.id]
  backend {
    group           = google_compute_instance_group_manager.default.instance_group
    balancing_mode  = "UTILIZATION"
    capacity_scaler = 1.0
  }
}

Créer l'interface et le mappage d'URL de l'équilibreur de charge dans le projet de service A

Toutes les étapes de cette section doivent être effectuées dans le projet de service A.

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 Interne, puis cliquez sur Suivant.
  5. Pour Déploiement interrégional 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. Dans le champ Name (Nom), saisissez le nom de l'équilibreur de charge.
  2. Pour la région, sélectionnez us-west1.

  3. Pour le réseau, sélectionnez lb-network (dans Projet : HOST_PROJECT_NAME).

    Si le message d'avertissement Sous-réseau proxy réservé obligatoire dans le réseau VPC partagé s'affiche, confirmez que l'administrateur du projet hôte a créé l'adresse proxy-only-subnet dans la région us-west1 du réseau VPC partagé lb-network. La création de l'équilibreur de charge réussit même si vous ne disposez pas des autorisations nécessaires pour afficher le sous-réseau proxy réservé sur cette page.

  4. Laissez la fenêtre ouverte pour continuer.

Configurer le backend

  1. Cliquez sur Configuration du backend.
  2. Cliquez sur Services de backend multiprojets.
  3. Dans le champ ID du projet, saisissez l'ID du projet de service B.
  4. Dans la liste Sélectionner des services backend, sélectionnez les services backend du projet de service B que vous souhaitez utiliser. Dans cet exemple, vous saisissez cross-ref-backend-service.
  5. Cliquez sur OK.

Configurer les règles de routage

  • Cliquez sur Règles de routage. Assurez-vous que le service cross-ref-backend-service est le seul service de backend pour tous les hôtes et chemins sans correspondance.

Pour en savoir plus sur la gestion du trafic, consultez la page Configurer la gestion du trafic.

Configurer l'interface

Pour que la référence multiprojet fonctionne, l'interface doit utiliser le même réseau (lb-network) que celui utilisé pour créer le service de backend.

Pour HTTP :

  1. Cliquez sur Configuration de l'interface.
  2. Saisissez un nom pour la règle de transfert : cross-ref-http-forwarding-rule.
  3. Définissez le paramètre Protocole sur HTTP.
  4. Définissez le paramètre Sous-réseau sur lb-frontend-and-backend-subnet. Ne sélectionnez pas le sous-réseau proxy réservé pour l'interface, même s'il s'agit d'une option de la liste déroulante.
  5. Définissez le paramètre Port sur 80.
  6. Cliquez sur le menu Adresse IP, puis sur Créer une adresse IP.
  7. Dans le panneau Réserver une adresse IP statique interne, fournissez les informations suivantes :
    1. Dans le champ Nom, saisissez cross-ref-ip-address.
    2. Pour Adresse IP statique, cliquez sur Laissez-moi choisir. Pour Adresse IP personnalisée, saisissez 10.1.2.98.
    3. (Facultatif) Si vous souhaitez partager cette adresse IP avec différentes interfaces, définissez la section Objectif sur Partagée.
  8. Cliquez sur OK.

Pour HTTPS :

Si vous utilisez HTTPS entre le client et l'équilibreur de charge, vous devez disposer d'une ou de plusieurs ressources de certificat SSL pour configurer le proxy. Pour en savoir plus sur la création de ressources de certificat SSL, consultez la page Certificats SSL. À l'heure actuelle, les certificats gérés par Google ne sont pas compatibles avec les équilibreurs de charge d'application internes.

  1. Cliquez sur Configuration de l'interface.
  2. Saisissez un nom pour la règle de transfert : cross-ref-https-forwarding-rule.
  3. Dans le champ Protocole, sélectionnez HTTPS (includes HTTP/2).
  4. Définissez le paramètre Sous-réseau sur lb-frontend-and-backend-subnet. Ne sélectionnez pas le sous-réseau proxy réservé pour l'interface, même s'il s'agit d'une option de la liste déroulante.
  5. Assurez-vous que le port est défini sur la valeur 443 pour autoriser le trafic HTTPS.
  6. Cliquez sur le menu Adresse IP, puis sur Créer une adresse IP.
  7. Dans le panneau Réserver une adresse IP statique interne, fournissez les informations suivantes :
    1. Dans le champ Nom, saisissez cross-ref-ip-address.
    2. Pour Adresse IP statique, cliquez sur Laissez-moi choisir. Pour Adresse IP personnalisée, saisissez 10.1.2.98.
    3. (Facultatif) Si vous souhaitez partager cette adresse IP avec différentes interfaces, définissez la section Objectif sur Partagée.
  8. Cliquez sur la liste Certificat.
    1. Si vous possédez déjà une ressource de certificat SSL autogérée que vous souhaitez utiliser comme certificat SSL principal, sélectionnez-la dans le menu déroulant.
    2. Sinon, sélectionnez Créer un certificat.
      1. Saisissez un nom pour le certificat SSL.
      2. Dans les champs appropriés, importez vos fichiers au format PEM :
        • Certificat de clé publique
        • Chaîne de certificats
        • Clé privée
      3. Cliquez sur Créer.
  9. Pour ajouter des ressources de certificat en plus de la ressource de certificat SSL principale, procédez comme suit :
    1. Cliquez sur Ajouter un certificat.
    2. Sélectionnez un certificat dans la liste Certificats ou cliquez sur Créer un certificat, puis suivez les instructions précédentes.
  10. Cliquez sur OK.

Vérifier et finaliser la configuration

  • Cliquez sur Créer.

Tester l'équilibreur de charge

Une fois l'équilibreur de charge créé, testez-le en suivant les étapes décrites dans la section Tester l'équilibreur de charge.

gcloud

  1. Facultatif: Avant de créer un équilibreur de charge avec des services de backend croisés, vérifiez si les services de backend auxquels vous souhaitez faire référence peuvent être référencés à l'aide d'un mappage d'URL:

    gcloud compute backend-services list-usable \
    --region=us-west1 \
    --project=SERVICE_PROJECT_B_ID

  2. Créez le mappage d'URL et définissez le service par défaut sur le service de backend créé dans le projet de service B.

    gcloud compute url-maps create URL_MAP_NAME \
    --default-service=projects/SERVICE_PROJECT_B_ID/regions/us-west1/backendServices/BACKEND_SERVICE_NAME \
    --region=us-west1 \
    --project=SERVICE_PROJECT_A_ID

    Remplacez les éléments suivants :

    • URL_MAP_NAME : nom du mappage d'URL.
    • BACKEND_SERVICE_NAME : nom du service de backend créé dans le projet de service B.
    • SERVICE_PROJECT_B_ID : ID du projet de service B, dans lequel les backends de l'équilibreur de charge et le service de backend sont créés.
    • SERVICE_PROJECT_A_ID : ID du projet de service A, dans lequel l'interface de l'équilibreur de charge est créée.

    La création du mappage d'URL échoue si vous ne disposez pas de l'autorisation compute.backendServices.use pour le service de backend dans le projet de service B.

  3. Créez le proxy cible.

    Pour HTTP :

    gcloud compute target-http-proxies create HTTP_TARGET_PROXY_NAME \
  --url-map=URL_MAP_NAME \
  --url-map-region=us-west1 \
  --region=us-west1 \
  --project=SERVICE_PROJECT_A_ID

    Remplacez les éléments suivants :

    • HTTP_TARGET_PROXY_NAME : nom du proxy HTTP cible.

    Pour HTTPS :

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

    gcloud compute ssl-certificates create SSL_CERTIFICATE_NAME \
  --certificate=PATH_TO_CERTIFICATE \
  --private-key=PATH_TO_PRIVATE_KEY \
  --region=us-west1 \
  --project=SERVICE_PROJECT_A_ID

    Remplacez les éléments suivants :

    • SSL_CERTIFICATE_NAME : nom de la ressource de certificat SSL.
    • PATH_TO_CERTIFICATE : chemin d'accès au fichier de certificat SSL local au format PEM.
    • PATH_TO_PRIVATE_KEY : chemin d'accès à la clé privée du certificat SSL local au format PEM.

    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 HTTPS_TARGET_PROXY_NAME \
  --url-map=URL_MAP_NAME \
  --region=us-west1 \
  --ssl-certificates=SSL_CERTIFICATE_NAME \
  --project=SERVICE_PROJECT_A_ID

    Remplacez les éléments suivants :

    • HTTPS_TARGET_PROXY_NAME : nom du proxy HTTPS cible.

  4. Créez la règle de transfert. Pour que la référence de service multiprojet fonctionne, la règle de transfert doit utiliser le même réseau (lb-network) que celui du projet hôte de VPC partagé utilisé pour créer le service de backend.

    Pour HTTP :

    gcloud compute forwarding-rules create HTTP_FORWARDING_RULE_NAME \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --network=projects/HOST_PROJECT_ID/global/networks/lb-network \
  --subnet=projects/HOST_PROJECT_ID/regions/us-west1/subnetworks/lb-frontend-and-backend-subnet \
  --address=IP_ADDRESS_CROSS_REF \
  --ports=80 \
  --region=us-west1 \
  --target-http-proxy=HTTP_TARGET_PROXY_NAME \
  --target-http-proxy-region=us-west1 \
  --project=SERVICE_PROJECT_A_ID

    Remplacez les éléments suivants :

    • HTTP_FORWARDING_RULE_NAME : nom de la règle de transfert utilisée pour gérer le trafic HTTP.

    Pour HTTPS :

    gcloud compute forwarding-rules create HTTPS_FORWARDING_RULE_NAME \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --network=projects/HOST_PROJECT_ID/global/networks/lb-network \
  --subnet=projects/HOST_PROJECT_ID/regions/us-west1/subnetworks/lb-frontend-and-backend-subnet \
  --address=IP_ADDRESS_CROSS_REF \
  --ports=443 \
  --region=us-west1 \
  --target-https-proxy=HTTPS_TARGET_PROXY_NAME \
  --target-https-proxy-region=us-west1 \
  --project=SERVICE_PROJECT_A_ID

    Remplacez les éléments suivants :

    • HTTPS_FORWARDING_RULE_NAME : nom de la règle de transfert utilisée pour gérer le trafic HTTPS.

  5. Pour tester l'équilibreur de charge, suivez les étapes décrites dans la section Tester l'équilibreur de charge.

Terraform

  1. Créez le mappage d'URL.

    # URL map
resource "google_compute_region_url_map" "default" {
  name            = "l7-ilb-map"
  provider        = google-beta
  project         = "my-service-project-a-id"
  region          = "us-west1"
  default_service = google_compute_region_backend_service.default.id
}

  2. Créez le proxy cible.

    Pour HTTP

    # HTTP target proxy
resource "google_compute_region_target_http_proxy" "default" {
  name     = "l7-ilb-proxy"
  provider = google-beta
  project  = "my-service-project-a-id"
  region   = "us-west1"
  url_map  = google_compute_region_url_map.default.id
}

    Pour HTTPS

    Créer un certificat SSL régional

    # Use self-signed SSL certificate
resource "google_compute_region_ssl_certificate" "default" {
  name        = "l7-ilb-cert"
  provider    = google-beta
  project     = "my-service-project-a-id"
  region      = "us-west1"
  private_key = file("sample-private.key") # path to PEM-formatted file
  certificate = file("sample-server.cert") # path to PEM-formatted file
}

    Utilisez le certificat SSL régional pour créer un proxy cible.

    # HTTPS target proxy
resource "google_compute_region_target_https_proxy" "default" {
  name             = "l7-ilb-proxy"
  provider         = google-beta
  project          = "my-service-project-a-id"
  region           = "us-west1"
  url_map          = google_compute_region_url_map.default.id
  ssl_certificates = [google_compute_region_ssl_certificate.default.id]
}

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

    Pour HTTP

    # Forwarding rule
resource "google_compute_forwarding_rule" "default" {
  name                  = "l7-ilb-forwarding-rule"
  provider              = google-beta
  project               = "my-service-project-a-id"
  region                = "us-west1"
  ip_protocol           = "TCP"
  port_range            = "80"
  load_balancing_scheme = "INTERNAL_MANAGED"
  target                = google_compute_region_target_http_proxy.default.id
  network               = google_compute_network.lb_network.id
  subnetwork            = google_compute_subnetwork.lb_frontend_and_backend_subnet.id
  network_tier          = "PREMIUM"
  depends_on            = [google_compute_subnetwork.lb_frontend_and_backend_subnet]
}

    Pour HTTPS

    # Forwarding rule
resource "google_compute_forwarding_rule" "default" {
  name                  = "l7-ilb-forwarding-rule"
  provider              = google-beta
  project               = "my-service-project-a-id"
  region                = "us-west1"
  ip_protocol           = "TCP"
  port_range            = "443"
  load_balancing_scheme = "INTERNAL_MANAGED"
  target                = google_compute_region_target_https_proxy.default.id
  network               = google_compute_network.lb_network.id
  subnetwork            = google_compute_subnetwork.lb_frontend_and_backend_subnet.id
  network_tier          = "PREMIUM"
  depends_on            = [google_compute_subnetwork.lb_frontend_and_backend_subnet]
}

  4. Pour tester l'équilibreur de charge, suivez les étapes décrites dans la section Tester l'équilibreur de charge.

Accorder des autorisations à l'administrateur de l'équilibreur de charge pour utiliser le service de backend

Si vous souhaitez que les équilibreurs de charge référencent des services de backend dans d'autres projets de service, l'administrateur de l'équilibreur de charge doit disposer de l'autorisation compute.backendServices.use. Pour accorder cette autorisation, vous pouvez utiliser le rôle IAM prédéfini appelé Utilisateur des services de l'équilibreur de charge Compute (roles/compute.loadBalancerServiceUser). Ce rôle doit être attribué par l'administrateur de projet de service et peut être appliqué au niveau du projet ou au niveau du service de backend.

Cette étape n'est pas nécessaire si vous avez déjà accordé les autorisations requises au niveau du service de backend lors de la création du service de backend. Vous pouvez ignorer cette section ou continuer à lire pour savoir comment accorder l'accès à tous les services de backend de ce projet, afin de ne pas avoir à le faire chaque fois que vous créez un backend.

Dans cet exemple, un administrateur de projet de service du projet B doit exécuter l'une des commandes suivantes pour accorder l'autorisation compute.backendServices.use à un administrateur de l'équilibreur de charge du projet de service A. Cette opération peut être effectuée au niveau du projet (pour tous les services de backend du projet) ou par service de backend.

Console

Autorisations au niveau du projet

Procédez comme suit pour accorder des autorisations à tous les services de backend de votre projet.

Vous avez besoin des autorisations compute.regionBackendServices.setIamPolicy et resourcemanager.projects.setIamPolicy pour effectuer cette étape.

  1. Dans la console Google Cloud, accédez à la page IAM.

    Accéder à IAM

  2. Sélectionnez votre projet.

  3. Cliquez sur Accorder l'accès.

  4. Dans le champ Nouveaux comptes principaux, saisissez l'adresse e-mail du compte principal ou un autre identifiant.

  5. Dans la liste Sélectionner un rôle, sélectionnez Utilisateur des services d'équilibrage de charge Compute.

  6. Facultatif : ajoutez une condition au rôle.

  7. Cliquez sur Enregistrer.

Autorisations au niveau des ressources pour des services de backend individuels

Procédez comme suit pour accorder des autorisations à chaque service de backend de votre projet.

Vous devez disposer de l'autorisation compute.regionBackendServices.setIamPolicy pour effectuer cette étape.

  1. Dans la console Google Cloud, accédez à la page Backends.

    Accéder à la page Backends

  2. Dans la liste des backends, sélectionnez le service de backend auquel vous souhaitez accorder l'accès, puis cliquez sur Autorisations.

  3. Cliquez sur Ajouter un compte principal.

  4. Dans le champ Nouveaux comptes principaux, saisissez l'adresse e-mail du compte principal ou un autre identifiant.

  5. Dans la liste Sélectionner un rôle, sélectionnez Utilisateur des services d'équilibrage de charge Compute.

  6. Cliquez sur Enregistrer.

gcloud

Autorisations au niveau du projet

Procédez comme suit pour accorder des autorisations à tous les services de backend de votre projet.

Vous avez besoin des autorisations compute.regionBackendServices.setIamPolicy et resourcemanager.projects.setIamPolicy pour effectuer cette étape. 

gcloud projects add-iam-policy-binding SERVICE_PROJECT_B_ID \
    --member="user:LOAD_BALANCER_ADMIN" \
    --role="roles/compute.loadBalancerServiceUser"

Autorisations au niveau des ressources pour des services de backend individuels

Au niveau du service de backend, les administrateurs de projet de service peuvent utiliser l'une des commandes suivantes pour attribuer le rôle d'utilisateur des services de l'équilibreur de charge Compute (roles/compute.loadBalancerServiceUser).

Vous devez disposer de l'autorisation compute.regionBackendServices.setIamPolicy pour effectuer cette étape. 

gcloud projects add-iam-policy-binding SERVICE_PROJECT_B_ID \
    --member="user:LOAD_BALANCER_ADMIN" \
    --role="roles/compute.loadBalancerServiceUser" \
    --condition='expression=resource.name=="projects/SERVICE_PROJECT_B_ID/regions/us-west1/backend-services/BACKEND_SERVICE_NAME",title=Shared VPC condition'

ou

gcloud compute backend-services add-iam-policy-binding BACKEND_SERVICE_NAME \
    --member="user:LOAD_BALANCER_ADMIN" \
    --role="roles/compute.loadBalancerServiceUser" \
    --project=SERVICE_PROJECT_B_ID \
    --region=us-west1

Pour utiliser ces commandes, remplacez LOAD_BALANCER_ADMIN par le compte principal de l'utilisateur, par exemple test-user@gmail.com.

Vous pouvez également configurer des autorisations IAM afin qu'elles ne s'appliquent qu'à un sous-ensemble de services de backend régionaux, en utilisant des conditions et en spécifiant des attributs de condition.

Pour afficher les mappages d'URL référençant un service de backend VPC partagé spécifique, procédez comme suit:

gcloud

Pour afficher les ressources référençant un service de backend VPC partagé régional, exécutez la commande suivante:

gcloud compute backend-services describe BACKEND_SERVICE_NAME \
    --region REGION

Remplacez les éléments suivants :

  • BACKEND_SERVICE_NAME: nom du service de backend de l'équilibreur de charge
  • REGION : la région de l'équilibreur de charge

Dans le résultat de la commande, examinez le champ usedBy, qui affiche les ressources référençant le service de backend, comme illustré dans l'exemple suivant:

id: '123456789'
kind: compute#backendService
loadBalancingScheme: INTERNAL_MANAGED
...
usedBy:
-   reference: https://www.googleapis.com/compute/v1/projects/my-project/region/us-central1/urlMaps/my-url-map

Étape suivante