Cette page a été traduite par l'API Cloud Translation.

Configurer un équilibreur de charge réseau passthrough interne avec des backends de groupe d'instances de VM

Ce guide s'appuie sur un exemple pour expliquer les principes fondamentaux des équilibreurs de charge réseau passthrough internes Google Cloud. Avant de le suivre, familiarisez-vous avec les points suivants :

Pour obtenir des instructions détaillées sur cette tâche directement dans la console Google Cloud , cliquez sur Visite guidée :

Visite guidée

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 de réseaux Compute (`roles/compute.networkAdmin`)
Ajouter et supprimer des règles de pare-feu	Administrateur de sécurité de Compute (`roles/compute.securityAdmin`)
Créer des instances	Administrateur d'instances Compute (`roles/compute.instanceAdmin`)

Pour en savoir plus, consultez les guides suivants :

Access control (Contrôle des accès)
Conditions IAM

Configurer un équilibreur de charge avec des sous-réseaux et des backends IPv4 uniquement

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

Exemple utilisant un réseau VPC en mode personnalisé nommé lb-network.
Un sous-réseau à pile unique (stack-type défini sur IPv4) qui est requis pour le trafic IPv4. Lorsque vous créez un sous-réseau à pile unique sur un réseau VPC en mode personnalisé, vous choisissez une plage de sous-réseau IPv4 pour le sous-réseau.
Des règles de pare-feu autorisant les connexions entrantes aux instances de machine virtuelle (VM) de backend.
Le groupe d'instances backend, situé dans la région et le sous-réseau suivants pour cet exemple :
- Région : us-west1
- Sous-réseau: lb-subnet, avec plage d'adresses IPv4 principale 10.1.2.0/24.
Quatre VM de backend : deux VM dans un groupe d'instances non géré dans la zone us-west1-a et deux VM dans un groupe d'instances non géré dans la zone us-west1-c. 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
VM cliente pour tester les connexions
Les composants de l'équilibreur de charge réseau passthrough 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 d'un équilibreur de charge réseau passthrough interne. — Exemple de configuration d'un équilibreur de charge réseau passthrough interne (cliquez pour agrandir).

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

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

Console

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

Accéder aux réseaux VPC
Cliquez sur Créer un réseau VPC.
Dans le champ Nom, saisissez lb-network.
Dans la section Sous-réseaux, procédez comme suit :
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-subnet
  - Région : us-west1
  - Type de pile IP : IPv4 (pile unique)
  - Plage d'adresses IP : 10.1.2.0/24
3. Cliquez sur OK.
4. Cliquez sur Ajouter un sous-réseau et saisissez les informations suivantes :
  - Nom : europe-subnet
  - Région : europe-west1
  - Type de pile IP : IPv4 (pile unique)
  - Plage d'adresses IP : 10.3.4.0/24
5. Cliquez sur OK.
Cliquez sur Créer.

gcloud

Créez le réseau VPC personnalisé :

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

Au sein du réseau lb-network, créez un sous-réseau pour les backends dans la région us-west1 :

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

Dans le réseau lb-network, créez un autre sous-réseau pour tester l'accès mondial dans la région europe-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 des 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 sources plus restrictive pour cette règle. Par exemple, vous pouvez spécifier uniquement les plages d'adresses IP du système à partir duquel vous souhaitez lancer des sessions SSH. Cet exemple utilise le tag cible allow-ssh pour identifier les VM auxquelles la règle doit s'appliquer.
fw-allow-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

Dans la console Google Cloud , accédez à la page Règles de pare-feu.

Accéder aux stratégies de pare-feu
Pour autoriser le trafic de sous-réseau, cliquez sur Créer une règle de pare-feu, puis saisissez les informations suivantes :
- Nom : fw-allow-lb-access
- Réseau : lb-network
- Priorité : 1000
- Sens du trafic : entrée
- Action en cas de correspondance : autoriser
- Cibles : All instances in the network
- Filtre source : Plages IPv4
- Plages IPv4 sources : 10.1.2.0/24
- Protocoles et ports : tout autoriser
Cliquez sur Créer.
Pour autoriser les connexions SSH entrantes, cliquez à nouveau sur Créer une règle de pare-feu et saisissez les informations suivantes :
- 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 : Plages IPv4
- Plages IPv4 sources : 0.0.0.0/0
- Protocoles et ports : sélectionnez Protocoles et ports spécifiés, cochez la case TCP, puis saisissez 22 dans Ports.
Cliquez sur Créer.
Pour autoriser les vérifications de l'état Google Cloud , cliquez une troisième fois sur Créer une règle de pare-feu, puis saisissez les informations suivantes :
- 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 : Plages IPv4
- Plages IPv4 sources : 130.211.0.0/22 et 35.191.0.0/16
- Protocoles et ports : tout autoriser
Cliquez sur Créer.

gcloud

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

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

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 des équilibreurs de charge réseau passthrough internes, 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 et peuvent se connecter via SSH.

Par défaut, Apache est configuré pour se lier à n’importe quelle adresse IP. Les équilibreurs de charge réseau passthrough internes transmettent 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 backend par un équilibreur de charge réseau passthrough 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 12.

Console

Créer des VM de backend

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

Accéder à la page Instances de VM
Répétez les étapes 3 à 8 pour chaque 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
Cliquez sur Créer une instance.
Définissez le Nom comme indiqué à l'étape 2.
Dans le champ Région, sélectionnez us-west1, puis choisissez une zone comme indiqué à l'étape 2.
Dans la section Disque de démarrage, assurez-vous que Debian GNU/Linux 12 (bookworm) est sélectionné pour les options du disque de démarrage. Si nécessaire, cliquez sur Modifier pour modifier l'image.
Cliquez sur Options avancées.
Cliquez sur Mise en réseau et configurez les champs suivants :
1. Pour Tags réseau, saisissez allow-ssh et allow-health-check.
2. Pour Interfaces réseau, sélectionnez l'option suivante :
  - Réseau : lb-network
  - Sous-réseau : lb-subnet
  - Type de pile IP : IPv4 (pile unique)
  - Adresse IPv4 interne principale : Éphémère (automatique)
  - Adresse IPv4 externe : Éphémère

Cliquez sur Gestion, puis dans le champ Script de démarrage, saisissez le 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://metadata.google.internal/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

Cliquez sur Créer.

Créer des groupes d'instances

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

Accéder à la page "Groupes d'instances"
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 :
- Nom du groupe d'instances : ig-a, zone : us-west1-a, VM : vm-a1 et vm-a2
- Nom du groupe d'instances : ig-c, zone : us-west1-c, VM : vm-c1 et vm-c2
Cliquez sur Créer un groupe d'instances.
Cliquez sur Nouveau groupe d'instances non géré.
Définissez le Nom comme indiqué à l'étape 2.
Dans la section Emplacement, sélectionnez us-west1 pour la Région, puis choisissez une zone comme indiqué à l'étape 2.
Pour Réseau, sélectionnez lb-network.
Pour Sous-réseau, sélectionnez lb-subnet.
Dans la section Instances de VM, ajoutez les VM comme indiqué à l'étape 2.
Cliquez sur Créer.

gcloud

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, ZONE: us-west1-a
VM-NAME: vm-a2, ZONE: us-west1-a
VM-NAME: vm-c1, ZONE: us-west1-c
VM-NAME: vm-c2, ZONE: us-west1-c

gcloud compute instances create VM-NAME \
    --zone=ZONE \
    --image-family=debian-12 \
    --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://metadata.google.internal/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'

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

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, ZONE: us-west1-a
VM-NAME: vm-a2, ZONE: us-west1-a
VM-NAME: vm-c1, ZONE: us-west1-c
VM-NAME: vm-c2, 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-12"

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://metadata.google.internal/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"
   }
 ]
}

Configurer les composants de l'équilibreur de charge

Ces étapes permettent de configurer tous les composants de l'équilibreur de charge passthrough 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'équilibreur de charge réseau passthrough interne.
Service de backend : étant donné que vous devez transmettre le trafic HTTP via l'équilibreur de charge interne, vous devez 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, vous spécifiez une adresse IP interne, 10.1.2.99, lors de la création de la règle de transfert.

Console

Démarrer la configuration

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

Accéder à la page "Équilibrage de charge"
Cliquez sur Créer un équilibreur de charge.
Sous Type d'équilibreur de charge, sélectionnez Équilibreur de charge réseau (TCP/UDP/SSL), puis cliquez sur Suivant.
Pour Proxy ou passthrough, sélectionnez Équilibreur de charge passthrough, puis cliquez sur Suivant.
Pour Public ou interne, sélectionnez Interne, puis cliquez sur Suivant.
Cliquez sur Configurer.

Configuration de base

Sur la page Créer un équilibreur de charge réseau passthrough interne, saisissez les informations suivantes :

Nom de l'équilibreur de charge : be-ilb
Région : us-west1
Réseau : lb-network

Configurer les backends

Cliquez sur Configuration du backend.
Pour ne gérer que le trafic IPv4, procédez comme suit : dans la section Nouveau backend de Backends, sélectionnez IPv4 (pile unique) comme Type de pile IP.
Dans Groupe d'instances, sélectionnez le groupe d'instances ig-c et cliquez sur Terminé.
Cliquez sur Ajouter un backend et répétez cette étape pour ajouter ig-a.
Dans la liste Vérification d'état, sélectionnez Créer une vérification d'état, saisissez les informations suivantes, puis cliquez sur Enregistrer.
- Nom : hc-http-80
- Protocole : HTTP
- Port : 80
- Protocole de proxy : NONE
- Chemin de requête : /
Sachez que lorsque vous créez un équilibreur de charge à l'aide de la console Google Cloud , 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.
Vérifiez qu'une coche bleue apparaît à côté de Configuration du backend avant de continuer.

Configurer l'interface

Cliquez sur Configuration de l'interface.
Dans la section Nouveaux IP et port frontend, procédez comme suit :
1. Dans le champ Nom, saisissez fr-ilb.
2. Pour Sous-réseau, sélectionnez lb-subnet.
3. Dans la section Objectif de l'adresse IP interne, dans la liste Adresse IP, sélectionnez Créer une adresse IP, saisissez les informations suivantes, puis cliquez sur Réserver.
  - Nom : ip-ilb
  - Version IP : IPv4
  - Adresse IP statique : Laissez-moi choisir
  - Adresse IP personnalisée : 10.1.2.99
4. Pour Ports, sélectionnez Plusieurs puis dans Numéros de port, saisissez 80, 8008, 8080 et 8088.
5. Vérifiez qu'une coche bleue apparaît à côté de Configuration de l'interface avant de continuer.

Vérifier la configuration

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

gcloud

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

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

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

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

Tester votre équilibreur de charge

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

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

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

Accéder à la page Instances de VM
Cliquez sur Créer une instance.
Dans le champ Nom, saisissez vm-client.
Pour Région, sélectionnez us-west1.
Pour Zone, sélectionnez us-west1-a.
Cliquez sur Options avancées.
Cliquez sur Mise en réseau et configurez les champs suivants :
1. Pour Tags réseau, saisissez allow-ssh.
2. Pour Interfaces réseau, sélectionnez l'option suivante :
  - Réseau : lb-network
  - Sous-réseau : lb-subnet
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-12 \
    --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
}

Tester la connexion depuis la VM cliente

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.

Connectez-vous à l'instance de VM cliente.

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

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. Par exemple, les réponses attendues ressemblent à Page served from: vm-a1 et Page served from: vm-a2.
```
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
  
```

