Configurer un équilibreur de charge réseau passthrough interne avec des backends de groupes d'instances de VM pour plusieurs protocoles

Cette page fournit des instructions pour créer des équilibreurs de charge réseau passthrough internes afin d'équilibrer la charge du trafic de plusieurs protocoles.

Pour configurer un équilibreur de charge pour plusieurs protocoles, y compris TCP et UDP, vous devez créer une règle de transfert avec le protocole défini sur L3_DEFAULT. Cette règle de transfert pointe vers un service de backend dont le protocole est défini sur UNSPECIFIED.

Dans cet exemple, nous utilisons un équilibreur de charge réseau passthrough interne pour distribuer le trafic sur une VM de backend dans la région us-west1. L'équilibreur de charge dispose d'une règle de transfert avec le protocole L3_DEFAULT pour gérer les flux TCP, UDP, ICMP, ICMPv6, SCTP, ESP, AH et GRE.

Équilibrage de charge du trafic IPv4 et IPv6 en fonction des protocoles, avec des services de backend pour gérer la distribution des connexions vers un seul groupe d'instances zonal.
Équilibreur de charge réseau passthrough interne pour plusieurs protocoles (cliquez pour agrandir)

Avant de commencer

Autorisations

Pour obtenir les autorisations nécessaires pour suivre ce guide, demandez à votre administrateur de vous accorder les rôles IAM suivants sur le projet :

Pour en savoir plus sur l'attribution de rôles, consultez la section Gérer les accès.

Vous pouvez également obtenir les autorisations requises via des rôles personnalisés ou d'autres rôles prédéfinis.

Configurer l'équilibreur de charge pour le trafic L3_DEFAULT

