Esta página foi traduzida pela API Cloud Translation.

Implantar um servidor web Flask básico usando o Terraform
Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Neste tutorial, você aprenderá como começar a usar o Terraform usando o Terraform para criar um servidor da Web básico no Compute Engine.

Neste tutorial, você faz o seguinte:

Use o Terraform para criar uma VM em Google Cloud.
Inicie 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.

Selecione ou crie um projeto

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

Go to project selector
Select or create a Google Cloud project.

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.*

Acesse a página do IAM

Saiba mais sobre funções e permissões.

Habilite a API

Enable the Compute Engine API.

Enable the API

Iniciar o Cloud Shell

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

As credenciais de serviço associadas a esta máquina virtual são automáticas, portanto não há necessidade de configurar ou baixar uma chave de conta de serviço.

O Terraform é integrado ao Cloud Shell, e o Cloud Shell autentica automaticamente o Terraform, permitindo que você comece com menos configuração.

Criar a VM do Compute Engine

Primeiro, você define as configurações da VM em um arquivo de configuração do Terraform. Em seguida, você executa comandos do Terraform para criar a VM em seu projeto.

Crie o diretório

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

No Cloud Shell:

mkdir tf-tutorial && cd tf-tutorial

nano main.tf

Crie 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 seguintes recursos do Terraform 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ê usa o menor tipo de máquina disponível. Posteriormente, você poderá atualizar para um tipo de máquina maior.

Adicione o seguinte 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 código de exemplo define o Google Cloud zona para us-west1-a . Você pode alterar isso para uma zona diferente.

Inicializar o Terraform

Neste ponto, você pode executar terraform init para adicionar os plug-ins necessários e construir o diretório .terraform .

terraform init

Saída:

Initializing the backend...

Initializing provider plugins...
...

Terraform has been successfully initialized!

Valide a configuração do Terraform

Opcionalmente, você pode validar o código Terraform que você construiu 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.

Aplicar a configuração

Para criar a VM, execute terraform apply .

terraform apply

Quando solicitado, digite yes .

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

Execute um servidor web em Google Cloud

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

Adicione 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, você pode adicionar 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.

Conecte-se à VM com SSH

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

Vá para a página Instâncias de VM .
Encontre a VM com o nome flask-vm .
Na coluna Conectar , clique em SSH .
Uma janela de terminal SSH no navegador é aberta para a VM em execução.

Para obter mais informações, consulte Conectando-se a VMs .

Crie o aplicativo Flask

Você cria um aplicativo Python Flask para este tutorial para que possa ter um único arquivo descrevendo seu servidor web e endpoints de teste.

No terminal SSH no 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
```
Flask atende tráfego em localhost:5000 por padrão.
Aviso: Este é um servidor de desenvolvimento. Não o use em uma implantação de produção.
Abra uma segunda conexão SSH:
1. Vá para 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 se a saudação configurada em app.py foi retornada.
```
curl http://0.0.0.0:5000
```
A saída deste comando é Hello Cloud .

Abra a porta 5000 na VM

Para se conectar ao servidor web a partir do seu computador local, a VM deve ter a porta 5000 aberta. Google Cloud permite abrir portas ao tráfego usando regras de firewall.

Adicione o seguinte recurso google_compute_firewall Terraform no 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.

Adicione uma variável de saída para o URL do servidor web

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

// A variable for extracting the external IP address of the VM
output "Web-server-URL" {
 value = join("",["https://",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 e a porta 5000 da VM na tela, da seguinte forma:
```
Web-server-URL = "http://IP_ADDRESS:5000"
```
A qualquer momento, você pode executar terraform output para retornar esta saída:
```
terraform output
```
Clique no URL da etapa anterior e veja a mensagem "Hello Cloud!" mensagem.
Isso significa que seu servidor está em execução.

Solução de problemas

Se uma API necessária não estiver habilitada, o Terraform retornará um erro. A mensagem de erro inclui um link para ativar a API. Depois de ativar a API, você pode executar novamente terraform apply .
Se você não conseguir se conectar à sua VM por meio de SSH:
- Certifique-se de adicionar a regra de firewall SSH .
- Certifique-se de que sua VM inclua o argumento tags = ["ssh"] .

Limpar

Depois de concluir o tutorial, você pode excluir tudo o que criou para não incorrer em 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.

O que vem a seguir

Aprenda como exportar seu Google Cloud recursos no formato Terraform .