Terraform, the 80/20.

O que é e o 20% que importaWhat it is and the 20% that matters

Terraform é uma ferramenta de infraestrutura como código (IaC): em vez de clicar no console da nuvem, você descreve em arquivos de texto o que quer que exista (redes, servidores, buckets, permissões) e o Terraform descobre o que precisa criar, alterar ou apagar para a realidade ficar igual à descrição. A linguagem é a HCL, e o trabalho é feito por providers (plugins) que falam com a API de cada serviço: AWS, Azure, Google Cloud, Cloudflare, GitHub, Kubernetes e milhares de outros.Terraform is an infrastructure as code (IaC) tool: instead of clicking in the cloud console, you describe in text files what should exist (networks, servers, buckets, permissions) and Terraform works out what to create, change or delete so reality matches the description. The language is HCL, and the work is done by providers (plugins) that talk to each service’s API: AWS, Azure, Google Cloud, Cloudflare, GitHub, Kubernetes and thousands more.

A ideia central é ser declarativo: você diz o destino (“quero 2 subnets e 1 bucket”), não os passos. É como a planta de uma casa: o Terraform compara a planta com a obra e só executa a diferença. Rodar de novo sem mudar nada não faz nada (idempotência).The core idea is being declarative: you state the destination (“I want 2 subnets and 1 bucket”), not the steps. It is like a house blueprint: Terraform compares the blueprint with the building and only carries out the difference. Running it again with no changes does nothing (idempotence).

Terraform, OpenTofu, CloudFormation e PulumiTerraform, OpenTofu, CloudFormation and Pulumi

Tudo que você aprende aqui vale para o OpenTofu também; só troque terraform por tofu no terminal.Everything you learn here also applies to OpenTofu; just swap terraform for tofu in the terminal.

O 20% que rende 80%The 20% that pays 80%

Instalar e rodar o primeiro projetoInstall and run your first project

Vamos rodar o ciclo completo sem nuvem nenhuma, usando o provider local, que só cria arquivos. Assim você vê o que o Terraform faz antes de gastar um centavo.Let us run the full cycle with no cloud at all, using the local provider, which only creates files. That way you see what Terraform does before spending a cent.

InstalarInstall

# Linux (Debian/Ubuntu): repositório oficial da HashiCorp
wget -O- https://apt.releases.hashicorp.com/gpg | sudo gpg --dearmor -o /usr/share/keyrings/hashicorp-archive-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] https://apt.releases.hashicorp.com $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/hashicorp.list
sudo apt update && sudo apt install terraform

# macOS
brew tap hashicorp/tap && brew install hashicorp/tap/terraform

terraform version
terraform -install-autocomplete    # completa comandos com Tab (reabra o terminal)

Primeiro projetoFirst project

# main.tf
terraform {
  required_version = ">= 1.10"
  required_providers {
    local = {
      source  = "hashicorp/local"
      version = "~> 2.5"
    }
  }
}

variable "name" {
  type    = string
  default = "world"
}

resource "local_file" "greeting" {
  filename = "${path.module}/hello.txt"
  content  = "Hello, ${var.name}!\n"
}

output "file_path" {
  value = local_file.greeting.filename
}

terraform init       # baixa o provider e cria .terraform/ e .terraform.lock.hcl
terraform fmt        # formata o código no padrão oficial
terraform validate   # confere sintaxe e referências
terraform plan       # mostra o que vai acontecer
terraform apply      # pede "yes" e executa
cat hello.txt        # Hello, world!
terraform apply -var name=Ana   # muda uma variável e aplica de novo
terraform destroy    # apaga tudo o que ele criou

O plan usa quatro símbolos. Aprenda a ler:The plan uses four symbols. Learn to read them:

O que fica na pastaWhat ends up in the folder

# .gitignore para Terraform
.terraform/
*.tfstate
*.tfstate.*
crash.log
*.tfplan
override.tf
override.tf.json
# valores com segredos: use um nome próprio e ignore-o aqui
*.auto.tfvars

A linguagem HCLThe HCL language