Les étapes de cette section décrivent les configurations suivantes :

  • Exemple utilisant un réseau VPC en mode personnalisé nommé lb-network. Vous pouvez utiliser un réseau en mode automatique si vous souhaitez uniquement gérer le trafic IPv4. Cependant, le trafic IPv6 requiert un sous-réseau en mode personnalisé.
  • 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. Pour le trafic IPv6, nous demandons également un sous-réseau à double pile (stack-type défini sur IPv4_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.
  • Des règles de pare-feu autorisant les connexions entrantes aux VM de backend.
  • Le groupe d'instances backend et les composants de l'équilibreur de charge utilisés pour cet exemple sont situés dans cette région et ce sous-réseau :
    • Région : us-west1
    • Sous-réseau: lb-subnet, avec plage d'adresses IPv4 principale 10.1.2.0/24. Bien que vous choisissiez la plage d'adresses IPv4 configurée sur le sous-réseau, la plage d'adresses IPv6 est attribuée automatiquement. Google fournit un bloc CIDR IPv6 de taille fixe (/64).
  • Une VM de backend dans un groupe d'instances géré dans la zone us-west1-a.
  • Une VM cliente pour tester les connexions aux backends.
  • Un équilibreur de charge réseau passthrough interne avec les composants suivants :
    • Vérification d'état du service de backend
    • Un service de backend dans la région us-west1 avec le protocole défini sur UNSPECIFIED pour gérer la distribution des connexions vers le groupe d'instances zonal.
    • Une règle de transfert avec le protocole défini sur L3_DEFAULT et le port défini sur ALL.

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

Pour configurer des sous-réseaux avec des plages IPv6 internes, activez une plage IPv6 interne ULA du réseau cloud privé virtuel (VPC). Les plages de sous-réseaux IPv6 internes sont allouées à partir de cette plage. Pour créer le réseau et les sous-réseaux d'exemple, procédez comme suit :

Console

Pour assurer la compatibilité avec le trafic IPv4 et IPv6, procédez comme suit:

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

    Accéder aux réseaux VPC

  2. Cliquez sur Créer un réseau VPC.

  3. Dans le champ Nom, saisissez lb-network.

  4. 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 le champ Plage IPv6 interne ULA du réseau VPC, sélectionnez Activée.
    2. Dans le champ Allouer une plage IPv6 interne, sélectionnez Automatiquement ou Manuellement.

  5. Dans le champ Mode de création de sous-réseau, sélectionnez Personnalisé.

  6. Dans la section Nouveau sous-réseau, spécifiez les paramètres de configuration de sous-réseau suivants :

    1. Dans le champ Nom, saisissez lb-subnet.
    2. Pour Région, sélectionnez us-west1.
    3. Pour créer un sous-réseau à double pile, sélectionnez IPv4 et IPv6 (double pile) dans le champ Type de pile d'adresses IP.
    4. Dans Plage IPv4, saisissez 10.1.2.0/24.
    5. Dans le champ Type d'accès IPv6, sélectionnez Interne.

  7. Cliquez sur OK.

  8. Cliquez sur Créer.

Pour assurer la compatibilité avec le trafic IPv4, procédez comme suit :

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

    Accéder aux réseaux VPC

  2. Cliquez sur Créer un réseau VPC.

  3. Dans le champ Nom, saisissez lb-network.

  4. Dans la section Sous-réseaux :

    • Définissez Mode de création du sous-réseau sur Personnalisé.
    • Dans la section Nouveau sous-réseau, saisissez les informations suivantes :
      • Nom : lb-subnet
      • Région : us-west1
      • Type de pile IP : IPv4 (pile unique)
      • Plage d'adresses IP : 10.1.2.0/24
    • Cliquez sur OK.

  5. Cliquez sur Créer.

gcloud

Pour le trafic IPv4 et IPv6, utilisez les commandes suivantes :

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

    gcloud compute networks create lb-network \
 --subnet-mode=custom \
 --enable-ula-internal-ipv6

  2. Au sein de lb-network, créez un sous-réseau pour les backends dans la région us-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 \
 --range=10.1.2.0/24 \
 --region=us-west1 \
 --stack-type=IPV4_IPV6 --ipv6-access-type=INTERNAL

Pour le trafic IPv4 uniquement, utilisez les commandes suivantes :

  1. Pour créer un réseau VPC personnalisé, utilisez la gcloud compute networks createcommande :

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

  2. Pour créer le sous-réseau des backends dans la région us-west1 du réseau lb-network, utilisez la commande gcloud compute networks subnets create.

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

API

Pour le trafic IPv4 et IPv6, utilisez les commandes suivantes :

  1. Créez un réseau VPC en mode personnalisé. Envoyez une requête POST à la méthode networks.insert.

    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.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks
{
  "autoCreateSubnetworks": false,
  "name": "lb-network",
  "mtu": MTU,
  "enableUlaInternalIpv6": true,
}

    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.

  2. Envoyez une requête 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",
"name": "lb-subnet"
"stackType": IPV4_IPV6,
"ipv6AccessType": Internal
}