Pinguer 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 réseau passthrough internes sont implémentés dans une programmation de réseau virtuel. Il ne s'agit pas d'appareils distincts.

Connectez-vous à l'instance de VM cliente.

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

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

Envoyer des requêtes à partir de VM à équilibrage de charge

Ce test montre que lorsqu'une VM de backend envoie des paquets à l'adresse IP de la règle de transfert de son équilibreur de charge, ces requêtes sont réacheminées vers elle-même. Cela s'applique quel que soit l'état de la vérification d'état de la VM de backend.

Les équilibreurs de charge réseau passthrough internes sont implémentés à 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é crée une route pour l'adresse IP de l'équilibreur de charge dans la table de routage locale du système d'exploitation.

Comme cette route locale se trouve dans la VM elle-même (et non dans une route du réseau VPC), les paquets envoyés à l'adresse IP de l'équilibreur de charge ne sont pas traités par le réseau VPC. À la place, les paquets envoyés à l'adresse IP de l'équilibreur de charge restent dans le système d'exploitation de la VM.

Connectez-vous à une VM de backend, telle que vm-a1 :
```
gcloud compute ssh vm-a1 --zone=us-west1-a
```
Important : Vous ne pourrez pas vous connecter à une VM de backend si vous avez supprimé son adresse IP externe. Pour connaître les options de connexion si vos VM de backend ne possèdent pas d'adresse IP externe, consultez la section Choisir une option de connexion pour les VM internes uniquement.
Envoyez une requête Web à l'équilibreur de charge (par adresse IP ou nom de service) à l'aide de curl. La réponse provient de la VM de backend qui envoie la requête. Les requêtes répétées sont traitées de la même manière. 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
```
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'équilibreur de charge réseau passthrough 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
```

Lorsqu'une VM backend pour un équilibreur de charge réseau passthrough interne envoie des paquets à l'adresse IP de la règle de transfert de l'équilibreur de charge, les paquets sont toujours réacheminés vers la VM qui effectue la requête. En effet, un équilibreur de charge réseau passthrough interne est un équilibreur de charge passthrough. Il est implémenté en créant une route locale pour l'adresse IP de l'équilibreur de charge dans le système d'exploitation invité de la VM, comme indiqué dans cette section. Dans le cas où les backends à équilibrage de charge doivent envoyer du trafic TCP à l'adresse IP de l'équilibreur de charge et que vous devez distribuer le trafic comme s'il provenait d'une instance qui n'a pas de charge backend équilibrée, envisagez plutôt d'utiliser un équilibreur de charge réseau proxy interne régional.

Pour en savoir plus, consultez la section Équilibreurs de charge réseau passthrough internes comme sauts suivants.

Configurer l'équilibreur de charge avec des sous-réseaux et des backends à double pile

Ce document vous explique comment configurer et tester un équilibreur de charge réseau passthrough interne compatible avec le trafic IPv4 et IPv6. La procédure décrite dans cette section explique comment configurer les éléments suivants :

L'exemple de cette page utilise un réseau VPC en mode personnalisé nommé lb-network-dual-stack. Le trafic IPv6 requiert un sous-réseau en mode personnalisé.
Un sous-réseau à double pile (stack-type défini sur IPv4_IPv6), requis pour le trafic IPv6. Lorsque vous créez un sous-réseau à double pile sur un réseau VPC en mode personnalisé, choisissez un type d'accès IPv6 pour le sous-réseau. Pour cet exemple, nous définissons le paramètre ipv6-access-type du sous-réseau sur INTERNAL. Cela signifie que les nouvelles VM de ce sous-réseau peuvent se voir attribuer des adresses IPv4 internes et des adresses IPv6 internes. Pour obtenir des instructions, consultez la documentation VPC sur l'ajout d'un sous-réseau à deux piles.
Des règles de pare-feu autorisant les connexions entrantes aux VM de backend.
Le groupe d'instances backend, situé dans la région et le sous-réseau suivants pour cet exemple :
- Région : us-west1
- Sous-réseau: lb-subnet, avec plage d'adresses IPv4 principale 10.1.2.0/24. Bien que vous choisissiez la plage d'adresses IPv4 à configurer sur le sous-réseau, la plage d'adresses IPv6 est attribuée automatiquement. Google fournit un bloc CIDR IPv6 de taille fixe (/64).
Quatre VM à double pile de backend : deux VM dans un groupe d'instances non géré dans la zone us-west1-a et deux VM dans un groupe d'instances non géré dans la zone us-west1-c. 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
VM cliente pour tester les connexions
Les composants de l'équilibreur de charge réseau passthrough 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.
- Deux règles de transfert internes pour l'interface de l'équilibreur de charge.

Le diagramme suivant montre l'architecture de cet exemple :

Un réseau VPC à double pile avec un service de backend pour gérer la distribution des connexions vers deux groupes d'instances zonaux. — Exemple de configuration d'un équilibreur de charge réseau passthrough interne (cliquez pour agrandir).

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

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

Pour configurer des sous-réseaux avec des plages IPv6 internes, activez une plage IPv6 interne ULA du réseau VPC. Les plages de sous-réseaux IPv6 internes sont allouées à partir de cette plage.

Console

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

Accéder aux réseaux VPC
Cliquez sur Créer un réseau VPC.
Dans le champ Nom, saisissez lb-network-dual-stack.
Si vous souhaitez configurer des plages d'adresses IPv6 internes sur les sous-réseaux de ce réseau, procédez comme suit :
1. Dans Paramètres d'adresses IPv6 privée, sélectionnez Configurer une plage d'adresses IPv6 interne ULA pour ce réseau VPC.
2. Dans le champ Allouer une plage IPv6 interne, sélectionnez Automatiquement ou Manuellement. Si vous sélectionnez Manuellement, saisissez une plage /48 comprise dans la plage fd20::/20. Si la plage est utilisée, vous êtes invité à en fournir une autre.
Dans le champ Mode de création de sous-réseau, sélectionnez Personnalisé.
Dans la section Nouveau sous-réseau, spécifiez les paramètres de configuration de sous-réseau suivants :
- Nom : lb-subnet
- Région : us-west1
- Type de pile d'adresses IP: IPv4 et IPv6 (double pile)
- Plage IPv4 : 10.1.2.0/24.
- Type d'accès IPv6 : Interne.
Cliquez sur OK.
Cliquez sur Ajouter un sous-réseau et saisissez les informations suivantes :
- Nom : europe-subnet
- Région : europe-west1
- Type de pile IP : IPv4 (pile unique)
- Plage d'adresses IP : 10.3.4.0/24
Cliquez sur OK.
Cliquez sur Créer.

gcloud

Pour créer un réseau VPC en mode personnalisé, exécutez la commande gcloud compute networks create.

Pour configurer des plages IPv6 internes sur n'importe quel sous-réseau de ce réseau, utilisez l'option --enable-ula-internal-ipv6. Cette option attribue un préfixe ULA /48 compris dans la plage fd20::/20 utilisée par Google Cloud pour les plages de sous-réseaux IPv6 internes. Si vous souhaitez sélectionner la plage IPv6 /48 attribuée, utilisez l'option --internal-ipv6-range pour spécifier une plage.
```
gcloud compute networks create lb-network-dual-stack \
 --subnet-mode=custom \
 --enable-ula-internal-ipv6 \
 --internal-ipv6-range=ULA_IPV6_RANGE \
 --bgp-routing-mode=regional
```
Remplacez ULA_IPV6_RANGE par un préfixe /48 compris dans la plage fd20::/20 utilisée par Google pour les plages de sous-réseaux IPv6 internes. Si vous n'utilisez pas l'option --internal-ipv6-range, Google sélectionne un préfixe /48 pour le réseau, par exemple fd20:bc7:9a1c::/48.

Au sein du réseau 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 :

Pour créer les sous-réseaux, exécutez la commande gcloud compute networks subnets create.

gcloud compute networks subnets create lb-subnet \
 --network=lb-network-dual-stack \
 --range=10.1.2.0/24 \
 --region=us-west1 \
 --stack-type=IPV4_IPV6 \
 --ipv6-access-type=INTERNAL

gcloud compute networks subnets create europe-subnet \
 --network=lb-network-dual-stack \
 --range=10.3.4.0/24 \
 --region=europe-west1 \
 --stack-type=IPV4_IPV6 \
 --ipv6-access-type=INTERNAL

API

Créez un réseau VPC en mode personnalisé.

Pour configurer les plages IPv6 internes sur n'importe quel sous-réseau de ce réseau, définissez enableUlaInternalIpv6 sur "true". Cette option attribue une plage /48 comprise dans la plage fd20::/20 utilisée par Google pour les plages de sous-réseaux IPv6 internes. Si vous souhaitez sélectionner la plage IPv6 /48 attribuée, utilisez également le champ internalIpv6Range pour spécifier une plage.

 POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks
 {
   "autoCreateSubnetworks": false,
   "name": "lb-network-dual-stack",
   "mtu": MTU,
   "enableUlaInternalIpv6": true,
   "internalIpv6Range": "ULA_IPV6_RANGE",
   "routingConfig": {
   "routingMode": "DYNAMIC_ROUTING_MODE"
  }
 }

Remplacez les éléments suivants :

PROJECT_ID : ID du projet où le réseau VPC a été créé.
MTU : unité de transmission maximale du réseau. La MTU peut être de 1460 (par défaut) ou de 1500. Consultez la page Présentation de l'unité de transmission maximale avant de définir la MTU sur 1500.
ULA_IPV6_RANGE : préfixe /48 de la plage fd20::/20 utilisée par Google pour les plages de sous-réseaux IPv6 internes. Si vous ne fournissez pas de valeur pour internalIpv6Range, Google sélectionne un préfixe /48 pour le réseau.
DYNAMIC_ROUTING_MODE : global ou regional pour contrôler le comportement de l'annonce de routage des routeurs cloud dans le réseau. Pour plus d'informations, consultez la documentation relative au mode de routage dynamique.

Pour plus d'informations, référez-vous à la méthode networks.insert.

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

 POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/subnetworks
 {
   "ipCidrRange": "10.1.2.0/24",
   "network": "lb-network-dual-stack",
   "name": "lb-subnet"
   "stackType": IPV4_IPV6,
   "ipv6AccessType": Internal
 }

 POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/subnetworks
 {
   "ipCidrRange": "10.3.4.0/24",
   "network": "lb-network-dual-stack",
   "name": "europe-subnet"
   "stackType": IPV4_IPV6,
   "ipv6AccessType": Internal
 }

Configurer des 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. Par la suite, vous pourrez configurer et tester l'accès mondial.
fw-allow-lb-access-ipv6 : règle d'entrée, applicable à toutes les cibles du réseau VPC, autorisant le trafic provenant de sources de la plage IPv6 configurée dans le sous-réseau. Cette règle autorise le trafic IPv6 entrant de n'importe quel client situé dans l'un des deux sous-réseaux. Par la suite, vous pourrez 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 sources plus restrictive pour cette règle. Par exemple, vous pouvez spécifier uniquement les plages d'adresses IP du système à partir duquel vous souhaitez lancer des sessions SSH. Cet exemple utilise le tag cible allow-ssh pour identifier les VM auxquelles la règle doit s'appliquer.
fw-allow-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.
fw-allow-health-check-ipv6 : 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 (2600:2d00:1:b029::/64). Cet exemple utilise le tag cible allow-health-check-ipv6 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

Dans la console Google Cloud , accédez à la page Règles de pare-feu.