HCL (HashiCorp Configuration Language) tem só duas peças: blocos e argumentos. Um bloco tem um tipo, zero ou mais rótulos e um corpo entre chaves; o corpo tem argumentos (nome = valor) e outros blocos.HCL (HashiCorp Configuration Language) has only two pieces: blocks and arguments. A block has a type, zero or more labels and a body in braces; the body holds arguments (name = value) and other blocks.

resource "aws_s3_bucket" "logs" {   # tipo do bloco, tipo do recurso, nome local
  bucket = "acme-logs-prod"         # argumento
  tags = {                          # argumento cujo valor é um mapa
    Team = "platform"
  }
  lifecycle {                       # bloco aninhado
    prevent_destroy = true
  }
}

Tipos, referências e expressõesTypes, references and expressions

variable "region"   { type = string }                     # "sa-east-1"
variable "count_n"  { type = number }                     # 3
variable "enabled"  { type = bool }                       # true
variable "azs"      { type = list(string) }               # ["a", "b"] (ordenada)
variable "cidrs"    { type = set(string) }                # sem ordem e sem repetição
variable "tags"     { type = map(string) }                # { Team = "x" }
variable "disk"     {
  type = object({ size = number, encrypted = bool })      # estrutura fixa
}

locals {
  env      = "dev"
  name     = "${var.project}-${local.env}"                 # interpolação
  size     = var.enabled ? 100 : 20                        # condicional
  upper    = [for s in var.azs : upper(s)]                 # lista -> lista
  by_az    = { for s in var.azs : s => "${var.region}${s}" }   # lista -> mapa
  ids      = aws_instance.web[*].id                        # splat: todos os ids
  merged   = merge(var.tags, { Env = local.env })          # junta mapas
  safe     = try(var.disk.size, 20)                        # valor padrão se falhar
}

Referências seguem o padrão tipo.nome.atributo: aws_vpc.main.id, var.region, local.tags, module.vpc.public_subnets, data.aws_region.current.name. Funções úteis para decorar: merge, lookup, join, format, toset, try, coalesce, cidrsubnet, jsonencode, file. Teste qualquer expressão no terraform console.References follow the type.name.attribute pattern: aws_vpc.main.id, var.region, local.tags, module.vpc.public_subnets, data.aws_region.current.name. Useful functions to memorise: merge, lookup, join, format, toset, try, coalesce, cidrsubnet, jsonencode, file. Test any expression in terraform console.

terraform console
> cidrsubnet("10.0.0.0/16", 8, 1)
"10.0.1.0/24"
> upper("abc")
"ABC"

O fluxo e os comandosThe workflow and commands

Estado, backend e driftState, backend and drift

O estado é um arquivo JSON que mapeia cada bloco do código ao objeto real (por exemplo, aws_s3_bucket.logs ↔ o bucket acme-logs-prod) e guarda os atributos conhecidos. Sem ele o Terraform não sabe o que já criou. Três regras de ouro:The state is a JSON file mapping each code block to the real object (for example, aws_s3_bucket.logs ↔ the bucket acme-logs-prod) and storing the known attributes. Without it Terraform does not know what it already created. Three golden rules:

1. Nunca edite à mão nem coloque no Git: ele pode conter senhas e chaves em texto puro.Never edit it by hand and never commit it: it may hold passwords and keys in plain text.
2. Em equipe, use backend remoto com trava (S3, GCS, Azure Blob, HCP Terraform) para ninguém aplicar ao mesmo tempo.In a team, use a remote backend with locking (S3, GCS, Azure Blob, HCP Terraform) so nobody applies at the same time.
3. Mude o estado só pelos comandos e blocos oficiais (terraform state, moved, import, removed).Change state only through the official commands and blocks (terraform state, moved, import, removed).

terraform state list                       # tudo que o estado conhece
terraform state show aws_s3_bucket.logs    # os atributos de um recurso
terraform state mv A B                     # renomeia no estado (prefira o bloco moved)
terraform state rm aws_s3_bucket.logs      # "esquece" sem apagar na nuvem (prefira removed)
terraform force-unlock LOCK_ID             # só se um apply morreu e deixou a trava

Refatorar e adotar sem destruirRefactor and adopt without destroying

# 1) Renomeou um recurso no código? Diga ao Terraform que é o MESMO objeto:
moved {
  from = aws_s3_bucket.logs
  to   = aws_s3_bucket.access_logs
}

