Primeiros passos com 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á a executar um servidor da Web simples no Compute Engine usando o Terraform para provisionar os recursos.

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 tutorial, usamos 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 este tutorial, exclua os recursos criados para evitar o faturamento contínuo. Para mais informações, consulte Limpeza.

Antes de começar

Prepare-se para iniciar o tutorial.

Escolher ou criar um projeto

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

    Acessar o seletor de projetos

  2. Selecione ou crie um projeto do Google Cloud.

Configurar permissões

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

  • compute.instance.*
  • compute.firewalls.*

Acessar a página do IAM

Saiba mais sobre papéis e permissões.

Ative as APIs

Ative as APIs Compute Engine and OS Login.

Ative as APIs

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

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

  metadata = {
    enable-oslogin = "TRUE"
  }
  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 python-pip rsync; pip install flask"

  network_interface {
    network = "default"

    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       = "default"
  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:

    python 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 flash-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 = "default"

  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!" enviar mensagens

    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