Infraestrutura como código com Terraform: do gerenciamento de nuvem manual ao automatizado

Organizações que usam ambientes de provisionamento de infraestrutura como código (IaC) são 90% mais rápidas e enfrentam 60% menos interrupções relacionadas à configuração do que aquelas que gerenciam a infraestrutura manualmente. O Terraform emergiu como a ferramenta IaC dominante, com mais de 3.000 provedores oferecendo suporte a todas as principais plataformas de nuvem e serviços SaaS.

Este guia aborda o uso prático do Terraform para aplicativos da web, sistemas ERP e plataformas de comércio eletrônico – desde a primeira definição de recursos até implantações em vários ambientes de nível de produção.

Principais conclusões

• O Terraform torna as alterações de infraestrutura revisáveis, testáveis e reversíveis por meio do controle de versão
• O gerenciamento remoto de estado evita conflitos quando vários engenheiros modificam a infraestrutura
• Módulos encapsulam padrões reutilizáveis, reduzindo a configuração de centenas de linhas para alguns parâmetros
• A integração Terraform Cloud ou CI/CD impõe a disciplina de planejar antes de aplicar para mudanças seguras

---

Por que o Terraform para pequenas e médias empresas

O problema manual da infraestrutura

Sem IaC, seu conhecimento de infraestrutura reside em:

• Caminhos de clique do Console AWS que ninguém documentou
• Comandos SSH executados há meses e ninguém se lembra
• Arquivos de configuração editados diretamente nos servidores
• O modelo mental de um engenheiro sobre "como a rede funciona"

Com o Terraform, sua infraestrutura reside no Git. Cada mudança é uma solicitação pull. Cada implantação é reproduzível. Todo engenheiro pode entender o quadro completo.

Conceitos Básicos

---

Primeira configuração do Terraform

AWS VPC e EC2 para um aplicativo da Web

# providers.tf
terraform {
  required_version = ">= 1.7"
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }

  backend "s3" {
    bucket = "ecosire-terraform-state"
    key    = "production/terraform.tfstate"
    region = "us-east-1"
    encrypt = true
    dynamodb_table = "terraform-locks"
  }
}

provider "aws" {
  region = var.aws_region
}

# variables.tf
variable "aws_region" {
  type    = string
  default = "us-east-1"
}

variable "environment" {
  type    = string
  default = "production"
}

variable "instance_type" {
  type    = string
  default = "t3.large"
}

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

  tags = {
    Name        = "${var.environment}-vpc"
    Environment = var.environment
    ManagedBy   = "terraform"
  }
}

resource "aws_subnet" "public" {
  count             = 2
  vpc_id            = aws_vpc.main.id
  cidr_block        = "10.0.${count.index + 1}.0/24"
  availability_zone = data.aws_availability_zones.available.names[count.index]

  map_public_ip_on_launch = true

  tags = {
    Name = "${var.environment}-public-${count.index + 1}"
  }
}

resource "aws_instance" "app" {
  ami           = data.aws_ami.ubuntu.id
  instance_type = var.instance_type
  subnet_id     = aws_subnet.public[0].id

  vpc_security_group_ids = [aws_security_group.app.id]
  key_name               = aws_key_pair.deploy.key_name

  root_block_device {
    volume_size = 50
    volume_type = "gp3"
    encrypted   = true
  }

  tags = {
    Name        = "${var.environment}-app"
    Environment = var.environment
  }
}

resource "aws_db_instance" "postgres" {
  identifier     = "${var.environment}-db"
  engine         = "postgres"
  engine_version = "17"
  instance_class = "db.t3.medium"

  allocated_storage     = 50
  max_allocated_storage = 200
  storage_encrypted     = true

  db_name  = "ecosire"
  username = "app"
  password = var.db_password

  vpc_security_group_ids = [aws_security_group.db.id]
  db_subnet_group_name   = aws_db_subnet_group.main.name

  backup_retention_period = 7
  backup_window           = "03:00-04:00"
  maintenance_window      = "sun:04:00-sun:05:00"

  skip_final_snapshot = false
  final_snapshot_identifier = "${var.environment}-db-final"

  tags = {
    Environment = var.environment
  }
}

---

Módulos para infraestrutura reutilizável

Criando um Módulo de Aplicativo Web

# modules/web-app/main.tf
variable "name" {
  type = string
}

variable "environment" {
  type = string
}

variable "instance_type" {
  type    = string
  default = "t3.medium"
}

variable "vpc_id" {
  type = string
}

variable "subnet_ids" {
  type = list(string)
}

resource "aws_lb" "app" {
  name               = "${var.name}-${var.environment}-alb"
  internal           = false
  load_balancer_type = "application"
  security_groups    = [aws_security_group.alb.id]
  subnets            = var.subnet_ids
}

resource "aws_lb_target_group" "app" {
  name     = "${var.name}-${var.environment}-tg"
  port     = 3000
  protocol = "HTTP"
  vpc_id   = var.vpc_id

  health_check {
    path                = "/health"
    healthy_threshold   = 2
    unhealthy_threshold = 3
    interval            = 30
  }
}

resource "aws_autoscaling_group" "app" {
  name                = "${var.name}-${var.environment}-asg"
  min_size            = 2
  max_size            = 10
  desired_capacity    = 2
  vpc_zone_identifier = var.subnet_ids
  target_group_arns   = [aws_lb_target_group.app.arn]

  launch_template {
    id      = aws_launch_template.app.id
    version = "$Latest"
  }

  tag {
    key                 = "Name"
    value               = "${var.name}-${var.environment}"
    propagate_at_launch = true
  }
}

output "alb_dns_name" {
  value = aws_lb.app.dns_name
}