# 2) Já existe na nuvem e foi criado no console? Adote no estado (Terraform >= 1.5):
import {
  to = aws_s3_bucket.legacy
  id = "bucket-criado-no-console"
}
# terraform plan -generate-config-out=generated.tf  escreve o código por você

# 3) Quer parar de gerenciar sem apagar o objeto? (Terraform >= 1.7)
removed {
  from = aws_s3_bucket.legacy
  lifecycle {
    destroy = false
  }
}

DriftDrift

Drift é quando alguém muda a nuvem pelo console e o código fica desatualizado. O plan normal já mostra a diferença (o Terraform tenta desfazer a mudança manual). Use plan -refresh-only para só atualizar o estado com o que existe, ou aplique o código para corrigir a nuvem. Em times, o remédio é simples: permissões de escrita no console só para emergências.Drift is when someone changes the cloud in the console and the code gets out of date. A normal plan already shows the difference (Terraform tries to undo the manual change). Use plan -refresh-only to merely update state with what exists, or apply the code to fix the cloud. For teams the cure is simple: console write access only for emergencies.

Variáveis, locals e outputsVariables, locals and outputs

Três blocos separam o que muda do como é feito: variable (entrada de fora), locals (valor calculado dentro) e output (saída). Todo módulo, inclusive o diretório raiz, é uma função: entra variável, sai output.Three blocks separate what changes from how it is done: variable (input from outside), locals (computed value inside) and output (result). Every module, including the root directory, is a function: variables go in, outputs come out.

variable "environment" {
  description = "Nome do ambiente"
  type        = string
  default     = "dev"

  validation {
    condition     = contains(["dev", "staging", "prod"], var.environment)
    error_message = "environment deve ser dev, staging ou prod."
  }
}

variable "db_password" {
  type      = string
  sensitive = true          # some da saída do plan/apply (mas continua no state!)
}

locals {
  name_prefix = "${var.project}-${var.environment}"
  tags = {
    Project     = var.project
    Environment = var.environment
  }
}

output "name_prefix" {
  description = "Prefixo usado nos recursos"
  value       = local.name_prefix
}

Os valores chegam por vários caminhos. Em caso de conflito vence o de baixo da lista (o último):Values arrive through several paths. On conflict the one lower in the list (the last) wins:

1. o default da variávelthe variable’s default
2. variáveis de ambiente TF_VAR_nomeenvironment variables TF_VAR_name
3. terraform.tfvars e terraform.tfvars.jsonterraform.tfvars and terraform.tfvars.json
4. *.auto.tfvars (em ordem alfabética)*.auto.tfvars (in alphabetical order)
5. -var-file=… e -var nome=valor na linha de comando, na ordem em que aparecem-var-file=… and -var name=value on the command line, in the order given

terraform plan -var-file=prod.tfvars
export TF_VAR_db_password="$(aws secretsmanager get-secret-value --secret-id app/db --query SecretString --output text)"

Dependências, repetição e lifecycleDependencies, repetition and lifecycle

Dependências e o grafoDependencies and the graph

Cada vez que um recurso referencia outro (vpc_id = aws_vpc.main.id) o Terraform cria uma aresta no grafo: o referenciado nasce primeiro e morre por último. O que não depende entre si roda em paralelo (padrão: 10 ao mesmo tempo). Você quase nunca precisa de depends_on; ele serve só para dependências que o Terraform não enxerga (por exemplo, uma política IAM que precisa existir antes de uma aplicação funcionar).Each time a resource references another (vpc_id = aws_vpc.main.id) Terraform adds an edge to the graph: the referenced one is born first and dies last. Things that do not depend on each other run in parallel (default: 10 at a time). You almost never need depends_on; it is only for dependencies Terraform cannot see (for example, an IAM policy that must exist before an application works).

count, for_each e dynamiccount, for_each and dynamic

# for_each: um recurso por item, com CHAVE estável
variable "buckets" {
  type    = set(string)
  default = ["logs", "assets"]
}

resource "aws_s3_bucket" "this" {
  for_each = var.buckets
  bucket   = "${var.project}-${each.key}"     # each.key / each.value
}
# endereços: aws_s3_bucket.this["logs"], aws_s3_bucket.this["assets"]