Accéder aux stratégies de pare-feu
Pour créer la règle autorisant le trafic de sous-réseau, cliquez sur Créer une règle de pare-feu, puis saisissez les informations suivantes :
- Nom : fw-allow-lb-access
- Réseau : lb-network-dual-stack
- Priorité : 1000
- Sens du trafic : entrée
- Action en cas de correspondance : autoriser
- Cibles : All instances in the network
- Filtre source : Plages IPv4
- Plages IPv4 sources : 10.1.2.0/24 et 10.3.4.0/24
- Protocoles et ports : tout autoriser
Cliquez sur Créer.
Pour autoriser le trafic de sous-réseau IPv6, cliquez à nouveau sur Créer une règle de pare-feu, puis saisissez les informations suivantes :
- Nom : fw-allow-lb-access-ipv6
- Réseau : lb-network-dual-stack
- Priorité : 1000
- Sens du trafic : entrée
- Action en cas de correspondance : autoriser
- Cibles : All instances in the network
- Filtre source : Plages IPv6
- Plages IPv6 sources : adresse IPV6_ADDRESS attribuée dans lb-subnet
- Protocoles et ports : tout autoriser
Cliquez sur Créer.
Pour autoriser les connexions SSH entrantes, cliquez à nouveau sur Créer une règle de pare-feu et saisissez les informations suivantes :
- Nom : fw-allow-ssh
- Réseau : lb-network-dual-stack
- 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 : Plages IPv4
- Plages IPv4 sources : 0.0.0.0/0
- Protocoles et ports : sélectionnez Protocoles et ports spécifiés, cochez la case TCP, puis saisissez 22 dans Ports.
Cliquez sur Créer.
Pour autoriser les vérifications d'état IPv6, cliquez à nouveau sur Créer une règle de pare-feu, puis saisissez les informations suivantes : Google Cloud
- Nom : fw-allow-health-check-ipv6
- Réseau : lb-network-dual-stack
- Priorité : 1000
- Sens du trafic : entrée
- Action en cas de correspondance : autoriser
- Cibles : Tags cibles spécifiés
- Tags cibles : allow-health-check-ipv6
- Filtre source : Plages IPv6
- Plages IPv6 sources : 2600:2d00:1:b029::/64
- Protocoles et ports : tout autoriser
Cliquez sur Créer.
Pour autoriser les vérifications de l'état Google Cloud , cliquez à nouveau sur Créer une règle de pare-feu, puis saisissez les informations suivantes :
- Nom : fw-allow-health-check
- Réseau : lb-network-dual-stack
- 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 : Plages IPv4
- Plages IPv4 sources : 130.211.0.0/22 et 35.191.0.0/16
- Protocoles et ports : tout autoriser
Cliquez sur Créer.

gcloud

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-dual-stack \
    --action=allow \
    --direction=ingress \
    --source-ranges=10.1.2.0/24,10.3.4.0/24 \
    --rules=all

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

gcloud compute firewall-rules create fw-allow-lb-access-ipv6 \
    --network=lb-network-dual-stack \
    --action=allow \
    --direction=ingress \
    --source-ranges=IPV6_ADDRESS \
    --rules=all

Remplacez IPV6_ADDRESS par l'adresse IPv6 attribuée dans lb-subnet.

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-dual-stack \
    --action=allow \
    --direction=ingress \
    --target-tags=allow-ssh \
    --rules=tcp:22
```

Créez la règle fw-allow-health-check-ipv6 pour autoriser les vérifications d'étatGoogle Cloud IPv6.

gcloud compute firewall-rules create fw-allow-health-check-ipv6 \
    --network=lb-network-dual-stack \
    --action=allow \
    --direction=ingress \
    --target-tags=allow-health-check-ipv6 \
    --source-ranges=2600:2d00:1:b029::/64 \
    --rules=tcp,udp

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-dual-stack \
    --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-dual-stack",
"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-lb-access-ipv6 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-ipv6",
 "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network-dual-stack",
 "priority": 1000,
 "sourceRanges": [
   "IPV6_ADDRESS"
 ],
 "allowed": [
   {
      "IPProtocol": "tcp"
    },
    {
      "IPProtocol": "udp"
    },
    {
      "IPProtocol": "icmp"
    }
 ],
 "direction": "INGRESS",
 "logConfig": {
    "enable": false
 },
 "disabled": false
}

Remplacez IPV6_ADDRESS par l'adresse IPv6 attribuée dans lb-subnet.

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-dual-stack",
"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-ipv6 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-ipv6",
"network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network-dual-stack",
"priority": 1000,
"sourceRanges": [
  "2600:2d00:1:b029::/64"
],
"targetTags": [
  "allow-health-check-ipv6"
],
"allowed": [
  {
    "IPProtocol": "tcp"
  },
  {
    "IPProtocol": "udp"
  }
],
"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-dual-stack",
"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

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.

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 backend par un équilibreur de charge réseau passthrough interne est l'adresse IP interne de la règle de transfert.

Si vous utilisez des groupes d'instances gérés, assurez-vous que le type de pile du sous-réseau correspond au type de pile des modèles d'instances utilisés par les groupes d'instances gérés. Le sous-réseau doit être une pile double si le groupe d'instances géré utilise un modèle d'instance à double pile.

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

Console

Créer des VM de backend

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

Accéder à la page Instances de VM
Répétez les étapes 3 à 8 pour chaque 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
Cliquez sur Créer une instance.
Définissez le Nom comme indiqué à l'étape 2.
Dans le champ Région, sélectionnez us-west1, puis choisissez une zone comme indiqué à l'étape 2.
Dans la section Disque de démarrage, assurez-vous que Debian GNU/Linux 12 (bookworm) est sélectionné pour les options du disque de démarrage. Si nécessaire, cliquez sur Modifier pour modifier l'image.
Cliquez sur Options avancées.

Cliquez sur Mise en réseau et configurez les champs suivants :

Pour Tags réseau, saisissez allow-ssh et allow-health-check-ipv6.
Pour Interfaces réseau, sélectionnez l'option suivante :
- Réseau : lb-network-dual-stack
- Sous-réseau : lb-subnet
- Type de pile d'adresses IP: IPv4 et IPv6 (double pile)
- Adresse IPv4 interne principale : Éphémère (automatique)
- Adresse IPv4 externe : Éphémère

Cliquez sur Gestion, puis dans le champ Script de démarrage, saisissez le 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://metadata.google.internal/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

Cliquez sur Créer.

Créer des groupes d'instances

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

Accéder à la page "Groupes d'instances"
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 :
- Nom du groupe d'instances : ig-a, zone : us-west1-a, VM : vm-a1 et vm-a2
- Nom du groupe d'instances : ig-c, zone : us-west1-c, VM : vm-c1 et vm-c2
Cliquez sur Créer un groupe d'instances.
Cliquez sur Nouveau groupe d'instances non géré.
Définissez le Nom comme indiqué à l'étape 2.
Dans la section Emplacement, sélectionnez us-west1 pour la région, puis choisissez une zone comme indiqué à l'étape 2.
Pour Réseau, sélectionnez lb-network-dual-stack.
Pour Sous-réseau, sélectionnez lb-subnet.
Dans la section Instances de VM, ajoutez les VM comme indiqué à l'étape 2.
Cliquez sur Créer.

gcloud

Pour créer les quatre VM, exécutez la commande gcloud compute instances create 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, ZONE: us-west1-a
VM-NAME: vm-a2, ZONE: us-west1-a
VM-NAME: vm-c1, ZONE: us-west1-c

VM-NAME: vm-c2, ZONE: us-west1-c

gcloud compute instances create VM-NAME \
  --zone=ZONE \
  --image-family=debian-12 \
  --image-project=debian-cloud \
  --tags=allow-ssh,allow-health-check-ipv6 \
  --subnet=lb-subnet \
  --stack-type=IPV4_IPV6 \
  --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://metadata.google.internal/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'

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

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, ZONE: us-west1-a
VM-NAME: vm-a2, ZONE: us-west1-a
VM-NAME: vm-c1, ZONE: us-west1-c
VM-NAME: vm-c2, 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-12"

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-ipv6",
     "allow-ssh"
   ]
 },
 "machineType": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/[ZONE]/machineTypes/e2-standard-2",
 "canIpForward": false,
 "networkInterfaces": [
   {
     "stackType": "IPV4_IPV6",
     "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network-dual-stack",
     "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-dual-stack",
 "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-dual-stack",
 "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"
   }
 ]
}

Configurer les composants de l'équilibreur de charge

Ces étapes permettent de configurer tous les composants de l'équilibreur de charge réseau passthrough 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'équilibreur de charge réseau passthrough interne.
Service de backend : étant donné que vous devez transmettre le trafic HTTP via l'équilibreur de charge interne, vous devez utiliser TCP, et non UDP.
Règle de transfert : cet exemple crée deux règles de transfert internes pour le trafic IPv4 et IPv6.
Adresse IP interne : dans cet exemple, vous spécifiez une adresse IP interne, 10.1.2.99, lors de la création de la règle de transfert IPv4. Pour en savoir plus, consultez la page Adresse IP interne. Bien que vous choisissiez l'adresse IPv4 configurée, l'adresse IPv6 est attribuée automatiquement.

Console

Démarrer la configuration

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

Accéder à la page "Équilibrage de charge"
Cliquez sur Créer un équilibreur de charge.
Sous Type d'équilibreur de charge, sélectionnez Équilibreur de charge réseau (TCP/UDP/SSL), puis cliquez sur Suivant.
Pour Proxy ou passthrough, sélectionnez Équilibreur de charge passthrough, puis cliquez sur Suivant.
Pour Public ou interne, sélectionnez Interne, puis cliquez sur Suivant.
Cliquez sur Configurer.

Configuration de base

Sur la page Créer un équilibreur de charge réseau passthrough interne, saisissez les informations suivantes :

Nom de l'équilibreur de charge : be-ilb
Région : us-west1
Réseau : lb-network-dual-stack

Configuration du backend

Cliquez sur Configuration du backend.
Dans la section Nouveau backend de Backends, sélectionnez IPv4 et IPv6 (double pile) sous type de pile IP.
Dans Groupe d'instances, sélectionnez le groupe d'instances ig-a puis cliquez sur OK.
Cliquez sur Ajouter un backend et répétez cette étape pour ajouter ig-c.
Dans la liste Vérification d'état, sélectionnez Créer une vérification d'état, saisissez les informations suivantes, puis cliquez sur Enregistrer :
- Nom : hc-http-80.
- Champ d'application : Régional.
- Protocole : HTTP
- Port : 80.
- Proxy protocol : NONE.
- Chemin de requête : /.
Vérifiez qu'une coche bleue apparaît à côté de Configuration du backend.

Configuration du frontend

Cliquez sur Configuration de l'interface. Dans la section Nouveaux IP et port frontend, procédez comme suit :
1. Dans le champ Nom, saisissez fr-ilb-ipv6.
2. Pour gérer le trafic IPv6, procédez comme suit :
  1. Pour Version IP, sélectionnez IPv6.
  2. Pour Sous-réseau, sélectionnez lb-subnet. La plage d'adresses IPv6 de la règle de transfert est toujours éphémère.
  3. Pour Ports, sélectionnez Plusieurs, puis saisissez 80,8008,8080,8088 dans le champ Numéro de port.
  4. Cliquez sur OK.
3. Pour gérer le trafic IPv4, procédez comme suit :
  1. Cliquez sur Ajouter une adresse IP et un port frontend.
  2. Dans le champ Nom, saisissez fr-ilb.
  3. Pour Sous-réseau, sélectionnez lb-subnet.
  4. Dans la section Objectif de l'adresse IP interne, dans la liste Adresse IP, sélectionnez Créer une adresse IP, saisissez les informations suivantes, puis cliquez sur Réserver.
    - Nom : ip-ilb
    - Version IP : IPv4
    - Adresse IP statique : Laissez-moi choisir
    - Adresse IP personnalisée : 10.1.2.99
  5. Pour Ports, sélectionnez Plusieurs, puis dans Numéros de ports, saisissez 80, 8008, 8080 et 8088.
  6. Cliquez sur OK.
  7. Vérifiez qu'une coche bleue apparaît à côté de Configuration de l'interface avant de continuer.

Vérifier la configuration

Cliquez sur Vérifier et finaliser. Vérifiez tous vos paramètres.
Si les paramètres sont corrects, cliquez sur Créer. La création de l'équilibreur de charge réseau passthrough interne prend quelques minutes.

gcloud

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

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

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

Créez deux règles de transfert pour le service de backend. Lorsque vous créez la règle de transfert IPv4, spécifiez 10.1.2.99 pour l'adresse IP interne dans le sous-réseau pour les adresses IPv4.

gcloud compute forwarding-rules create fr-ilb \
    --region=us-west1 \
    --load-balancing-scheme=internal \
    --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-ipv6 \
    --region=us-west1 \
    --load-balancing-scheme=internal \
    --subnet=lb-subnet \
    --ip-protocol=TCP \
    --ports=80,8008,8080,8088 \
    --backend-service=be-ilb \
    --backend-service-region=us-west1 \
    --ip-version=IPV6

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-ipv6",
"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",
"backendService": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb",
"ipVersion": "IPV6",
"networkTier": "PREMIUM"
}

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",
"backendService": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb",
"networkTier": "PREMIUM"
}

Tester votre équilibreur de charge

Pour tester l'équilibreur de charge, créez une VM cliente dans la même région que l'équilibreur de charge, puis envoyez le trafic du client vers l'équilibreur de charge.

Créer une VM cliente

Console

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

Accéder à la page Instances de VM
Cliquez sur Créer une instance.
Dans le champ Nom, saisissez vm-client.
Pour Région, sélectionnez us-west1.
Pour Zone, sélectionnez us-west1-a.
Cliquez sur Options avancées.
Cliquez sur Mise en réseau et configurez les champs suivants :
1. Pour Tags réseau, saisissez allow-ssh.
2. Pour Interfaces réseau, sélectionnez l'option suivante :
  - Réseau : lb-network-dual-stack
  - Sous-réseau : lb-subnet
  - Type de pile d'adresses IP: IPv4 et IPv6 (double pile)
  - Adresse IP interne principale : Éphémère (automatique)
  - Adresse IP externe : Éphémère
3. Cliquez sur OK.
Cliquez sur Créer.

gcloud

gcloud compute instances create vm-client \
    --zone=us-west1-a \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --stack-type=IPV4_IPV6 \
    --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": [
   {
     "stackType": "IPV4_IPV6",
     "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network-dual-stack",
     "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
}

Tester la connexion

Connectez-vous à l'instance de VM cliente.

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

Décrivez la règle de transfert IPv6 fr-ilb-ipv6. Notez l'élément IPV6_ADDRESS dans la description.
```
gcloud compute forwarding-rules describe fr-ilb-ipv6 --region=us-west1
```

Décrivez la règle de transfert IPv4 fr-ilb.

gcloud compute forwarding-rules describe fr-ilb --region=us-west1

À partir de clients disposant d'une connectivité IPv6, exécutez la commande suivante:
```
$ curl -m 10 -s http://IPV6_ADDRESS:80
```
Par exemple, si l'adresse IPv6 attribuée est [fd20:1db0:b882:802:0:46:0:0/96]:80, la commande doit se présenter comme suit :
```
$  curl -m 10 -s http://[fd20:1db0:b882:802:0:46:0:0]:80
```
À partir de clients disposant d'une connectivité IPv4, exécutez la commande suivante:
```
$ curl -m 10 -s http://10.1.2.99:80
```
Remplacez les espaces réservés par des valeurs valides :
- IPV6_ADDRESS correspond à l'adresse IPv6 éphémère de la règle de transfert fr-ilb-ipv6.

Configurer un équilibreur de charge avec des sous-réseaux et des backends IPv6 uniquement

Ce document explique comment configurer et tester un équilibreur de charge réseau passthrough interne qui n'accepte que le trafic IPv6. La procédure décrite dans cette section explique comment configurer les éléments suivants :

Un réseau VPC en mode personnalisé nommé lb-network-ipv6-only. Le trafic IPv6 requiert un sous-réseau en mode personnalisé.
Un sous-réseau interne IPv6 uniquement appelé lb-subnet-ipv6-only (stack-type défini sur IPv6_ONLY), requis pour le trafic IPv6 uniquement.
Des règles de pare-feu autorisant les connexions entrantes aux VM de backend.
Le groupe d'instances backend, situé dans la région et le sous-réseau suivants pour cet exemple :
- Région : us-west1
- Sous-réseau : lb-subnet-ipv6-only La plage d'adresses IPv6 du sous-réseau est attribuée automatiquement. Google fournit un bloc CIDR IPv6 de taille fixe (/64).
Quatre VM de backend IPv6 uniquement : deux VM dans un groupe d'instances non géré dans la zone us-west1-a et deux VM dans un groupe d'instances non géré dans la zone us-west1-c.
Un serveur TCP IPv6 sur les VM de backend. Le serveur écoute les connexions entrantes sur l'adresse IP virtuelle spécifiée dans la règle de transfert de l'équilibreur de charge et sur l'interface réseau spécifiée. Le serveur accepte les connexions client entrantes, envoie une réponse, puis ferme la connexion.
VM cliente pour tester les connexions
Les composants de l'équilibreur de charge réseau passthrough 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 IPv6

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

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

Pour configurer des sous-réseaux avec des plages IPv6 internes, activez une plage IPv6 interne ULA du réseau VPC. Les plages de sous-réseaux IPv6 internes sont allouées à partir de cette plage.

Plus loin, dans la section Installer un serveur TCP IPv6 sur les VM de backend à l'aide d'un script de démarrage Bash de ce document, la plage de sous-réseau IPv6 interne est utilisée pour créer une règle de routage permettant de router le trafic du sous-réseau VPC via la passerelle et l'interface réseau spécifiées.

Console

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

Accéder aux réseaux VPC
Cliquez sur Créer un réseau VPC.
Dans le champ Nom, saisissez lb-network-ipv6-only.
Si vous souhaitez configurer des plages d'adresses IPv6 internes sur les sous-réseaux de ce réseau, procédez comme suit :
1. Dans Paramètres d'adresses IPv6 privée, sélectionnez Configurer une plage d'adresses IPv6 interne ULA pour ce réseau VPC.
2. Dans le champ Allouer une plage IPv6 interne, sélectionnez Automatiquement ou Manuellement. Si vous sélectionnez Manuellement, saisissez une plage /48 comprise dans la plage fd20::/20. Si la plage est déjà utilisée, vous êtes invité à en fournir une autre.
Dans le champ Mode de création de sous-réseau, sélectionnez Personnalisé.
Dans la section Nouveau sous-réseau, spécifiez les paramètres de configuration de sous-réseau suivants :
- Nom : lb-subnet-ipv6-only
- Région : us-west1
- Type de pile IP : IPv6 (pile unique)
- Type d'accès IPv6 : Interne.
Cliquez sur OK.
Cliquez sur Créer.

gcloud

Pour créer un réseau VPC en mode personnalisé, exécutez la commande gcloud compute networks create.

Pour configurer des plages IPv6 internes sur n'importe quel sous-réseau de ce réseau, utilisez l'option --enable-ula-internal-ipv6.
```
gcloud compute networks create lb-network-ipv6-only \
  --subnet-mode=custom \
  --enable-ula-internal-ipv6 \
  --bgp-routing-mode=regional