Pour le trafic IPv4 uniquement, suivez les étapes suivantes :

  1. Envoyez une requête POST à la méthode networks.insert. Remplacez PROJECT_ID par l'ID de votre projet Google Cloud.

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

  2. 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
}

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. Cette règle autorise le trafic entrant de n'importe quel client situé dans le sous-réseau.

  • 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 le sous-réseau.

  • 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

  1. Dans la console Google Cloud, accédez à la page Règles d'administration.

    Accéder à la page "Stratégies de pare-feu"

  2. Pour autoriser le trafic TCP, UDP et ICMP IPv4 à atteindre le groupe d'instances backend ig-a, procédez comme suit :

    • Cliquez sur Créer une règle de pare-feu.
    • Nom : fw-allow-lb-access
    • Réseau : lb-network
    • Priorité : 1000
    • Sens du trafic : entrée
    • Action en cas de correspondance : autoriser
    • Cibles : toutes les instances du réseau
    • Filtre source : plages IPv4
    • Plages IPv4 sources : 10.1.2.0/24
    • Protocoles et ports : sélectionnez Protocoles et ports spécifiés.
      • Sélectionnez TCP et saisissez ALL.
      • Sélectionnez UDP.
      • Sélectionnez Autre et saisissez ICMP.

  3. Cliquez sur Créer.

  4. Pour autoriser les connexions SSH entrantes :

    • Cliquez sur Créer une règle de pare-feu.
    • 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, puis saisissez tcp:22.

  5. Cliquez sur Créer.

  6. Pour autoriser le trafic TCP, UDP et ICMP IPv6 à atteindre le groupe d'instances backend ig-a, procédez comme suit :

    • Cliquez sur Créer une règle de pare-feu.
    • Nom : fw-allow-lb-access-ipv6
    • Réseau : lb-network
    • Priorité : 1000
    • Sens du trafic : entrée
    • Action en cas de correspondance : autoriser
    • Cibles : toutes les instances du réseau
    • Filtre source : Plages IPv6
    • Plages IPv6 sources : adresse IPV6_ADDRESS attribuée dans lb-subnet
    • Protocoles et ports : sélectionnez Protocoles et ports spécifiés.
      • Sélectionnez TCP et saisissez 0-65535.
      • Sélectionnez UDP.
      • SélectionnerAutre et pour le protocole ICMPv6, saisissez 58.

  7. Cliquez sur Créer.

  8. Pour autoriser les vérifications d'état IPv6 de Google Cloud, procédez comme suit :

    • Cliquez sur Créer une règle de pare-feu.
    • Nom : fw-allow-health-check-ipv6
    • 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-ipv6
    • Filtre source : Plages IPv6
    • Plages IPv6 sources : 2600:2d00:1:b029::/64
    • Protocoles et ports : tout autoriser

  9. Cliquez sur Créer.

  10. Pour autoriser les vérifications d'état IPv4 de Google Cloud, procédez comme suit :

    • Cliquez sur Créer une règle de pare-feu.
    • 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

  11. Cliquez sur Create (Créer).

gcloud

  1. Pour permettre au trafic TCP IPv4 d'atteindre le groupe d'instances backend ig-a, créez la règle suivante :

    gcloud compute firewall-rules create fw-allow-lb-access \
    --network=lb-network \
    --action=allow \
    --direction=ingress \
    --source-ranges=10.1.2.0/24 \
    --rules=tcp,udp,icmp

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

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

  3. Pour permettre au trafic IPv6 d'atteindre le groupe d'instances backend ig-a, créez la règle suivante :

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

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

  4. Créez la règle de pare-feu 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

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

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

API

  1. Pour créer la règle de pare-feu fw-allow-lb-access, envoyez une requête POST à la méthode firewalls.insert. Remplacez PROJECT_ID par l'ID de votre projet Google Cloud.

    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"
],
"allPorts": true,
"allowed": [
  {
    "IPProtocol": "tcp"
  },
  {
    "IPProtocol": "udp"
  },
  {
    "IPProtocol": "icmp"
  }
],
"direction": "INGRESS",
"logConfig": {
  "enable": false
},
"disabled": false
}

  2. 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",
 "priority": 1000,
 "sourceRanges": [
   "IPV6_ADDRESS"
 ],
 "allPorts": true,
 "allowed": [
   {
      "IPProtocol": "tcp"
    },
    {
      "IPProtocol": "udp"
    },
    {
      "IPProtocol": "58"
    }
 ],
 "direction": "INGRESS",
 "logConfig": {
    "enable": false
 },
 "disabled": false
}

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

  3. Pour créer la règle de pare-feu fw-allow-ssh, envoyez 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
}

  4. Pour créer la règle de pare-feu fw-allow-health-check, envoyez 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
}

  5. 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",
"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éer des VM de backend et des groupes d'instances

Dans ce scénario d'équilibrage de charge, vous allez créer un groupe d'instances géré zonal Compute Engine et installer un serveur Web Apache.

Pour gérer le trafic IPv4 et IPv6, configurez les VM backend en une pile double. Définissez le paramètre stack-type de la VM sur IPv4_IPv6. Les VM héritent également du paramètre ipv6-access-type (dans cet exemple, INTERNAL) du sous-réseau. Pour en savoir plus sur les exigences IPv6, consultez la page Présentation de l'équilibreur de charge réseau passthrough interne : règles de transfert.

Si vous souhaitez utiliser des VM existantes comme backends, mettez-les à jour en pile double en utilisant la commande gcloud compute instances network-interfaces update.

