Implantar um servidor da Web básico da Flask usando o Terraform

Neste tutorial, você vai aprender os primeiros passos com o Terraform usando o Terraform para criar um servidor da Web básico no Compute Engine.

Neste tutorial, você faz as ações a seguir:

  • Usar o Terraform para criar uma VM no Google Cloud.
  • Iniciar um servidor Python Flask básico.

Custos

Neste documento, você usará os seguintes componentes faturáveis do Google Cloud:

Compute Engine

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços. Novos usuários do Google Cloud podem estar qualificados para uma avaliação gratuita.

Ao concluir as tarefas descritas neste documento, é possível evitar o faturamento contínuo excluindo os recursos criados. Saiba mais em Limpeza.

Antes de começar

Prepare-se para iniciar o tutorial.

Escolher ou criar um projeto

  1. In the Google Cloud console, go to the project selector page.

    Go to project selector

  2. Select or create a Google Cloud project.

Configurar permissões

Verifique se você tem as permissões necessárias do Compute Engine na sua conta de usuário:

  • compute.instances.*
  • compute.firewalls.*

Acessar a página do IAM

Saiba mais sobre papéis e permissões.

Ativar a API

Enable the Compute Engine API.

Enable the API

Iniciar Cloud Shell

O Cloud Shell é uma máquina virtual do Compute Engine.

As credenciais de serviço associadas a essa máquina virtual são automáticas. Por isso, não é necessário configurar ou fazer o download de uma chave de conta de serviço.

O Terraform é integrado ao Cloud Shell, que autentica automaticamente o Terraform, reduzindo as configurações iniciais necessárias.

Criar a VM do Compute Engine

Primeiro defina as configurações da VM em um arquivo de configuração do Terraform. Em seguida, execute comandos do Terraform para criar a VM no projeto.

Criar o diretório

Crie um novo diretório. No novo diretório, crie um arquivo main.tf para a configuração do Terraform. O conteúdo desse arquivo descreve todos os recursos do Google Cloud a serem criados no projeto.

No Cloud Shell, faça o seguinte:

mkdir tf-tutorial && cd tf-tutorial

nano main.tf

Criar a rede e a sub-rede de nuvem privada virtual

Nesta seção, você cria uma rede e uma sub-rede de nuvem privada virtual (VPC) para a interface de rede da VM.

Adicione o recurso do Terraform main.tf a seguir ao arquivo que você criou:

resource "google_compute_network" "vpc_network" {
  name                    = "my-custom-mode-network"
  auto_create_subnetworks = false
  mtu                     = 1460
}

resource "google_compute_subnetwork" "default" {
  name          = "my-custom-subnet"
  ip_cidr_range = "10.0.1.0/24"
  region        = "us-west1"
  network       = google_compute_network.vpc_network.id
}

Crie o recurso de VM do Compute Engine

Nesta seção, você cria uma única instância do Compute Engine executando o Debian. Neste tutorial, você usará o menor tipo de máquina disponível. Depois, faça upgrade para um tipo de máquina maior.

Adicione o seguinte recurso do Terraform google_compute_instance ao arquivo main.tf que você criou.

# Create a single Compute Engine instance
resource "google_compute_instance" "default" {
  name         = "flask-vm"
  machine_type = "f1-micro"
  zone         = "us-west1-a"
  tags         = ["ssh"]

  boot_disk {
    initialize_params {
      image = "debian-cloud/debian-11"
    }
  }

  # Install Flask
  metadata_startup_script = "sudo apt-get update; sudo apt-get install -yq build-essential python3-pip rsync; pip install flask"

  network_interface {
    subnetwork = google_compute_subnetwork.default.id

    access_config {
      # Include this section to give the VM an external IP address
    }
  }
}

O código de amostra define a zona do Google Cloud como us-west1-a. É possível mudar isso para uma zona diferente.

Inicialize o Terraform

Neste ponto, é possível executar terraform init para adicionar os plug-ins necessários e criar o diretório .terraform.

terraform init

Saída:

Initializing the backend...

Initializing provider plugins...
...

Terraform has been successfully initialized!

Validar a configuração do Terraform

Se preferir, valide o código do Terraform que você criou até agora. Execute terraform plan, que faz o seguinte:

  • verifica se a sintaxe de main.tf está correta;
  • Mostra uma prévia dos recursos que serão criados.
terraform plan

Saída:

...

Plan: 1 to add, 0 to change, 0 to destroy.

Note: You didn't use the -out option to save this plan, so Terraform can't
guarantee to take exactly these actions if you run "terraform apply" now.

