Load Balanced VMs es una secuencia de comandos para crear infraestructuras que configura un clúster de VMs y un balanceador de carga para exponer una ruta pública a las VMs:
- Compute - VMs - Compute Engine
- Compute - Cluster - Managed Instance Group
- Compute - Machine Template - Instance Template
- Redes - Balanceo de carga - Balanceador de carga en la nube
Esta aplicación de ejemplo configura un sitio HTML estático sencillo con NGINX y equilibra la carga en tu clúster.
Empezar
Haz clic en el siguiente enlace para acceder a una copia del código fuente en Cloud Shell. Una vez allí, con un solo comando se creará una copia de trabajo de la aplicación en tu proyecto.
Ver el código fuente en GitHub
Componentes de las VMs con balanceo de carga
La arquitectura de las VMs con balanceo de carga usa varios productos. A continuación, se enumeran los componentes y se incluye más información sobre ellos, como enlaces a vídeos relacionados, documentación del producto y tutoriales interactivos.
Secuencias de comandos
La secuencia de comandos de instalación usa un ejecutable escrito en go y las herramientas de la CLI de Terraform para tomar un proyecto vacío e instalar la aplicación en él. El resultado debe ser una aplicación que funcione y una URL para la dirección IP de balanceo de carga.
./main.tf
Activación de servicios
Los servicios de Google Cloud están inhabilitados en un proyecto de forma predeterminada. Activa los siguientes servicios obligatorios:
- Compute Engine: máquinas virtuales y servicios de redes (como 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
}
Crea una instancia ejemplar en la que basar las VMs gestionadas
El siguiente comando crea una VM, instala el software necesario y despliega el código.
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]
}
Crear una captura y una imagen de disco
El siguiente comando usa la VM para crear una instantánea. A continuación, la captura se usa para crear una imagen de disco. Todas las VMs del clúster se basan en esta imagen.
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]
}
Crear plantilla de instancia
El siguiente comando crea una plantilla con los ajustes y la configuración de todas las VMs del clúster. Usa la imagen de disco creada en el comando anterior.
El comando incluye una secuencia de comandos de inicio que personaliza el HTML que sirven las VMs del clúster.
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]
}
Crear grupo de instancias gestionado
Solicita que se gestionen N máquinas de la plantilla de instancia como parte de este grupo.
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]
}
Crear una dirección IP externa
Necesaria para vincular un host al nombre de dominio y comunicarse en general en Internet.
resource "google_compute_global_address" "default" {
project = var.project_id
name = "${var.basename}-ip"
ip_version = "IPV4"
}
Crear balanceador de carga
El siguiente comando crea un balanceador de carga e implementa comprobaciones del estado y servicios de backend. Configura el balanceador de carga para que se conecte al grupo de instancias.
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
}
Habilitar HTTP
El siguiente comando configura las reglas de red que dirigen el puerto 80 del balanceador de carga al servicio.
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
}
Conclusión
Una vez que se haya ejecutado, deberías tener un sitio web sencillo en varias instancias de Compute Engine, con un balanceador de carga en tu proyecto. Además, deberías tener todo el código para modificar o ampliar esta solución y adaptarla a tu entorno.