Configurer l'équilibrage de charge TCP/UDP interne

Ce guide s'appuie sur un exemple pour expliquer les principes fondamentaux de l'équilibrage de charge TCP/UDP interne de Google Cloud. Avant de le suivre, familiarisez-vous avec les points suivants :

Autorisations

Pour suivre ce guide, vous devez 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 Compute

Pour en savoir plus, consultez les guides suivants :

Prérequis

Ce guide vous explique comment configurer et tester un équilibreur de charge TCP/UDP interne. Les étapes de cette section décrivent comment configurer les éléments suivants :

  1. Un exemple de réseau VPC avec des sous-réseaux personnalisés
  2. Des règles de pare-feu autorisant les connexions entrantes aux VM de backend
  3. Quatre VM de backend :
    • Deux VM dans un groupe d'instances non géré dans la zone us-west1-a
    • Deux VM dans un groupe d'instances non géré dans la zone us-west1-c
  4. VM cliente pour tester les connexions
  5. Les composants de l'équilibreur de charge TCP/UDP interne suivants :
    • Vérification d'état du service de backend
    • Un service de backend interne dans la région us-west1 pour gérer la distribution des connexions vers les deux groupes d'instances zonaux
    • Règle de transfert interne et adresse IP interne pour l'interface de l'équilibreur de charge

L'architecture de cet exemple se présente comme suit :

Exemple de configuration de l'équilibrage de charge TCP/UDP interne (cliquez pour agrandir)
Exemple de configuration de l'équilibrage de charge TCP/UDP interne (cliquez pour agrandir)

Configurer un réseau, une région et un sous-réseau

L'exemple d'équilibreur de charge TCP/UDP interne décrit sur cette page est créé dans un réseau VPC en mode personnalisé nommé lb-network.

Les VM de backend et les composants de l'équilibreur de charge de cet exemple sont situés dans cette région et ce sous-réseau :

  • Région : us-west1
  • Sous-réseau : lb-subnet, avec plage d'adresses IP principale 10.1.2.0/24

Pour démontrer l'accès mondial, cet exemple crée une deuxième VM cliente de test dans une région et un sous-réseau différents :

  • Région : europe-west1
  • Sous-réseau : europe-subnet, avec plage d'adresses IP principale 10.3.4.0/24

Pour créer les exemples de réseau et de sous-réseaux, procédez comme suit :

Console

  1. Accédez à la page "Réseaux VPC" dans Google Cloud Console.
    Accéder à la page "Réseaux VPC"
  2. Cliquez sur Créer un réseau VPC.
  3. Saisissez le nom lb-network.
  4. Dans la section Sous-réseaux :
    • Définissez Mode de création du sous-réseau sur Personnalisé.
    • Dans la section Nouveau sous-réseau, saisissez les informations suivantes :
      • Nom : lb-subnet
      • Région : us-west1
      • Plage d'adresses IP : 10.1.2.0/24
      • Cliquez sur OK.
    • Cliquez sur Ajouter un sous-réseau et saisissez les informations suivantes :
      • Nom : europe-subnet
      • Région : europe-west1
      • Plage d'adresses IP : 10.3.4.0/24
      • Cliquez sur OK.
  5. Cliquez sur Créer.

gcloud

  1. Créez le réseau VPC personnalisé :

    gcloud compute networks create lb-network --subnet-mode=custom
    
    1. Au sein du réseau lb-network, créez un sous-réseau pour les backends dans la région us-west1 et un autre sous-réseau pour tester l'accès mondial dans la région europe-west1 :
    gcloud compute networks subnets create lb-subnet \
        --network=lb-network \
        --range=10.1.2.0/24 \
        --region=us-west1
    
    gcloud compute networks subnets create europe-subnet \
        --network=lb-network \
        --range=10.3.4.0/24 \
        --region=europe-west1
    

api

Envoyez une requête POST à la méthode networks.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks

{
  "routingConfig": {
    "routingMode": "REGIONAL"
  },
  "name": "lb-network",
  "autoCreateSubnetworks": false
}

Envoyez deux requêtes POST à la méthode subnetworks.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks

{
  "name": "lb-subnet",
  "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
  "ipCidrRange": "10.1.2.0/24",
  "privateIpGoogleAccess": false
}

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/europe-west1/subnetworks

{
  "name": "europe-subnet",
  "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
   "ipCidrRange": "10.3.4.0/24",
   "privateIpGoogleAccess": false
}

Configurer les règles de pare-feu

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

  • fw-allow-lb-access : règle d'entrée, applicable à toutes les cibles du réseau VPC, autorisant le trafic provenant de sources dans les plages 10.1.2.0/24 et 10.3.4.0/24. Cette règle autorise le trafic entrant de n'importe quel client situé dans l'un des deux sous-réseaux. Elle vous permet ultérieurement de configurer et tester l'accès mondial.

  • 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 source plus restrictive pour cette règle. Par exemple, vous pouvez spécifier uniquement les plages d'adresses IP du système à partir duquel vous prévoyez de lancer des sessions SSH. Cet exemple utilise le tag cible allow-ssh pour identifier les VM auxquelles la règle doit s'appliquer.

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

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.

Console

  1. Accédez à la page Pare-feu de Google Cloud Console.
    Accéder à la page "Pare-feu"
  2. Cliquez sur Créer une règle de pare-feu et saisissez les informations suivantes pour créer la règle permettant d'autoriser le trafic de sous-réseau :
    • Nom : fw-allow-lb-access
    • Réseau : lb-network
    • Priorité : 1000
    • Sens du trafic : entrée
    • Action en cas de correspondance : autoriser
    • Cibles : toutes les instances du réseau
    • Filtre source : IP ranges
    • Plages d'adresses IP sources : 10.1.2.0/24 et 10.3.4.0/24
    • Protocoles et ports : tout autoriser
  3. Cliquez sur Créer.
  4. Cliquez de nouveau sur Créer une règle de pare-feu pour créer la règle autorisant les connexions SSH entrantes :
    • Nom : fw-allow-ssh
    • Réseau : lb-network
    • Priorité : 1000
    • Sens du trafic : entrée
    • Action en cas de correspondance : autoriser
    • Cibles : tags cibles spécifiés
    • Tags cibles : allow-ssh
    • Filtre source : IP ranges
    • Plages d'adresses IP sources : 0.0.0.0/0
    • Protocoles et ports : choisissez Protocoles et ports spécifiés, puis saisissez tcp:22.
  5. Cliquez sur Créer.
  6. Cliquez une troisième fois sur Créer une règle de pare-feu pour créer la règle autorisant les vérifications d'état Google Cloud :
    • Nom : fw-allow-health-check
    • Réseau : lb-network
    • Priorité : 1000
    • Sens du trafic : entrée
    • Action en cas de correspondance : autoriser
    • Cibles : tags cibles spécifiés
    • Tags cibles : allow-health-check
    • Filtre source : IP ranges
    • Plages d'adresses IP sources : 130.211.0.0/22 et 35.191.0.0/16
    • Protocoles et ports : tout autoriser
  7. Cliquez sur Créer.

gcloud

  1. Créez la règle de pare-feu fw-allow-lb-access pour autoriser la communication depuis le sous-réseau :

    gcloud compute firewall-rules create fw-allow-lb-access \
        --network=lb-network \
        --action=allow \
        --direction=ingress \
        --source-ranges=10.1.2.0/24,10.3.4.0/24 \
        --rules=tcp,udp,icmp
    
  2. Créez la règle de pare-feu fw-allow-ssh pour autoriser la connectivité SSH aux VM avec le tag réseau allow-ssh. Lorsque vous omettez source-ranges, Google Cloud interprète la règle comme désignant n'importe quelle source.

    gcloud compute firewall-rules create fw-allow-ssh \
        --network=lb-network \
        --action=allow \
        --direction=ingress \
        --target-tags=allow-ssh \
        --rules=tcp:22
    
  3. Créez la règle fw-allow-health-check pour autoriser les vérifications d'état Google Cloud.

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

api

Créez la règle de pare-feu fw-allow-lb-access en envoyant une requête POST à la méthode firewalls.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls

{
  "name": "fw-allow-lb-access",
  "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
  "priority": 1000,
  "sourceRanges": [
    "10.1.2.0/24", "10.3.4.0/24"
  ],
  "allowed": [
    {
      "IPProtocol": "tcp"
    },
    {
      "IPProtocol": "udp"
    },
    {
      "IPProtocol": "icmp"
    }
  ],
  "direction": "INGRESS",
  "logConfig": {
    "enable": false
  },
  "disabled": false
}

Créez la règle de pare-feu fw-allow-ssh en envoyant une requête POST à la méthode firewalls.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls

{
  "name": "fw-allow-ssh",
       "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
  "priority": 1000,
  "sourceRanges": [
    "0.0.0.0/0"
  ],
  "targetTags": [
    "allow-ssh"
  ],
  "allowed": [
   {
     "IPProtocol": "tcp",
     "ports": [
       "22"
     ]
   }
  ],
 "direction": "INGRESS",
 "logConfig": {
   "enable": false
 },
 "disabled": false
}

Créez la règle de pare-feu fw-allow-health-check en envoyant une requête POST à la méthode firewalls.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls

{
  "name": "fw-allow-health-check",
  "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
  "priority": 1000,
  "sourceRanges": [
    "130.211.0.0/22",
    "35.191.0.0/16"
  ],
  "targetTags": [
    "allow-health-check"
  ],
  "allowed": [
    {
      "IPProtocol": "tcp"
    },
    {
      "IPProtocol": "udp"
    },
    {
      "IPProtocol": "icmp"
    }
  ],
  "direction": "INGRESS",
  "logConfig": {
    "enable": false
  },
  "disabled": false
}

Créer des VM de backend et des groupes d'instances

Cet exemple utilise deux groupes d'instances non gérés ayant chacun deux VM de backend (serveur). Pour démontrer la nature régionale de l'équilibrage de charge TCP/UDP interne, les deux groupes d'instances sont placés dans des zones distinctes, us-west1-a et us-west1-c.

  • Le groupe d'instances ig-a contient les deux VM suivantes :
    • vm-a1
    • vm-a2
  • Le groupe d'instances ig-c contient les deux VM suivantes :
    • vm-c1
    • vm-c2

Le trafic vers les quatre VM de backend est équilibré.

Pour utiliser cet exemple et les options de configuration supplémentaires, chacune des quatre VM exécute un serveur Web Apache qui écoute sur les ports TCP suivants : 80, 8008, 8080, 8088, 443 et 8443.

Chaque VM reçoit une adresse IP interne dans lb-subnet et une adresse IP externe éphémère (publique). Vous pouvez supprimer les adresses IP externes ultérieurement.

Les adresses IP externes des VM de backend ne sont pas obligatoires. Toutefois, elles sont utiles dans cet exemple, car elles permettent aux VM de backend de télécharger Apache depuis Internet, en plus de faciliter la connexion via SSH.

Par défaut, Apache est configuré pour se lier à n'importe quelle adresse IP. Les équilibreurs de charge TCP/UDP internes distribuent les paquets en conservant l'adresse IP de destination. Vérifiez que le logiciel serveur exécuté sur les VM de backend écoute l'adresse IP de la règle de transfert interne de l'équilibreur de charge. Si vous configurez plusieurs règles de transfert internes, assurez-vous que votre logiciel écoute l'adresse IP interne associée à chacune d'elles. L'adresse IP de destination d'un paquet distribué à une VM de backend par un équilibreur de charge TCP/UDP interne est l'adresse IP interne de la règle de transfert.

Pour plus de simplicité, ces VM de backend exécutent Debian GNU/Linux 10.

Console

Créer des VM de backend

  1. Accédez à la page "Instances de VM" de Google Cloud Console.
    Accéder à la page "Instances de VM"
  2. Répétez les étapes ci-dessous pour créer quatre VM, en utilisant les combinaisons de noms et de zones suivantes :
    • Nom : vm-a1, zone : us-west1-a
    • Nom : vm-a2, zone : us-west1-a
    • Nom : vm-c1, zone : us-west1-c
    • Nom : vm-c2, zone : us-west1-c
  3. Cliquez sur Créer une instance.
  4. Définissez le Nom comme indiqué à l'étape 2.
  5. Dans le champ Région, choisissez us-west1, puis sélectionnez une zone comme indiqué à l'étape 2.
  6. Dans la section Disque de démarrage, assurez-vous que les options sélectionnées sont Debian pour le système d'exploitation et 10 (Buster) pour la version. Si nécessaire, cliquez sur Sélectionner pour modifier l'image.
  7. Cliquez sur Gestion, sécurité, disques, mise en réseau et location unique et apportez les modifications suivantes :

    • Cliquez sur Mise en réseau et ajoutez les tags réseau suivants : allow-ssh et allow-health-check.
    • Cliquez sur le bouton Modifier () sous Interfaces réseau, apportez les modifications suivantes, puis cliquez sur OK :
      • Réseau : lb-network
      • Sous-réseau : lb-subnet
      • Adresse IP interne principale : éphémère (automatique)
      • Adresse IP externe : Éphémère
    • Cliquez sur Gestion. Dans le champ Script de démarrage, copiez et collez le contenu de script suivant. Le contenu du script est identique pour les quatre VM :

      #! /bin/bash
      if [ -f /etc/startup_script_completed ]; then
      exit 0
      fi
      apt-get update
      apt-get install apache2 -y
      a2ensite default-ssl
      a2enmod ssl
      file_ports="/etc/apache2/ports.conf"
      file_http_site="/etc/apache2/sites-available/000-default.conf"
      file_https_site="/etc/apache2/sites-available/default-ssl.conf"
      http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
      http_vh_prts="*:80 *:8008 *:8080 *:8088"
      https_listen_prts="Listen 443\nListen 8443"
      https_vh_prts="*:443 *:8443"
      vm_hostname="$(curl -H "Metadata-Flavor:Google" \
      http://169.254.169.254/computeMetadata/v1/instance/name)"
      echo "Page served from: $vm_hostname" | \
      tee /var/www/html/index.html
      echo "Page served from: $vm_hostname" | \
      tee /var/www/html/index.html
      prt_conf="$(cat "$file_ports")"
      prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
      prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
      echo "$prt_conf" | tee "$file_ports"
      http_site_conf="$(cat "$file_http_site")"
      http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
      echo "$http_site_conf_2" | tee "$file_http_site"
      https_site_conf="$(cat "$file_https_site")"
      https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
      echo "$https_site_conf_2" | tee "$file_https_site"
      systemctl restart apache2
      touch /etc/startup_script_completed
      
  8. Cliquez sur Créer.

Créer des groupes d'instances

  1. Accédez à la page "Groupes d'instances" de Google Cloud Console.
    Accéder à la page "Groupes d'instances"
  2. Répétez les étapes ci-dessous pour créer deux groupes d'instances non gérés, comportant chacun deux VM, à l'aide des combinaisons suivantes :
    • Groupe d'instances : ig-a, zone : us-west1-a, VM : vm-a1 et vm-a2
    • Groupe d'instances : ig-c, zone : us-west1-c, VM : vm-c1 et vm-c2
  3. Cliquez sur Créer un groupe d'instances.
  4. Cliquez sur Nouveau groupe d'instances non géré.
  5. Définissez le Nom comme indiqué à l'étape 2.
  6. Dans la section Emplacement, sélectionnez us-west1 pour la région, puis choisissez une zone comme indiqué à l'étape 2.
  7. Pour Réseau, saisissez la valeur suivante : lb-network.
  8. Pour Sous-réseau, saisissez la valeur suivante : lb-subnet.
  9. Dans la section Instances de VM, ajoutez les VM comme indiqué à l'étape 2.
  10. Cliquez sur Créer.

