TerraformComunidade
Nível de dificuldade: Básico (2 de 5)
Pipeline ECS Fargate com Terraform e OIDC elimina credenciais da AWS do repositório
Em números
- $32 por mês é quanto a equipe economizou só por não usar NAT Gateway, mantendo as tasks em subnets públicas protegidas por security group.
- 2 minutos e 47 segundos foi o tempo observado numa execução real do pipeline, do merge na
mainaté o ECS reportar o serviço estável. - 256 CPU units (equivalente a 0,25 vCPU) e 512 MiB é o tamanho da task Fargate que roda a API Node.js.
- 14 dias é quanto tempo os logs ficam retidos no CloudWatch antes de expirar.
O problema
O case study, publicado no blog DevOps with Umar e republicado no DEV Community, descreve um projeto fechado por preço fixo e prazo de cinco dias: colocar uma API Node.js em contêiner na AWS, com deploy automatizado e toda a infraestrutura em código. O cliente é mantido anônimo e o repositório é privado, mas o autor documentou o desenho técnico que entregou no handover.
O requisito que organiza a arquitetura inteira não é a aplicação em si, que é propositalmente simples, mas três restrições de operação: nenhuma chave da AWS pode ficar armazenada em lugar nenhum do GitHub, tudo precisa ser reproduzível a partir de código, e o ambiente precisa poder ser destruído e recriado sem sobra de custo. Para um arquiteto ou time de DevOps que herda esse tipo de entrega, o ponto não é a API, é saber reconstruir esse ambiente do zero com um comando e confiar que o pipeline não guarda segredo nenhum.
A arquitetura
O fluxo, do commit até o tráfego em produção, segue esta sequência:
- Um pull request dispara o GitHub Actions, que roda só os testes unitários, sem tocar em infraestrutura.
- Um merge na
mainaciona o workflowdeploy.yml: o GitHub Actions pede um token OIDC de curta duração ao próprio GitHub e troca esse token por credenciais temporárias da AWS via STS. - O pipeline builda a imagem Docker, publica no Amazon ECR com a tag igual ao SHA do commit (tags imutáveis, scan on push habilitado).
- Uma nova revisão de task definition é registrada apontando para a imagem recém-publicada.
- O serviço ECS Fargate é atualizado para usar a nova revisão; as tasks sobem em subnets públicas (CIDR
10.20.0.0/16, duas zonas de disponibilidade) com IP público, mas o security group só aceita tráfego vindo do load balancer. - O application load balancer faz health check em
/healthe só direciona tráfego para os alvos saudáveis. - O job do GitHub Actions espera o ECS reportar o serviço como estável antes de marcar o deploy como verde.
- Se as novas tasks falharem no health check, o deployment circuit breaker do ECS reverte sozinho para a revisão anterior, sem intervenção humana.
- CloudWatch coleta logs (retidos por 14 dias), alimenta um dashboard e três alarmes, que notificam um tópico SNS por e-mail.
- O estado do Terraform vive num bucket S3 com criptografia KMS, versionamento e lock nativo do S3, sem tabela DynamoDB.
Os serviços envolvidos
A infraestrutura é organizada em módulos Terraform separados por responsabilidade, o que importa tanto para quem vai ler o código quanto para quem vai dar manutenção nele depois:
| Peça | Serviço AWS | Papel |
|---|---|---|
| Rede | VPC, subnets públicas, internet gateway | Isola o ambiente e distribui as tasks em duas AZs |
| Load balancer | Application Load Balancer | Faz health check em /health e distribui tráfego |
| Registro | Amazon ECR | Guarda as imagens com tag imutável e scan on push |
| Serviço | ECS Fargate | Roda a task de 256 CPU units (0,25 vCPU) / 512 MiB sem servidor para gerenciar |
| Acesso | IAM role + OIDC | Credencial temporária para o GitHub Actions, sem chave fixa |
| Observabilidade | CloudWatch + SNS | Dashboard, três alarmes e notificação por e-mail |
| Estado | S3 + KMS | Terraform state com lock nativo (exige Terraform 1.10+) |
Os módulos têm nomes diretos: network, alb, ecr, ecs, github_oidc e monitoring. Uma pasta de ambiente consome todos eles e nenhuma variável tem valor default, uma escolha deliberada do autor para que nada fique escondido dentro dos módulos: todo parâmetro sensível ao contexto vive só no arquivo terraform.tfvars.
Trade-offs
A decisão mais discutível do desenho mexe no pilar de otimização de custos às custas do pilar de segurança: as tasks rodam em subnets públicas com IP público, não em subnets privadas atrás de um NAT Gateway. A mitigação é o security group, que só libera tráfego vindo do load balancer, então as tasks continuam inalcançáveis diretamente da internet mesmo tendo IP público atribuído.
Outra escolha afeta o pilar de excelência operacional: o recurso ECS no Terraform ignora mudanças na task definition e no número desejado de tasks (via lifecycle.ignore_changes). Isso evita que um terraform apply de rotina reverta a aplicação para a primeira imagem publicada, mas também significa que o Terraform não é mais a fonte única de verdade sobre qual versão está rodando, o pipeline de deploy é.
No pilar de confiabilidade, o lock de state via S3 nativo (sem DynamoDB) simplifica a stack, mas só funciona a partir do Terraform 1.10. Times que ainda operam em versões anteriores precisam manter a tabela de lock tradicional ou atualizar o Terraform antes de copiar esse padrão.
Custo estimado
A fonte só confirma um número de custo com precisão: pular o NAT Gateway economiza cerca de $32 por mês frente a uma VPC com subnets privadas e NAT. A tabela resume a troca:
| Opção | Isolamento de rede | Custo mensal de rede |
|---|---|---|
| Com NAT Gateway | Tasks em subnets privadas, sem IP público | Custo base + ~$32/mês de NAT |
| Sem NAT Gateway (usado no projeto) | Tasks em subnets públicas, IP público, security group restrito ao ALB | Custo base, sem NAT |
O restante do custo (horas de task Fargate, ALB, ECR, CloudWatch) depende do tráfego e não está detalhado no case study, então não vale inventar uma conta aqui. O ponto prático para quem orça algo parecido é outro: um Makefile com make up e make destroy cria e derruba a stack inteira com um comando, o que importa para ambiente de demonstração ou de teste, porque a fatura para de rodar assim que o ambiente é destruído.
Como adaptar
Para quem escreve Terraform no dia a dia e pensa esse desenho sob a ótica do Well-Architected, o case study já é entregue com os pontos de extensão separados por módulo, o que facilita adaptar sem redesenhar:
- Trocar subnets públicas por privadas com NAT Gateway ou VPC endpoints, se a carga de trabalho exigir isolamento de rede mais forte que o security group sozinho oferece.
- Adicionar HTTPS no load balancer, com certificado e redirecionamento da porta 80, hoje ausente no setup descrito.
- Substituir o número fixo de tasks por autoscaling baseado em CPU ou em contagem de requisições.
- Duplicar a pasta de ambiente para criar um staging, reaproveitando os mesmos módulos com outro
terraform.tfvars.
Um detalhe que vale conferir antes de copiar o padrão de OIDC: o GitHub mudou o formato do subject do token para repositórios mais novos, e a trust policy da IAM role do case study aceita as duas formas (a antiga e a numérica), para funcionar independente de quando o repositório foi criado. Quem for montar a github_oidc role do zero precisa checar qual formato o próprio repositório usa antes de travar a condição da trust policy, senão o AssumeRoleWithWebIdentity falha silenciosamente no primeiro deploy.
O autor do case study é direto sobre o que esse desenho não resolve sozinho: ele foi escopado para ser uma base limpa e funcional, não um ambiente de produção pronto. As quatro lacunas que ele lista (subnets privadas, HTTPS, autoscaling, staging) não exigem reescrever nada, porque módulos e pipeline já separam essas responsabilidades, só falta ligá-las quando o projeto justificar o custo extra.
Fonte: DEV Community — #aws
Serviços neste textoTerraformWell-Architected
Leve para a sua IA
Decida com o seu assistente, com o contexto deste texto já montado.
1. O que você quer saber
Ver o prompt
Li no AWS Hub: "Pipeline ECS Fargate com Terraform e OIDC elimina credenciais da AWS do repositório" (https://awshub.com.br/comunidade/pipeline-ecs-fargate-com-terraform-e-oidc-elimina-credenciais-da-aws-do-reposito). Resumo: Um case study de projeto fechado em cinco dias mostra como Terraform, GitHub Actions e OIDC publicam uma API em contêiner no ECS Fargate sem armazenar nenhuma chave da AWS, economizando NAT Gateway e automatizando o rollback. Serviços: Terraform, Well-Architected Minha stack: [descreva em uma linha: serviços, linguagem, volume, região] Isso muda alguma coisa na minha arquitetura? O que eu faria diferente a partir de amanhã?