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:

• Use o Terraform para criar uma VM em Trusted Cloud.
• Iniciar um servidor Python Flask básico.

Custos

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

Compute Engine

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços.

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 Trusted Cloud console, go to the project selector page.

   Go to project selector

2. Select or create a Trusted 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

Instalar a CLI da gcloud

Para usar o Terraform em um ambiente de desenvolvimento local, instale e inicialize a CLI do Google Cloud e configure o Application Default Credentials com suas credenciais de usuário:

1. Instale a gcloud CLI.
2. Inicialize a gcloud CLI:

   gcloud init

3. Crie as credenciais de autenticação local para sua conta:

   gcloud auth application-default login

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 Trusted 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:

• google_compute_network
• google_compute_subnetwork

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 Trusted 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 Trusted 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 em Trusted 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 Trusted 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"]
}

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:

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