gcloud

  1. Créez quatre VM en exécutant la commande suivante quatre fois, en utilisant ces quatre combinaisons pour [VM-NAME] et [ZONE]. Le contenu du script est identique pour les quatre VM.

    • [VM-NAME] : vm-a1 et [ZONE] : us-west1-a
    • [VM-NAME] : vm-a2 et [ZONE] : us-west1-a
    • [VM-NAME] : vm-c1 et [ZONE] : us-west1-c
    • [VM-NAME] : vm-c2 et [ZONE] : us-west1-c
    gcloud compute instances create [VM-NAME] \
        --zone=[ZONE] \
        --image-family=debian-10 \
        --image-project=debian-cloud \
        --tags=allow-ssh,allow-health-check \
        --subnet=lb-subnet \
        --metadata=startup-script='#! /bin/bash
    if [ -f /etc/startup_script_completed ]; then
    exit 0
    fi
    apt-get update
    apt-get install apache2 -y
    a2ensite default-ssl
    a2enmod ssl
    file_ports="/etc/apache2/ports.conf"
    file_http_site="/etc/apache2/sites-available/000-default.conf"
    file_https_site="/etc/apache2/sites-available/default-ssl.conf"
    http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
    http_vh_prts="*:80 *:8008 *:8080 *:8088"
    https_listen_prts="Listen 443\nListen 8443"
    https_vh_prts="*:443 *:8443"
    vm_hostname="$(curl -H "Metadata-Flavor:Google" \
    http://169.254.169.254/computeMetadata/v1/instance/name)"
    echo "Page served from: $vm_hostname" | \
    tee /var/www/html/index.html
    prt_conf="$(cat "$file_ports")"
    prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
    prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
    echo "$prt_conf" | tee "$file_ports"
    http_site_conf="$(cat "$file_http_site")"
    http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
    echo "$http_site_conf_2" | tee "$file_http_site"
    https_site_conf="$(cat "$file_https_site")"
    https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
    echo "$https_site_conf_2" | tee "$file_https_site"
    systemctl restart apache2
    touch /etc/startup_script_completed'
    
  2. Créez les deux groupes d'instances non gérés dans chaque zone :

    gcloud compute instance-groups unmanaged create ig-a \
        --zone=us-west1-a
    gcloud compute instance-groups unmanaged create ig-c \
        --zone=us-west1-c
    
  3. Ajoutez les VM aux groupes d'instances appropriés :

    gcloud compute instance-groups unmanaged add-instances ig-a \
        --zone=us-west1-a \
        --instances=vm-a1,vm-a2
    gcloud compute instance-groups unmanaged add-instances ig-c \
        --zone=us-west1-c \
        --instances=vm-c1,vm-c2
    

api

Pour les quatre VM, utilisez les noms et zones de VM suivants :

  • [VM-NAME] : vm-a1 et [ZONE] : us-west1-a
  • [VM-NAME] : vm-a2 et [ZONE] : us-west1-a
  • [VM-NAME] : vm-c1 et [ZONE] : us-west1-c
  • [VM-NAME] : vm-c2 et [ZONE] : us-west1-c

Vous pouvez obtenir le DEBIAN_IMAGE_NAME actuel en exécutant la commande gcloud suivante :

gcloud compute images list \
 --filter="family=debian-10"

Créez quatre VM de backend en envoyant quatre requêtes POST à la méthode instances.insert :

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/[ZONE]/instances

{
  "name": "[VM-NAME]",
  "tags": {
    "items": [
      "allow-health-check",
      "allow-ssh"
    ]
  },
  "machineType": "https://www.googleapis.com/compute/v1/projects/project-id/zones/[ZONE]/machineTypes/e2-standard-2",
  "canIpForward": false,
  "networkInterfaces": [
    {
      "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
      "subnetwork": "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/subnetworks/lb-subnet",
      "accessConfigs": [
        {
          "type": "ONE_TO_ONE_NAT",
          "name": "external-nat",
          "networkTier": "PREMIUM"
        }
      ]
    }
  ],
  "disks": [
    {
      "type": "PERSISTENT",
      "boot": true,
      "mode": "READ_WRITE",
      "autoDelete": true,
      "deviceName": "[VM-NAME]",
      "initializeParams": {
        "sourceImage": "projects/debian-cloud/global/images/debian-image-name",
        "diskType": "projects/project-id/zones/zone/diskTypes/pd-standard",
        "diskSizeGb": "10"
      }
    }
  ],
  "metadata": {
    "items": [
      {
        "key": "startup-script",
        "value": "#! /bin/bash\napt-get update\napt-get install apache2 -y\na2ensite default-ssl\na2enmod ssl\nfile_ports=\"/etc/apache2/ports.conf\"\nfile_http_site=\"/etc/apache2/sites-available/000-default.conf\"\nfile_https_site=\"/etc/apache2/sites-available/default-ssl.conf\"\nhttp_listen_prts=\"Listen 80\\nListen 8008\\nListen 8080\\nListen 8088\"\nhttp_vh_prts=\"*:80 *:8008 *:8080 *:8088\"\nhttps_listen_prts=\"Listen 443\\nListen 8443\"\nhttps_vh_prts=\"*:443 *:8443\"\nvm_hostname=\"$(curl -H \"Metadata-Flavor:Google\" \\\nhttp://169.254.169.254/computeMetadata/v1/instance/name)\"\necho \"Page served from: $vm_hostname\" | \\\ntee /var/www/html/index.html\nprt_conf=\"$(cat \"$file_ports\")\"\nprt_conf_2=\"$(echo \"$prt_conf\" | sed \"s|Listen 80|${http_listen_prts}|\")\"\nprt_conf=\"$(echo \"$prt_conf_2\" | sed \"s|Listen 443|${https_listen_prts}|\")\"\necho \"$prt_conf\" | tee \"$file_ports\"\nhttp_site_conf=\"$(cat \"$file_http_site\")\"\nhttp_site_conf_2=\"$(echo \"$http_site_conf\" | sed \"s|*:80|${http_vh_prts}|\")\"\necho \"$http_site_conf_2\" | tee \"$file_http_site\"\nhttps_site_conf=\"$(cat \"$file_https_site\")\"\nhttps_site_conf_2=\"$(echo \"$https_site_conf\" | sed \"s|_default_:443|${https_vh_prts}|\")\"\necho \"$https_site_conf_2\" | tee \"$file_https_site\"\nsystemctl restart apache2"
      }
    ]
  },
  "scheduling": {
    "preemptible": false
  },
  "deletionProtection": false
}

Créez deux groupes d'instances en envoyant une requête POST à la méthode instanceGroups.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups

{
  "name": "ig-a",
  "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
  "subnetwork": "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/subnetworks/lb-subnet"
}

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instanceGroups

{
  "name": "ig-c",
  "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
  "subnetwork": "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/subnetworks/lb-subnet"
}

Ajoutez des instances à chaque groupe d'instances en envoyant une requête POST à la méthode instanceGroups.addInstances.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups/ig-a/addInstances

{
  "instances": [
    {
      "instance": "https://www.googleapis.com/compute/v1/projects/project-id/zones/us-west1-a/instances/vm-a1",
      "instance": "https://www.googleapis.com/compute/v1/projects/project-id/zones/us-west1-a/instances/vm-a2"
    }
  ]
}

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instanceGroups/ig-c/addInstances

{
  "instances": [
    {
      "instance": "https://www.googleapis.com/compute/v1/projects/project-id/zones/us-west1-c/instances/vm-c1",
      "instance": "https://www.googleapis.com/compute/v1/projects/project-id/zones/us-west1-c/instances/vm-c2"
    }
  ]
}

Créer une VM cliente

Cet exemple crée une VM cliente (vm-client) dans la même région que les VM de backend (serveur). Le client est utilisé pour valider la configuration de l'équilibreur de charge et faire la démonstration du comportement attendu, tel que décrit dans la section consacrée aux tests.

Console

  1. Accédez à la page "Instances de VM" de Google Cloud Console.
    Accéder à la page Instances de VM
  2. Cliquez sur Créer une instance.
  3. Définissez le paramètre Nom sur vm-client.
  4. Définissez le paramètre Zone sur us-west1-a.
  5. Cliquez sur Gestion, sécurité, disques, mise en réseau et location unique et apportez les modifications suivantes :
    • Cliquez sur Mise en réseau et ajoutez allow-ssh aux tags réseau.
    • Cliquez sur le bouton de modification sous Interfaces réseau, apportez les modifications suivantes, puis cliquez sur OK :
      • Réseau : lb-network
      • Sous-réseau : lb-subnet
      • Adresse IP interne principale : éphémère (automatique)
      • Adresse IP externe : Éphémère
  6. Cliquez sur Créer.

gcloud

La VM cliente peut se trouver dans n'importe quelle zone de la même région que l'équilibreur de charge, et utiliser n'importe quel sous-réseau de cette région. Dans cet exemple, le client se situe dans la zone us-west1-a et utilise le même sous-réseau que les VM de backend.

