Préparer la configuration de l'équilibrage de charge HTTP(S) interne

La configuration de l'équilibrage de charge HTTP(S) interne s'effectue en deux phases :

  • Effectuer des tâches préalables, comme s'assurer que les comptes requis disposent des autorisations adéquates et préparer le réseau VPC
  • Configurer les ressources de l'équilibreur de charge

Ce guide explique comment configurer les conditions préalables. Des guides supplémentaires expliquent comment configurer les ressources de l'équilibrage des charges.

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

Autorisations

Pour suivre ce guide, vous devez savoir comment créer des instances et modifier un réseau dans un projet. Vous devez être propriétaire ou éditeur du projet, ou disposer de tous les rôles IAM Compute Engine suivants :

Tâche Rôle requis
Créer des réseaux, des sous-réseaux et des composants de l'équilibreur de charge Administrateur réseau
Ajouter et supprimer des règles de pare-feu Administrateur de sécurité
Créer des instances Administrateur d'instances

Pour en savoir plus, consultez les guides suivants :

Vue d'ensemble de la configuration

Vous pouvez configurer l'équilibrage de charge HTTP(S) interne comme décrit dans le flux de configuration de haut niveau suivant. Les étapes numérotées font référence aux numéros du schéma.

Composants de l'équilibrage de charge HTTP(S) interne (cliquez pour agrandir)
Composants de l'équilibrage de charge HTTP(S) interne (cliquez pour agrandir)

Comme le montre le schéma, cet exemple crée un équilibreur de charge HTTP(S) interne dans un réseau VPC dans la région us-west1, avec un service de backend et deux groupes de backend.