Les instances qui participent en tant que VM backend pour les équilibreurs de charge réseau passthrough internes doivent exécuter l'environnement invité Linux, l'environnement invité Windows ou d'autres processus appropriés présentant des fonctionnalités équivalentes.

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

Créer le groupe d'instances

Console

Pour assurer la compatibilité avec le trafic IPv4 et IPv6, procédez comme suit:

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

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

    1. Cliquez sur Create instance template (Créer un modèle d'instance).
    2. Dans le champ Nom, saisissez vm-a1.
    3. Assurez-vous que le disque de démarrage est défini sur une image Debian, telle que Debian GNU/Linux 10 (Buster). Ces instructions utilisent des commandes uniquement disponibles dans Debian, comme apt-get.
    4. Cliquez sur Mise en réseau, disques, sécurité, gestion, location unique.

    5. Cliquez sur Gestion et copiez le script suivant dans le champ Script de démarrage. Le script de démarrage configure également le serveur Apache pour qu'il écoute sur le port 8080 au lieu du port 80.

      #! /bin/bash
apt-get update
apt-get install apache2 -y
a2ensite default-ssl
a2enmod ssl
vm_hostname="$(curl -H "Metadata-Flavor:Google" \
http://metadata.google.internal/computeMetadata/v1/instance/name)"
echo "Page served from: $vm_hostname" | \
tee /var/www/html/index.html
sed -ire 's/^Listen 80$/Listen 8080/g' /etc/apache2/ports.conf
systemctl restart apache2

    6. Cliquez sur Mise en réseau.

      1. Pour Tags réseau, ajoutez allow-ssh et allow-health-check-ipv6.
      2. Pour Interfaces réseau, cliquez sur l'interface default et configurez les champs suivants :
        • Réseau : lb-network
        • Sous-réseau : lb-subnet
        • Type de pile d'adresses IP: IPv4 et IPv6 (double pile)

    7. Cliquez sur Créer.

Pour assurer la compatibilité avec le trafic IPv4, procédez comme suit :

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

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

    1. Cliquez sur Create instance template (Créer un modèle d'instance).
    2. Dans le champ Nom, saisissez vm-a1.
    3. Assurez-vous que le disque de démarrage est défini sur une image Debian, telle que Debian GNU/Linux 10 (Buster). Ces instructions utilisent des commandes uniquement disponibles dans Debian, comme apt-get.
    4. Cliquez sur Mise en réseau, disques, sécurité, gestion, location unique.

    5. Cliquez sur Gestion et copiez le script suivant dans le champ Script de démarrage. Le script de démarrage configure également le serveur Apache pour qu'il écoute sur le port 8080 au lieu du port 80.

      #! /bin/bash
apt-get update
apt-get install apache2 -y
a2ensite default-ssl
a2enmod ssl
vm_hostname="$(curl -H "Metadata-Flavor:Google" \
http://metadata.google.internal/computeMetadata/v1/instance/name)"
echo "Page served from: $vm_hostname" | \
tee /var/www/html/index.html
sed -ire 's/^Listen 80$/Listen 8080/g' /etc/apache2/ports.conf
systemctl restart apache2

    6. Cliquez sur Mise en réseau.

      1. Pour Tags réseau, ajoutez allow-ssh et allow-health-check.
      2. Pour Interfaces réseau, cliquez sur l'interface default et configurez les champs suivants :
        • Réseau : lb-network
        • Sous-réseau : lb-subnet
        • Type de pile IP : IPv4 (pile unique)

    7. Cliquez sur Créer.

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

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

    1. Cliquez sur Créer un groupe d'instances.
    2. Choisissez Nouveau groupe d'instances géré (sans état). Pour des informations plus détaillées, consultez la page Groupes d'instances gérés (MIG) sans état ou avec état.
    3. Dans le champ Nom, saisissez ig-a.
    4. Pour Emplacement, sélectionnez Zone unique.
    5. Pour la région, sélectionnez us-west1.
    6. Pour la zone, sélectionnez us-west1-a.
    7. Pour Modèle d'instance, sélectionnez vm-a1.

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

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

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

    9. Cliquez sur Créer.

gcloud

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

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

    Le script de démarrage configure également le serveur Apache pour qu'il écoute sur le port 8080 au lieu du port 80.

    Pour gérer le trafic IPv4 et IPv6, utilisez la commande suivante.

    gcloud compute instance-templates create vm-a1 \
    --region=us-west1 \
    --network=lb-network \
    --subnet=lb-subnet \
    --ipv6-network-tier=PREMIUM \
    --stack-type=IPv4_IPv6 \
    --tags=allow-ssh \
    --image-family=debian-10 \
    --image-project=debian-cloud \
    --metadata=startup-script='#! /bin/bash
      apt-get update
      apt-get install apache2 -y
      a2ensite default-ssl
      a2enmod ssl
      vm_hostname="$(curl -H "Metadata-Flavor:Google" \
      http://metadata.google.internal/computeMetadata/v1/instance/name)"
      echo "Page served from: $vm_hostname" | \
      tee /var/www/html/index.html
      sed -ire "s/^Listen 80$/Listen 8080/g" /etc/apache2/ports.conf
      systemctl restart apache2'

    Si vous souhaitez gérer le trafic IPv4 uniquement, utilisez la commande suivante.

    gcloud compute instance-templates create vm-a1 \
    --region=us-west1 \
    --network=lb-network \
    --subnet=lb-subnet \
    --tags=allow-ssh \
    --image-family=debian-10 \
    --image-project=debian-cloud \
    --metadata=startup-script='#! /bin/bash
      apt-get update
      apt-get install apache2 -y
      a2ensite default-ssl
      a2enmod ssl
      vm_hostname="$(curl -H "Metadata-Flavor:Google" \
      http://metadata.google.internal/computeMetadata/v1/instance/name)"
      echo "Page served from: $vm_hostname" | \
      tee /var/www/html/index.html
      sed -ire "s/^Listen 80$/Listen 8080/g" /etc/apache2/ports.conf
      systemctl restart apache2'

  2. Créez un groupe d'instances géré dans la zone à l'aide de la commande gcloud compute instance-groups managed create.

    gcloud compute instance-groups managed create ig-a \
    --zone us-west1-a \
    --size 2 \
    --template vm-a1

api

Pour gérer le trafic IPv4 et IPv6, suivez les étapes suivantes :

  1. Créez une VM en envoyant des requêtes POST à la méthode instances.insert :

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances
{
"name": "vm-a1",
"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",
   "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-a1",
   "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\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\nsed -ire "s/^Listen 80$/Listen 8080/g" /etc/\\napache2/ports.conf\nsystemctl restart apache2"
   }
 ]
},
"scheduling": {
 "preemptible": false
},
"deletionProtection": false
}