gcloud compute instances create vm-client \
    --zone=us-west1-a \
    --image-family=debian-10 \
    --image-project=debian-cloud \
    --tags=allow-ssh \
    --subnet=lb-subnet

api

Envoyez une requête POST à la méthode instances.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances

{
  "name": "vm-client",
  "tags": {
    "items": [
      "allow-ssh"
    ]
  },
  "machineType": "https://www.googleapis.com/compute/v1/projects/project-id/zones/us-west1-a/machineTypes/e2-standard-2",
  "canIpForward": false,
  "networkInterfaces": [
    {
      "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
      "subnetwork": "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/subnetworks/lb-subnet",
      "accessConfigs": [
        {
          "type": "ONE_TO_ONE_NAT",
          "name": "external-nat",
          "networkTier": "PREMIUM"
        }
      ]
    }
  ],
  "disks": [
    {
      "type": "PERSISTENT",
      "boot": true,
      "mode": "READ_WRITE",
      "autoDelete": true,
      "deviceName": "vm-client",
      "initializeParams": {
        "sourceImage": "projects/debian-cloud/global/images/debian-image-name",
        "diskType": "projects/project-id/zones/us-west1-a/diskTypes/pd-standard",
        "diskSizeGb": "10"
      }
    }
  ],
  "scheduling": {
    "preemptible": false
  },
  "deletionProtection": false
}

Configurer les composants de l'équilibreur de charge

Ces étapes permettent de configurer tous les composants de l'équilibreur de charge TCP/UDP interne, en commençant par la vérification d'état et le service de backend, puis en passant aux composants d'interface :

  • Vérification d'état : dans cet exemple, la vérification d'état HTTP recherche une réponse HTTP 200 (OK). Pour plus d'informations, consultez la section sur les vérifications d'état de la présentation de l'équilibrage de charge TCP/UDP interne.

  • Service de backend : Étant donné que nous devons transmettre le trafic HTTP via l'équilibreur de charge interne, nous devons utiliser TCP, et non UDP.

  • Règle de transfert : Cet exemple crée une seule règle de transfert interne.

  • Adresse IP interne : dans cet exemple, nous indiquons une adresse IP interne, 10.1.2.99, lors de la création de la règle de transfert.

Console

Créer l'équilibreur de charge et configurer un service de backend

  1. Accédez à la page Équilibrage de charge dans Google Cloud Console.
    Accéder à la page "Équilibrage de charge"
  2. Cliquez sur Créer un équilibreur de charge.
  3. Sous Équilibrage de charge TCP, cliquez sur Démarrer la configuration.
  4. Sous Web ou interne uniquement, sélectionnez Seulement entre les VM.
  5. Cliquez sur Continuer.
  6. Définissez le paramètre Nom sur be-ilb.
  7. Cliquez sur Configuration du backend et apportez les modifications suivantes :
    1. Région : us-west1
    2. Réseau : lb-network
    3. Sous Backends, dans la section Nouvel élément, sélectionnez le groupe d'instances ig-a et cliquez sur OK.
    4. Cliquez sur Ajouter le backend. Dans la section Nouvel élément qui s'affiche, sélectionnez le groupe d'instances ig-c, puis cliquez à nouveau sur OK.
    5. Sous Vérification d'état, sélectionnez Créer une autre vérification d'état, saisissez les informations suivantes, puis cliquez sur Enregistrer et continuer :
      • Nom : hc-http-80
      • Protocole : HTTP
      • Port : 80
      • Protocole de proxy : NONE
      • Chemin de requête : / Notez que lorsque vous créez un équilibreur de charge à l'aide de Cloud Console, la vérification de l'état est globale. Si vous souhaitez créer une vérification de l'état régionale, utilisez gcloud ou l'API.
    6. Vérifiez qu'une coche bleue apparaît à côté de Configuration du backend avant de continuer. Répétez cette étape si ce n'est pas le cas.
  8. Cliquez sur Configuration du frontend. Dans la section Nouveaux IP et port frontend, apportez les modifications suivantes :
    1. Nom : fr-ilb
    2. Sous-réseau : lb-subnet
    3. Dans Adresse IP interne, sélectionnez Réserver une adresse IP statique interne, saisissez les informations suivantes, puis cliquez sur Réserver :
      • Nom : ip-ilb
      • Adresse IP statique : Laissez-moi choisir
      • Adresse IP personnalisée : 10.1.2.99
    4. Ports : sélectionnez Plusieurs et saisissez 80,8008,8080,8088 pour le numéro de port.
    5. Vérifiez qu'une coche bleue apparaît à côté de Configuration du frontend avant de continuer. Reprenez la procédure depuis le début si ce n'est pas le cas.
  9. Cliquez sur Vérification et finalisation. Vérifiez vos paramètres.
  10. Cliquez sur Créer.

gcloud

  1. Créez une vérification d'état HTTP régionale pour tester la connectivité HTTP aux VM sur le port 80.

    gcloud compute health-checks create http hc-http-80 \
        --region=us-west1 \
        --port=80
    
  2. Créez le service de backend pour le trafic HTTP :

    gcloud compute backend-services create be-ilb \
        --load-balancing-scheme=internal \
        --protocol=tcp \
        --region=us-west1 \
        --health-checks=hc-http-80 \
        --health-checks-region=us-west1
    
  3. Ajoutez les deux groupes d'instances au service de backend :

    gcloud compute backend-services add-backend be-ilb \
        --region=us-west1 \
        --instance-group=ig-a \
        --instance-group-zone=us-west1-a
    gcloud compute backend-services add-backend be-ilb \
        --region=us-west1 \
        --instance-group=ig-c \
        --instance-group-zone=us-west1-c
    
  4. Créez une règle de transfert pour le service de backend. Lorsque vous créez la règle de transfert, indiquez 10.1.2.99 pour l'adresse IP interne dans le sous-réseau.

    gcloud compute forwarding-rules create fr-ilb \
        --region=us-west1 \
        --load-balancing-scheme=internal \
        --network=lb-network \
        --subnet=lb-subnet \
        --address=10.1.2.99 \
        --ip-protocol=TCP \
        --ports=80,8008,8080,8088 \
        --backend-service=be-ilb \
        --backend-service-region=us-west1
    

api

Créez la vérification d'état en envoyant une requête POST à la méthode regionHealthChecks.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/regionHealthChecks

{
  "name": "hc-http-80",
  "type": "HTTP",
  "httpHealthCheck": {
    "port": 80
  }
}

Créez le service de backend régional en envoyant une requête POST à la méthode regionBackendServices.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices

{
  "name": "be-ilb",
  "backends": [
    {
      "group": "https://www.googleapis.com/compute/v1/projects/project-id/zones/us-west1-a/instanceGroups/ig-a",
      "balancingMode": "CONNECTION"
    },
    {
      "group": "https://www.googleapis.com/compute/v1/projects/project-id/zones/us-west1-c/instanceGroups/ig-c",
      "balancingMode": "CONNECTION"
    }
  ],
  "healthChecks": [
    "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/healthChecks/hc-http-80"
  ],
  "loadBalancingScheme": "INTERNAL",
  "connectionDraining": {
    "drainingTimeoutSec": 0
   }
}

Créez la règle de transfert en envoyant une requête POST à la méthode forwardingRules.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules

{
  "name": "fr-ilb",
  "IPAddress": "10.1.2.99",
  "IPProtocol": "TCP",
  "ports": [
    "80", "8008", "8080", "8088"
  ],
  "loadBalancingScheme": "INTERNAL",
  "subnetwork": "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/subnetworks/lb-subnet",
  "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
  "backendService": "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/backendServices/be-ilb",
  "networkTier": "PREMIUM"
}

Test

Ces tests vous montrent comment valider la configuration de votre équilibreur de charge et en savoir plus sur son comportement attendu.

Test de l'équilibrage de charge