```
Configurez un sous-réseau avec le paramètre ipv6-access-type défini sur INTERNAL. Cela indique que les VM de ce sous-réseau ne peuvent avoir que des adresses IPv6 internes.Pour créer le sous-réseau, exécutez la commande gcloud compute networks subnets create.
```
gcloud compute networks subnets create lb-subnet-ipv6-only \
  --network=lb-network-ipv6-only \
  --region=us-west1 \
  --stack-type=IPV6_ONLY \
  --ipv6-access-type=INTERNAL
```

Configurer des règles de pare-feu

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

fw-allow-lb-access-ipv6-only : règle d'entrée, applicable à toutes les cibles du réseau VPC, autorisant le trafic provenant de toutes les sources IPv6.
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 VM auxquelles la règle doit s'appliquer.
fw-allow-health-check-ipv6-only : 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 (2600:2d00:1:b029::/64). Cet exemple utilise le tag cible allow-health-check-ipv6 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

Dans la console Google Cloud , accédez à la page Règles de pare-feu.

Accéder aux stratégies de pare-feu
Pour autoriser le trafic de sous-réseau IPv6, cliquez à nouveau sur Créer une règle de pare-feu, puis saisissez les informations suivantes :
- Nom : fw-allow-lb-access-ipv6-only
- Réseau : lb-network-ipv6-only
- Priorité : 1000
- Sens du trafic : entrée
- Action en cas de correspondance : autoriser
- Cibles : All instances in the network
- Filtre source : Plages IPv6
- Plages IPv6 sources : ::/0
- Protocoles et ports : tout autoriser
Cliquez sur Créer.
Pour autoriser les connexions SSH entrantes, cliquez à nouveau sur Créer une règle de pare-feu et saisissez les informations suivantes :
- Nom : fw-allow-ssh
- Réseau : lb-network-ipv6-only
- 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 : Plages IPv4
- Plages IPv4 sources : 0.0.0.0/0
- Protocoles et ports : sélectionnez Protocoles et ports spécifiés, cochez la case TCP, puis saisissez 22 dans Ports.
Cliquez sur Créer.
Pour autoriser les vérifications d'état IPv6 Google Cloud , cliquez à nouveau sur Créer une règle de pare-feu, puis saisissez les informations suivantes :
- Nom : fw-allow-health-check-ipv6-only
- Réseau : lb-network-ipv6-only
- Priorité : 1000
- Sens du trafic : entrée
- Action en cas de correspondance : autoriser
- Cibles : Tags cibles spécifiés
- Tags cibles : allow-health-check-ipv6
- Filtre source : Plages IPv6
- Plages IPv6 sources : 2600:2d00:1:b029::/64
- Protocoles et ports : tout autoriser
Cliquez sur Créer.

gcloud

Créez la règle de pare-feu fw-allow-lb-access-ipv6-only pour autoriser le trafic IPv6 vers toutes les instances de VM du réseau VPC.

gcloud compute firewall-rules create fw-allow-lb-access-ipv6-only \
    --network=lb-network-ipv6-only \
    --action=allow \
    --direction=ingress \
    --source-ranges=::/0 \
    --rules=all

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-ipv6-only \
    --action=allow \
    --direction=ingress \
    --target-tags=allow-ssh \
    --rules=tcp:22
```

Créez la règle fw-allow-health-check-ipv6 pour autoriser les vérifications d'état IPv6Google Cloud .

gcloud compute firewall-rules create fw-allow-health-check-ipv6-only \
    --network=lb-network-ipv6-only \
    --action=allow \
    --direction=ingress \
    --target-tags=allow-health-check-ipv6 \
    --source-ranges=2600:2d00:1:b029::/64 \
    --rules=tcp,udp

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

