1) Fundamentos práticos para começar

Neste primeiro bloco, quem começa com Terraform costuma buscar um fluxo repetível e previsível. Foco nos conceitos centrais que guiam a construção de infraestruturas estáveis:

• Provedor (provider): a camada que integra a ferramenta com a sua nuvem.
• Recursos (resources): componentes de infraestrutura que você cria e gerencia.
• Dados (data sources): informações que vêm de fontes externas para compor a configuração.
• Variáveis (variables) e Outputs: parâmetros de entrada e valores que interessam para outros módulos.
• Estado (state) e backends: como manter o estado da sua infraestrutura de forma consistente e segura.

O objetivo deste post é avançar de forma prática, utilizando exemplos simples que você pode adaptar ao seu ambiente. Evito abstrações desnecessárias e tento manter a clareza entre código e conceito.

2) Projeto 1 — Provisionamento de uma VPC na AWS com Terraform

Este projeto ilustra a criação de uma VPC básica, com sub-rede pública, gateway de internet e associações de tabela de rotas. O foco é demonstrar a estrutura mínima para um ambiente de rede que possa hospedar recursos adicionais (EC2, RDS, etc.).

// main.tf (trecho simplificado)
provider "aws" {
  region  = "us-east-1"
  profile = "default"
}

resource "aws_vpc" "main" {
  cidr_block           = "10.0.0.0/16"
  enable_dns_support   = true
  enable_dns_hostnames = true

  tags = {
    Name = "vpc-pratica-terraform"
  }
}

resource "aws_subnet" "public" {
  vpc_id                  = aws_vpc.main.id
  cidr_block              = "10.0.1.0/24"
  map_public_ip_on_launch = true
  availability_zone       = "us-east-1a"

  tags = {
    Name = "public-subnet"
  }
}

resource "aws_internet_gateway" "gw" {
  vpc_id = aws_vpc.main.id

  tags = {
    Name = "igw"
  }
}

resource "aws_route_table" "rt" {
  vpc_id = aws_vpc.main.id

  route {
    cidr_block = "0.0.0.0/0"
    gateway_id = aws_internet_gateway.gw.id
  }

  tags = {
    Name = "public-rt"
  }
}

resource "aws_route_table_association" "a" {
  subnet_id      = aws_subnet.public.id
  route_table_id = aws_route_table.rt.id
}

O código acima configura uma VPC com uma sub-rede pública, conectando-a a um gateway de internet. Em um cenário real, você ampliaria com sub-redes adicionais, grupos de segurança e recursos relevantes (EC2, ALB, etc.).

3) Projeto 2 — Módulos para reuso de infraestrutura

Para manter a base de código limpa e reutilizável, utilize módulos. Um módulo encapsula recursos, variáveis de entrada e outputs, permitindo compor ambientes consistentes entre equipes e ambientes (dev, staging, prod).

// Exemplo de uso de módulo (root)
module "vpc" {
  source     = "./modules/vpc"
  cidr_block = "10.1.0.0/16"
  name       = "infra-prod-vpc"
}

Estrutura de módulo típica (modules/vpc):

// modules/vpc/main.tf
resource "aws_vpc" "this" {
  cidr_block           = var.cidr_block
  enable_dns_support   = true
  enable_dns_hostnames = true
  tags = { Name = var.name }
}

// modules/vpc/variables.tf
variable "cidr_block" { type = string }
variable "name"       { type = string }

// modules/vpc/outputs.tf
output "vpc_id" { value = aws_vpc.this.id }

Ao adotar módulos, você reduz duplicação, facilita revisões e facilita a manutenção de ambientes com padrões similares.

4) Projeto 3 — Backend remoto para o estado da infraestrutura

Gerenciar o estado da infraestrutura de forma centralizada é essencial para evitar divergências entre equipes. Neste exemplo, utilizamos um backend S3 com bloqueio via DynamoDB para assegurar que apenas uma operação de modificação ocorra por vez.

// backend no Terraform (root)
terraform {
  required_version = ">= 1.5.0"

  backend "s3" {
    bucket         = "my-terraform-state-prod"
    key            = "network/terraform.tfstate"
    region         = "us-east-1"
    dynamodb_table = "terraform-lock-prod"
    encrypt        = true
  }
}

Observações práticas:

• Habilite o versionamento do bucket e aplique políticas de acesso restritivas aos estados.
• Considere segregação de estados por ambiente (prod, staging) para evitar conflitos entre equipes.
• Use comandos como terraform fmt, terraform validate e terraform plan para manter a qualidade do código antes de aplicar.