# count: ligar/desligar (0 ou 1) ou N cópias idênticas
resource "aws_eip" "web" {
  count    = var.enable_eip ? 1 : 0
  instance = aws_instance.web.id
}

# dynamic: repete um BLOCO ANINHADO
resource "aws_security_group" "web" {
  name   = "web"
  vpc_id = var.vpc_id

  dynamic "ingress" {
    for_each = var.allowed_ports
    content {
      from_port   = ingress.value
      to_port     = ingress.value
      protocol    = "tcp"
      cidr_blocks = ["0.0.0.0/0"]
    }
  }
}

lifecycle: regras para casos delicadoslifecycle: rules for delicate cases

resource "aws_instance" "web" {
  # ...
  lifecycle {
    create_before_destroy = true         # sobe o novo antes de derrubar o velho
    prevent_destroy       = true         # erro se um plan tentar destruir (proteção de dados)
    ignore_changes        = [ami, tags["LastDeploy"]]   # ignora mudanças feitas por fora
    replace_triggered_by  = [aws_launch_template.web.latest_version]

    precondition {
      condition     = var.instance_type != "t2.nano"
      error_message = "Tipo de instância pequeno demais."
    }
  }
}

Módulos e ambientesModules and environments

Um módulo é uma pasta com arquivos .tf usada por outro código via bloco module. O diretório onde você roda terraform apply é o módulo raiz; os que ele chama são módulos filhos. Variáveis são as entradas e outputs, as saídas. Módulos vêm de uma pasta local, do Terraform Registry, do Git ou de um bucket.A module is a folder of .tf files used by other code through a module block. The directory where you run terraform apply is the root module; the ones it calls are child modules. Variables are the inputs and outputs the results. Modules come from a local folder, the Terraform Registry, Git or a bucket.

infra/
├── modules/
│   └── web/                 # módulo reutilizável
│       ├── main.tf          # recursos
│       ├── variables.tf     # entradas
│       ├── outputs.tf       # saídas
│       └── README.md        # gerado com terraform-docs
└── envs/
    ├── dev/
    │   ├── main.tf          # module "web" { source = "../../modules/web" ... }
    │   ├── backend.tf       # state em outro "key" do bucket
    │   └── dev.tfvars
    └── prod/
        └── ...

module "web" {
  source        = "../../modules/web"        # pasta local
  name          = "loja"
  instance_type = "t3.micro"
  subnet_id     = module.network.public_subnets[0]
}

module "vpc" {
  source  = "terraform-aws-modules/vpc/aws"  # Terraform Registry
  version = "~> 6.0"                         # SEMPRE fixe a versão
  # ...
}

Ambientes: pastas ou workspaces?Environments: folders or workspaces?

Times, CI e boas práticasTeams, CI and best practices

Em produção ninguém roda apply do notebook. O fluxo de equipe é: Pull Request → verificações automáticas + plan como comentário → revisão → merge → apply automático (ou aprovado) do mesmo plano.In production nobody runs apply from a laptop. The team flow is: Pull Request → automatic checks + plan as a comment → review → merge → automatic (or approved) apply of the same plan.

# .github/workflows/terraform.yml (trecho; confira as versões atuais das actions)
name: terraform
on:
  pull_request:
  push:
    branches: [main]
permissions:
  id-token: write       # OIDC
  contents: read
  pull-requests: write  # comentar o plan
jobs:
  plan:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: hashicorp/setup-terraform@v3
      - uses: aws-actions/configure-aws-credentials@v4
        with:
          role-to-assume: arn:aws:iam::123456789012:role/terraform-plan
          aws-region: sa-east-1
      - run: terraform fmt -check -recursive
      - run: terraform init -input=false
      - run: terraform validate
      - run: terraform plan -input=false -out=tfplan

Ferramentas que valem a penaTools worth having

# tests/bucket.tftest.hcl
run "bucket_is_private" {
  command = plan

  assert {
    condition     = aws_s3_bucket_public_access_block.assets.block_public_acls == true
    error_message = "O bucket precisa bloquear ACLs públicas."
  }
}

Hábitos que evitam 90% dos incidentesHabits that prevent 90% of incidents

