Les VM à équilibrage de charge sont un script de création d'infrastructures qui configure un cluster de VM et configure 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 site HTML statique simple à l'aide de NGINX. des équilibreurs de charge votre cluster.
Premiers pas
Cliquez sur le lien suivant pour obtenir une copie du code source dans Cloud Shell. Une fois une seule commande lance une copie de travail de l'application projet...
Afficher le code source sur GitHub
Composants de VM à équilibrage de charge
L'architecture de VM à équilibrage de charge utilise plusieurs produits. Voici la liste des composants, ainsi que des informations complémentaires sur les des composants, y compris des liens vers des vidéos similaires, la documentation du 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. La sortie doit être une
une application opérationnelle 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 (par exemple, é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. Elle 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 le cadre de 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écessaires 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 les vérifications de l'état et les 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 pointent le port 80 sur l'équilibreur de charge au 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 avoir un simple site Web s'exécutant sur plusieurs à des instances Compute Engine, placées devant un équilibreur de charge dans votre projet. En outre, vous doit disposer de tout le code nécessaire pour modifier ou étendre cette solution afin qu'elle s'adapte environnement.