Esta página foi traduzida pela API Cloud Translation.

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

Neste tutorial, você vai aprender a usar o Terraform para criar um servidor da Web básico no Compute Engine.

Confira abaixo as atividades incluídas no tutorial:

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

Custos

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

Compute Engine

Para gerar uma estimativa de custo baseada na sua projeção de uso, utilize a calculadora de preços.

Novos usuários do Google Cloud podem estar qualificados para um teste sem custo financeiro.

Ao concluir as tarefas descritas neste documento, é possível evitar o faturamento contínuo excluindo os recursos criados. Para mais informações, consulte Limpeza.

Antes de começar

Prepare-se para iniciar o tutorial.

Escolher ou criar um projeto

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

Go to project selector
Select or create a Google Cloud project.
Roles required to select or create a project
- Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
- Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.
Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the 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.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

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 para reduzir a quantidade de 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 diretório. Nele, 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 da 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 os recursos do Terraform abaixo ao arquivo main.tf 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
}

Criar 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 recurso google_compute_instance do Terraform 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 exemplo de código define a zona do Google Cloud como us-west1-a. É possível mudar 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 conferir a nova VM.

Executar um servidor da Web no Google Cloud

Nas próximas etapas, você vai criar um aplicativo da Web, implantá-lo na VM e criar uma regra de firewall para permitir solicitações de clientes para ele.

Adicionar uma regra de firewall SSH personalizada

A regra de firewall default-allow-ssh na rede default permite usar SSH para se conectar à VM. Para usar sua própria regra de firewall personalizada, adicione o seguinte recurso ao 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 pelo computador local, a VM precisa ter a porta 5000 aberta. O Google Cloud permite abrir portas para tráfego usando regras de firewall.

Adicione o recurso google_compute_firewall abaixo do Terraform 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"].

Limpeza

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.