1. Versões fixas: required_version, version = "~> X.Y" nos providers e módulos, e .terraform.lock.hcl no Git. Atualize de propósito (init -upgrade + revisar), de preferência com Renovate/Dependabot.Pinned versions: required_version, version = "~> X.Y" on providers and modules, and .terraform.lock.hcl in Git. Upgrade on purpose (init -upgrade + review), ideally with Renovate/Dependabot.
2. Um estado por ambiente e por “raio de impacto”: um estado gigante deixa o plan lento e o risco enorme.One state per environment and per “blast radius”: one giant state makes plan slow and the risk huge.
3. Nomes e tags padronizados (default_tags no provider AWS).Standard names and tags (default_tags on the AWS provider).
4. prevent_destroy em bancos e buckets de dados; backups e versionamento ligados.prevent_destroy on databases and data buckets; backups and versioning on.
5. Nunca -target como rotina e nunca apply sem ler o plan.Never -target as routine and never apply without reading the plan.
6. O papel que o Terraform assume deve ter só as permissões necessárias (e papéis separados para plan e apply).The role Terraform assumes should have only the needed permissions (and separate roles for plan and apply).
7. Tudo na nuvem pelo código; o console é para ler. Drift se detecta com plan agendado.Everything in the cloud through code; the console is for reading. Detect drift with a scheduled plan.

AWS: provider e credenciaisAWS: provider and credentials

A partir daqui o foco é a AWS. O provider hashicorp/aws usa as mesmas credenciais da AWS CLI e dos SDKs. A regra é simples: nunca escreva chaves no código. Para pessoas, use o IAM Identity Center (SSO); para pipelines, OIDC; para servidores na AWS, papéis de instância.From here on the focus is AWS. The hashicorp/aws provider uses the same credentials as the AWS CLI and SDKs. The rule is simple: never write keys in code. For people, use IAM Identity Center (SSO); for pipelines, OIDC; for servers on AWS, instance roles.

# versions.tf
terraform {
  required_version = ">= 1.10"
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 6.0"          # confira a versão maior atual no Registry
    }
  }
}

# providers.tf
provider "aws" {
  region              = var.region
  allowed_account_ids = [var.account_id]     # TRAVA: recusa rodar na conta errada

  default_tags {
    tags = {
      Project     = var.project
      Environment = var.environment
      ManagedBy   = "terraform"
    }
  }
}

# um segundo provider para outra região (ex.: certificados do CloudFront só em us-east-1)
provider "aws" {
  alias  = "virginia"
  region = "us-east-1"
}

resource "aws_acm_certificate" "site" {
  provider          = aws.virginia
  domain_name       = "exemplo.com"
  validation_method = "DNS"
}

aws sts get-caller-identity     # SEMPRE confirme conta e papel antes de um apply

AWS: estado remoto no S3AWS: remote state on S3

O estado em equipe vai para um bucket S3. Desde o Terraform 1.10 o backend S3 tem trava nativa (use_lockfile = true): ele grava um arquivo .tflock ao lado do estado, sem precisar de DynamoDB (o bloqueio por DynamoDB ainda existe, mas está obsoleto). Existe um ovo-e-galinha: o bucket precisa existir antes do Terraform que o usa. A solução mais simples é criá-lo uma vez à mão (ou com um pequeno projeto de “bootstrap” de estado local).In a team, state goes into an S3 bucket. Since Terraform 1.10 the S3 backend has native locking (use_lockfile = true): it writes a .tflock file next to the state, with no DynamoDB needed (DynamoDB locking still exists but is deprecated). There is a chicken-and-egg problem: the bucket must exist before the Terraform that uses it. The simplest fix is to create it once by hand (or with a tiny local-state “bootstrap” project).

# Bootstrap (uma vez por conta). Troque nome e região; S3 exige nome GLOBALMENTE único.
BUCKET=acme-tfstate-123456789012
REGION=sa-east-1

aws s3api create-bucket --bucket $BUCKET --region $REGION \
  --create-bucket-configuration LocationConstraint=$REGION   # (em us-east-1 omita esta linha)
aws s3api put-bucket-versioning --bucket $BUCKET \
  --versioning-configuration Status=Enabled
aws s3api put-public-access-block --bucket $BUCKET \
  --public-access-block-configuration BlockPublicAcls=true,IgnorePublicAcls=true,BlockPublicPolicy=true,RestrictPublicBuckets=true