Ce test contacte l'équilibreur de charge à partir d'une VM cliente distincte (autre qu'une VM de backend de l'équilibreur de charge). Le comportement attendu est une répartition du trafic entre les quatre VM de backend, car aucune affinité de session n'a été configurée.

  1. Connectez-vous à l'instance de VM cliente.

    gcloud compute ssh vm-client --zone=us-west1-a
    
  2. Envoyez une requête Web à l'équilibreur de charge à l'aide de curl pour contacter son adresse IP. Répétez la requête pour que les réponses proviennent de différentes VM de backend. Le nom de la VM qui génère la réponse est affiché dans le texte de la réponse HTML, selon le contenu de /var/www/html/index.html sur chaque VM de backend. Les réponses attendues ressemblent à ceci : Page served from: vm-a1, Page served from: vm-a2, etc.

    curl http://10.1.2.99
    

    La règle de transfert est configurée pour desservir les ports 80, 8008, 8080 et 8088. Pour envoyer du trafic vers ces autres ports, ajoutez deux points (:) et le numéro de port après l'adresse IP, comme ceci :

    curl http://10.1.2.99:8008
    
    • Si vous ajoutez un libellé de service à la règle de transfert interne, vous pouvez utiliser le DNS interne pour contacter l'équilibreur de charge à l'aide de son nom de service.

      curl http://web-test.fr-ilb.il4.us-west1.lb.project-id.internal
      

Ping de l'adresse IP de l'équilibreur de charge

Ce test illustre un comportement attendu : vous ne pouvez pas pinguer l'adresse IP de l'équilibreur de charge. En effet, les équilibreurs de charge TCP/UDP internes sont mis en œuvre dans la programmation de réseaux virtuels. Il ne s'agit pas d'appareils distincts.

  1. Connectez-vous à l'instance de VM cliente.

    gcloud compute ssh vm-client --zone=us-west1-a
    
  2. Essayez de pinguer l'adresse IP de l'équilibreur de charge. Notez que vous n'obtenez pas de réponse et que la commande ping expire au bout de 10 secondes dans cet exemple.

    timeout 10 ping 10.1.2.99
    

Envoi de requêtes à partir de VM à équilibrage de charge

Ce test montre que les requêtes adressées à l'équilibreur de charge provenant de l'une des VM de backend (VM du serveur à équilibrage de charge) reçoivent toujours une réponse de la même VM qui envoie la requête.

L'équilibrage de charge TCP/UDP interne est mis en œuvre à l'aide d'une programmation de réseau virtuel et de la configuration de VM dans l'OS invité. Sur les VM Linux, l'environnement invité Linux effectue la configuration locale en installant une route dans la table de routage de l'OS invité. En raison de ce routage local, le trafic vers l'adresse IP de l'équilibreur de charge reste sur la VM à équilibrage de charge elle-même (cette route locale est différente des routes du réseau VPC).

  1. Connectez-vous à une VM de backend, telle que vm-a1 :

    gcloud compute ssh vm-a1 --zone=us-west1-a
    
  2. Envoyez une requête Web à l'équilibreur de charge (par adresse IP ou nom de service) à l'aide de curl. Répétez la requête et notez que la réponse est envoyée par la VM de backend qui effectue la requête. La réponse attendue lors du test à partir de vm-a1 est toujours la suivante : Page served from: vm-a1.

    curl http://10.1.2.99
    
  3. Inspectez la table de routage locale et recherchez une destination correspondant à l'adresse IP de l'équilibreur de charge lui-même : 10.1.2.99. Ce routage fait partie intégrante de l'équilibrage de charge TCP/UDP interne, mais il permet également de comprendre pourquoi une requête provenant d'une VM derrière l'équilibreur de charge reçoit toujours une réponse de la même VM.

    ip route show table local | grep 10.1.2.99
    

Options de configuration supplémentaires

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

Activer l'accès mondial

Vous pouvez activer l'accès mondial pour votre exemple d'équilibreur de charge TCP/UDP interne afin de le rendre accessible aux clients situés dans toutes les régions. Les backends de votre exemple d'équilibreur de charge doivent toujours être situés dans une région (us-west1).

Équilibrage de charge TCP/UDP interne avec accès mondial (cliquez pour agrandir)
Équilibrage de charge TCP/UDP interne avec accès mondial (cliquez pour agrandir)

Pour configurer l'accès mondial, procédez aux modifications de configuration ci-dessous.

Console

Modifier la règle de transfert de l'équilibreur de charge

  1. Accédez à la page Équilibrage de charge dans Google Cloud Console.
    Accéder à la page "Équilibrage de charge"
  2. Dans la colonne Nom, cliquez sur votre équilibreur de charge TCP/UDP interne. L'exemple d'équilibreur de charge est nommé be-ilb.

  3. Cliquez sur Configuration du frontend.

  4. Cliquez sur Modifier ().

  5. Sous Accès mondial, sélectionnez Activer.

  6. Cliquez sur OK.

  7. Cliquez sur Mettre à jour.

Sur la page Détails de l'équilibreur de charge, vérifiez que la configuration du frontend indique Régional (REGION) avec accès mondial.

gcloud

  1. Mettez à jour l'exemple de règle de transfert de l'équilibreur de charge, fr-ilb, pour inclure l'option --allow-global-access.

    gcloud compute forwarding-rules update fr-ilb \
       --region=us-west1 \
       --allow-global-access
    
  2. Assurez-vous que la règle de transfert autorise un accès mondial.

    gcloud compute forwarding-rules describe fr-ilb \
       --region=us-west1 \
       --format="get(name,region,allowGlobalAccess)"
    

    Le mot True apparaît dans la sortie, après le nom et la région de la règle de transfert, lorsque l'accès mondial est activé.

api

Envoyez une requête PATCH à la méthode forwardingRules/patch.

PATCH https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules/fr-ilb

{
  "allowGlobalAccess": true
}

Créer une VM cliente pour tester l'accès mondial

Console

  1. Accédez à la page "Instances de VM" de Google Cloud Console.
    Accéder à la page Instances de VM
  2. Cliquez sur Créer une instance.
  3. Définissez le paramètre Nom sur vm-client2.
  4. Définissez le paramètre Zone sur europe-west1-b.
  5. Cliquez sur Gestion, sécurité, disques, mise en réseau et location unique et apportez les modifications suivantes :
    • Cliquez sur Mise en réseau et ajoutez allow-ssh aux tags réseau.
    • Cliquez sur le bouton de modification sous Interfaces réseau, apportez les modifications suivantes, puis cliquez sur OK :
      • Réseau : lb-network
      • Sous-réseau : europe-subnet
      • Adresse IP interne principale : éphémère (automatique)
      • Adresse IP externe : Éphémère
  6. Cliquez sur Créer.

gcloud

La VM cliente peut se trouver dans n'importe quelle zone de la même région que l'équilibreur de charge, et utiliser n'importe quel sous-réseau de cette région. Dans cet exemple, le client se situe dans la zone europe-west1-b et utilise le même sous-réseau que les VM de backend.

gcloud compute instances create vm-client2 \
    --zone=europe-west1-b \
    --image-family=debian-10 \
    --image-project=debian-cloud \
    --tags=allow-ssh \
    --subnet=europe-subnet

api

Envoyez une requête POST à la méthode instances.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/europe-west1-b/instances

{
  "name": "vm-client2",
  "tags": {
    "items": [
      "allow-ssh"
    ]
  },
  "machineType": "https://www.googleapis.com/compute/v1/projects/project-id/zones/europe-west1-b/machineTypes/e2-standard-2",
  "canIpForward": false,
  "networkInterfaces": [
    {
      "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
      "subnetwork": "https://www.googleapis.com/compute/v1/projects/project-id/regions/europe-west1/subnetworks/europe-subnet",
      "accessConfigs": [
        {
          "type": "ONE_TO_ONE_NAT",
          "name": "external-nat",
          "networkTier": "PREMIUM"
        }
      ]
    }
  ],
  "disks": [
    {
      "type": "PERSISTENT",
      "boot": true,
      "mode": "READ_WRITE",
      "autoDelete": true,
      "deviceName": "vm-client2",
      "initializeParams": {
        "sourceImage": "projects/debian-cloud/global/images/debian-image-name",
        "diskType": "projects/project-id/zones/europe-west1-b/diskTypes/pd-standard",
        "diskSizeGb": "10"
      }
    }
  ],
  "scheduling": {
    "preemptible": false
  },
  "deletionProtection": false
}

Se connecter à la VM cliente et tester la connectivité

gcloud compute ssh vm-client2 --zone=europe-west1-b