Pour gérer le trafic IPv4, procédez comme suit :

  1. Créez une VM en envoyant des requêtes POST à la méthode instances.insert :

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances
{
"name": "vm-a1",
"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": [
 {
   "stackType": "IPV4",
   "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-a1",
   "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\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\nsed -ire "s/^Listen 80$/Listen 8080/g" /etc/\\napache2/ports.conf\nsystemctl restart apache2"
   }
 ]
},
"scheduling": {
 "preemptible": false
},
"deletionProtection": false
}

  2. Créez un groupe d'instance 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"
}

  3. 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"
}
]
}

Créer une VM cliente

Cet exemple crée une VM cliente 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.

Pour le trafic IPv4 et IPv6 :

Console

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

    Accéder à la page "Instances de VM"

  2. Cliquez sur Créer une instance.

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

  4. Définissez le paramètre Zone sur us-west1-a.

  5. Cliquez sur Gestion, sécurité, disques, mise en réseau et location unique et apportez les modifications suivantes :

    • Cliquez sur Mise en réseau et ajoutez allow-ssh aux tags réseau.
    • Sous Interfaces réseau, cliquez sur Modifier, apportez les modifications suivantes, puis cliquez sur OK :
      • Réseau : lb-network
      • 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

  6. Cliquez sur Créer.

gcloud

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