Cet exemple utilise deux groupes d'instances non gérés, chacun comportant deux VM de backend. Pour démontrer la nature régionale des équilibreurs de charge réseau passthrough internes, 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é.

Console

Créer des VM de backend

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

Accéder à la page Instances de VM
Répétez ces étapes pour chaque 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
Cliquez sur Créer une instance.
Définissez le Nom comme indiqué à l'étape 2.
Dans le champ Région, sélectionnez us-west1, puis choisissez une zone comme indiqué à l'étape 2.
Dans la section Disque de démarrage, assurez-vous que Debian GNU/Linux 12 (bookworm) est sélectionné pour les options du disque de démarrage. Si nécessaire, cliquez sur Modifier pour modifier l'image.
Cliquez sur Options avancées.
Cliquez sur Mise en réseau et configurez les champs suivants :
1. Pour Tags réseau, saisissez allow-ssh et allow-health-check-ipv6.
2. Pour Interfaces réseau, sélectionnez l'option suivante :
  - Réseau : lb-network-ipv6-only
  - Sous-réseau : lb-subnet-ipv6-only
  - Type de pile IP : IPv6 (pile unique)
  - Adresse IPv6 interne principale : Éphémère (automatique)
Cliquez sur Créer.

La VM de backend doit exécuter un serveur TCP IPv6 qui écoute les connexions entrantes. Vous installez ce serveur sur les VM de backend après avoir configuré l'équilibreur de charge. En effet, le script du serveur crée un socket qui se lie à la règle de transfert de l'équilibreur de charge.

Créer des groupes d'instances

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

Accéder à la page "Groupes d'instances"
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 :
- Nom du groupe d'instances : ig-a, zone : us-west1-a, VM : vm-a1 et vm-a2
- Nom du groupe d'instances : ig-c, zone : us-west1-c, VM : vm-c1 et vm-c2
Cliquez sur Créer un groupe d'instances.
Cliquez sur Nouveau groupe d'instances non géré.
Définissez le Nom comme indiqué à l'étape 2.
Dans la section Emplacement, sélectionnez us-west1 pour la région, puis choisissez une zone comme indiqué à l'étape 2.
Pour Réseau, sélectionnez lb-network-ipv6-only.
Pour Sous-réseau, sélectionnez lb-subnet-ipv6-only.
Dans la section Instances de VM, ajoutez les VM comme indiqué à l'étape 2.
Cliquez sur Créer.

gcloud

Pour créer les quatre VM, exécutez la commande gcloud compute instances create quatre fois, en utilisant ces quatre combinaisons pour [VM-NAME] et [ZONE].
- VM-NAME: vm-a1, ZONE: us-west1-a
- VM-NAME: vm-a2, ZONE: us-west1-a
- VM-NAME: vm-c1, ZONE: us-west1-c
- VM-NAME: vm-c2, ZONE: us-west1-c
```
gcloud beta compute instances create VM-NAME \
    --zone=ZONE \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --tags=allow-ssh,allow-health-check-ipv6 \
    --subnet=lb-subnet-ipv6-only \
    --stack-type=IPV6_ONLY
```
La VM de backend doit exécuter un serveur TCP IPv6 qui écoute les connexions entrantes. Vous installez ce serveur sur les VM de backend après avoir configuré l'équilibreur de charge. En effet, le script du serveur crée un socket qui se lie à la règle de transfert de l'équilibreur de charge.

Créez les deux groupes d'instances non gérés dans chaque zone :

gcloud beta compute instance-groups unmanaged create ig-a \
    --zone=us-west1-a
gcloud beta compute instance-groups unmanaged create ig-c \
    --zone=us-west1-c

Ajoutez les VM aux groupes d'instances appropriés :

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

Configurer les composants de l'équilibreur de charge

Console

Démarrer la configuration

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

Accéder à la page "Équilibrage de charge"
Cliquez sur Créer un équilibreur de charge.
Sous Type d'équilibreur de charge, sélectionnez Équilibreur de charge réseau (TCP/UDP/SSL), puis cliquez sur Suivant.
Pour Proxy ou passthrough, sélectionnez Équilibreur de charge passthrough, puis cliquez sur Suivant.
Pour Public ou interne, sélectionnez Interne, puis cliquez sur Suivant.
Cliquez sur Configurer.

Configuration de base

Sur la page Créer un équilibreur de charge réseau passthrough interne, saisissez les informations suivantes :

Nom de l'équilibreur de charge : ilb-ipv6-only
Région : us-west1
Réseau : lb-network-ipv6-only

Configuration du backend

Cliquez sur Configuration du backend.
Dans la section Nouveau backend de Backends, sélectionnez IPv6 (pile unique) sous type de pile IP.
Dans Groupe d'instances, sélectionnez le groupe d'instances ig-a, puis cliquez sur OK.
Cliquez sur Ajouter un backend et répétez cette étape pour ajouter ig-c.
Dans la liste Vérification d'état, sélectionnez Créer une vérification d'état, saisissez les informations suivantes, puis cliquez sur Enregistrer :
- Nom : hc-http-80.
- Champ d'application : Régional.
- Protocole : HTTP
- Port : 80.
- Proxy protocol : NONE.
- Chemin de requête : /.
Vérifiez qu'une coche bleue apparaît à côté de Configuration du backend.

Configuration de l'interface

Cliquez sur Configuration de l'interface. Dans la section Nouveaux IP et port frontend, procédez comme suit :
1. Dans le champ Nom, saisissez fr-ilb-ipv6-only.
2. Pour gérer le trafic IPv6, procédez comme suit :
  1. Pour Version IP, sélectionnez IPv6. Le serveur TCP IPv6 que vous allez créer dans la section suivante est associé à l'adresse IP virtuelle de la règle de transfert.
  2. Pour Sous-réseau, sélectionnez lb-subnet-ipv6-only. La plage d'adresses IPv6 de la règle de transfert est toujours éphémère.
  3. Pour Ports, sélectionnez Plusieurs, puis saisissez 80,8008,8080,8088 dans le champ Numéro de port.
  4. Cliquez sur OK.
3. Vérifiez qu'une coche bleue apparaît à côté de Configuration du frontend avant de continuer.

Vérifier la configuration

Cliquez sur Vérifier et finaliser. Vérifiez tous vos paramètres.
Si les paramètres sont corrects, cliquez sur Créer. La création de l'équilibreur de charge réseau passthrough interne prend quelques minutes.

gcloud

Créez une vérification d'état HTTP régionale pour tester la connectivité HTTP aux VM sur le port 80.
```
gcloud beta compute health-checks create http hc-http-80 \
    --region=us-west1 \
    --port=80
```

Créez le service de backend :

gcloud beta compute backend-services create ilb-ipv6-only \
    --load-balancing-scheme=INTERNAL \
    --protocol=tcp \
    --region=us-west1 \
    --health-checks=hc-http-80 \
    --health-checks-region=us-west1

Ajoutez les deux groupes d'instances au service de backend :

gcloud beta compute backend-services add-backend ilb-ipv6-only \
    --region=us-west1 \
    --instance-group=ig-a \
    --instance-group-zone=us-west1-a

gcloud beta compute backend-services add-backend ilb-ipv6-only \
    --region=us-west1 \
    --instance-group=ig-c \
    --instance-group-zone=us-west1-c

Créez la règle de transfert IPv6 avec une adresse IPv6 éphémère.

gcloud beta compute forwarding-rules create fr-ilb-ipv6-only \
    --region=us-west1 \
    --load-balancing-scheme=INTERNAL \
    --subnet=lb-subnet-ipv6-only \
    --ip-protocol=TCP \
    --ports=80,8008,8080,8088 \
    --backend-service=ilb-ipv6-only \
    --backend-service-region=us-west1 \
    --ip-version=IPV6

Le serveur TCP IPv6 que vous allez créer dans la section suivante est associé à l'adresse IP virtuelle de la règle de transfert.

Installer un serveur TCP IPv6 sur les VM de backend à l'aide d'un script de démarrage Bash

Dans cet exemple, le script de démarrage Bash pour les VM de backend contient les éléments suivants :

Commandes Mise en réseau permettant d'acheminer tous les paquets sortants provenant d'un sous-réseau via une passerelle et une interface réseau spécifiées.
Script de serveur Python (server.py), qui est un serveur TCP IPv6, qui écoute les connexions entrantes sur l'adresse IP virtuelle et l'interface réseau spécifiées. Il accepte les connexions client entrantes, envoie une réponse, puis ferme la connexion.

Vous devez ajouter les informations suivantes dans le script Bash :

Adresse de la passerelle
Plage de sous-réseaux
Adresse IP virtuelle de la règle de transfert
Interface réseau

Vous pouvez identifier l'adresse de la passerelle et la plage de sous-réseau en exécutant la commande ip -6 route show table all dans la VM de backend. Pour en savoir plus sur les commandes utilisées dans le script Bash de démarrage, consultez la section Annexe.

Pour ajouter un script de démarrage à l'instance de VM :

Console

Dans la liste des instances de VM que vous avez créées précédemment, cliquez sur celle que vous devez mettre à jour.
Cliquez sur Modifier.

Dans la section Métadonnées, saisissez le script suivant dans le champ Script de démarrage.

#!/bin/bash

# Replace these with your actual values. Run the 'ip -6 route show table all' command to find the correct values.
GATEWAY_ADDRESS=fe80::57:2ff:fe36:ffbe
SUBNET_RANGE=fd20:307:120c:2000::/64

# Add a custom default route to routing table 1.
# The following command sends packets to the gateway using the network interface named 'ens4'.
sudo ip route add default via $GATEWAY_ADDRESS dev ens4 table 1

# Add a source-based policy routing rule.
# The following command adds a rule to route all outgoing packets originating
# from a specified subnet. If the source address matches the subnet,
# the system uses the default route defined in table 1 to forward the traffic.
sudo ip -6 rule add from $SUBNET_RANGE table 1

# Allow the server to bind to a non-local IPv6 address--the VIP of the load balancer.
sudo sysctl -w net.ipv6.ip_nonlocal_bind=1

# Overview:
# This script sets up a simple IPv6 TCP server using Python's socket library.
# The server binds to a specific network interface and listens on a specified Virtual IP (VIP) address and port (default: 80).
# It accepts incoming client connections, sends a simple response ("Thank you for connecting"), and then closes the connection.
# Key features:
# - Uses IPv6 (AF_INET6) for networking.
# - Binds to a specific network interface using SO_BINDTODEVICE.
# - Handles multiple client connections in a loop.
# - Demonstrates basic socket programming concepts like binding, listening, accepting, and sending data.
# Note: Replace placeholders like 'FORWARDING_RULE_VIP' and 'ens4' with actual values for your setup.

# Write the Python file locally.
cat << 'EOF' > server.py

# Import the socket library to work with network connections
import socket
import urllib.request

# Fetch the VM hostname from Google Cloud metadata server
def get_vm_hostname():
    url = "http://metadata.google.internal/computeMetadata/v1/instance/name"
    req = urllib.request.Request(url, headers={"Metadata-Flavor": "Google"})
    with urllib.request.urlopen(req) as response:
        return response.read().decode()

vm_hostname = get_vm_hostname()

# Create a socket object for IPv6 and TCP connections
# AF_INET6 specifies IPv6, SOCK_STREAM specifies TCP
server_socket = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)

# Set the SO_REUSEADDR option to allow reusing the address
# This is useful to avoid "address already in use" errors when restarting the server
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