Testez la connexion à l'équilibreur de charge sur tous les ports configurés, comme vous l'avez fait depuis le client vm-client dans la région us-west1. Testez la connectivité HTTP sur les quatre ports configurés sur la règle de transfert :

curl http://10.1.2.99
curl http://10.1.2.99:8008
curl http://10.1.2.99:8080
curl http://10.1.2.99:8088

Configurer des groupes d'instances gérés

L'exemple de configuration a créé deux groupes d'instances non gérés. Vous pouvez également utiliser des groupes d'instances gérés, y compris des groupes d'instances gérés zonaux et régionaux, comme backends pour l'équilibrage de charge TCP/UDP interne.

Les groupes d'instances gérés nécessitent la création d'un modèle d'instance. Cette procédure montre comment remplacer les deux groupes d'instances zonaux non gérés de l'exemple par un seul groupe d'instances géré régional. Un groupe d'instances géré régional crée automatiquement des VM dans plusieurs zones de la région, ce qui simplifie la distribution du trafic de production entre les zones.

Les groupes d'instances gérés sont également compatibles avec l'autoscaling et l'autoréparation. Si vous utilisez l'autoscaling avec l'équilibrage de charge TCP/UDP interne, vous ne pouvez pas effectuer de scaling en fonction de l'équilibrage de charge.

Cette procédure vous montre comment modifier le service de backend pour l'exemple d'équilibreur de charge TCP/UDP interne afin qu'il utilise un groupe d'instances géré régional.

Console

Modèle d'instance

  1. Accédez à la page "Modèles d'instances de VM" dans Google Cloud Console.
    Accéder à la page "Modèles d'instances de VM"
  2. Cliquez sur Créer un modèle d'instance.
  3. Définissez le paramètre Nom sur template-vm-ilb.
  4. Choisissez un type de machine.
  5. Pour Disque de démarrage, cliquez sur Modifier, choisissez Debian pour le système d'exploitation et 10 (Buster) pour la version.
  6. Cliquez sur Enregistrer pour confirmer les options de ce disque de démarrage.
  7. Cliquez sur Gestion, sécurité, disques, réseau et location unique.

    • Cliquez sur Mise en réseau, puis apportez les modifications suivantes :
      • Réseau : lb-network
      • Sous-réseau : lb-subnet
      • Tags réseau : allow-ssh et allow-health-check
    • Cliquez sur Gestion. Dans le champ Script de démarrage, copiez et collez le contenu de script suivant :
    #! /bin/bash
    if [ -f /etc/startup_script_completed ]; then
    exit 0
    fi
    apt-get update
    apt-get install apache2 -y
    a2ensite default-ssl
    a2enmod ssl
    file_ports="/etc/apache2/ports.conf"
    file_http_site="/etc/apache2/sites-available/000-default.conf"
    file_https_site="/etc/apache2/sites-available/default-ssl.conf"
    http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
    http_vh_prts="*:80 *:8008 *:8080 *:8088"
    https_listen_prts="Listen 443\nListen 8443"
    https_vh_prts="*:443 *:8443"
    vm_hostname="$(curl -H "Metadata-Flavor:Google" \
    http://169.254.169.254/computeMetadata/v1/instance/name)"
    echo "Page served from: $vm_hostname" | \
    tee /var/www/html/index.html
    echo "Page served from: $vm_hostname" | \
    tee /var/www/html/index.html
    prt_conf="$(cat "$file_ports")"
    prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
    prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
    echo "$prt_conf" | tee "$file_ports"
    http_site_conf="$(cat "$file_http_site")"
    http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
    echo "$http_site_conf_2" | tee "$file_http_site"
    https_site_conf="$(cat "$file_https_site")"
    https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
    echo "$https_site_conf_2" | tee "$file_https_site"
    systemctl restart apache2
    touch /etc/startup_script_completed
    
  8. Cliquez sur Créer.

Groupe d'instances géré

  1. Accédez à la page "Groupes d'instances de VM" dans Google Cloud Console.
    Accéder à la page "Groupes d'instances de VM"
  2. Cliquez sur Créer un groupe d'instances.
  3. Définissez le paramètre Nom sur ig-ilb.
  4. Pour Emplacement, sélectionnez Multizone et définissez la région sur us-west1.
  5. Définissez le Modèle d'instance sur template-vm-ilb.
  6. (Facultatif) Configurez l'autoscaling. Vous ne pouvez pas effectuer d'autoscaling sur le groupe d'instances en fonction de l'utilisation de l'équilibrage de charge HTTP, car le groupe d'instances est un backend pour l'équilibrage de charge TCP/UDP interne.
  7. Définissez le nombre minimal d'instances sur 1 et le nombre maximal d'instances sur 6.
  8. (Facultatif) Configurez l'autoréparation. Si vous configurez l'autoréparation, utilisez la même vérification d'état que celle utilisée par le service de backend pour l'équilibreur de charge TCP/UDP interne. Dans cet exemple, utilisez hc-http-80.
  9. Cliquez sur Créer.

gcloud

  1. Créez le modèle d'instance. Si vous le souhaitez, vous pouvez définir d'autres paramètres, tels que le type de machine, que le modèle d'image doit utiliser.

    gcloud compute instance-templates create template-vm-ilb \
        --image-family=debian-10 \
        --image-project=debian-cloud \
        --tags=allow-ssh,allow-health-check \
        --subnet=lb-subnet \
        --region=us-west1 \
        --network=lb-network \
           --metadata=startup-script='#! /bin/bash
             if [ -f /etc/startup_script_completed ]; then
             exit 0
             fi
             apt-get update
             apt-get install apache2 -y
             a2ensite default-ssl
             a2enmod ssl
             file_ports="/etc/apache2/ports.conf"
             file_http_site="/etc/apache2/sites-available/000-default.conf"
             file_https_site="/etc/apache2/sites-available/default-ssl.conf"
             http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
             http_vh_prts="*:80 *:8008 *:8080 *:8088"
             https_listen_prts="Listen 443\nListen 8443"
             https_vh_prts="*:443 *:8443"
             vm_hostname="$(curl -H "Metadata-Flavor:Google" \
             http://169.254.169.254/computeMetadata/v1/instance/name)"
             echo "Page served from: $vm_hostname" | \
             tee /var/www/html/index.html
             prt_conf="$(cat "$file_ports")"
             prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
             prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
             echo "$prt_conf" | tee "$file_ports"
             http_site_conf="$(cat "$file_http_site")"
             http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
             echo "$http_site_conf_2" | tee "$file_http_site"
             https_site_conf="$(cat "$file_https_site")"
             https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
             echo "$https_site_conf_2" | tee "$file_https_site"
             systemctl restart apache2
             touch /etc/startup_script_completed'
    
  2. Créez un groupe d'instances géré régional à l'aide du modèle :

    gcloud compute instance-groups managed create ig-ilb \
        --template=template-vm-ilb \
        --region=us-west1 \
        --size=6
    
  3. Ajoutez le groupe d'instances géré régional en tant que backend au service de backend que vous avez déjà créé :

    gcloud compute backend-services add-backend be-ilb \
        --region=us-west1 \
        --instance-group=ig-ilb \
        --instance-group-region=us-west1
    
  4. Déconnectez les deux groupes d'instances non gérés (zonaux) du service de backend :

    gcloud compute backend-services remove-backend be-ilb \
        --region=us-west1 \
        --instance-group=ig-a \
        --instance-group-zone=us-west1-a
    gcloud compute backend-services remove-backend be-ilb \
        --region=us-west1 \
        --instance-group=ig-c \
        --instance-group-zone=us-west1-c
    

Supprimer les adresses IP externes des VM de backend

Lors de la création des VM de backend, une adresse IP externe éphémère a été attribuée à chaque VM pour que celles-ci puissent télécharger Apache via un script de démarrage. Étant donné que les VM de backend ne sont utilisées que par un équilibreur de charge interne, vous pouvez supprimer leurs adresses IP externes. La suppression des adresses IP externes empêche les VM de backend d'accéder directement à Internet.

Console

  1. Accédez à la page "Instances de VM" de Google Cloud Console.
    Accéder à la page "Instances de VM"
  2. Répétez les étapes ci-dessous pour chaque VM de backend.
  3. Cliquez sur le nom de la VM de backend (par exemple, vm-a1) pour afficher la page Informations sur l'instance de VM.
  4. Cliquez sur Modifier ().
  5. Dans la section Interfaces réseau, cliquez sur le bouton Modifier.
  6. Dans la fenêtre pop-up Adresse IP externe, sélectionnez Aucune, puis cliquez sur Terminé.
  7. Cliquez sur Enregistrer.

