Load Balanced Vms est un script de création d'infrastructure qui configure un cluster de VM et un équilibreur de charge pour exposer un routage public aux VM:
- Calcul - VM - Compute Engine
- Compute - Cluster - Managed Instance Group
- Compute - Machine Template - Instance Template
- Mise en réseau - Équilibrage de charge - Cloud Load Balancing
Cet exemple d'application configure un site HTML statique simple à l'aide de NGINX et équilibre la charge dans votre cluster.
Premiers pas
Cliquez sur le lien suivant pour obtenir une copie du code source dans Cloud Shell. Une seule commande permet de lancer une copie fonctionnelle de l'application dans votre projet.
Afficher le code source sur GitHub
Composants des VM à équilibrage de charge
L'architecture des VM à équilibrage de charge utilise plusieurs produits. Vous trouverez ci-dessous la liste des composants, ainsi que des informations supplémentaires à leur sujet, y compris des liens vers des vidéos, des documentations produit et des tutoriels interactifs associés.
Scripts
Le script d'installation utilise un exécutable écrit en go et des outils de la CLI Terraform pour prendre un projet vide et y installer l'application. La sortie doit être une application fonctionnelle et une URL pour l'adresse IP d'équilibrage de charge.
./main.tf
Activer les services
Les services Google Cloud sont désactivés par défaut dans un projet. Activez les services requis suivants:
- Compute Engine : machines virtuelles et services de mise en réseau (comme Load Balancer)
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 du 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 de 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. Elle utilise l'image de disque créée dans 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 que N machines du modèle d'instance soient gérées 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 associer 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 de l'é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 des règles réseau qui pointent 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 terminée, vous devriez disposer d'un site Web simple exécuté sur plusieurs instances Compute Engine, avec un équilibreur de charge en face de votre projet. De plus, vous devez disposer de tout le code nécessaire pour modifier ou étendre cette solution en fonction de votre environnement.