gcloud compute instances create vm-client-ipv6 \
    --zone=us-west1-a \
    --image-family=debian-10 \
    --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-ipv6",
 "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",
     "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
}

Pour le trafic IPv4.

Console

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

    Accéder à la page "Instances de VM"

  2. Cliquez sur Créer une instance.

  3. Dans le champ Nom, saisissez vm-client.

  4. Dans le champ Zone, saisissez us-west1-a.

  5. Cliquez sur Options avancées.

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

  7. Cliquez sur Créer.

gcloud

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

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

API

Envoyez une requête POST à la méthode instances.insert. Remplacez PROJECT_ID par l'ID de votre projet Google Cloud.

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

Configurer les composants de l'équilibreur de charge

Créer un équilibreur de charge pour plusieurs protocoles

gcloud

  1. Créez une vérification d'état HTTP pour le port 80. Cette vérification d'état permet de vérifier l'état des backends dans le groupe d'instances ig-a.

    gcloud compute health-checks create http hc-http-80 \
    --region=us-west1 \
    --port=80

  2. Créez le service de backend avec le protocole défini sur UNSPECIFIED :

    gcloud compute backend-services create be-ilb-l3-default \
    --load-balancing-scheme=internal \
    --protocol=UNSPECIFIED \
    --region=us-west1 \
    --health-checks=hc-http-80 \
    --health-checks-region=us-west1

  3. Ajoutez le groupe d'instances backend au service de backend :

    gcloud compute backend-services add-backend be-ilb-l3-default \
    --region=us-west1 \
    --instance-group=ig-a \
    --instance-group-zone=us-west1-a

  4. Pour le trafic IPv6 : créez une règle de transfert en définissant le protocole sur L3_DEFAULT pour gérer tout le trafic IPv6 compatible. Tous les ports doivent être configurés avec des règles de transfert L3_DEFAULT.

    gcloud compute forwarding-rules create fr-ilb-ipv6 \
   --region=us-west1 \
   --load-balancing-scheme=internal \
   --subnet=lb-subnet \
   --ip-protocol=L3_DEFAULT \
   --ports=ALL \
   --backend-service=be-ilb-l3-default \
   --backend-service-region=us-west1 \
   --ip-version=IPV6

  5. Pour le trafic IPv4 : créez une règle de transfert en définissant le protocole sur L3_DEFAULT pour gérer tout le trafic IPv4 compatible. Tous les ports doivent être configurés avec des règles de transfert L3_DEFAULT. Utilisez 10.1.2.99 comme adresse IP interne.

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

API

  1. Créez la vérification d'état en envoyant une requête POST à la méthode regionHealthChecks.insert. Remplacez PROJECT_ID par l'ID de votre projet Google Cloud.

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

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

  2. 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-l3-default",
"backends": [
 {
   "group": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups/ig-a",
   "balancingMode": "CONNECTION"
 }
],
"healthChecks": [
 "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/healthChecks/hc-http-80"
],
"loadBalancingScheme": "INTERNAL",
"protocol": "UNSPECIFIED",
"connectionDraining": {
 "drainingTimeoutSec": 0
}
}

  3. Pour le trafic IPv6 : 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": "L3_DEFAULT",
"allPorts": true,
"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-l3-default",
"ipVersion": "IPV6",
"networkTier": "PREMIUM"
}

  4. Pour le trafic IPv4 : 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-l3-default",
"IPAddress": "10.1.2.99",
"IPProtocol": "L3_DEFAULT",
"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-l3-default",
"networkTier": "PREMIUM"
}

Tester votre équilibreur de charge

Les tests suivants montrent comment valider la configuration de votre équilibreur de charge et permettent d'en savoir plus sur son comportement attendu.

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

gcloud : IPv6

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

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

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

  3. À partir de clients disposant d'une connectivité IPv6, exécutez la commande suivante. Remplacez IPV6_ADDRESS par l'adresse IPv6 éphémère dans la règle de transfert fr-ilb-ipv6.

    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

gcloud : IPv4

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

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

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

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

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

    curl http://10.1.2.99

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

    curl http://10.1.2.99:80

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.

