Un VM à équilibrage de charge est un script de création d'infrastructure qui configure un cluster de VM et un équilibreur de charge pour exposer une route publique aux VM:
- Calcul – VM – Compute Engine
- Calcul – Cluster – Groupe d'instances géré
- Calcul – Modèle de machine – Modèle d'instance
- Mise en réseau – Équilibrage de charge – Équilibreur de charge cloud
Cet exemple d'application configure un simple site HTML statique à l'aide de NGINX et équilibre la charge sur votre cluster.
Commencer
Cliquez sur le lien suivant pour copier le code source dans Cloud Shell. Une seule commande permet alors de lancer une copie de travail de l'application dans votre projet.
Afficher le code source sur GitHub
Composants VM à équilibrage de charge
L'architecture de VM à équilibrage de charge utilise plusieurs produits. Vous trouverez ci-dessous la liste des composants, ainsi que des informations supplémentaires et des liens vers des vidéos associées, de la documentation produit et des tutoriels interactifs.
Scripts
Le script d'installation utilise un exécutable écrit dans go et les outils de la CLI Terraform pour prendre un projet vide et y installer l'application. Le résultat doit correspondre à une application fonctionnelle et à une URL pour l'adresse IP de l'équilibrage de charge.
./main.tf
Activer les services
Les services Google Cloud sont désactivés par défaut dans les projets. Activez les services requis suivants:
- Compute Engine : Machines virtuelles et services réseau (tels que l'équilibreur de charge)
variable "gcp_service_list" {
description = "The list of apis necessary for the project"
type = list(string)
default = [
"compute.googleapis.com",
]
}
resource "google_project_service" "all" {
for_each = toset(var.gcp_service_list)
project = var.project_number
service = each.key
disable_dependent_services = false
disable_on_destroy = false
}
Créer un exemple d'instance sur lequel baser les VM gérées
La commande suivante crée une VM, y installe le logiciel requis et déploie le code.
resource "google_compute_instance" "exemplar" {
name = "${var.basename}-exemplar"
machine_type = "n1-standard-1"
zone = var.zone
project = var.project_id
tags = ["http-server"]
metadata_startup_script = "apt-get update -y \n apt-get install nginx -y \n printf '${data.local_file.index.content}' | tee /var/www/html/index.html \n chgrp root /var/www/html/index.html \n chown root /var/www/html/index.html \n chmod +r /var/www/html/index.html"
boot_disk {
auto_delete = true
device_name = "${var.basename}-exemplar"
initialize_params {
image = "family/debian-10"
size = 200
type = "pd-standard"
}
}
network_interface {
network = "default"
access_config {
// Ephemeral public IP
}
}
depends_on = [google_project_service.all]
}
Créer un instantané et une image disque
La commande suivante utilise la VM pour créer un instantané. L'instantané est ensuite utilisé pour créer une image disque. Toutes les VM du cluster sont basées sur cette image.
resource "google_compute_snapshot" "snapshot" {
project = var.project_id
name = "${var.basename}-snapshot"
source_disk = google_compute_instance.exemplar.boot_disk[0].source
zone = var.zone
storage_locations = ["${var.region}"]
depends_on = [time_sleep.startup_completion]
}
resource "google_compute_image" "exemplar" {
project = var.project_id
name = "${var.basename}-latest"
family = var.basename
source_snapshot = google_compute_snapshot.snapshot.self_link
depends_on = [google_compute_snapshot.snapshot]
}
Créer un modèle d'instance
La commande suivante crée un modèle avec les paramètres et la configuration de toutes les VM du cluster. Il utilise l'image disque créée lors de la commande précédente.
La commande inclut un script de démarrage qui personnalise le code HTML diffusé par les VM du cluster.
resource "google_compute_instance_template" "default" {
project = var.project_id
name = "${var.basename}-template"
description = "This template is used to create app server instances."
tags = ["httpserver"]
metadata_startup_script = "sed -i.bak \"s/\{\{NODENAME\}\}/$HOSTNAME/\" /var/www/html/index.html"
instance_description = "BasicLB node"
machine_type = "n1-standard-1"
can_ip_forward = false
// Create a new boot disk from an image
disk {
source_image = google_compute_image.exemplar.self_link
auto_delete = true
boot = true
}
network_interface {
network = "default"
}
depends_on = [google_compute_image.exemplar]
}
Créer un groupe d'instances géré
Demande le nombre N de machines du modèle d'instance à gérer dans ce groupe.
resource "google_compute_instance_group_manager" "default" {
project = var.project_id
name = "${var.basename}-mig"
zone = var.zone
target_size = var.nodes
base_instance_name = "${var.basename}-mig"
version {
instance_template = google_compute_instance_template.default.id
}
named_port {
name = "http"
port = "80"
}
depends_on = [google_compute_instance_template.default]
}
Créer une adresse IP externe
Nécessaire pour lier un hôte au nom de domaine et communiquer en général sur Internet.
resource "google_compute_global_address" "default" {
project = var.project_id
name = "${var.basename}-ip"
ip_version = "IPV4"
}
Créer un équilibreur de charge
La commande suivante crée un équilibreur de charge et implémente des vérifications d'état et des services de backend. Il configure l'équilibreur de charge pour qu'il se connecte au groupe d'instances.
resource "google_compute_health_check" "http" {
project = var.project_id
name = "${var.basename}-health-chk"
tcp_health_check {
port = "80"
}
}
resource "google_compute_firewall" "allow-health-check" {
project = var.project_id
name = "allow-health-check"
network = local.defaultnetwork
source_ranges = ["130.211.0.0/22", "35.191.0.0/16"]
allow {
protocol = "tcp"
ports = ["80"]
}
}
resource "google_compute_backend_service" "default" {
project = var.project_id
name = "${var.basename}-service"
load_balancing_scheme = "EXTERNAL"
protocol = "HTTP"
port_name = "http"
backend {
group = google_compute_instance_group_manager.default.instance_group
}
health_checks = [google_compute_health_check.http.id]
}
resource "google_compute_url_map" "lb" {
project = var.project_id
name = "${var.basename}-lb"
default_service = google_compute_backend_service.default.id
}
Activer HTTP
La commande suivante configure les règles de mise en réseau qui dirigent le port 80 de l'équilibreur de charge vers le service.
resource "google_compute_target_http_proxy" "default" {
project = var.project_id
name = "${var.basename}-lb-proxy"
url_map = google_compute_url_map.lb.id
}
resource "google_compute_forwarding_rule" "google_compute_forwarding_rule" {
project = var.project_id
name = "${var.basename}-http-lb-forwarding-rule"
provider = google-beta
region = "none"
load_balancing_scheme = "EXTERNAL"
port_range = "80"
target = google_compute_target_http_proxy.default.id
ip_address = google_compute_global_address.default.id
}
Conclusion
Une fois l'exécution exécutée, vous devez maintenant disposer d'un site Web simple s'exécutant sur plusieurs instances Compute Engine, intercalé par un équilibreur de charge dans votre projet. De plus, vous devez disposer de tout le code nécessaire pour modifier ou étendre cette solution afin de l'adapter à votre environnement.