Aplique a configuração

Para criar a VM, execute terraform apply.

terraform apply

Quando solicitado, digite yes.

O Terraform chama as APIs do Google Cloud para configurar a nova VM. Verifique a página de instâncias de VM para ver a nova VM.

Executar um servidor da Web no Google Cloud

As próximas etapas são criar um aplicativo da Web, implantá-lo na VM e criar uma regra de firewall para permitir solicitações de cliente para o aplicativo da Web.

Adicionar uma regra de firewall SSH personalizada

A regra de firewall default-allow-ssh na rede default permite usar SSH para se conectar à VM. Se preferir usar sua própria regra de firewall personalizada, adicione o seguinte recurso no final do arquivo main.tf:

resource "google_compute_firewall" "ssh" {
  name = "allow-ssh"
  allow {
    ports    = ["22"]
    protocol = "tcp"
  }
  direction     = "INGRESS"
  network       = google_compute_network.vpc_network.id
  priority      = 1000
  source_ranges = ["0.0.0.0/0"]
  target_tags   = ["ssh"]
}

Execute terraform apply para criar a regra de firewall.

Conectar-se à VM com SSH

Verifique se tudo está configurado corretamente neste momento, conectando-se à VM com SSH.

  1. Acesse a página Instâncias de VM.

  2. Encontre a VM com o nome flask-vm.

  3. Na coluna Conectar, clique em SSH.

    Uma janela do terminal SSH no navegador é aberta para a VM em execução.

Para mais informações, consulte Como se conectar a VMs.

Criar o app Flask

Crie um app Python Flask para este tutorial para ter um único arquivo que descreve o servidor da Web e os endpoints de teste.

  1. No terminal SSH do navegador, crie um arquivo chamado app.py.

    nano app.py

  2. Adicione o seguinte ao arquivo app.py.

    from flask import Flask
app = Flask(__name__)

@app.route('/')
def hello_cloud():
  return 'Hello Cloud!'

app.run(host='0.0.0.0')

  3. Execute app.py:

    python3 app.py

    O Flask exibe o tráfego em localhost:5000 por padrão.

  4. Abra uma segunda conexão SSH:

    1. Acesse a página Instâncias de VM.
    2. Encontre a VM chamada flask-vm e clique em SSH.

  5. Na segunda conexão SSH, execute curl para confirmar que a saudação que você configurou em app.py é retornada.

    curl http://0.0.0.0:5000

    A saída desse comando é Hello Cloud.

Abrir a porta 5000 na VM

Para se conectar ao servidor da Web a partir do computador local, a VM precisa ter a porta 5000 aberta. O Google Cloud permite abrir portas para o tráfego usando regras de firewall.

Adicione o seguinte recurso do Terraform google_compute_firewall ao final do arquivo main.tf.

resource "google_compute_firewall" "flask" {
  name    = "flask-app-firewall"
  network = google_compute_network.vpc_network.id

  allow {
    protocol = "tcp"
    ports    = ["5000"]
  }
  source_ranges = ["0.0.0.0/0"]
}

No Cloud Shell, execute terraform apply para criar a regra de firewall.

Adicionar uma variável de saída ao URL do servidor da Web

  1. No final de main.tf, adicione uma variável de saída do Terraform para gerar o URL do servidor da Web:

    // A variable for extracting the external IP address of the VM
output "Web-server-URL" {
 value = join("",["http://",google_compute_instance.default.network_interface.0.access_config.0.nat_ip,":5000"])
}

  2. Execute terraform apply.

    terraform apply

    Quando solicitado, digite yes. O Terraform imprime o endereço IP externo da VM e a porta 5000 na tela da seguinte maneira:

    Web-server-URL = "http://IP_ADDRESS:5000"

    A qualquer momento, é possível executar terraform output para retornar esta saída:

    terraform output

  3. Clique no URL da etapa anterior e veja a mensagem "Hello Cloud!"

    Isso significa que o servidor está em execução.

Solução de problemas

  • Se uma API obrigatória não estiver ativada, o Terraform retornará um erro. A mensagem desse erro inclui um link para ativar a API. Depois de ativar a API, execute terraform apply novamente.

  • Se não for possível se conectar à sua VM por SSH:

Limpar

Depois de concluir o tutorial, exclua tudo o que foi criado para que você não tenha custos adicionais.

O Terraform permite remover todos os recursos definidos no arquivo de configuração executando o comando terraform destroy:

terraform destroy

Digite yes para permitir que o Terraform exclua seus recursos.

A seguir