gcloud : IPv6

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

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

  2. Essayez de pinguer l'adresse IPv6 de l'équilibreur de charge. Remplacez IPV6_ADDRESS par l'adresse IPv6 éphémère dans la règle de transfert fr-ilb-ipv6.

    Notez que vous obtenez une réponse et que la commande ping fonctionne dans cet exemple.

    ping6 IPV6_ADDRESS

    Par exemple, si l'adresse IPv6 attribuée est [2001:db8:1:1:1:1:1:1/96], la commande est la suivante :

    ping6 2001:db8:1:1:1:1:1:1

    Le résultat ressemble à ce qui suit :

    @vm-client: ping IPV6_ADDRESS
PING IPV6_ADDRESS (IPV6_ADDRESS) 56(84) bytes of data.
64 bytes from IPV6_ADDRESS: icmp_seq=1 ttl=64 time=1.58 ms

gcloud : IPv4

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

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

  2. Essayez de pinguer l'adresse IPv4 de l'équilibreur de charge. Notez que vous obtenez une réponse et que la commande ping fonctionne dans cet exemple.

    ping 10.1.2.99

    Le résultat est le suivant :

    @vm-client: ping 10.1.2.99
PING 10.1.2.99 (10.1.2.99) 56(84) bytes of data.
64 bytes from 10.1.2.99: icmp_seq=1 ttl=64 time=1.58 ms
64 bytes from 10.1.2.99: icmp_seq=2 ttl=64 time=0.242 ms
64 bytes from 10.1.2.99: icmp_seq=3 ttl=64 time=0.295 ms

Options de configuration supplémentaires

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

Vous pouvez réserver une adresse IP interne statique pour votre exemple. Cette configuration permet à plusieurs règles de transfert internes d'utiliser la même adresse IP avec différents protocoles et ports. Les backends de votre exemple d'équilibreur de charge doivent toujours être situés dans une région us-west1.

Le diagramme suivant montre l'architecture de cet exemple.

Équilibrage de charge du trafic en fonction des protocoles, avec des services de backend pour gérer la distribution des connexions vers un seul groupe d'instances zonal.
Équilibreur de charge réseau passthrough interne pour plusieurs protocoles utilisant une adresse IP interne statique (cliquez pour agrandir).

Vous pouvez également envisager d'utiliser les configurations de règles de transfert suivantes :

  • Règles de transfert avec plusieurs ports :

    • Protocole TCP avec les ports 80,8080
    • Protocole L3_DEFAULT avec les ports ALL

  • Règles de transfert avec tous les ports :

    • Protocole TCP avec les ports ALL
    • Protocole L3_DEFAULT avec les ports ALL

Réserver une adresse IPv4 interne statique

Réservez une adresse IP interne statique pour 10.1.2.99 et définissez l'option --purpose sur SHARED_LOADBALANCER_VIP. L'option --purpose est obligatoire pour que de nombreuses règles de transfert puissent utiliser la même adresse IP interne.

gcloud

Exécutez la commande gcloud compute addresses create :

gcloud compute addresses create internal-lb-ipv4 \
    --region us-west1 \
    --subnet lb-subnet \
    --purpose SHARED_LOADBALANCER_VIP \
    --addresses 10.1.2.99

API

Appelez la méthode addresses.insert. Remplacez PROJECT_ID par l'ID de votre projet Google Cloud.

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

Le corps de la requête doit inclure le type d'adresse (addressType) avec la valeur INTERNAL, le nom de l'adresse (name) et le sous-réseau (subnetwork) auquel appartient l'adresse IP. Vous devez spécifier address en tant que 10.1.2.99.

{
  "addressType": "INTERNAL",
  "name": "internal-lb-ipv4",
  "subnetwork": "regions/us-west1/subnetworks/lb-subnet",
  "purpose": "SHARED_LOADBALANCER_VIP",
  "address": "10.1.2.99"
}

Configurer les composants de l'équilibreur de charge

