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

No console do Google Cloud, acesse a página do seletor de projetos.

Acessar o seletor de projetos
Selecione ou crie um projeto do Google Cloud.

Observação: se você não pretende manter os recursos criados neste procedimento, crie um projeto novo em vez de selecionar um que já existe. Depois de concluir essas etapas, é possível excluir o projeto. Para fazer isso, basta remover todos os recursos associados a ele.

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

Ative a API Compute Engine.

Ative a 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

No Cloud Shell, 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.

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.

Acesse a página Instâncias de VM.
Encontre a VM com o nome flask-vm.
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.

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

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')

Execute app.py:
```
python3 app.py
```
O Flask exibe o tráfego em localhost:5000 por padrão.

Aviso: este é um servidor de desenvolvimento. Não a use em uma implantação de produção.
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.
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

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"])
}

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
```
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:
- Adicione a regra de firewall SSH.
- Verifique se a VM inclui o argumento tags = ["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

Saiba como exportar seus recursos do Google Cloud para o formato Terraform.