gcloud

  1. Pour rechercher une instance dans une zone, par exemple si vous utilisez un groupe d'instances géré régional, exécutez la commande suivante pour chaque instance afin de déterminer sa zone. Remplacez [SERVER-VM] par le nom de la VM à rechercher.

    gcloud compute instances list --filter="name=[SERVER-VM]"
    
  2. Répétez l'étape ci-dessous pour chaque VM de backend. Remplacez [SERVER-VM] par le nom de la VM et [ZONE] par la zone de la VM.

    gcloud compute instances delete-access-config [SERVER-VM] \
        --zone=[ZONE] \
        --access-config-name=external-nat
    

api

Envoyez une requête POST à la méthode instances.deleteAccessConfig pour chaque VM de backend, en remplaçant vm-a1 par le nom de la VM et us-west1-a par la zone de la VM.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances/vm-a1/deleteAccessConfig?accessConfig=external-nat&networkInterface=None

Accepter le trafic sur tous les ports

La règle de transfert de l'équilibreur de charge, et non son service de backend, détermine le ou les ports sur lesquels l'équilibreur de charge accepte le trafic. Pour plus d'informations sur l'utilité de chaque composant, consultez la section Composants.

Lorsque vous avez créé cet exemple de règle de transfert d'équilibreur de charge, vous avez configuré les ports 80, 8008, 8080 et 8088. Le script de démarrage qui installe Apache le configure également pour accepter les connexions HTTPS sur les ports 443 et 8443.

Pour utiliser ces six ports, vous pouvez configurer la règle de transfert de façon à accepter le trafic sur tous les ports. Avec cette stratégie, vous pouvez également configurer la ou les règles de pare-feu qui autorisent les connexions entrantes vers les VM de backend afin qu'elles n'autorisent que certains ports.

Cette procédure vous montre comment remplacer l'exemple de règle de transfert de l'équilibreur de charge par une règle qui accepte le trafic sur tous les ports.

Pour en savoir plus sur l'utilisation de cette configuration, consultez la page Équilibrage de charge TCP/UDP et règles de transfert internes avec adresse IP commune.

Console

Supprimer une règle de transfert et en créer une nouvelle

  1. Accédez à la page Équilibrage de charge dans Google Cloud Console.
    Accéder à la page "Équilibrage de charge"
  2. Cliquez sur votre équilibreur de charge be-ilb, puis sur Modifier.
  3. Cliquez sur Configuration du frontend.
  4. Passez la souris sur votre règle de transfert 10.1.2.9 et cliquez sur l'icône de la corbeille pour la supprimer.
  5. Cliquez sur Ajouter une adresse IP et un port frontend.
  6. Dans la section Nouveaux IP et port frontend, apportez les modifications suivantes :
    1. Nom : fr-ilb
    2. Sous-réseau : lb-subnet
    3. Dans le champ Adresse IP interne, sélectionnez ip-ilb.
    4. Ports : Tous
    5. Cliquez sur OK.
    6. Vérifiez qu'une coche bleue apparaît à côté de Configuration du frontend avant de continuer. Reprenez la procédure depuis le début si ce n'est pas le cas.
  7. Cliquez sur Vérification et finalisation. Vérifiez vos paramètres.
  8. Cliquez sur Créer.

gcloud

  1. Supprimez votre règle de transfert existante, fr-ilb.

    gcloud compute forwarding-rules delete fr-ilb \
        --region=us-west1
    
  2. Créez une règle de transfert de remplacement portant le même nom et dont la configuration de port utilise le mot clé ALL. Les autres paramètres de la règle de transfert ne changent pas.

    gcloud compute forwarding-rules create fr-ilb \
        --region=us-west1 \
        --load-balancing-scheme=internal \
        --network=lb-network \
        --subnet=lb-subnet \
        --address=10.1.2.99 \
        --ip-protocol=TCP \
        --ports=ALL \
        --backend-service=be-ilb \
        --backend-service-region=us-west1
    

api

Supprimez la règle de transfert en envoyant une requête DELETE à la méthode forwardingRules.delete.

DELETE https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules/fr-ilb

Créez la règle de transfert en envoyant une requête POST à la méthode forwardingRules.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules

{
  "name": "fr-ilb",
  "IPAddress": "10.1.2.99",
  "IPProtocol": "TCP",
  "allPorts": true,
  "loadBalancingScheme": "INTERNAL",
  "subnetwork": "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/subnetworks/lb-subnet",
  "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
  "backendService": "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/backendServices/be-ilb",
  "networkTier": "PREMIUM"
}

Tester le trafic avec la configuration de tous les ports

Connectez-vous à l'instance de VM cliente et testez les connexions HTTP et HTTPS.

  • Connectez-vous à la VM cliente :

    gcloud compute ssh vm-client --zone=us-west1-a
    
  • Testez la connectivité HTTP sur les quatre ports :

    curl http://10.1.2.99
    curl http://10.1.2.99:8008
    curl http://10.1.2.99:8080
    curl http://10.1.2.99:8088
    
  • Testez la connectivité HTTPS sur les ports 443 et 8443. L'option --insecure est obligatoire, car chaque serveur Apache dans l'exemple de configuration utilise un certificat autosigné.

    curl https://10.1.2.99 --insecure
     curl https://10.1.2.99:8443 --insecure
    
  • Remarquez que les requêtes HTTP (sur les quatre ports) et HTTPS (sur les deux ports) sont réparties entre toutes les VM de backend.

Accepter le trafic sur plusieurs ports à l'aide de deux règles de transfert

Lorsque vous avez créé cet exemple de règle de transfert d'équilibreur de charge, vous avez configuré les ports 80, 8008, 8080 et 8088. Le script de démarrage qui installe Apache le configure également pour accepter les connexions HTTPS sur les ports 443 et 8443.

Une stratégie alternative à la configuration d'une règle de transfert unique pour accepter le trafic sur tous les ports consiste à créer plusieurs règles de transfert, acceptant chacune cinq ports ou moins.

Cette procédure vous montre comment remplacer l'exemple de règle de transfert de l'équilibreur de charge par deux règles de transfert, l'une traitant le trafic sur les ports 80, 8008, 8080 et 8088, et l'autre sur les ports 443 et 8443.

Pour en savoir plus sur l'utilisation de cette configuration, consultez la page Équilibrage de charge TCP/UDP et règles de transfert internes avec adresse IP commune.

gcloud

  1. Supprimez votre règle de transfert existante, fr-ilb.

    gcloud compute forwarding-rules delete fr-ilb \
        --region=us-west1
    
  2. Créez une adresse IP interne statique (réservée) pour 10.1.2.99 et définissez l'option --purpose sur SHARED_LOADBALANCER_VIP. L'option --purpose est obligatoire pour que deux règles de transfert internes puissent utiliser la même adresse IP interne.

    gcloud beta compute addresses create internal-10-1-2-99 \
        --region=us-west1 \
        --subnet=lb-subnet \
        --addresses=10.1.2.99 \
        --purpose=SHARED_LOADBALANCER_VIP
    
    1. Créez deux règles de transfert de remplacement avec les paramètres suivants :
    gcloud compute forwarding-rules create fr-ilb-http \
        --region=us-west1 \
        --load-balancing-scheme=internal \
        --network=lb-network \
        --subnet=lb-subnet \
        --address=10.1.2.99 \
        --ip-protocol=TCP \
        --ports=80,8008,8080,8088 \
        --backend-service=be-ilb \
        --backend-service-region=us-west1
    
    gcloud compute forwarding-rules create fr-ilb-https \
        --region=us-west1 \
        --load-balancing-scheme=internal \
        --network=lb-network \
        --subnet=lb-subnet \
        --address=10.1.2.99 \
        --ip-protocol=TCP \
        --ports=443,8443 \
        --backend-service=be-ilb \
        --backend-service-region=us-west1
    

api

Supprimez la règle de transfert en envoyant une requête DELETE à la méthode forwardingRules.delete.

DELETE https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules/fr-ilb

