O Load Balanced Vms é um script de criação de infraestrutura que configura um cluster de VMs e um balanceador de carga para expor uma rota pública às VMs:
- Computação - VMs - Compute Engine
- Compute - Cluster - Managed Instance Group
- Compute: modelo de máquina e modelo de instância
- Rede: balanceamento de carga: Cloud Load Balancing
Este aplicativo de exemplo configura um site HTML estático simples usando o NGINX e balanceia a carga no cluster.
Primeiros passos
Clique no link a seguir para acessar uma cópia do código-fonte no Cloud Shell. Depois disso, um único comando vai ativar uma cópia funcional do aplicativo no projeto.
Acessar o código-fonte no GitHub
Componentes de VMs com balanceamento de carga
A arquitetura de VMs com balanceamento de carga usa vários produtos. A lista a seguir mostra 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
instalar o aplicativo em um projeto vazio. A saída deve ser um
aplicativo em funcionamento e um URL para o endereço IP do balanceamento de carga.
./main.tf
Ativar serviços
Os serviços do Google Cloud ficam desativados por padrão em um projeto. 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
}
Crie um exemplo de instância para usar como base para 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 um snapshot e uma imagem do disco
O comando a seguir usa a VM para criar um snapshot. O snapshot é usado para criar uma imagem de disco. Todas as VMs no 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 modelo de instância
O comando a seguir cria um modelo com as definições e a configuração de todas as VMs no cluster. Ele usa a imagem de disco criada no comando anterior.
O comando inclui um script de inicialização que personaliza o HTML fornecido 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 N máquinas do modelo de instância sejam gerenciadas 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
É necessário vincular um host ao nome de domínio e se comunicar de modo 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 o HTTP
O comando a seguir configura regras de rede que apontam a porta 80 no balanceador de carga para o serviço.
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 da Web simples em execução em várias instâncias do Compute Engine, com um balanceador de carga no projeto. Além disso, você precisa ter todo o código para modificar ou estender essa solução para se adaptar ao seu ambiente.