# Specify the network interface to bind the server to
# Replace "ens4" with the name of your network interface
interface_name = "ens4"
# Get the index of the network interface
interface_index = socket.if_nametoindex(interface_name)
# Bind the socket to the specified network interface
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_BINDTODEVICE, interface_name.encode())

# Bind the socket to an address and port
# Replace 'FORWARDING_RULE_VIP' with the actual VIP (Virtual IP) address
server_address = ('FORWARDING_RULE_VIP', 80, 0, 0)
server_socket.bind(server_address)

# Start listening for incoming connections
# The argument '5' specifies the maximum number of queued connections
server_socket.listen(5)

# Print a message indicating that the server is ready to accept connections
print(f"Server listening on {server_address}, bound to {interface_name}")

# Serve incoming connections
while True:
    client_socket, client_address = server_socket.accept()
    print(f"Accepted connection from {client_address}")

    # Generate response body
    body = f"Thank you for connecting to {vm_hostname}\n"

    # Construct a proper HTTP/1.1 response
    response = (
        "HTTP/1.1 200 OK\r\n"
        f"Content-Length: {len(body)}\r\n"
        "Content-Type: text/plain\r\n"
        "Connection: close\r\n"
        "\r\n"
        f"{body}"
    )

    # Send the response and close the connection
    client_socket.sendall(response.encode())
    client_socket.close()
EOF

# Make the Python script executable
chmod +x server.py

# Run the server
sudo python3 server.py

Cliquez sur Enregistrer.
Redémarrez l'instance.

gcloud

Créez un script de démarrage.
```
nano startup.sh
```

Ajoutez le script suivant et enregistrez le fichier.

#!/bin/bash

# Replace these with your actual values. Run the 'ip -6 route show table all' command to find the correct values.
GATEWAY_ADDRESS=fe80::57:2ff:fe36:ffbe
SUBNET_RANGE=fd20:307:120c:2000::/64

# Add a custom default route to routing table 1.
# The following command sends packets to the gateway using the network interface named 'ens4'.
sudo ip route add default via $GATEWAY_ADDRESS dev ens4 table 1

# Add a source-based policy routing rule.
# The following command adds a rule to route all outgoing packets originating
# from a specified subnet. If the source address matches the subnet,
# the system uses the default route defined in table 1 to forward the traffic.
sudo ip -6 rule add from $SUBNET_RANGE table 1

# Allow the server to bind to a non-local IPv6 address--the VIP of the load balancer.
sudo sysctl -w net.ipv6.ip_nonlocal_bind=1

# Overview:
# This script sets up a simple IPv6 TCP server using Python's socket library.
# The server binds to a specific network interface and listens on a specified Virtual IP (VIP) address and port (default: 80).
# It accepts incoming client connections, sends a simple response ("Thank you for connecting"), and then closes the connection.
# Key features:
# - Uses IPv6 (AF_INET6) for networking.
# - Binds to a specific network interface using SO_BINDTODEVICE.
# - Handles multiple client connections in a loop.
# - Demonstrates basic socket programming concepts like binding, listening, accepting, and sending data.
# Note: Replace placeholders like 'FORWARDING_RULE_VIP' and 'ens4' with actual values for your setup.

# Write the Python file locally.
cat << 'EOF' > server.py

# Import the socket library to work with network connections
import socket
import urllib.request

# Fetch the VM hostname from Google Cloud metadata server
def get_vm_hostname():
    url = "http://metadata.google.internal/computeMetadata/v1/instance/name"
    req = urllib.request.Request(url, headers={"Metadata-Flavor": "Google"})
    with urllib.request.urlopen(req) as response:
        return response.read().decode()

vm_hostname = get_vm_hostname()

# Create a socket object for IPv6 and TCP connections
# AF_INET6 specifies IPv6, SOCK_STREAM specifies TCP
server_socket = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)

# Set the SO_REUSEADDR option to allow reusing the address
# This is useful to avoid "address already in use" errors when restarting the server
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

# Specify the network interface to bind the server to
# Replace "ens4" with the name of your network interface
interface_name = "ens4"
# Get the index of the network interface
interface_index = socket.if_nametoindex(interface_name)
# Bind the socket to the specified network interface
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_BINDTODEVICE, interface_name.encode())

# Bind the socket to an address and port
# Replace 'FORWARDING_RULE_VIP' with the actual VIP (Virtual IP) address
server_address = ('FORWARDING_RULE_VIP', 80, 0, 0)
server_socket.bind(server_address)

# Start listening for incoming connections
# The argument '5' specifies the maximum number of queued connections
server_socket.listen(5)

# Print a message indicating that the server is ready to accept connections
print(f"Server listening on {server_address}, bound to {interface_name}")

# Serve incoming connections
while True:
    client_socket, client_address = server_socket.accept()
    print(f"Accepted connection from {client_address}")

    # Generate response body
    body = f"Thank you for connecting to {vm_hostname}\n"

    # Construct a proper HTTP/1.1 response
    response = (
        "HTTP/1.1 200 OK\r\n"
        f"Content-Length: {len(body)}\r\n"
        "Content-Type: text/plain\r\n"
        "Connection: close\r\n"
        "\r\n"
        f"{body}"
    )

    # Send the response and close the connection
    client_socket.sendall(response.encode())
    client_socket.close()
EOF

# Make the Python script executable
chmod +x server.py

# Run the server
sudo python3 server.py

Ajoutez le fichier de métadonnées à l'instance de VM.

gcloud compute instances add-metadata VM-NAME \
  --metadata-from-file=startup-script=startup.sh

Redémarrez l'instance.

Tester votre équilibreur de charge

Pour tester l'équilibreur de charge, créez une VM cliente dans la même région que l'équilibreur de charge, puis envoyez le trafic du client vers l'équilibreur de charge.

Créer une VM cliente

Console

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

Accéder à la page Instances de VM
Cliquez sur Créer une instance.
Dans le champ Nom, saisissez vm-client.
Pour Région, sélectionnez us-west1.
Pour Zone, sélectionnez us-west1-a.
Cliquez sur Options avancées.
Cliquez sur Mise en réseau et configurez les champs suivants :
1. Pour Tags réseau, saisissez allow-ssh.
2. Pour Interfaces réseau, sélectionnez l'option suivante :
  - Réseau : lb-network-ipv6-only
  - Sous-réseau : lb-subnet-ipv6-only
  - Type de pile IP : IPv6 (pile unique)
3. Cliquez sur OK.
Cliquez sur Créer.

gcloud

gcloud beta compute instances create vm-client \
    --zone=us-west1-a \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --stack-type=IPV6_ONLY \
    --tags=allow-ssh \
    --subnet=lb-subnet-ipv6-only

Tester la connexion

Connectez-vous à l'instance de VM cliente à l'aide de SSH.
```
gcloud compute ssh vm-client --zone=us-west1-a
```
Décrivez la règle de transfert IPv6 fr-ilb-ipv6-only. Notez l'élément IPV6_ADDRESS dans la description.
```
gcloud beta compute forwarding-rules describe fr-ilb-ipv6-only \
    --region=us-west1
```
À partir de clients disposant d'une connectivité IPv6, exécutez la commande suivante:
```
curl http://IPV6_ADDRESS:80
```
Par exemple, si l'adresse IPv6 attribuée est [fd20:307:120c:2000:0:1:0:0/96]:80, la commande doit se présenter comme suit :
```
curl http://[fd20:307:120c:2000:0:1:0:0]:80
```

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 réseau passthrough 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).

Équilibreur de charge réseau passthrough interne avec accès mondial. — Équilibreur de charge réseau passthrough 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

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

Accéder à la page "Équilibrage de charge"
Dans la colonne Nom, cliquez sur votre équilibreur de charge réseau passthrough interne. L'exemple d'équilibreur de charge est nommé be-ilb.
Cliquez sur Configuration du frontend.
Cliquez sur Modifier ().
Sous Accès mondial, sélectionnez Activer.
Cliquez sur OK.
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

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
```
Vous pouvez utiliser la commande forwarding-rules describe pour déterminer si l'accès mondial est activé pour une règle de transfert. Exemple :
```
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

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

Accéder à la page Instances de VM
Cliquez sur Créer une instance.
Définissez le paramètre Nom sur vm-client2.
Définissez le paramètre Région sur europe-west1.
Définissez le paramètre Zone sur europe-west1-b.
Cliquez sur Options avancées.
Cliquez sur Mise en réseau et configurez les champs suivants :
1. Pour Tags réseau, saisissez allow-ssh.
2. Pour Interfaces réseau, sélectionnez l'option suivante :
  - Réseau : lb-network
  - Sous-réseau : europe-subnet
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-12 \
    --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é

Pour tester la connectivité, exécutez la commande suivante :

  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 les équilibreurs de charge réseau passthrough internes.

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 des équilibreurs de charge réseau passthrough internes, 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 réseau passthrough interne afin qu'il utilise un groupe d'instances géré régional.

Console

Modèle d'instance

Dans la console Google Cloud , accédez à la page Modèles d'instances de VM.

Accéder à la page Modèles d'instance de VM
Cliquez sur Créer un modèle d'instance.
Dans le champ Nom, spécifiez template-vm-ilb.
Choisissez un type de machine.
Dans la section Disque de démarrage, assurez-vous que Debian GNU/Linux 12 (bookworm) est sélectionné pour les options du disque de démarrage. Si nécessaire, cliquez sur Modifier pour modifier l'image.
Cliquez sur Options avancées.
Cliquez sur Mise en réseau et configurez les champs suivants :
1. Pour Tags réseau, saisissez allow-ssh et allow-health-check.
2. Pour Interfaces réseau, sélectionnez l'option suivante :
  - Réseau : lb-network
  - Sous-réseau : lb-subnet

Cliquez sur Gestion, puis dans le champ Script de démarrage, saisissez le 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://metadata.google.internal/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

Cliquez sur Créer.

Groupe d'instances géré

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

Accéder à la page "Groupes d'instances"
Cliquez sur Créer un groupe d'instances.
Définissez le paramètre Nom sur ig-ilb.
Pour Emplacement, sélectionnez Multizone et définissez la région sur us-west1.
Définissez le Modèle d'instance sur template-vm-ilb.
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'équilibreur de charge réseau passthrough interne.
Définissez le nombre minimal d'instances sur 1 et le nombre maximal d'instances sur 6.
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 réseau passthrough interne. Dans cet exemple, utilisez hc-http-80.
Cliquez sur Créer.

gcloud

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-12 \
    --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://metadata.google.internal/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'

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

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

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 afin de pouvoir télécharger Apache via un script de démarrage. Étant donné que les VM backend ne sont utilisées que par un équilibreur de charge réseau passthrough 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

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

Accéder à la page Instances de VM
Répétez les étapes ci-dessous pour chaque VM de backend.
Cliquez sur le nom de la VM de backend, par exemple vm-a1.
Cliquez sur Modifier ().
Dans la section Interfaces réseau, cliquez sur le réseau.
Dans la liste Adresse IP externe, sélectionnez Aucune, puis cliquez sur Terminé.
Cliquez sur Enregistrer.