Usando o Módulo

# environments/production/main.tf
module "web" {
  source = "../../modules/web-app"

  name          = "ecosire-web"
  environment   = "production"
  instance_type = "t3.large"
  vpc_id        = module.network.vpc_id
  subnet_ids    = module.network.public_subnet_ids
}

module "api" {
  source = "../../modules/web-app"

  name          = "ecosire-api"
  environment   = "production"
  instance_type = "t3.large"
  vpc_id        = module.network.vpc_id
  subnet_ids    = module.network.public_subnet_ids
}

---

Gestão de Estado

Estado remoto com S3

# Bootstrap: create the state bucket and DynamoDB table manually or with a separate config
resource "aws_s3_bucket" "terraform_state" {
  bucket = "ecosire-terraform-state"

  lifecycle {
    prevent_destroy = true
  }
}

resource "aws_s3_bucket_versioning" "terraform_state" {
  bucket = aws_s3_bucket.terraform_state.id
  versioning_configuration {
    status = "Enabled"
  }
}

resource "aws_dynamodb_table" "terraform_locks" {
  name         = "terraform-locks"
  billing_mode = "PAY_PER_REQUEST"
  hash_key     = "LockID"

  attribute {
    name = "LockID"
    type = "S"
  }
}

O bloqueio de estado via DynamoDB evita que dois engenheiros executem terraform apply simultaneamente, o que pode corromper o estado.

Segurança de arquivos de estado

O arquivo de estado do Terraform contém informações confidenciais, incluindo senhas de banco de dados, chaves de API e IDs de recursos. Proteja-o:

• Criptografar em repouso: controle de versão do bucket S3 + criptografia no lado do servidor
• Criptografar em trânsito: HTTPS apenas para acesso estatal
• Acesso restrito: políticas do IAM que limitam quem pode ler/gravar estado
• Nunca se comprometa com o Git: os arquivos de estado nunca devem estar no controle de versão
• Ativar controle de versão: o controle de versão S3 permite a recuperação de um estado corrompido

---

Integração CI/CD

Pipeline do Terraform de ações do GitHub

name: Terraform
on:
  pull_request:
    paths: ['infrastructure/**']
  push:
    branches: [main]
    paths: ['infrastructure/**']

jobs:
  plan:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: hashicorp/setup-terraform@v3

      - name: Terraform Init
        run: terraform init
        working-directory: infrastructure/environments/production

      - name: Terraform Plan
        run: terraform plan -out=tfplan
        working-directory: infrastructure/environments/production

      - name: Comment PR with plan
        if: github.event_name == 'pull_request'
        uses: actions/github-script@v7
        with:
          script: |
            const plan = require('fs').readFileSync('infrastructure/environments/production/tfplan.txt', 'utf8');
            github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
              body: `## Terraform Plan\n\`\`\`\n${plan}\n\`\`\``
            });

  apply:
    needs: plan
    if: github.ref == 'refs/heads/main'
    runs-on: ubuntu-latest
    environment: production
    steps:
      - uses: actions/checkout@v4
      - uses: hashicorp/setup-terraform@v3

      - name: Terraform Apply
        run: terraform apply -auto-approve
        working-directory: infrastructure/environments/production

---

Estratégia Multiambiente

Use espaços de trabalho do Terraform ou diretórios separados por ambiente:

infrastructure/
  modules/
    web-app/
    database/
    network/
  environments/
    development/
      main.tf
      terraform.tfvars
    staging/
      main.tf
      terraform.tfvars
    production/
      main.tf
      terraform.tfvars

---

Perguntas frequentes

Terraform ou Pulumi --- qual devemos escolher?

Terraform se sua equipe incluir engenheiros de operações que preferem configuração declarativa. Pulumi se sua equipe tem muitos desenvolvedores e prefere escrever infraestrutura em TypeScript ou Python. Terraform possui um ecossistema maior e mais módulos comunitários. Pulumi tem uma curva de aprendizado inicial mais acentuada, mas é mais flexível para lógica complexa.

Como importamos a infraestrutura existente para o Terraform?

Use terraform import para colocar os recursos existentes sob o gerenciamento do Terraform. Por exemplo: terraform import aws_instance.app i-1234567890abcdef0. Após a importação, escreva a configuração correspondente. Terraform 1.5+ oferece suporte a blocos de importação em arquivos de configuração para importações em massa.

Como lidamos com segredos no Terraform?

Nunca comprometa segredos em arquivos do Terraform. Use terraform.tfvars (excluído do Git), variáveis ​​de ambiente (TF_VAR_db_password) ou um gerenciador de segredos (AWS Secrets Manager, HashiCorp Vault). Marque variáveis ​​sensíveis com sensitive = true para evitar que apareçam na saída do plano.

Qual é o custo de gerenciamento do Terraform?

O próprio Terraform é gratuito e de código aberto. Terraform Cloud tem um nível gratuito para até 5 usuários com estado remoto e planejamento/aplicação. O principal custo é a curva de aprendizado (20 a 40 horas para um engenheiro experiente) e a manutenção contínua (2 a 4 horas por mês). Isto é compensado pelo tempo economizado no gerenciamento manual da infraestrutura.

---

O que vem a seguir

Terraform fornece a base para infraestrutura automatizada. Combine-o com pipelines de CI/CD para implantação automatizada, monitoramento para visibilidade operacional e recuperação de desastres para resiliência.

Entre em contato com a ECOSIRE para obter consultoria em automação de infraestrutura ou explore nosso guia DevOps para pequenas empresas para obter o roteiro completo.

---

Publicado pela ECOSIRE – ajudando empresas a automatizar a infraestrutura em nuvem.