Configurer un backend de groupe d'instances géré

Console

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

   Accéder aux réseaux VPC

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

3. Saisissez un Nom pour le réseau.

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

5. Dans la section Nouveau sous-réseau, configurez les champs suivants :

   1. Renseignez un Nom pour le sous-réseau.
   2. Sélectionnez une Région.
   3. Pour Type de pile IP, sélectionnez IPv4 (pile simple).
   4. Saisissez une plage d'adresses IP. Il s'agit de la plage d'adresses IPv4 principale du sous-réseau.

6. Cliquez sur OK.

7. Pour ajouter un sous-réseau dans une autre région, cliquez sur Ajouter un sous-réseau et répétez les étapes précédentes.

8. Cliquez sur Créer.

gcloud

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

   gcloud compute networks create NETWORK \
       --subnet-mode=custom
   

2. Dans le réseau, créez un sous-réseau pour les backends:

   gcloud compute networks subnets create SUBNET \
       --network=NETWORK \
       --stack-type=IPV4_ONLY \
       --range=10.1.2.0/24 \
       --region=REGION
   

   Remplacez les éléments suivants :

   • NETWORK : nom du réseau VPC.

   • SUBNET: nom du sous-réseau

   • REGION : nom de la région.

Console

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

1. Dans Google Cloud Console, accédez à la page Modèles d'instances.

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