gcloud

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]"
```
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

Utiliser une adresse IP interne réservée

Lorsque vous créez des VM et des groupes d'instances de backend, l'instance de VM utilise une adresse IPv4 ou IPv6 interne éphémère.

Les étapes suivantes vous expliquent comment convertir une adresse IPv4 ou IPv6 interne en adresse IPv4 ou IPv6 interne statique, puis comment mettre à jour l'instance de VM pour utiliser l'adresse IP interne statique :

Les étapes suivantes vous montrent également comment réserver une nouvelle adresse IPv4 ou IPv6 interne statique, puis comment mettre à jour l'instance de VM pour utiliser l'adresse IP interne statique :

Réservez une nouvelle adresse IPv4 ou IPv6 interne statique.

Contrairement à la réservation IPv4 interne, la réservation IPv6 interne ne permet pas de réserver une adresse IP spécifique auprès du sous-réseau. À la place, une adresse IPv6 interne /96 est automatiquement allouée à partir de la plage d'adresses IPv6 interne /64 du sous-réseau.
Modifiez ou attribuez une adresse IPv6 interne à une instance existante.

Pour en savoir plus, consultez la section Réserver une adresse IP interne statique.

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 supprimer la règle de transfert actuelle de l'équilibreur de charge et en créer une qui accepte le trafic sur tous les ports.

Pour en savoir plus sur l'utilisation de cette configuration, consultez la section Équilibreurs de charge réseau passthrough internes et règles de transfert avec une adresse IP commune.

Console

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

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

Accéder à la page "Équilibrage de charge"
Cliquez sur l'équilibreur de charge be-ilb, puis sur Modifier.
Cliquez sur Configuration de l'interface.
Gardez le pointeur de la souris sur la règle de transfert 10.1.2.9, puis cliquez sur Supprimer.
Cliquez sur Ajouter une adresse IP et un port frontend.
Dans la section Nouveaux IP et port frontend, saisissez les informations suivantes, puis cliquez sur Terminé :
- Nom : fr-ilb
- Sous-réseau : lb-subnet
- Adresse IP interne : ip-ilb
- Ports : Tous
Vérifiez qu'une coche bleue apparaît à côté de Configuration de l'interface avant de continuer.
Cliquez sur Vérification et finalisation et vérifiez les paramètres de configuration de votre équilibreur de charge.
Cliquez sur Créer.

gcloud

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

gcloud compute forwarding-rules delete fr-ilb \
    --region=us-west1

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

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 section Équilibreurs de charge réseau passthrough internes et règles de transfert avec une adresse IP commune.

Console

Dans la console Google Cloud , accédez à la page Règles de transfert.

Accéder à la page Règles de transfert
Dans la colonne Nom, cliquez sur fr-ilb, puis sur Supprimer.
Dans la console Google Cloud , accédez à la page Équilibrage de charge.

Accéder à la page "Équilibrage de charge"
Dans la colonne Nom, cliquez sur be-ilb.
Cliquez sur Modifier.
Cliquez sur Frontend configuration (Configuration du frontend).
Cliquez sur Ajouter une adresse IP et un port frontend.
Dans la section Nouveaux IP et port frontend, procédez comme suit :
1. Dans le champ Nom, saisissez fr-ilb-http.
2. Pour Sous-réseau, sélectionnez lb-subnet.
3. Pour Objectif de l'adresse IP interne, sélectionnez Partagé.
4. Dans la liste Adresse IP, sélectionnez Créer une adresse IP, saisissez les informations suivantes, puis cliquez sur Réserver :
  - Nom : internal-10-1-2-99
  - Adresse IP statique : Laissez-moi choisir
  - Adresse IP personnalisée : 10.1.2.99
5. Pour Ports, sélectionnez Plusieurs, puis dans Numéros de ports, saisissez 80, 8008, 8080 et 8088.
6. Cliquez sur OK.
Cliquez sur Ajouter une adresse IP et un port frontend.
Dans la section Nouveaux IP et port frontend, procédez comme suit :
1. Dans le champ Nom, saisissez fr-ilb-https.
2. Pour Sous-réseau, sélectionnez lb-subnet.
3. Pour Objectif de l'adresse IP interne, sélectionnez Partagé.
4. Dans la liste Adresse IP, sélectionnez internal-10-1-2-99.
5. Pour Ports, sélectionnez Plusieurs, puis dans Numéros de ports, saisissez 443 et 8443.
6. Cliquez sur OK.
Cliquez sur Vérification et finalisation, et vérifiez les paramètres de configuration de l'équilibreur de charge.
Cliquez sur Mettre à jour.

gcloud

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

gcloud compute forwarding-rules delete fr-ilb \
    --region=us-west1

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 compute addresses create internal-10-1-2-99 \
    --region=us-west1 \
    --subnet=lb-subnet \
    --addresses=10.1.2.99 \
    --purpose=SHARED_LOADBALANCER_VIP

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 réseau passthrough 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.

Pour découvrir les types d'affinité de session compatibles, consultez la section Options d'affinité de session.

Console

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

Accéder à la page "Équilibrage de charge"
Cliquez sur be-ilb (nom du service de backend que vous avez créé pour cet exemple), puis cliquez sur Modifier.
Sur la page Modifier l'équilibreur de charge réseau passthrough interne, cliquez sur Configuration du backend.
Dans la liste Affinité de session, sélectionnez IP client.
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"
}

Configurer une règle de suivi des connexions

Cette section explique comment mettre à jour le service de backend afin de modifier la règle de suivi des connexions par défaut de l'équilibreur de charge.

Une règle de suivi des connexions inclut les paramètres suivants :

gcloud

Exécutez la commande gcloud compute backend-services suivante pour mettre à jour la règle de suivi des connexions pour le service de backend :

gcloud compute backend-services update BACKEND_SERVICE \
    --region=REGION \
    --tracking-mode=TRACKING_MODE \
    --connection-persistence-on-unhealthy-backends=CONNECTION_PERSISTENCE_BEHAVIOR \
    --idle-timeout-sec=IDLE_TIMEOUT_VALUE

Remplacez les espaces réservés par des valeurs valides :

BACKEND_SERVICE : le service de backend que vous mettez à jour
REGION : région du service de backend que vous mettez à jour
TRACKING_MODE : mode de suivi des connexions à utiliser pour les paquets entrants. Pour obtenir la liste des valeurs acceptées, consultez la section Mode de suivi.
CONNECTION_PERSISTENCE_BEHAVIOR : comportement de persistance des connexions lorsque les backends ne sont pas opérationnels. Pour obtenir la liste des valeurs acceptées, consultez la section Persistance des connexions sur les backends non opérationnels.
IDLE_TIMEOUT_VALUE : nombre de secondes pendant lesquelles une entrée de table de suivi des connexions doit être conservée après que l'équilibreur de charge a traité le dernier paquet correspondant à l'entrée.

Vous ne pouvez modifier cette propriété que lorsque le suivi des connexions est inférieur à cinq tuples (c'est-à-dire, lorsque l'affinité de session est configurée pour être CLIENT_IP ou CLIENT_IP_PROTO, et que le mode de suivi est PER_SESSION).

Le délai par défaut est 600 secondes (10 minutes). La valeur maximale du délai d'inactivité configurable est de 57 600 secondes (16 heures).

Utiliser l'affinité zonale

Cette section vous explique comment configurer un équilibreur de charge réseau passthrough interne pour activer l'affinité zonale sur le service de backend de l'équilibreur de charge. Par défaut, l'affinité zonale est désactivée. Pour en savoir plus, consultez Affinité de zone pour les équilibreurs de charge réseau passthrough internes.

Utilisez la commande suivante pour configurer l'option d'affinité zonale ZONAL_AFFINITY_STAY_WITHIN_ZONE. Pour en savoir plus sur le fonctionnement de cette option, consultez Fonctionnement de ZONAL_AFFINITY_STAY_WITHIN_ZONE.
```
gcloud beta compute backend-services update be-ilb \
    --zonal-affinity-spillover=ZONAL_AFFINITY_STAY_WITHIN_ZONE \
    --region=us-west1
```
Exécutez la commande suivante pour configurer l'affinité zonale ZONAL_AFFINITY_SPILL_CROSS_ZONE avec le ratio de débordement 0.0 par défaut. Pour en savoir plus sur le fonctionnement de cette option, consultez les sections Fonctionnement de ZONAL_AFFINITY_SPILL_CROSS_ZONE et du ratio de retombées et Ratio de retombées nul.
```
gcloud beta compute backend-services update be-ilb \
    --zonal-affinity-spillover=ZONAL_AFFINITY_SPILL_CROSS_ZONE \
    --region=us-west1
```
Exécutez la commande suivante pour configurer l'affinité zonale ZONAL_AFFINITY_SPILL_CROSS_ZONE avec un taux de débordement de 30 %. Pour en savoir plus sur le fonctionnement de cette option, consultez les sections Fonctionnement de ZONAL_AFFINITY_SPILL_CROSS_ZONE et du ratio de retombées et Ratio de retombées non nul.
```
gcloud beta compute backend-services update be-ilb \
    --zonal-affinity-spillover=ZONAL_AFFINITY_SPILL_CROSS_ZONE \
    --zonal-affinity-spillover-ratio=0.3 \
    --region=us-west1
```

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 réseau passthrough 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 réseau passthrough interne.

Console

Ajouter le deuxième sous-réseau

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

Accéder aux réseaux VPC
Cliquez sur Créer un réseau VPC.
Cliquez sur lb-network.
Dans la section Sous-réseaux, procédez comme suit :
1. Cliquez sur Ajouter un sous-réseau.
2. 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
3. Cliquez sur Ajouter.

Ajouter la deuxième règle de transfert

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

Accéder à la page "Équilibrage de charge"
Cliquez sur l'équilibreur de charge be-ilb, puis sur Modifier.
Cliquez sur Configuration de l'interface.
Cliquez sur Ajouter une adresse IP et un port frontend.
Dans la section Nouveaux IP et port frontend, définissez les champs suivants, puis cliquez sur Terminé :
- Nom : fr-ilb-2
- Version IP : IPv4
- Sous-réseau : second-subnet
- Adresse IP interne : ip-ilb
- Ports : 80 et 443
Vérifiez qu'une coche bleue apparaît à côté de Configuration de l'interface avant de continuer.
Cliquez sur Vérification et finalisation, et vérifiez les paramètres de configuration de l'équilibreur de charge.
Cliquez sur Créer.

gcloud

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

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

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.

Utiliser le sous-paramètre de backend

L'exemple de configuration crée un service de backend sans sous-paramètre.

Cette procédure vous montre comment activer le sous-paramètre sur le service de backend pour l'exemple d'équilibreur de charge réseau passthrough interne afin que le déploiement puisse évoluer vers un plus grand nombre d'instances backend.

Vous ne devez activer le sous-paramètre que si vous devez accepter plus de 250 VM de backend sur un seul équilibreur de charge.

Pour en savoir plus sur ce cas d'utilisation, consultez la section Sous-paramètre du backend.

gcloud

Utilisez la commande gcloud suivante pour mettre à jour le service de backend be-ilb, en spécifiant la règle de sous-paramètre :

gcloud compute backend-services update be-ilb \
    --subsetting-policy=CONSISTENT_HASH_SUBSETTING

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

{
"subsetting":
  {
    "policy": CONSISTENT_HASH_SUBSETTING
  }
}

Créer un équilibreur de charge pour la mise en miroir de paquets

La mise en miroir de paquets vous permet de copier et de collecter des données de paquets à partir d'instances spécifiques dans un VPC. Les données collectées peuvent vous permettre de détecter les menaces de sécurité et de surveiller les performances des applications.

La mise en miroir de paquets nécessite un équilibreur de charge réseau passthrough interne pour équilibrer le trafic vers un groupe d'instances de destinations de collecteur. Pour créer un équilibreur de charge réseau passthrough interne avec mise en miroir de paquets, procédez comme suit.

Console

Démarrer la configuration

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

Accéder à la page "Équilibrage de charge"
Cliquez sur Créer un équilibreur de charge.
Sous Type d'équilibreur de charge, sélectionnez Équilibreur de charge réseau (TCP/UDP/SSL), puis cliquez sur Suivant.
Pour Proxy ou passthrough, sélectionnez Équilibreur de charge passthrough, puis cliquez sur Suivant.
Pour Public ou interne, sélectionnez Interne, puis cliquez sur Suivant.
Cliquez sur Configurer.

Configuration de base

Dans le champ Nom de l'équilibreur de charge, saisissez un nom.
Dans le champ Région, sélectionnez la région des instances de VM dans lesquelles vous souhaitez mettre en miroir les paquets.
Pour Réseau, sélectionnez le réseau sur lequel vous souhaitez mettre en miroir les paquets.
Cliquez sur Configuration du backend.
Dans la section Nouveau backend, pour Groupe d'instances, sélectionnez le groupe d'instances vers lequel transférer les paquets.
Dans la liste Vérification d'état, sélectionnez Créer une vérification d'état, saisissez les informations suivantes, puis cliquez sur Enregistrer :
1. Dans le champ Nom, saisissez le nom de la vérification d'état.
2. Pour Protocole, sélectionnez HTTP.
3. Dans la section Port, saisissez 80.
Cliquez sur Configuration de l'interface.
Dans la section Nouveaux IP et port frontend, procédez comme suit :
1. Dans le champ Nom, saisissez un nom.
2. Pour le Sous-réseau, sélectionnez un sous-réseau situé dans la même région que les instances à mettre en miroir.
3. Pour Ports, sélectionnez Tous.
4. Cliquez sur Configurations avancées et cochez la case Activer cet équilibreur de charge pour la mise en miroir de paquets.
5. Cliquez sur OK.
Cliquez sur Créer.

gcloud

Créez une vérification d'état HTTP régionale pour tester la connectivité HTTP à un groupe d'instances sur le port 80:
```
gcloud compute health-checks create http HEALTH_CHECK_NAME \
    --region=REGION \
    --port=80