# backend.tf  (o bloco backend NÃO aceita variáveis)
terraform {
  backend "s3" {
    bucket       = "acme-tfstate-123456789012"
    key          = "loja/dev/terraform.tfstate"   # um "key" por projeto e ambiente
    region       = "sa-east-1"
    encrypt      = true
    use_lockfile = true                           # trava nativa (Terraform >= 1.10)
  }
}

terraform init                    # detecta o backend novo e oferece migrar o estado local
terraform init -migrate-state     # (ou explicitamente)
terraform init -backend-config="key=loja/prod/terraform.tfstate"   # muda o key sem editar o código

Permissões mínimas do papel que roda o Terraform sobre o estado:Minimum permissions for the role that runs Terraform over the state:

{
  "Version": "2012-10-17",
  "Statement": [
    { "Effect": "Allow", "Action": "s3:ListBucket",
      "Resource": "arn:aws:s3:::acme-tfstate-123456789012" },
    { "Effect": "Allow", "Action": ["s3:GetObject", "s3:PutObject", "s3:DeleteObject"],
      "Resource": "arn:aws:s3:::acme-tfstate-123456789012/loja/*" }
  ]
}

AWS: VPC, EC2 e S3 passo a passoAWS: VPC, EC2 and S3 step by step

Vamos montar uma pilha pequena e realista: uma VPC com subnets públicas, um servidor EC2 com nginx acessível por HTTP, sem SSH (acesso pelo Session Manager do SSM, com papel IAM) e um bucket S3 privado. É o mesmo esqueleto de muitos ambientes reais, em ponto pequeno.Let us build a small, realistic stack: a VPC with public subnets, an EC2 server running nginx reachable over HTTP, no SSH (access through SSM Session Manager, with an IAM role) and a private S3 bucket. It is the skeleton of many real environments, in miniature.

Variáveis e redeVariables and network

# variables.tf
variable "project" {
  type    = string
  default = "loja"
}

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

variable "region" {
  type    = string
  default = "sa-east-1"
}

variable "account_id" {
  type        = string
  description = "ID da conta onde é permitido aplicar"
}

# network.tf
data "aws_availability_zones" "available" {
  state = "available"
}

data "aws_caller_identity" "current" {}

module "vpc" {
  source  = "terraform-aws-modules/vpc/aws"
  version = "~> 6.0"

  name = "${var.project}-${var.environment}"
  cidr = "10.0.0.0/16"

  azs            = slice(data.aws_availability_zones.available.names, 0, 2)
  public_subnets = ["10.0.1.0/24", "10.0.2.0/24"]

  enable_nat_gateway = false   # NAT Gateway cobra por hora; só ligue se houver subnets privadas
}

Segurança, papel e servidorSecurity, role and server

# security.tf
resource "aws_security_group" "web" {
  name_prefix = "${var.project}-web-"
  description = "HTTP de entrada, tudo de saida"
  vpc_id      = module.vpc.vpc_id

  lifecycle {
    create_before_destroy = true
  }
}

resource "aws_vpc_security_group_ingress_rule" "http" {
  security_group_id = aws_security_group.web.id
  cidr_ipv4         = "0.0.0.0/0"
  from_port         = 80
  to_port           = 80
  ip_protocol       = "tcp"
}

resource "aws_vpc_security_group_egress_rule" "all" {
  security_group_id = aws_security_group.web.id
  cidr_ipv4         = "0.0.0.0/0"
  ip_protocol       = "-1"
}

# iam.tf  (acesso por SSM: sem chave SSH e sem porta 22)
data "aws_iam_policy_document" "ec2_assume" {
  statement {
    actions = ["sts:AssumeRole"]
    principals {
      type        = "Service"
      identifiers = ["ec2.amazonaws.com"]
    }
  }
}

resource "aws_iam_role" "web" {
  name               = "${var.project}-${var.environment}-web"
  assume_role_policy = data.aws_iam_policy_document.ec2_assume.json
}

resource "aws_iam_role_policy_attachment" "ssm" {
  role       = aws_iam_role.web.name
  policy_arn = "arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore"
}