2. Cliquez sur Create instance template (Créer un modèle d'instance).

3. Dans le champ Nom, saisissez lb-backend-template.

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

5. Développez les options avancées.

6. Développez Mise en réseau et configurez les champs suivants :

   1. Pour Tags réseau, saisissez allow-health-check.
   2. Dans la section Interfaces réseau, cliquez sur editModifier et apportez les modifications suivantes :
      • Réseau : NETWORK
      • Sous-réseau : SUBNET
      • Trafic IPv4 : IPv4 (pile unique)
   3. Cliquez sur OK.

7. Développez Gestion. Dans le champ Script de démarrage, saisissez le script suivant :

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

8. Cliquez sur Créer.

gcloud

Pour prendre en charge le trafic IPv4, exécutez la commande suivante :

gcloud compute instance-templates create TEMPLATE_NAME \
  --region=REGION \
  --network=NETWORK \
  --subnet=SUBNET \
  --stack-type=IPV4_ONLY \
  --tags=allow-health-check \
  --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
    systemctl restart apache2'

Terraform

Pour créer le modèle d'instance, utilisez la ressource google_compute_instance_template.

resource "google_compute_instance_template" "default" {
  name = "lb-backend-template"
  disk {
    auto_delete  = true
    boot         = true
    device_name  = "persistent-disk-0"
    mode         = "READ_WRITE"
    source_image = "projects/debian-cloud/global/images/family/debian-11"
    type         = "PERSISTENT"
  }
  labels = {
    managed-by-cnrm = "true"
  }
  machine_type = "n1-standard-1"
  metadata = {
    startup-script = "#! /bin/bash\n     sudo apt-get update\n     sudo apt-get install apache2 -y\n     sudo a2ensite default-ssl\n     sudo a2enmod ssl\n     vm_hostname=\"$(curl -H \"Metadata-Flavor:Google\" \\\n   http://169.254.169.254/computeMetadata/v1/instance/name)\"\n   sudo echo \"Page served from: $vm_hostname\" | \\\n   tee /var/www/html/index.html\n   sudo systemctl restart apache2"
  }
  network_interface {
    access_config {
      network_tier = "PREMIUM"
    }
    network    = "global/networks/default"
    subnetwork = "regions/us-east1/subnetworks/default"
  }
  region = "us-east1"
  scheduling {
    automatic_restart   = true
    on_host_maintenance = "MIGRATE"
    provisioning_model  = "STANDARD"
  }
  service_account {
    email  = "default"
    scopes = ["https://www.googleapis.com/auth/devstorage.read_only", "https://www.googleapis.com/auth/logging.write", "https://www.googleapis.com/auth/monitoring.write", "https://www.googleapis.com/auth/pubsub", "https://www.googleapis.com/auth/service.management.readonly", "https://www.googleapis.com/auth/servicecontrol", "https://www.googleapis.com/auth/trace.append"]
  }
  tags = ["allow-health-check"]
}

Console

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

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

2. Cliquez sur Créer un groupe d'instances.

3. Sur la gauche, sélectionnez Nouveau groupe d'instances géré (sans état).

4. Dans le champ Nom, saisissez lb-backend-example.

5. Pour l'emplacement, sélectionnez Zone unique.

6. Pour Région, sélectionnez la région de votre choix.

7. Pour Zone, sélectionnez une zone.

8. Dans la section Modèle d'instance, sélectionnez le modèle d'instance lb-backend-template.

9. Dans le champ Mode autoscaling, sélectionnez Activé : ajouter et supprimer des instances dans le groupe.

   Définissez le paramètre Nombre minimal d'instances sur 2 et le paramètre Nombre maximal d'instances sur 2 ou plus.

10. Pour créer le groupe d'instances, cliquez sur Créer.

gcloud

1. Créez un groupe d'instances géré basé sur ce modèle.

   gcloud compute instance-groups managed create lb-backend-example \
      --template=TEMPLATE_NAME --size=2 --zone=ZONE_A
   

Terraform

Pour créer le groupe d'instances géré, utilisez la ressource google_compute_instance_group_manager.

resource "google_compute_instance_group_manager" "default" {
  name = "lb-backend-example"
  zone = "us-east1-b"
  named_port {
    name = "http"
    port = 80
  }
  version {
    instance_template = google_compute_instance_template.default.id
    name              = "primary"
  }
  base_instance_name = "vm"
  target_size        = 2
}

Pour savoir comment appliquer ou supprimer une configuration Terraform, consultez la page Commandes Terraform de base.

Console

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

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

2. Cliquez sur lb-backend-example.

3. Sur la page Présentation du groupe d'instances, cliquez sur editModifier.

4. Dans la section Mappage de port, cliquez sur Ajouter un port.

   1. Pour le nom du port, saisissez http. Pour le numéro de port, saisissez 80.

5. Cliquez sur Enregistrer.

gcloud

Exécutez la commande gcloud compute instance-groups set-named-ports.

gcloud compute instance-groups set-named-ports lb-backend-example \
    --named-ports http:80 \
    --zone ZONE_A

Terraform

L'attribut named_port est inclus dans l'exemple de groupe d'instances géré.

Console

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

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

2. Cliquez sur Créer une règle de pare-feu pour créer la règle de pare-feu.

3. Dans le champ Nom, saisissez fw-allow-health-check.

4. Sélectionnez un réseau.

5. Sous Cibles, sélectionnez Tags cibles spécifiés.

6. Dans le champ Tags cibles, saisissez allow-health-check.

7. Définissez Filtre source sur Plages IPv4.

8. Définissez Plages IPv4 sources sur 130.211.0.0/22 et 35.191.0.0/16.

9. Dans Protocoles et ports, sélectionnez Protocoles et ports spécifiés.

10. Cochez la case TCP, puis saisissez 80 pour les numéros de port.

11. Cliquez sur Créer.

gcloud

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

Terraform

Pour créer la règle de pare-feu, utilisez la ressource google_compute_firewall.

resource "google_compute_firewall" "default" {
  name          = "fw-allow-health-check"
  direction     = "INGRESS"
  network       = "global/networks/default"
  priority      = 1000
  source_ranges = ["130.211.0.0/22", "35.191.0.0/16"]
  target_tags   = ["allow-health-check"]
  allow {
    ports    = ["80"]
    protocol = "tcp"
  }
}

Pour savoir comment appliquer ou supprimer une configuration Terraform, consultez la page Commandes Terraform de base.

Console

1. Dans Google Cloud Console, accédez à la page Adresses IP externes.

   Accéder à la page "Adresses IP externes"

2. Pour réserver une adresse IPv4, cliquez sur Réserver une adresse IP statique externe.

3. Dans le champ Nom, saisissez lb-ipv4-1.

4. Définissez Niveau de service réseau sur Premium.

5. Définissez Version IP sur IPv4.

6. Définissez Type sur Global.

7. Cliquez sur Réserver.

gcloud

gcloud compute addresses create lb-ipv4-1 \
    --ip-version=IPV4 \
    --network-tier=PREMIUM \
    --global

Notez l'adresse IPv4 réservée :

gcloud compute addresses describe lb-ipv4-1 \
    --format="get(address)" \
    --global

Terraform

Pour réserver l'adresse IP, utilisez la ressource google_compute_global_address.

resource "google_compute_global_address" "default" {
  name       = "lb-ipv4-1"
  ip_version = "IPV4"
}

Pour savoir comment appliquer ou supprimer une configuration Terraform, consultez la page Commandes Terraform de base.

Console

Démarrer la configuration

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

   Accéder à la page "Équilibrage de charge"

2. Cliquez sur Créer un équilibreur de charge.
3. Dans le champ Type d'équilibreur de charge, sélectionnez Équilibreur de charge d'application (HTTP/HTTPS), puis cliquez sur Suivant.
4. Pour Public ou interne, sélectionnez Public (externe), puis cliquez sur Suivant.
5. Pour Déploiement mondial ou dans une seule région, sélectionnez Recommandé pour les charges de travail à l'échelle mondiale, puis cliquez sur Suivant.
6. Pour Génération de l'équilibreur de charge, sélectionnez Équilibreur de charge d'application classique, puis cliquez sur Suivant.
7. Cliquez sur Configurer.

Configuration de base

Pour le champ Nom de l'équilibreur de charge, saisissez une valeur telle que web-map-https ou web-map-http.

Configuration de l'interface

1. Cliquez sur Configuration de l'interface.
2. Définissez Protocole sur HTTPS.
3. Sélectionnez IPv4 pour le trafic IPv4. Définissez Adresse IP sur lb-ipv4-1, que vous avez créé précédemment.
4. Définissez le paramètre Port sur 443.
5. Cliquez sur Certificat, puis sélectionnez votre certificat SSL principal.
6. Facultatif : créez une règle SSL :
   1. Dans la liste Règle SSL, sélectionnez Créer une règle.
   2. Nommez la règle SSL my-ssl-policy.
   3. Sous Version minimale de TLS, sélectionnez TLS 1.0.
   4. Dans le champ Profil, sélectionnez Moderne. Les Fonctionnalités activées et les Fonctionnalités désactivées s'affichent.
   5. Cliquez sur Enregistrer.
   Si vous n'avez pas créé de règles SSL, une règle SSL par défaut est appliquée.
7. Facultatif : cochez la case Activer la redirection HTTP vers HTTPS pour activer les redirections.

   Si vous cochez cette case, vous allez créer un équilibreur de charge HTTP partiel supplémentaire qui utilise la même adresse IP que votre équilibreur de charge HTTPS et qui redirige les requêtes HTTP entrantes vers l'interface HTTPS de votre équilibreur de charge.

   Cette case ne peut être cochée que lorsque le protocole HTTPS est sélectionné et qu'une adresse IP réservée est utilisée.

8. Cliquez sur OK.

Configuration du backend

1. Cliquez sur Configuration du backend.
2. Sous Créer ou sélectionner des services backend et des buckets backend, sélectionnez Services de backend > Créer un service de backend.
3. Ajoutez un nom pour votre service de backend (par exemple, web-backend-service).
4. Sous Protocole, sélectionnez HTTP.
5. Pour le port nommé, saisissez http.
6. Dans Backends > Nouveau backend > Groupe d'instances, sélectionnez le groupe d'instances lb-backend-example.
7. Pour le champ Numéros de ports, saisissez 80.
8. Conservez les autres paramètres par défaut.
9. Sous Vérification d'état, sélectionnez Créer une vérification d'état, puis attribuez-lui un nom, tel que http-basic-check.
10. Définissez le protocole sur HTTP, puis cliquez sur Enregistrer.

11. Facultatif : configurez une stratégie de sécurité backend par défaut. La stratégie de sécurité par défaut limite le trafic au-delà d'un seuil configuré par l'utilisateur. Pour en savoir plus sur les stratégies de sécurité par défaut, consultez la page Présentation de la limitation du débit.

    1. Pour désactiver la stratégie de sécurité par défaut de Google Cloud Armor, sélectionnez None dans le menu de la liste des stratégies de sécurité backend.
    2. Dans la section Sécurité, sélectionnez Stratégie de sécurité par défaut.
    3. Dans le champ Nom de la règle, acceptez le nom généré automatiquement ou saisissez un nom pour votre stratégie de sécurité.
    4. Dans le champ Nombre de requêtes, acceptez le nombre de requêtes par défaut ou saisissez un nombre entier compris entre 1 et 10,000.
    5. Dans le champ Intervalle, sélectionnez un intervalle.
    6. Dans le champ Appliquer à la clé, choisissez l'une des valeurs suivantes : Tous, Adresse IP ou Adresse IP X-Forwarded-For. Pour en savoir plus sur ces options, consultez la section Identifier les clients pour la limitation du débit.
12. Sélectionnez Activer Cloud CDN.
13. (Facultatif) Modifiez les paramètres du mode cache et de la TTL.
14. Conservez les autres paramètres par défaut.
15. Cliquez sur Créer.

Règles d'hôte et de chemin d'accès

Dans Règles d'hôte et de chemin d'accès, conservez les paramètres par défaut.

Vérifier et finaliser

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

gcloud

1. Créez une vérification d'état.

    gcloud compute health-checks create http http-basic-check \
        --port 80
    

2. Créez un service de backend.

   gcloud compute backend-services create web-backend-service \
       --load-balancing-scheme=EXTERNAL \
       --protocol=HTTP \
       --port-name=http \
       --health-checks=http-basic-check \
       --global
   

3. Ajoutez votre groupe d'instances en tant que backend au service de backend :

   gcloud beta compute backend-services add-backend web-backend-service \
     --instance-group=lb-backend-example \
     --instance-group-zone=ZONE_A \
     --global
   

4. Pour le protocole HTTP, créez un mappage d'URL pour acheminer les requêtes entrantes vers le service de backend par défaut.

   gcloud beta compute url-maps create web-map-http \
     --default-service web-backend-service
   

5. Pour le protocole HTTPS, créez un mappage d'URL pour acheminer les requêtes entrantes vers le service de backend par défaut.

   gcloud beta compute url-maps create web-map-https \
     --default-service web-backend-service
   

Configurer une interface HTTPS

Ignorez cette section pour les équilibreurs de charge HTTP.

1. Pour le protocole HTTPS, si vous ne l'avez pas déjà fait, créez la ressource de certificat SSL global, comme indiqué dans les sections suivantes :
• Créer une ressource de certificat SSL géré par Google
• Créer une ressource de certificat SSL autogéré

2. Pour le protocole HTTPS, créez un proxy HTTPS cible pour acheminer les requêtes vers votre mappage d'URL. Le proxy est la partie de l'équilibreur de charge qui contient le certificat SSL pour un équilibreur de charge HTTPS. Vous chargez donc également votre certificat à cette étape.

   gcloud compute target-https-proxies create https-lb-proxy \
     --url-map=web-map-https \
     --ssl-certificates=www-ssl-cert
   

3. Pour le protocole HTTPS, créez une règle de transfert globale pour acheminer les requêtes entrantes vers le proxy.

   gcloud compute forwarding-rules create https-content-rule \
     --load-balancing-scheme=EXTERNAL \
     --network-tier=PREMIUM \
     --address=lb-ipv4-1 \
     --global \
     --target-https-proxy=https-lb-proxy \
     --ports=443
   

4. Facultatif : pour HTTPS, créez une règle SSL globale et associez-la au proxy HTTPS.
   Pour créer une règle SSL globale :

   gcloud compute ssl-policies create my-ssl-policy \
     --profile MODERN \
     --min-tls-version 1.0
   

   Pour associer la règle SSL au proxy HTTPS cible mondial :

   gcloud compute target-https-proxies update https-lb-proxy \
     --ssl-policy my-ssl-policy
   

Configurer une interface HTTP

Ignorez cette section pour les équilibreurs de charge HTTPS.

1. Pour HTTP, créez un proxy HTTP cible qui va acheminer les requêtes vers votre mappage d'URL.

   gcloud compute target-http-proxies create http-lb-proxy \
     --url-map=web-map-http
   

2. Pour le protocole HTTP, créez une règle de transfert globale pour acheminer les requêtes entrantes vers le proxy.

   gcloud compute forwarding-rules create http-content-rule \
     --load-balancing-scheme=EXTERNAL \
     --address=lb-ipv4-1 \
     --global \
     --target-http-proxy=http-lb-proxy \
     --ports=80
   

Terraform

1. Pour créer la vérification d'état, utilisez la ressource google_compute_health_check.

   resource "google_compute_health_check" "default" {
     name               = "http-basic-check"
     check_interval_sec = 5
     healthy_threshold  = 2
     http_health_check {
       port               = 80
       port_specification = "USE_FIXED_PORT"
       proxy_header       = "NONE"
       request_path       = "/"
     }
     timeout_sec         = 5
     unhealthy_threshold = 2
   }

2. Pour créer le service de backend, utilisez la ressource google_compute_backend_service.

   Cet exemple utilise load_balancing_scheme="EXTERNAL_MANAGED", qui configure un équilibreur de charge d'application externe global avec une fonctionnalité de gestion avancée du trafic. Pour créer un équilibreur de charge d'application classique, veillez à remplacer load_balancing_scheme par EXTERNAL avant d'exécuter le script.

   resource "google_compute_backend_service" "default" {
     name                            = "web-backend-service"
     connection_draining_timeout_sec = 0
     health_checks                   = [google_compute_health_check.default.id]
     load_balancing_scheme           = "EXTERNAL_MANAGED"
     port_name                       = "http"
     protocol                        = "HTTP"
     session_affinity                = "NONE"
     timeout_sec                     = 30
     backend {
       group           = google_compute_instance_group_manager.default.instance_group
       balancing_mode  = "UTILIZATION"
       capacity_scaler = 1.0
     }
   }

3. Pour créer le mappage d'URL, utilisez la ressource google_compute_url_map.

   resource "google_compute_url_map" "default" {
     name            = "web-map-http"
     default_service = google_compute_backend_service.default.id
   }

4. Pour créer le proxy HTTP cible, utilisez la ressource google_compute_target_http_proxy.

   resource "google_compute_target_http_proxy" "default" {
     name    = "http-lb-proxy"
     url_map = google_compute_url_map.default.id
   }

5. Pour créer la règle de transfert, utilisez la ressource google_compute_global_forwarding_rule.

   Cet exemple utilise load_balancing_scheme="EXTERNAL_MANAGED", qui configure un équilibreur de charge d'application externe global avec une fonctionnalité de gestion avancée du trafic. Pour créer un équilibreur de charge d'application classique, veillez à remplacer load_balancing_scheme par EXTERNAL avant d'exécuter le script.

   resource "google_compute_global_forwarding_rule" "default" {
     name                  = "http-content-rule"
     ip_protocol           = "TCP"
     load_balancing_scheme = "EXTERNAL_MANAGED"
     port_range            = "80-80"
     target                = google_compute_target_http_proxy.default.id
     ip_address            = google_compute_global_address.default.id
   }

Pour savoir comment appliquer ou supprimer une configuration Terraform, consultez la page Commandes Terraform de base.

Console

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

   Accéder à la page "Équilibrage de charge"

2. Cliquez sur l'équilibreur de charge que vous venez de créer.

3. Dans la section Backend, vérifiez que les VM sont opérationnelles. La colonne Opérationnelles doit indiquer que les deux VM sont opérationnelles (2/2). Si ce n'est pas le cas, commencez par actualiser la page. Il peut s'écouler quelques instants avant que la console Google Cloud n'indique que les VM sont opérationnelles. Si les backends ne semblent toujours pas opérationnels au bout de quelques minutes, vérifiez la configuration du pare-feu et le tag réseau attribué à vos VM de backend.

4. Pour HTTPS, si vous utilisez un certificat géré par Google, vérifiez que l'état de votre ressource de certificat est ACTIVE. Pour plus d'informations, consultez la section État d'une ressource de certificat SSL géré par Google.
5. Une fois que la console Google Cloud indique que les instances backend sont opérationnelles, vous pouvez tester votre équilibreur de charge à l'aide d'un navigateur Web en accédant à https://IP_ADDRESS (ou http://IP_ADDRESS). Remplacez IP_ADDRESS par l'adresse IP de l'équilibreur de charge.
6. Si vous avez utilisé un certificat autosigné pour les tests HTTPS, votre navigateur affiche un avertissement. Vous devez explicitement lui indiquer d'accepter un certificat autosigné.
7. Votre navigateur doit afficher une page dont le contenu indique le nom de l'instance ayant diffusé la page, ainsi que sa zone (par exemple, Page served from: lb-backend-example-xxxx). Si ce n'est pas le cas, vérifiez les paramètres de configuration décrits dans ce guide.

gcloud

gcloud compute addresses describe lb-ipv4-1 \
   --format="get(address)" \
   --global

Au bout de quelques minutes, vous pouvez effectuer un test en exécutant la commande curl suivante.

curl http://IP_ADDRESS

-OU-

curl https://HOSTNAME

Console

Désactiver Cloud CDN pour un seul service de backend

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

   Accéder à Cloud CDN

2. Sur le côté droit de la ligne concernant l'origine, cliquez sur Menu more_vert, puis sélectionnez editModifier.

3. Décochez les cases des services de backend qui ne doivent plus utiliser Cloud CDN.

4. Cliquez sur Mettre à jour.

Supprimer Cloud CDN pour tous les services de backend d'une origine

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

   Accéder à Cloud CDN

2. Sur le côté droit de la ligne concernant l'origine, cliquez sur Menu more_vert, puis sélectionnez Supprimer.

3. Cliquez sur Supprimer pour confirmer votre choix.

gcloud

gcloud compute backend-services update BACKEND_SERVICE_NAME \
    --no-enable-cdn