Do Zero ao Deploy: Criando sua Primeira Infraestrutura na AWS com Terraform

A gestão de infraestrutura em nuvem evoluiu drasticamente. A era da configuração manual de servidores, redes e bancos de dados através de consoles web está sendo substituída por uma abordagem mais robusta, escalável e segura: a Infraestrutura como Código (IaC). Neste cenário, o terraform, da HashiCorp, emerge como uma ferramenta líder, permitindo que desenvolvedores e engenheiros de devops definam e provisionem infraestrutura de forma declarativa e automatizada.

Este artigo é um guia prático e detalhado para quem deseja dar os primeiros passos com IaC na Amazon Web Services (AWS). Iremos explorar os conceitos fundamentais do Terraform, configurar o ambiente de desenvolvimento e construir uma infraestrutura básica, porém funcional, composta por uma VPC, uma sub-rede, um grupo de segurança e uma instância EC2. Ao final, você terá o conhecimento necessário para iniciar seus próprios projetos e automatizar o deploy de recursos na nuvem.

O que é Terraform e por que utilizá-lo com a AWS?

O Terraform é uma ferramenta de código aberto que permite definir infraestrutura em nuvem e on-premise através de uma linguagem de configuração de alto nível, conhecida como HashiCorp Configuration Language (HCL). A sua principal característica é a abordagem declarativa: em vez de escrever scripts sequenciais que ditam *como* criar a infraestrutura, você descreve o *estado final* desejado, e o Terraform se encarrega de planejar e executar as ações necessárias para alcançá-lo.

A combinação do Terraform com a AWS é particularmente poderosa por diversos motivos:

• Automação e Reprodutibilidade: Defina sua infraestrutura uma vez e implante-a consistentemente em múltiplos ambientes (desenvolvimento, homologação, produção), eliminando o “drift” de configuração.
• Versionamento: Armazene seus arquivos de configuração do Terraform em um sistema de controle de versão como o Git. Isso permite rastrear alterações, colaborar em equipe e reverter para estados anteriores com facilidade.
• Planejamento Seguro: Antes de aplicar qualquer mudança, o comando terraform plan gera um plano de execução que detalha exatamente quais recursos serão criados, modificados ou destruídos. Isso oferece uma camada crucial de segurança e previsibilidade.
• Ecossistema Multi-Cloud: Embora este artigo foque na AWS, o Terraform suporta centenas de outros provedores, como Google Cloud, Azure, Kubernetes, entre outros. Isso o torna uma habilidade valiosa e transferível, evitando o aprisionamento tecnológico (vendor lock-in).

Pré-requisitos: Preparando seu Ambiente de Desenvolvimento

Antes de começarmos a codificar, é essencial garantir que seu ambiente local esteja corretamente configurado. Siga os passos abaixo para instalar as ferramentas necessárias.

1. Conta na AWS

Você precisará de uma conta na AWS. Se ainda não tiver uma, pode criar uma no portal da AWS. Para os fins deste tutorial, o nível gratuito (Free Tier) é mais do que suficiente para evitar custos. É altamente recomendável ativar a Autenticação Multi-Fator (MFA) em seu usuário root para aumentar a segurança.

2. Instalação do Terraform

O Terraform é distribuído como um único binário. Acesse a página oficial de downloads da HashiCorp e baixe a versão apropriada para o seu sistema operacional. Após o download, adicione o executável ao PATH do seu sistema. Para verificar se a instalação foi bem-sucedida, abra um terminal e execute:

terraform --version

3. Configuração do AWS CLI

A maneira mais comum de o Terraform se autenticar com sua conta AWS é através das credenciais configuradas na AWS Command Line Interface (CLI). Siga o guia oficial de instalação da AWS CLI para o seu sistema operacional.

4. Credenciais da AWS

Com a AWS CLI instalada, configure suas credenciais. É uma péssima prática usar o usuário root para tarefas programáticas. Crie um usuário IAM (Identity and Access Management) com permissões programáticas (Access Key ID e Secret Access Key) e privilégios mínimos necessários (por exemplo, permissões para gerenciar VPC, EC2 e Security Groups). Após criar o usuário e salvar as chaves, execute no seu terminal:

aws configure

O sistema solicitará seu Access Key ID, Secret Access Key, região padrão (ex: us-east-1) e formato de saída padrão (ex: json). Essas credenciais serão armazenadas localmente e utilizadas pelo Terraform para se autenticar na sua conta.

Estruturando seu Primeiro Projeto Terraform

Uma boa organização de arquivos facilita a manutenção e a escalabilidade do seu projeto. Para nosso primeiro projeto, criaremos uma estrutura simples, mas eficaz.

Crie um novo diretório para o projeto (ex: terraform-aws-inicial) e, dentro dele, crie os seguintes arquivos:

• providers.tf: Onde declaramos os provedores necessários para o nosso projeto, como o provedor da AWS, e fixamos sua versão para garantir a estabilidade.
• main.tf: O arquivo principal onde a maior parte da nossa infraestrutura (VPC, EC2, etc.) será definida.
• variables.tf: Usado para declarar as variáveis de entrada, permitindo que nosso código seja mais flexível e reutilizável.
• outputs.tf: Define os valores de saída que queremos exibir após a aplicação da infraestrutura, como o endereço IP público da nossa instância.

Passo a Passo: Codificando a Infraestrutura

Agora, vamos preencher nossos arquivos com o código HCL necessário para criar nossa infraestrutura.

Definindo o Provedor (providers.tf)