Créez une adresse IP interne statique (réservée) pour 10.1.2.99 et définissez son objectif sur SHARED_LOADBALANCER_VIP en envoyant une requête POST à la méthode addresses.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/addresses

{
  "name": "internal-10-1-2-99",
  "address": "10.1.2.99",
  "prefixLength": 32,
  "addressType": INTERNAL,
  "purpose": SHARED_LOADBALANCER_VIP,
  "subnetwork": "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/subnetworks/lb-subnet"
}

Créez deux règles de transfert en envoyant deux requêtes POST à la méthode forwardingRules.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules

{
  "name": "fr-ilb-http",
  "IPAddress": "10.1.2.99",
  "IPProtocol": "TCP",
  "ports": [
    "80", "8008", "8080",  "8088"
  ],
  "loadBalancingScheme": "INTERNAL",
  "subnetwork": "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/subnetworks/lb-subnet",
  "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
  "backendService": "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/backendServices/be-ilb",
  "networkTier": "PREMIUM"
}
{
  "name": "fr-ilb-https",
  "IPAddress": "10.1.2.99",
  "IPProtocol": "TCP",
  "ports": [
    "443", "8443"
  ],
  "loadBalancingScheme": "INTERNAL",
  "subnetwork": "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/subnetworks/lb-subnet",
  "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
  "backendService": "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/backendServices/be-ilb",
  "networkTier": "PREMIUM"
}

Tester le trafic avec la configuration multiport

Connectez-vous à l'instance de VM cliente et testez les connexions HTTP et HTTPS.

  • Connectez-vous à la VM cliente :

    gcloud compute ssh vm-client --zone=us-west1-a
    
  • Testez la connectivité HTTP sur les quatre ports :

    curl http://10.1.2.99
    curl http://10.1.2.99:8008
    curl http://10.1.2.99:8080
    curl http://10.1.2.99:8088
    
  • Testez la connectivité HTTPS sur les ports 443 et 8443. L'option --insecure est obligatoire, car chaque serveur Apache dans l'exemple de configuration utilise un certificat autosigné.

    curl https://10.1.2.99 --insecure
    curl https://10.1.2.99:8443 --insecure
    
  • Remarquez que les requêtes HTTP (sur les quatre ports) et HTTPS (sur les deux ports) sont réparties entre toutes les VM de backend.

Utiliser l'affinité de session

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

Cette procédure vous montre comment mettre à jour le service de backend pour l'exemple d'équilibreur de charge TCP/UDP interne afin qu'il utilise l'affinité de session basée sur un hachage créé à partir des adresses IP du client et de l'adresse IP de la règle de transfert interne de l'équilibreur de charge. Actuellement, il n'est pas possible de définir l'affinité de session pour un équilibreur de charge UDP interne.

Console

  1. Accédez à la page Équilibrage de charge dans Google Cloud Console.
    Accéder à la page "Équilibrage de charge"
  2. Cliquez sur be-ilb (nom du service de backend que vous avez créé pour cet exemple), puis cliquez sur Modifier.
  3. Sur la page Modifier l'équilibreur de charge interne, cliquez sur Configuration du backend.
  4. Sélectionnez IP client dans le menu contextuel Affinité de session.
  5. Cliquez sur Mettre à jour.

gcloud

Exécutez la commande gcloud suivante pour mettre à jour le service de backend be-ilb, en spécifiant l'affinité de session basée sur les adresses IP client :

gcloud compute backend-services update be-ilb \
    --region=us-west1 \
    --session-affinity CLIENT_IP

api

Envoyez une requête PATCH à la méthode regionBackendServices/patch.

PATCH https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb

{
  "sessionAffinity": "CLIENT_IP"
}

Pour plus d'informations sur l'utilisation de l'affinité de session pour influencer la répartition du trafic et pour obtenir une description de chaque option, consultez la page Répartition du trafic.

Créer une règle de transfert dans un autre sous-réseau

Cette procédure crée une deuxième adresse IP et une règle de transfert dans un sous-réseau différent pour démontrer que vous pouvez créer plusieurs règles de transfert pour un équilibreur de charge TCP/UDP interne. La région de la règle de transfert doit correspondre à celle du service de backend.

Sous réserve des règles de pare-feu, les clients de n'importe quel sous-réseau de la région peuvent contacter l'une ou l'autre des adresses IP de l'équilibreur de charge TCP/UDP interne.

Console

Ajouter le deuxième sous-réseau

  1. Accédez à la page "Réseaux VPC" dans Google Cloud Console.
    Accéder à la page "Réseaux VPC"
  2. Cliquez sur Créer un réseau VPC.
  3. Cliquez sur lb-network.
  4. Dans la section Sous-réseaux :
    • Cliquez sur Ajouter un sous-réseau.
    • Dans la section Nouveau sous-réseau, saisissez les informations suivantes :
      • Nom : second-subnet
      • Région : us-west1
      • Plage d'adresses IP : 10.5.6.0/24
      • Cliquez sur Ajouter.

Ajouter la deuxième règle de transfert

  1. Accédez à la page Équilibrage de charge dans Google Cloud Console.
    Accéder à la page "Équilibrage de charge"
  2. Cliquez sur votre équilibreur de charge be-ilb, puis sur Modifier.
  3. Cliquez sur Configuration du frontend.
  4. Cliquez sur Ajouter une adresse IP et un port frontend.
  5. Dans la section Nouveaux IP et port frontend, apportez les modifications suivantes :
    1. Nom : fr-ilb-2
    2. Sous-réseau : second-subnet
    3. Dans le champ Adresse IP interne, sélectionnez ip-ilb.
    4. Ports : 80, 443
    5. Cliquez sur OK.
    6. Vérifiez qu'une coche bleue apparaît à côté de Configuration du frontend avant de continuer. Reprenez la procédure depuis le début si ce n'est pas le cas.
  6. Cliquez sur Vérification et finalisation. Vérifiez vos paramètres.
  7. Cliquez sur Créer.

gcloud

  1. Créez un deuxième sous-réseau sur le réseau lb-network, dans la région us-west1 :

    gcloud compute networks subnets create second-subnet \
       --network=lb-network \
       --range=10.5.6.0/24 \
       --region=us-west1
    
  2. Créez une deuxième règle de transfert pour les ports 80 et 443. Les autres paramètres de cette règle, y compris l'adresse IP et le service de backend, sont identiques à ceux de la règle de transfert principale, fr-ilb.

    gcloud compute forwarding-rules create fr-ilb-2 \
       --region=us-west1 \
       --load-balancing-scheme=internal \
       --network=lb-network \
       --subnet=second-subnet \
       --address=10.5.6.99 \
       --ip-protocol=TCP \
       --ports=80,443 \
       --backend-service=be-ilb \
       --backend-service-region=us-west1
    

api

Envoyez une requête POST à la méthode subnetworks.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks

{
  "name": "second-subnet",
  "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
  "ipCidrRange": "10.5.6.0/24",
  "privateIpGoogleAccess": false
}

Créez la règle de transfert en envoyant une requête POST à la méthode forwardingRules.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules

{
 "name": "fr-ilb-2",
 "IPAddress": "10.5.6.99",
 "IPProtocol": "TCP",
 "ports": [
   "80", "443"
 ],
 "loadBalancingScheme": "INTERNAL",
 "subnetwork": "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/subnetworks/lb-subnet",
 "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
 "backendService": "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/backendServices/be-ilb",
 "networkTier": "PREMIUM"
}

Tester la nouvelle règle de transfert

  1. Connectez-vous à l'instance de VM cliente et testez les connexions HTTP et HTTPS aux adresses IP.

    • Connectez-vous à la VM cliente :
    gcloud compute ssh vm-client --zone=us-west1-a
    
    • Testez la connectivité HTTP aux adresses IP :
    curl http://10.1.2.99
    curl http://10.5.6.99
    
    • Testez la connectivité HTTPS. L'option --insecure est obligatoire, car la configuration du serveur Apache dans l'exemple de configuration utilise des certificats autosignés.
    curl https://10.1.2.99 --insecure
    curl https://10.5.6.99 --insecure
    
    • Notez que les requêtes sont traitées par toutes les VM de backend, quels que soient le protocole (HTTP ou HTTPS) et l'adresse IP utilisés.

Étapes suivantes