resource "aws_iam_instance_profile" "web" {
  name = "${var.project}-${var.environment}-web"
  role = aws_iam_role.web.name
}

# compute.tf
data "aws_ssm_parameter" "al2023" {
  name = "/aws/service/ami-amazon-linux-latest/al2023-ami-kernel-default-x86_64"
}

resource "aws_instance" "web" {
  ami                         = data.aws_ssm_parameter.al2023.value
  instance_type               = "t3.micro"
  subnet_id                   = module.vpc.public_subnets[0]
  vpc_security_group_ids      = [aws_security_group.web.id]
  iam_instance_profile        = aws_iam_instance_profile.web.name
  associate_public_ip_address = true

  user_data = <<-EOT
    #!/bin/bash
    dnf install -y nginx
    systemctl enable --now nginx
  EOT

  metadata_options {
    http_tokens = "required"        # IMDSv2 obrigatório
  }

  root_block_device {
    encrypted = true
  }

  tags = {
    Name = "${var.project}-${var.environment}-web"
  }

  lifecycle {
    ignore_changes = [ami]          # a AMI "latest" muda com o tempo: não recriar o servidor por isso
  }
}

Bucket privado e saídasPrivate bucket and outputs

# storage.tf
resource "aws_s3_bucket" "assets" {
  bucket = "${var.project}-${var.environment}-assets-${data.aws_caller_identity.current.account_id}"
}

resource "aws_s3_bucket_public_access_block" "assets" {
  bucket                  = aws_s3_bucket.assets.id
  block_public_acls       = true
  block_public_policy     = true
  ignore_public_acls      = true
  restrict_public_buckets = true
}

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

# outputs.tf
output "web_instance_id" {
  value = aws_instance.web.id
}

output "web_public_ip" {
  value = aws_instance.web.public_ip
}

output "assets_bucket" {
  value = aws_s3_bucket.assets.bucket
}

export AWS_PROFILE=dev
aws sts get-caller-identity                     # conta certa?
terraform init
terraform plan -var account_id=123456789012 -out=tfplan
terraform apply tfplan

curl http://$(terraform output -raw web_public_ip)           # página do nginx
aws ssm start-session --target $(terraform output -raw web_instance_id)   # shell sem SSH

terraform destroy -var account_id=123456789012  # ao terminar o estudo, para não gerar custo

AWS: padrões, erros e roteiroAWS: patterns, errors and roadmap

Padrões que se repetem em toda pilha AWSPatterns that repeat in every AWS stack

Erros comuns e o que fazerCommon errors and what to do

Ordem sugerida para aprender AWS com TerraformSuggested order for learning AWS with Terraform

1. Conta de estudo, SSO e aws sts get-caller-identity.Study account, SSO and aws sts get-caller-identity.
2. Um bucket S3 privado (o “hello world” da AWS), com plan/apply/destroy.A private S3 bucket (AWS’s “hello world”), with plan/apply/destroy.
3. Backend remoto no S3 e migração do estado local.Remote backend on S3 and migrating local state.
4. A pilha VPC + EC2 + IAM desta nota.The VPC + EC2 + IAM stack from this note.
5. Extrair para um módulo e criar envs/dev e envs/prod (contas diferentes).Extract into a module and create envs/dev and envs/prod (different accounts).
6. Pipeline com OIDC: plan no PR, apply no merge.Pipeline with OIDC: plan on PRs, apply on merge.
7. Serviços de dados e contêineres: RDS (manage_master_user_password), ECS/Fargate, ALB, Route 53, ACM.Data and container services: RDS (manage_master_user_password), ECS/Fargate, ALB, Route 53, ACM.

Cola e perguntas de revisãoCheat sheet and review questions

Cola (cheat sheet)Cheat sheet

# bloco              # forma mínima
terraform { required_version = ">= 1.10" }
provider "aws"       { region = "sa-east-1" }
resource "T" "N"     { arg = valor }              # criar: T.N.attr
data "T" "N"         { arg = valor }              # ler:   data.T.N.attr
variable "v"         { type = string }            # var.v
locals               { x = "${var.v}-x" }         # local.x
output "o"           { value = T.N.attr }
module "m"           { source = "./m" }           # module.m.out

Perguntas de revisão (estilo Terraform Associate)Review questions (Terraform Associate style)