Neste arquivo, informamos ao Terraform que usaremos o provedor AWS e especificamos a região onde nossos recursos serão criados.

# providers.tf

terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
}

provider "aws" {
  region = var.aws_region
}

Declarando Variáveis (variables.tf)

Vamos definir uma variável para a região da AWS. Isso nos permite alterar a região facilmente sem modificar o código principal.

# variables.tf

variable "aws_region" {
  description = "Região da AWS para provisionar os recursos"
  type        = string
  default     = "us-east-1"
}

Construindo os Recursos Principais (main.tf)

Este é o coração do nosso projeto. Aqui, definiremos a VPC, a sub-rede, o grupo de segurança e a instância EC2.

# main.tf

# 1. Criação da VPC
resource "aws_vpc" "main" {
  cidr_block = "10.0.0.0/16"

  tags = {
    Name = "vpc-principal"
  }
}

# 2. Criação da Sub-rede Pública
resource "aws_subnet" "public" {
  vpc_id     = aws_vpc.main.id
  cidr_block = "10.0.1.0/24"
  map_public_ip_on_launch = true # Atribui IP público automaticamente

  tags = {
    Name = "subnet-publica-1"
  }
}

# 3. Criação do Security Group
resource "aws_security_group" "web_server" {
  name        = "web-server-sg"
  description = "Permite tráfego HTTP e SSH"
  vpc_id      = aws_vpc.main.id

  ingress {
    description = "SSH a partir de qualquer IP"
    from_port   = 22
    to_port     = 22
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  ingress {
    description = "HTTP a partir de qualquer IP"
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }

  tags = {
    Name = "sg-web-server"
  }
}

# 4. Lançamento da Instância EC2
resource "aws_instance" "app_server" {
  ami           = "ami-0c55b159cbfafe1f0" # Amazon Linux 2 AMI (us-east-1) - Verifique o AMI ID mais recente para sua região!
  instance_type = "t2.micro"
  subnet_id     = aws_subnet.public.id
  vpc_security_group_ids = [aws_security_group.web_server.id]

  tags = {
    Name = "ServidorWeb-01"
  }
}

Atenção: O valor de `ami` pode variar por região e com o tempo. Sempre verifique o ID da Amazon Machine Image (AMI) mais recente para o Amazon Linux 2 (ou a imagem de sua preferência) na região que você está utilizando.

Definindo as Saídas (outputs.tf)

Finalmente, vamos configurar uma saída para que o Terraform nos mostre o IP público da instância EC2 após sua criação.

# outputs.tf

output "instance_public_ip" {
  description = "Endereço IP público da instância EC2"
  value       = aws_instance.app_server.public_ip
}

O Ciclo de Vida do Terraform: Init, Plan, Apply

Com nosso código pronto, podemos executar o fluxo de trabalho padrão do Terraform. Navegue até o diretório do seu projeto no terminal e execute os seguintes comandos.

1. `terraform init`

Este comando inicializa o diretório de trabalho. Ele faz o download do plugin do provedor AWS especificado no arquivo providers.tf e configura o backend de estado. Você só precisa executá-lo uma vez por projeto ou sempre que adicionar um novo provedor.

terraform init

2. `terraform plan`

O `plan` é um dos comandos mais importantes. Ele cria um plano de execução comparando o estado desejado (seu código) com o estado atual da infraestrutura real. Ele mostra exatamente quais recursos serão criados, alterados ou destruídos, sem fazer nenhuma alteração real. É sua chance de revisar e garantir que as mudanças estão corretas.

terraform plan

3. `terraform apply`

Após revisar o plano e concordar com as mudanças, o comando `apply` executa as ações planejadas. Ele solicitará uma confirmação final (digite `yes`) antes de começar a provisionar os recursos na sua conta AWS. Ao final do processo, ele exibirá os valores de saída definidos no arquivo `outputs.tf`.

terraform apply

Parabéns! Se tudo correu bem, você acabou de criar sua primeira infraestrutura na AWS utilizando Terraform.

Gerenciando o Estado (State) da Infraestrutura

Após a execução do `apply`, você notará um novo arquivo no seu diretório: terraform.tfstate. Este arquivo JSON é crucial, pois é onde o Terraform armazena o estado da sua infraestrutura gerenciada. Ele mapeia os recursos do seu código para os recursos reais na nuvem, rastreia metadados e melhora o desempenho.

É fundamental proteger este arquivo. Em um ambiente de equipe, armazenar o `tfstate` localmente é problemático, pois pode levar a conflitos e perda de estado. A prática recomendada é usar um backend remoto, como um bucket AWS S3 com bloqueio de estado via DynamoDB, para armazenar o arquivo de estado de forma centralizada e segura. Este é um tópico mais avançado, mas essencial para o trabalho colaborativo com Terraform.

Destruindo a Infraestrutura: `terraform destroy`

Tão importante quanto criar é saber como destruir os recursos para evitar cobranças inesperadas. O Terraform torna esse processo simples e seguro.

O comando terraform destroy analisa o arquivo de estado e cria um plano para remover todos os recursos gerenciados pelo seu projeto. Assim como o `apply`, ele mostrará o plano de destruição e solicitará uma confirmação antes de prosseguir.

terraform destroy

Após confirmar com `yes`, o Terraform irá remover a instância EC2, o grupo de segurança, a sub-rede e a VPC, deixando sua conta AWS limpa. Esta é uma operação destrutiva e deve ser usada com cuidado em ambientes de produção.