```
Remplacez les éléments suivants :
- HEALTH_CHECK_NAME : nom de la vérification d'état.
- REGION : région des instances de VM pour lesquelles vous souhaitez mettre en miroir les paquets.
Créez un service de backend pour le trafic HTTP:
```
gcloud compute backend-services create COLLECTOR_BACKEND_SERVICE \
    --region=REGION \
    --health-checks-region=REGION \
    --health-checks=HEALTH_CHECK_NAME \
    --load-balancing-scheme=internal \
    --protocol=tcp
```
Remplacez les éléments suivants :
- COLLECTOR_BACKEND_SERVICE : nom du service de backend.
- REGION : région des instances de VM dans lesquelles vous souhaitez mettre en miroir les paquets.
- HEALTH_CHECK_NAME : nom de la vérification d'état.
Ajoutez un groupe d'instances au service de backend:
```
gcloud compute backend-services add-backend COLLECTOR_BACKEND_SERVICE \
    --region=REGION \
    --instance-group=INSTANCE_GROUP \
    --instance-group-zone=ZONE
```
Remplacez les éléments suivants :
- COLLECTOR_BACKEND_SERVICE : nom du service de backend.
- REGION : région du groupe d'instances.
- INSTANCE_GROUP : nom du groupe d'instances.
- ZONE : zone du groupe d'instances.
Créez une règle de transfert pour le service de backend.
```
gcloud compute forwarding-rules create FORWARDING_RULE_NAME \
    --region=REGION \
    --network=NETWORK \
    --subnet=SUBNET \
    --backend-service=COLLECTOR_BACKEND_SERVICE \
    --load-balancing-scheme=internal \
    --ip-protocol=TCP \
    --ports=all \
    --is-mirroring-collector
```
Remplacez les éléments suivants :
- FORWARDING_RULE_NAME : nom de la règle de transfert.
- REGION : région de la règle de transfert.
- NETWORK : réseau pour la règle de transfert.
- SUBNET : sous-réseau dans la région des VM sur lesquelles vous souhaitez mettre en miroir les paquets.
- COLLECTOR_BACKEND_SERVICE : service de backend pour cet équilibreur de charge.

Remarque : Vous ne pouvez pas utiliser le protocole L3_DEFAULT dans votre règle de transfert pour configurer la mise en miroir de paquets.

Étapes suivantes

Pour connaître les principes de base importants, consultez la page Présentation de l'équilibreur de charge réseau passthrough interne.
Pour plus d'informations sur le basculement, consultez la page Concepts de basculement pour les équilibreurs de charge réseau passthrough internes.
Pour les options de noms DNS disponibles que votre équilibreur de charge peut utiliser, consultez la page Équilibrage de charge interne et noms DNS.
Pour obtenir les étapes de configuration, ainsi qu'un exemple de configuration de basculement d'équilibreur de charge réseau passthrough interne, consultez la page Configurer le basculement pour les équilibreurs de charge réseau passthrough internes.
Pour plus d'informations sur la configuration de la journalisation et de la surveillance pour les équilibreurs de charge réseau passthrough internes, consultez la page Journalisation et surveillance de l'équilibreur de charge réseau passthrough interne.
Pour en savoir plus sur l'accès aux équilibreurs de charge réseau passthrough internes à partir des réseaux pairs connectés à votre VPC, consultez la page Équilibreurs de charge réseau passthrough internes.
Pour plus d'informations sur la résolution des problèmes liés à votre équilibreur de charge réseau passthrough interne, consultez la page Résoudre les problèmes liés aux équilibreurs de charge réseau passthrough internes.
Nettoyez la configuration de l'équilibreur de charge.

Annexe : Introduction aux scripts Bash IPv6

Cette section fournit une brève description des différentes commandes réseau liées au script de démarrage Bash utilisé pour installer un serveur TCP IPv6 sur les VM de backend. Vous n'avez pas besoin de suivre à nouveau ces étapes. Elles ne sont présentées ici que pour fournir un contexte et faciliter la compréhension.

Affichez toutes les routes IPv6.

ip -6 route show table all

Voici le résultat :

fd20:307:120c:2000::/64 via fe80::57:2ff:fe36:ffbe dev ens4 proto ra metric 100 expires 62sec pref medium
fe80::/64 dev ens4 proto kernel metric 256 pref medium
default via fe80::57:2ff:fe36:ffbe dev ens4 proto ra metric 100 expires 62sec mtu 1460 pref medium
local ::1 dev lo table local proto kernel metric 0 pref medium
local fd20:307:120c:2000:0:b:: dev ens4 table local proto kernel metric 0 pref medium
local fe80::56:24ff:feb1:59b3 dev ens4 table local proto kernel metric 0 pref medium
multicast ff00::/8 dev ens4 table local proto kernel metric 256 pref medium

Dans le résultat de l'étape précédente, identifiez les éléments suivants :

Adresse IPv6 de liaison locale (commençant par fe80::/10) : dans l'exemple de résultat, l'adresse de liaison locale est fe80::57:2ff:fe36:ffbe. Cette adresse de liaison locale est utilisée dans la route par défaut définie dans la table de routage 1. Cette route par défaut est créée à l'étape 2.
Sous-réseau /64 : ce sous-réseau est référencé dans la règle de routage basée sur la source à l'étape 3.

Ajoutez une route par défaut personnalisée dans la table de routage 1.

La commande suivante envoie des paquets à la passerelle à l'aide de l'interface réseau nommée ens4.

sudo ip route add default via GATEWAY_ADDRESS dev ens4 table 1

Après avoir exécuté cette commande, une route par défaut est ajoutée à une table de routage personnalisée (table 1), pointant vers la passerelle fe80::57:2ff:fe36:ffbe via l'interface ens4.

Si vous exécutez à nouveau la commande ip -6 route show table all, le résultat est le suivant :

default via fe80::57:2ff:fe36:ffbe dev ens4 table 1 metric 1024 pref medium
fd20:307:120c:2000::/64 via fe80::57:2ff:fe36:ffbe dev ens4 proto ra metric 100 expires 89sec pref medium
fe80::/64 dev ens4 proto kernel metric 256 pref medium
default via fe80::57:2ff:fe36:ffbe dev ens4 proto ra metric 100 expires 89sec mtu 1460 pref medium
local ::1 dev lo table local proto kernel metric 0 pref medium
local fd20:307:120c:2000:0:1::/96 dev ens4 table local proto 66 metric 1024 pref medium
local fd20:307:120c:2000:0:b:: dev ens4 table local proto kernel metric 0 pref medium
local fe80::56:24ff:feb1:59b3 dev ens4 table local proto kernel metric 0 pref medium
multicast ff00::/8 dev ens4 table local proto kernel metric 256 pref medium

Ajoutez une règle de routage basé sur la source.

La commande suivante ajoute une règle pour acheminer tous les paquets sortants provenant d'un sous-réseau spécifié. Si l'adresse source correspond au sous-réseau, le système utilise la route par défaut définie dans le tableau 1 pour transférer le trafic.
```
sudo ip -6 rule add from SUBNET_RANGE table 1
```
Pour afficher la liste des règles de routage des stratégies, exécutez la commande suivante.
```
ip -6 rule show
```
Voici le résultat :
```
0:      from all lookup local
32765:  from fd20:307:120c:2000::/64 lookup 1
32766:  from all lookup main
```
La ligne avec from fd20:... lookup 1 correspond à la règle que vous avez ajoutée, qui indique au noyau d'utiliser la table de routage 1 pour le trafic provenant de ce sous-réseau.
Autorisez le serveur à se lier à une adresse IPv6 non locale, à savoir l'adresse IP virtuelle de l'équilibreur de charge.
```
sudo sysctl -w net.ipv6.ip_nonlocal_bind=1
```

Configurer un équilibreur de charge réseau passthrough interne avec des backends de groupe d'instances de VM Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Autorisations

Configurer un équilibreur de charge avec des sous-réseaux et des backends IPv4 uniquement

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

Console

gcloud

API

Configurer des règles de pare-feu

Console

gcloud

API

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

Console

gcloud

API

Configurer les composants de l'équilibreur de charge

Console

Démarrer la configuration

Configuration de base

Configurer les backends

Configurer l'interface

Vérifier la configuration

gcloud

API

Tester votre équilibreur de charge

Créer une VM cliente

Console

gcloud

API

Tester la connexion depuis la VM cliente

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

Envoyer des requêtes à partir de VM à équilibrage de charge

Configurer l'équilibreur de charge avec des sous-réseaux et des backends à double pile

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

Console

gcloud

API

Configurer des règles de pare-feu

Console

gcloud

API

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

Console

Créer des VM de backend

Créer des groupes d'instances

gcloud

api

Configurer les composants de l'équilibreur de charge

Console

Démarrer la configuration

Configuration de base

Configuration du backend

Configuration du frontend

Vérifier la configuration

gcloud

api

Tester votre équilibreur de charge

Créer une VM cliente

Console

gcloud

api

Tester la connexion

Configurer un équilibreur de charge avec des sous-réseaux et des backends IPv6 uniquement

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

Console

gcloud

Configurer des règles de pare-feu

Console

gcloud

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

Console

Créer des VM de backend

Créer des groupes d'instances

gcloud

Configurer les composants de l'équilibreur de charge

Console

Démarrer la configuration

Configuration de base

Configuration du backend

Configuration de l'interface

Configurer un équilibreur de charge réseau passthrough interne avec des backends de groupe d'instances de VM