Vms com balanceamento de carga é um script de construção de infraestrutura que configura um cluster de e configura um balanceador de carga para expor uma rota pública para elas:
- 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 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 criar uma cópia funcional do aplicativo no projeto.
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
aplicativo em funcionamento e um URL para o endereço IP de balanceamento de carga.
./main.tf
Ativar serviços
Por padrão, os serviços do Google Cloud ficam desativados em um projeto. Ative os seguintes serviços obrigatórios:
- Compute Engine: máquinas virtuais e serviços de rede (como 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 snapshot e imagem de disco
O comando a seguir usa a VM para criar um snapshot. O snapshot é usado para criar uma imagem do 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 do disco criada no comando anterior.
Ele 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 N número de máquinas do modelo de instância a ser 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
Precisam 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 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ê deve ter todo o código para modificar ou estender essa solução de acordo com de nuvem.