Configurez trois équilibreurs de charge avec les composants suivants :

  • Le premier équilibreur de charge dispose d'une règle de transfert avec le protocole TCP et le port 80. Le trafic TCP arrivant à l'adresse IP interne sur le port 80 est géré par la règle de transfert TCP.
  • Le second équilibreur de charge possède une règle de transfert avec le protocole UDP et le port 53. Le trafic UDP arrivant à l'adresse IP interne sur le port 53 est géré par la règle de transfert UDP.
  • Le troisième équilibreur de charge dispose d'une règle de transfert avec le protocole L3_DEFAULT et le port ALL. Tout autre trafic qui ne correspond pas aux règles de transfert TCP ou UDP est géré par la règle de transfert L3_DEFAULT.
  • Les trois équilibreurs de charge partagent la même adresse IP interne statique (internal-lb-ipv4) dans leurs règles de transfert.

Créer le premier équilibreur de charge

Créez le premier équilibreur de charge pour le trafic TCP sur le port 80.

gcloud

  1. Créez le service de backend pour le trafic TCP :

    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

  2. Ajoutez le groupe d'instances backend 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

  3. Créez une règle de transfert pour le service de backend. Utilisez l'adresse IP interne réservée statique (internal-lb-ipv4) pour l'adresse IP interne.

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

API

  1. Créez le service de backend régional en envoyant une requête POST à la méthode regionBackendServices.insert. Remplacez PROJECT_ID par l'ID de votre projet Google Cloud.

    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"
 }
],
"healthChecks": [
 "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/healthChecks/hc-http-80"
],
"loadBalancingScheme": "INTERNAL",
"protocol": "TCP",
"connectionDraining": {
 "drainingTimeoutSec": 0
}
}

  2. Create the forwarding rule by making a POST request to the forwardingRules.insert method:

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

{
"name": "fr-ilb",
"IPAddress": "internal-lb-ipv4",
"IPProtocol": "TCP",
"ports": [
 "80"
],
"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"
}

Créer le deuxième équilibreur de charge

Créez le deuxième équilibreur de charge pour le trafic UDP sur le port 53.

gcloud

  1. Créez le service de backend avec le protocole défini sur UDP :

    gcloud compute backend-services create be-ilb-udp \
    --load-balancing-scheme=internal \
    --protocol=UDP \
    --region=us-west1 \
    --health-checks=hc-http-80 \
    --health-checks-region=us-west1

  2. Ajoutez le groupe d'instances backend au service de backend :

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

  3. Créez une règle de transfert pour le service de backend. Utilisez l'adresse IP interne réservée statique (internal-lb-ipv4) pour l'adresse IP interne.

    gcloud compute forwarding-rules create fr-ilb-udp \
    --region=us-west1 \
    --load-balancing-scheme=internal \
    --network=lb-network \
    --subnet=lb-subnet \
    --address=internal-lb-ipv4 \
    --ip-protocol=UDP \
    --ports=53 \
    --backend-service=be-ilb-udp \
    --backend-service-region=us-west1

API

  1. Créez le service de backend régional en envoyant une requête POST à la méthode regionBackendServices.insert. Remplacez PROJECT_ID par l'ID de votre projet Google Cloud.

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

  2. 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-udp",
"IPAddress": "internal-lb-ipv4",
"IPProtocol": "UDP",
"ports": [
 "53"
],
"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-udp",
"networkTier": "PREMIUM"
}

Créer le troisième équilibreur de charge

Créez la règle de transfert du troisième équilibreur de charge pour utiliser l'adresse IP interne réservée statique.

gcloud

Créez la règle de transfert en définissant le protocole sur L3_DEFAULT pour gérer tout le reste du trafic IPv4 compatible. Utilisez l'adresse IP interne réservée statique (internal-lb-ipv4) comme adresse IP interne.

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

API

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

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

{
"name": "fr-ilb-l3-default",
"IPAddress": "internal-lb-ipv4",
"IPProtocol": "L3_DEFAULT",
"ports": [
  "ALL"
],
"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-l3-default",
"networkTier": "PREMIUM"
}

Tester votre équilibreur de charge

Pour tester votre équilibreur de charge, suivez les étapes de la section précédente.

Étapes suivantes