As VMs com balanceamento de carga são um script de criação de infraestrutura que configura um cluster de VMs e define um balanceador de carga para expor uma rota pública às VMs:
- Computação - VMs - Compute Engine
- Computação – Cluster – Grupo gerenciado de instâncias
- Computação – Modelo de máquina – Modelo de instância
- Rede - Balanceamento de carga - Balanceador de carga do Cloud
Este aplicativo de exemplo configura um site HTML estático simples usando NGINX e faz o balanceamento de carga em todo o cluster.
Comece já
Clique no link a seguir para copiar o código-fonte no Cloud Shell. Depois, um único comando ativará uma cópia de trabalho do aplicativo no seu projeto.
Ver código-fonte no GitHub (em inglês)
Componentes das VMs com balanceamento de carga
A arquitetura de VMs com balanceamento de carga usa vários produtos. Veja a seguir os componentes e mais informações sobre eles, incluindo links para vídeos relacionados, documentação do produto e tutoriais interativos.
Scripts
O script de instalação usa um executável escrito em go e ferramentas da CLI do Terraform para
pegar um projeto vazio e instalar o aplicativo nele. A saída será um aplicativo em funcionamento e um URL para o endereço IP de balanceamento de carga.
./main.tf
Ativar serviços
Os serviços do Google Cloud são desativados em um projeto por padrão. Ative os seguintes serviços obrigatórios:
- Compute Engine: máquinas virtuais e serviços de rede (como o balanceador de carga)
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
}
Criar exemplo de instância para basear as VMs gerenciadas
O comando a seguir cria uma VM, instala o software necessário nela e implanta o 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]
}
Criar snapshot e imagem de disco
O comando a seguir usa a VM para criar um snapshot. Depois disso, o snapshot é usado para criar uma imagem de disco. Todas as VMs do cluster são baseadas nessa imagem.
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]
}
Criar um modelo de instância,
O comando a seguir cria um modelo com as definições e configurações de todas as VMs no cluster. Ela usa a imagem de disco criada no comando anterior.
O comando inclui um script de inicialização que personaliza o HTML exibido pelas VMs no 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]
}
Criar grupo gerenciado de instâncias
Solicita que um número de máquinas do modelo de instância seja gerenciado como parte deste 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]
}
Criar endereço IP externo
Precisava vincular um host ao nome de domínio e se comunicar em geral na Internet.
resource "google_compute_global_address" "default" {
project = var.project_id
name = "${var.basename}-ip"
ip_version = "IPV4"
}
Criar balanceador de carga
O comando a seguir cria um balanceador de carga e implementa verificações de integridade e serviços de back-end. Ele configura o balanceador de carga para se conectar ao grupo de instâncias.
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
}
Ativar HTTP
Com o comando a seguir, as regras de rede que apontam a porta 80 do balanceador de carga para o serviço são configuradas.
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
}
Conclusão
Depois da execução, você terá um site simples em execução em várias instâncias do Compute Engine, com um balanceador de carga na frente do projeto. Além disso, você precisa ter todo o código para modificar ou estender essa solução para que se adeque ao seu ambiente.