Le schéma montre :

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

    1. Un sous-réseau est utilisé pour les backends (groupes d'instances et groupes de points de terminaison du réseau) et la règle de transfert. Sa plage d'adresses IP principale est 10.1.2.0/24.

    2. Un sous-réseau est un sous-réseau proxy uniquement dans la région us-west1. Vous devez créer un sous-réseau proxy réservé dans chaque région du réseau VPC dans lequel vous utilisez des équilibreurs de charge HTTP(S) internes. Le sous-réseau proxy réservé de la région est partagé entre tous les équilibreurs de charge HTTP(S) internes de la région. Les adresses sources des paquets envoyés depuis l'équilibreur de charge HTTP(S) interne vers les backends de votre service sont attribuées à partir du sous-réseau proxy réservé. Dans cet exemple, le sous-réseau proxy réservé de la région possède la plage d'adresses IP principale 10.129.0.0/26. Pour en savoir plus, consultez la page Sous-réseaux proxy réservés aux équilibreurs de charge HTTP(S) internes.

  2. Règles de pare-feu autorisant les flux de trafic souhaités dans votre réseau. Ces règles incluent l'ajout d'une règle autorisant les ports TCP 80, 443 et 8000 à partir de 10.129.0.0/26 (plage du sous-réseau proxy réservé dans cet exemple), ainsi qu'une autre règle pour les tests de vérification de l'état.

  3. Instances de backend. Cet exemple illustre les déploiements de backend suivants :

    1. VM Google Compute Engine
    2. Backends Google Kubernetes Engine (GKE) ajoutés aux groupes de points de terminaison du réseau (NEG)
  4. Groupes d'instances et NEG :

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

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

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

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

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

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

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

Configurer le réseau et les sous-réseaux

Vous avez besoin d'un réseau VPC avec deux sous-réseaux : l'un pour les backends de l'équilibreur de charge et l'autre pour les proxys de l'équilibreur de charge. Les équilibreurs de charge HTTP(S) internes sont régionaux. Le trafic au sein du réseau VPC est acheminé vers l'équilibreur de charge si la source du trafic se trouve dans un sous-réseau dans la même région que l'équilibreur de charge.

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

  • Réseau : le réseau est un réseau VPC en mode personnalisé nommé lb-network.

  • Sous-réseau pour les backends : un sous-réseau nommé backend-subnet dans la région us-west1 utilise 10.1.2.0/24 pour sa plage d'adresses IP principale.

  • Sous-réseau pour les proxys : un sous-réseau nommé proxy-only-subnet dans la région us-west1 utilise 10.129.0.0/26 pour sa plage d'adresses IP principale.

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

Console

  1. Accédez à la page "Réseaux VPC" dans Google Cloud Console.
    Accéder à la page "Réseaux VPC"
  2. Cliquez sur Créer un réseau VPC.
  3. 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 : backend-subnet
      • Région : us-west1
      • Plage d'adresses IP : 10.1.2.0/24
      • Cliquez sur OK.
  5. Cliquez sur Créer.

gcloud

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

        gcloud compute networks create lb-network --subnet-mode=custom
        
  2. Créez un sous-réseau dans le réseau lb-network de la région us-west1 avec la commande gcloud compute networks subnets create :

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

api

Envoyez une requête POST à la méthode networks.insert, en remplaçant [project-id] par l'ID de votre projet.

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

Envoyez une requête POST à la méthode subnetworks.insert, en remplaçant [project-id] par l'ID de votre projet.

POST https://www.googleapis.com/compute/v1/projects/[project-id]/regions/us-west1/subnetworks
    {
      "name": "backend-subnet",
      "network": "projects/[project-id]/global/networks/lb-network",
      "ipCidrRange": "10.1.2.0/24",
      "region": "projects/[project-id]/regions/us-west1",
    }
    

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

Le sous-réseau proxy réservé est destiné à tous les équilibreurs de charge HTTP(S) internes de la région us-west1.

console

Si vous utilisez la console GCP, vous pouvez créer le sous-réseau proxy réservé ultérieurement dans l'interface utilisateur de l'équilibrage de charge. Consultez la section Poursuivre le processus de configuration.

gcloud

Créez le sous-réseau proxy réservé à l'aide de la commande gcloud compute networks subnets create.

    gcloud compute networks subnets create proxy-only-subnet \
      --purpose=INTERNAL_HTTPS_LOAD_BALANCER \
      --role=ACTIVE \
      --region=us-west1 \
      --network=lb-network \
      --range=10.129.0.0/26
    

api

Créez un sous-réseau proxy réservé avec la méthode subnetworks.insert, en remplaçant [project-id] par l'ID de votre projet.

POST https://www.googleapis.com/compute/projects/[project-id]/regions/us-west1/subnetworks
    {
      "name": "proxy-only-subnet",
      "ipCidrRange": "10.129.0.0/26",
      "network": "projects/[project-id]/global/networks/lb-network",
      "region": "projects/[project-id]/regions/us-west1",
      "purpose": "INTERNAL_HTTPS_LOAD_BALANCER",
      "role": "ACTIVE"
    }
    

Configurer les règles de pare-feu

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

  • fw-allow-backend-subnet : règle d'entrée applicable à toutes les cibles du réseau VPC, autorisant l'ensemble du trafic TCP, UDP et ICMP provenant de sources dans la plage 10.1.2.0/24. Cette règle autorise le trafic entrant depuis n'importe quelle source du sous-réseau backend-subnet vers les instances (VM) faisant l'objet d'un équilibrage de charge. L'exemple montre la règle de pare-feu qui s'applique à toutes les instances du réseau. Vous pouvez également appliquer la règle uniquement aux backends de l'équilibreur de charge.

  • 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 de pare-feu s'applique.

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

  • fw-allow-proxies : règle d'entrée applicable aux instances faisant l'objet d'un équilibrage de charge, qui autorise le trafic TCP sur les ports 80, 443, 8000 et partir des proxys gérés de l'équilibreur de charge HTTP(S) interne. Cet exemple utilise le tag cible load-balanced-backend pour identifier les instances auxquelles il doit s'appliquer.

Sans ces règles de pare-feu, la règle d'entrée interdite par défaut bloque le trafic entrant vers les instances backend.

Console

  1. Accédez à la page "Règles de pare-feu" de Google Cloud Console.
    Accéder à la page "Règles de pare-feu"
  2. Cliquez sur Créer une règle de pare-feu et saisissez les informations suivantes pour créer la règle permettant d'autoriser le trafic de sous-réseau :
    • Nom : fw-allow-backend-subnet
    • Réseau : lb-network
    • Sens du trafic : entrée
    • Action en cas de correspondance : autoriser
    • Cibles : toutes les instances du réseau
    • Filtre source : IP ranges
    • Plages d'adresses IP sources : 10.1.2.0/24
    • Protocoles et ports :
      • Choisissez Protocoles et ports spécifiés.
      • Vérifiez tcp et udp.
      • Sous Autres protocoles, saisissez icmp.
  3. Cliquez sur Créer.
  4. Cliquez de nouveau sur Créer une règle de pare-feu pour créer la règle autorisant les connexions SSH entrantes :
    • Nom : fw-allow-ssh
    • Réseau : lb-network
    • Sens du trafic : entrée
    • Action en cas de correspondance : autoriser
    • Cibles : tags cibles spécifiés
    • Tags cibles : allow-ssh
    • Filtre source : IP ranges
    • Plages d'adresses IP sources : 0.0.0.0/0
    • Protocoles et ports :
      • Choisissez Protocoles et ports spécifiés.
      • Vérifiez tcp et saisissez 22 pour le numéro de port.
  5. Cliquez sur Créer.
  6. Cliquez une troisième fois sur Créer une règle de pare-feu pour créer la règle autorisant les vérifications d'état Google Cloud :
    • Nom : fw-allow-health-check
    • Réseau : lb-network
    • Sens du trafic : entrée
    • Action en cas de correspondance : autoriser
    • Cibles : tags cibles spécifiés
    • Tags cibles : load-balanced-backend
    • Filtre source : IP ranges
    • Plages d'adresses IP sources : 130.211.0.0/22 et 35.191.0.0/16
    • Protocoles et ports :
      • Choisissez Protocoles et ports spécifiés.
      • Vérifiez tcp et saisissez 80.
        Nous vous recommandons de limiter cette règle aux seuls protocoles et ports qui correspondent à ceux utilisés par votre vérification de l'état. Si vous utilisez tcp:80 pour le protocole et le port, Google Cloud peut contacter vos VM via HTTP sur le port 80, mais pas via HTTPS sur le port 443.
  7. Cliquez sur Créer.
  8. Cliquez une quatrième fois sur Créer la règle de pare-feu pour créer la règle permettant aux serveurs proxy de l'équilibreur de charge de connecter les backends :
    • Nom : fw-allow-proxies
    • Réseau : lb-network
    • Sens du trafic : entrée
    • Action en cas de correspondance : autoriser
    • Cibles : tags cibles spécifiés
    • Tags cibles : load-balanced-backend
    • Filtre source : IP ranges
    • Plages d'adresses IP sources : 10.129.0.0/26
    • Protocoles et ports :
      • Choisissez Protocoles et ports spécifiés.
      • Vérifiez tcp et saisissez 80, 443, 8000 pour les numéros de port.
  9. Cliquez sur Créer.

gcloud

  1. Créez la règle de pare-feu fw-allow-backend-subnet pour autoriser les communications à partir du sous-réseau avec la commande gcloud compute firewall-rules create.

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

        gcloud compute firewall-rules create fw-allow-ssh \
            --network=lb-network \
            --action=allow \
            --direction=ingress \
            --target-tags=allow-ssh \
            --rules=tcp:22
        
  3. Créez la règle fw-allow-health-check pour autoriser les vérifications d'état Google Cloud. Cet exemple autorise tout le trafic TCP provenant des tests de vérification d'état. Toutefois, vous pouvez configurer un ensemble de ports plus restreint en fonction de vos besoins.

        gcloud compute firewall-rules create fw-allow-health-check \
            --network=lb-network \
            --action=allow \
            --direction=ingress \
            --source-ranges=130.211.0.0/22,35.191.0.0/16 \
            --target-tags=load-balanced-backend \
            --rules=tcp
        
  4. Créez la règle fw-allow-proxies pour autoriser les proxys de l'équilibreur de charge HTTP(S) interne à se connecter à vos backends.

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

api

Créez la règle de pare-feu fw-allow-backend-subnet en effectuant une requête POST à la méthode firewalls.insert, en remplaçant [project-id] par l'ID de votre projet.

POST https://www.googleapis.com/compute/v1/projects/[project-id]/global/firewalls
    {
      "name": "fw-allow-backend-subnet",
      "network": "projects/[project-id]/global/networks/lb-network",
      "sourceRanges": [
        "10.1.2.0/24"
      ],
      "allowed": [
        {
          "IPProtocol": "tcp"
        },
        {
          "IPProtocol": "udp"
        },
        {
          "IPProtocol": "icmp"
        }
      ],
      "direction": "INGRESS"
    }
    

Créez la règle de pare-feu fw-allow-ssh en effectuant une requête POST à la méthode firewalls.insert, en remplaçant [project-id] par l'ID de votre projet.

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

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

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

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

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

Poursuivre le processus de configuration

Pour configurer l'équilibrage de charge HTTP(S) interne, appliquez l'une des procédures suivantes, selon que vos services de backend sont exécutés sur des VM Compute Engine ou GKE :

Étapes suivantes