Las VMs con balanceo de cargas son secuencias de comandos de creación de infraestructura que configuran y configura un balanceador de cargas para exponer una ruta pública a las VMs:
- Procesamiento, VMs, Compute Engine
- Procesamiento, clúster, grupo de instancias administrado
- Procesamiento: plantilla de máquina, plantilla de instancias
- Herramientas de redes - Balanceo de cargas - Balanceador de cargas de Cloud
En esta aplicación de ejemplo, se configura un sitio HTML estático simple con NGINX y se realiza el balanceo de cargas en el clúster.
Comenzar
Haz clic en el siguiente vínculo para obtener una copia del código fuente en Cloud Shell. Una vez ahí, un solo comando iniciará una copia de trabajo de la aplicación en tu proyecto...
Consulta el código fuente en GitHub
Componentes de VMs con balanceo de cargas
La arquitectura de VMs con balanceo de cargas utiliza varios productos. A continuación, se enumeran los componentes, junto con más información sobre ellos, incluidos vínculos a videos relacionados, documentación del producto y explicaciones interactivas.
Secuencias de comandos
La secuencia de comandos de instalación usa un ejecutable escrito en go y herramientas de la CLI de Terraform para tomar un proyecto vacío e instalar la aplicación en él. El resultado debe ser una
y una URL para la dirección IP
del balanceo de cargas.
./main.tf
Habilita los 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 red (como el balanceador de cargas)
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 un modelo de instancia en el que se basen las VMs administradas
El siguiente comando crea una VM, instala el software necesario en ella y, luego, implementa 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]
}
Crea instantáneas y una imagen de disco
El siguiente comando usa la VM para crear una instantánea. Luego, esta 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 instancias
El siguiente comando crea una plantilla con la configuración de todas las VMs del clúster. Utiliza la imagen de disco creada en el comando anterior.
El comando incluye una secuencia de comandos de inicio que personaliza el código HTML que entregan las VMs en el 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 administrado
Solicita una cantidad de N de máquinas de la plantilla de instancias que se administren 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]
}
Crea 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 cargas
El siguiente comando crea un balanceador de cargas e implementa verificaciones de estado y servicios de backend. Configura el balanceador de cargas 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
}
Habilita HTTP
El siguiente comando configura las reglas de red que apuntan al puerto 80 en el balanceador de cargas 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 ejecutado, ahora deberías tener un sitio web sencillo ejecutándose en varias instancias de Compute Engine, encabezadas por un balanceador de cargas en tu proyecto. Además, deberías tener todo el código para modificar o extender esta solución para que se adapte a tu entorno.