1) Arquitetura modular avançada e backends consistentes

Casos práticos de organização de código com módulos bem definidos e backends robustos que garantem estado centralizado, isolamento entre ambientes e governança de mudanças.

• Design de módulos por domínio com interfaces públicas claras.
• Backends compartilhados (S3 + DynamoDB) para estados entre equipes.
• Versionamento de módulos e controle de compatibilidade entre versões.

// Backend e providers (exemplo com AWS)
terraform {
  required_version = ">= 1.5"

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

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

// Exemplo de uso de módulo público/privado
module "network" {
  source = "./modules/network"
  env    = "prod"
  vpc_id = data.aws_vpc.main.id
}

2) Gerenciamento de estados, ambientes e isolação

Estruture ambientes com isolamento de estado e uso consciente de workspaces para evitar colisões e drift entre ambientes.

• Separação por backend por ambiente ou pelo uso de workspaces, conforme necessidade.
• Locais e variáveis dependentes do workspace atual para seleção de recursos.
• Definir regiões e provedores por ambiente para reduzir blast radius.

// Exemplo simples com terraform.workspace e map de regiões
locals {
  current_env = terraform.workspace
}

provider "aws" {
  region = lookup(var.regions, local.current_env, "us-east-1")
}

variable "regions" {
  type = map(string)
  default = {
    dev     = "us-west-2"
    staging = "us-east-1"
    prod    = "us-east-2"
  }
}

3) Padrões de design e casos de uso avançados

Aplique padrões com loops, blocos dinâmicos e lifecycle para alcançar implantação idempotente e previsível.

• Uso de for_each para criar recursos repetidos com mapeamento de ambientes.
• Dynamic blocks para configurações condicionais (por exemplo, regras de segurança).
• Lifecycle com create_before_destroy para evitar downtime em atualizações.

// Exemplo avançado: instâncias com for_each e dynamic blocks
variable "app_instances" {
  type = map(object({
    subnet_id     = string
    instance_type = string
  }))
  default = {
    dev = { subnet_id = "subnet-aaaa", instance_type = "t3.micro" }
    prod = { subnet_id = "subnet-bbbb", instance_type = "t3.medium" }
  }
}

resource "aws_instance" "app" {
  for_each = var.app_instances

  ami           = data.aws_ami.latest.id
  instance_type = each.value.instance_type
  subnet_id     = each.value.subnet_id

  lifecycle {
    create_before_destroy = true
  }

  tags = {
    Environment = each.key
  }
}

data "aws_ami" "latest" {
  most_recent = true
  owners      = ["amazon"]
  filter {
    name   = "name"
    values = ["amzn2-ami-hvm-2.0.*-ebs.standard.x86_64-ebs"]
  }
}

4) Validação, testes e governança de código

Práticas para manter código robusto, legível e previsível, com foco em validação estática, consistência de formatação e preservação de comportamento entre regravações de estado.

• Validação estática com terraform fmt e terraform validate.
• Bloqueio de provedores para reprodutibilidade (terraform providers lock).
• Geração de planos para revisão antes de aplicar mudanças reais.

// Procedimento recomendado (comandos)
# Formatar código
terraform fmt

# Validar sintaxe e referências
terraform validate

# Gerar plano de execução (salvar para revisão)
terraform plan -out=tfplan

# Mostrar plano de forma legível
terraform show -no-color tfplan

Observação: mantenha políticas de governança claras para mudanças de estado, com revisão de mudanças via pull requests e aprovação de arquitetos antes de aplicar alterações críticas.