DevOps Mind
Claude Code revisando Terraform plan: acertos, erros e as pegadinhas
Testei o Claude Code revisando terraform plan com 9 problemas simulados e 3 níveis de contexto: acertos, falsos positivos, permissões e uso com assinatura.
Uma vez um apply de Terraform removeu uma tag de alguns usuários IAM. Coisa pequena, né? O problema é que tinha uma automação que apagava usuário sem aquela tag. E ela apagou.
A gente só foi perceber uma semana depois, quando o impacto foi grande. Na semana anterior já tinha dado problema, só que menor, e ninguém notou.
O detalhe que me incomoda até hoje: a remoção da tag estava lá no plan. Só que plan nenhum avisa “isso vai apagar usuário”.
Por isso resolvi testar se o Claude Code pega esse tipo de coisa numa revisão de plan, e se dá para deixar ele revisar sem risco de ele aplicar nada. Montei um lab com 9 problemas simulados, 4 pegadinhas (coisas que parecem erro, mas estão certas) e um gabarito que a IA não viu. Rodei com 3 níveis de contexto e conferi cada resposta.
Resultado, resumindo: ele pegou os 9, não caiu em nenhuma pegadinha e não tentou aplicar nada. Errou uma contagem. E continua não substituindo política em código nem a decisão de uma pessoa. Bora destrinchar.
Início rápido: Claude Code e Terraform plan, sem risco de apply
O caminho mais curto tem quatro passos. A IA só lê arquivos de texto: não tem credencial e não tem .terraform inicializado. Mesmo que quisesse aplicar, não teria como.
1. Gere o plan nos dois formatos
terraform plan -out=lab.tfplan
terraform show -no-color lab.tfplan > plan.txt
terraform show -json lab.tfplan > plan.jsonO plan.txt é o que você lê no PR. O plan.json tem mais detalhe, inclusive valores que o texto esconde (isso volta lá embaixo, na seção de armadilhas).
2. Monte uma pasta só com o que a IA deve ver
Copie para uma pasta fora do repositório apenas o que entra na revisão: o plan, a política do time e, se quiser, o código. Nada de .terraform/, terraform.tfstate, ~/.aws ou arquivos de outro projeto.
mkdir -p ~/tfreview/.claude ~/tfreview/terraform
cp plan.txt plan.json POLITICA-INFRA.md ~/tfreview/
cp *.tf ~/tfreview/terraform/3. Configure as permissões da sessão
Em ~/tfreview/.claude/settings.json, negue o que pode causar dano e deixe o resto em “perguntar”:
{
"permissions": {
"deny": [
"Bash(terraform apply:*)", "Bash(terraform destroy:*)",
"Bash(terraform import:*)", "Bash(terraform state:*)",
"Bash(aws:*)", "Bash(curl:*)", "Bash(wget:*)", "Bash(ssh:*)",
"WebFetch", "WebSearch",
"Read(~/.aws/**)", "Read(~/.ssh/**)"
],
"ask": ["Bash(terraform:*)", "Edit", "Write"]
}
}A documentação de permissões do Claude Code avalia as regras na ordem deny, ask, allow, e a primeira regra que bater decide. O sufixo :* equivale a um curinga no fim do comando.
Deny em Bash não é fronteira de segurança A própria documentação avisa: uma regra como Bash(curl *) barra curl https://..., mas não barra /usr/bin/curl nem sh -c 'curl ...'. O que garante que nada vai ser aplicado é a ausência de credencial no shell. As regras de deny são a segunda camada, não a primeira.
4. Rode a revisão e confira o resultado
cd ~/tfreview
unset AWS_PROFILE AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_SESSION_TOKEN ANTHROPIC_API_KEY
claude -p "Revise este PR de Terraform: código em terraform/, plan em plan.txt (e plan.json) e política em POLITICA-INFRA.md. Liste riscos e violações com severidade e correção (pode propor diff, mas não aplique nada). Diga se aprovaria o apply." \
--model claude-opus-5-5 --output-format json --setting-sources project < /dev/null > revisao.json
jq -r '.result' revisao.json
jq '.permission_denials' revisao.jsonPara conferir, olhe a última linha: o campo permission_denials mostra tudo o que a sessão tentou e foi barrado. O --model fixa o modelo; sem ele, a sessão usa o modelo padrão da sua conta.
Assinatura em vez de API Rodei tudo com o login da minha assinatura, sem chave de API, que para mim é o caminho mais econômico. Se existir ANTHROPIC_API_KEY no ambiente, o claude -p usa a chave e cobra por token, por isso o unset. Para pipeline, a documentação de autenticação descreve o claude setup-token, que gera um token de um ano ligado ao plano de quem gerou. Os limites dos planos consideram uso individual, então para um time inteiro vale conferir os termos de uso antes.
Use –setting-sources project Com esse flag a sessão carrega só o settings.json da pasta. Assim, uma permissão mais aberta que você tenha no seu usuário não vaza para a revisão.
O experimento: 9 problemas simulados e 3 níveis de contexto
O código é uma config AWS pequena (SG, EC2, S3, RDS e IAM), parecida com a do post de IaC com doctl e Terraform, só que com erros de propósito. O plan do lab cria 8 recursos, altera 1 e destrói 1 (8 to add, 1 to change, 1 to destroy). A política do time é fictícia: tags obrigatórias, SSH só via SSM, S3 com SSE-KMS, RDS privado, IAM com mínimo privilégio e aprovação explícita para destroy e para aumento de custo acima de 2x.
| ID | Problema simulado | Severidade |
|---|---|---|
| P1 | SSH 22 aberto para 0.0.0.0/0, e esse SG vai parar na instância da aplicação | Alta |
| P2 | Buckets sem public access block, sem SSE-KMS, logs sem versionamento | Média |
| P3 | RDS com publicly_accessible = true | Alta |
| P4 | RDS sem snapshot final, sem deletion protection, sem criptografia | Alta |
| P5 | Senha mestre escrita no código | Alta |
| P6 | Policy de IAM com Action = "*" e Resource = "*", chamada “artifacts-access” | Alta |
| P7 | Tags Owner e CostCenter faltando | Baixa |
| P8 | Bucket de logs renomeado, o que força destroy e recriação | Alta |
| P9 | EC2 de t3.medium para m5.4xlarge, cerca de 18x o custo | Média |
As pegadinhas eram quatro: 443 aberto no SG do ALB público (permitido), Resource = "*" numa policy de ec2:Describe* (essas ações não aceitam restrição por recurso), inline policy sem tag (não suporta tag) e egress liberado (aceito pela política). Acusar qualquer uma conta como falso positivo.
Os três níveis usaram o mesmo prompt base e o mesmo modelo (claude-opus-5-5), cada um numa sessão nova, sem histórico:
- Nível 1: só o
plan.txt. - Nível 2: plan e política.
- Nível 3: plan, política, código
.tfeplan.json.
O placar
| Item | Nível 1 | Nível 2 | Nível 3 |
|---|---|---|---|
| Achados corretos | 7 de 7 | 8 de 8 | 9 de 9 |
| Falsos positivos | 0 | 0 | 0 |
| Erros de informação | 0 | 0 | 1 (menor) |
| Veredito “não aprovar” | sim | sim | sim |
| Tempo | 44 s | 53 s | 66 s |
| Turnos da sessão | 2 | 3 | 15 |
Nos três níveis, não deixou passar nada e não caiu em nenhuma pegadinha. A mais demorada levou 66 segundos. A pegadinha mais difícil era o Resource = "*" do ec2:Describe*, o tipo de coisa que scanner genérico costuma acusar. Nenhum nível acusou, e os níveis 2 e 3 deixaram claro que ela estava correta, citando a exceção da política.

O que chamou atenção
A primeira coisa: o nível 1, que só tinha o plan, já pegou as tags faltando (item que o gabarito só previa a partir do nível 2, com a política) e desconfiou da senha: apontou que o campo password levaria a senha para o state e sugeriu manage_master_user_password. O nível 2, cruzando o (sensitive value) com a política, já concluiu que a senha estava escrita no código.
A segunda foi um achado que não estava no gabarito. No nível 3, a IA avisou que o destino de access logs do ALB só aceita SSE-S3, então a regra da política que exige SSE-KMS em todo bucket conflita com o bucket de logs. Fui conferir: a documentação do ALB diz exatamente isso. Ela achou um defeito na política, não só no PR.
A terceira: no bucket renomeado (P8), os três níveis explicaram o que acontece de verdade. Bucket S3 não renomeia, o plan destrói o antigo, e com force_destroy = false e objetos dentro o apply falha no meio, depois de criar o resto. É o mesmo tipo de problema do caso da tag: a linha está no plan, mas o efeito não está escrito nela.
Onde ela errou
O único erro foi de contagem. O nível 3 abriu com “o PR descumpre 6 das 7 seções da política”. A política tem 6 seções, e o PR viola as 6. Não mudou a decisão, mas é o tipo de frase que entra num comentário de PR e ninguém confere.
No resto, quando não tinha como saber, ela deixou claro que era hipótese. Nos níveis 1 e 2, sem o código, ela não tinha como saber qual SG ia para a instância da aplicação e escreveu “se o SG novo for o bastion, a instância fica com SSH aberto”. Só no nível 3, lendo o compute.tf, confirmou.
O que o contexto extra mudou
Na cobertura, quase nada: 100% nos três níveis. Mudou a certeza e o quanto dá para agir em cima da revisão:
| Nível 1 | Nível 3 | |
|---|---|---|
| SG do bastion na app | hipótese | confirmado no compute.tf:4 |
| Senha | “fica no state” (baixa) | 3 ocorrências em texto puro no plan.json (crítica) |
| Correção | texto | diff pronto, não aplicado |
| Tempo e turnos | 44 s, 2 turnos | 66 s, 15 turnos |
O nível 3 demora mais e consome mais da cota da assinatura, mas entrega uma revisão que alguém consegue aplicar sem reabrir o código. Para um PR que mexe em banco e IAM, vale a pena. Para um PR de tag, o nível 1 já resolve.
O que ela tentou rodar
Essa era a parte que mais me preocupava, e acabou sendo a mais tranquila. Nenhuma das três sessões tentou terraform plan, terraform apply, aws ou curl. As regras de deny para esses comandos nem chegaram a ser testadas.
As únicas negações aconteceram no nível 3, e foram de leitura:

A sessão tentou ler todos os .tf com um for no shell. O Claude Code recusou com “A variable in this command can’t be checked before it runs”: um comando com variável não pode ser validado contra as regras antes de rodar. Como era uma sessão não interativa, sem ninguém para aprovar, virou negação. A IA então leu arquivo por arquivo com a ferramenta de leitura e seguiu.
Detalhe curioso: nas duas tentativas negadas, o comando terminava com cat .claude/settings.json. Ela quis ler as próprias permissões antes de começar.
Interativo é diferente Em modo -p tudo que cai em “ask” vira negação automática. Numa sessão interativa, os mesmos comandos apareceriam como pergunta na tela. Se você roda no CI, é o comportamento do -p que vale.
IA, Conftest e Atlantis: quem faz o quê
A revisão de PR de Terraform com que já trabalhei tem três camadas: Atlantis para rodar o plan no PR, Conftest para a política escrita em código e um step de IA comentando o plan. Pela minha experiência, o step de IA normalmente pega o que é necessário e, num geral, atende bem. O que ele deixa passar é regra de negócio muito específica. Depois desse teste, a divisão de trabalho ficou mais clara:
| Camada | Bom para | Fraco em |
|---|---|---|
| Conftest / OPA | Regra objetiva: tag obrigatória, porta proibida, publicly_accessible | Contexto: não sabe que o SG do bastion foi parar na app |
| IA no PR | Ligar pontos: rename que destrói dados, custo 18x, nome de policy que engana | Repetir o mesmo resultado: pode errar uma contagem, e duas execuções podem divergir |
| Atlantis / pipeline | Garantir que o plan revisado é o plan aplicado | Não julga nada, só executa |
| Humano | Decidir sobre exceção e risco aceito | Ler 300 linhas de plan com atenção |
A IA não substitui o Conftest. A regra “porta 22 proibida” tem que falhar sempre, em toda execução, e isso é trabalho de política em código. Onde a IA ganha é no que a política não consegue expressar. E o prompt do step de IA merece o mesmo cuidado de qualquer código do pipeline; os frameworks de prompt para DevOps ajudam a deixar papel, contexto e formato de saída explícitos.
Armadilhas que aparecem quando você leva isso para o pipeline
O plan.json expõe valores sensíveis O plan.txt mostra a senha como (sensitive value). O plan.json traz o valor em texto puro e só marca o campo em after_sensitive, como descreve o formato JSON do Terraform. Se o seu pipeline guarda o plan.json como artefato para a IA ler, ele guarda a senha junto.
- Plan desatualizado. Se o plan foi gerado com
-refresh=falseou é antigo, a revisão é em cima de uma foto antiga do ambiente. O nível 3 notou que o plan tinha 12 dias e pediu para gerar de novo. Gere o plan no mesmo job da revisão. - O que o plan.txt omite. Atributos inalterados aparecem como “hidden” no texto. No P8,
force_destroyestava oculto, e o nível 1 tratou isso corretamente como “depende de um valor que o plan não mostra”. - Defaults da AWS. Bucket novo já nasce com criptografia SSE-S3 e sem acesso público por padrão. Uma revisão que diz “o bucket vai ficar público” erra. As três rodadas acertaram: o problema é não estar declarado no código nem cumprir a exigência de SSE-KMS.
Limites deste teste
- Uma execução por nível. IA não dá sempre a mesma resposta. Rodar de novo pode dar outro resultado, e eu não medi variação.
- Problemas clássicos. SSH aberto, RDS público e
Action = "*"estão em todo material de segurança AWS. É o terreno onde a IA vai melhor. Um erro sutil e específico do seu ambiente, como o da tag que disparou a automação, é mais difícil: depende de algo que não está no plan. - Plan pequeno. 10 recursos. Num plan de 400 recursos, o consumo de tokens sobe e a chance de deixar algo passar também.
Perguntas frequentes
O Claude Code consegue aplicar o Terraform sozinho? Só se a sessão tiver credencial e permissão para isso. No setup deste post não tem credencial nenhuma e o apply está negado. Nos testes, a IA nem tentou.
Preciso do plan.json ou o plan.txt basta? Para pegar os problemas óbvios, o plan.txt bastou: 7 de 7 no nível 1. O plan.json e o código trouxeram a confirmação e a senha em texto puro. Cuidado com onde o JSON fica guardado.
Preciso de chave de API? Não. Rodei tudo com o login da assinatura. Só confira se não existe ANTHROPIC_API_KEY no ambiente, porque nesse caso o claude -p usa a chave e cobra por token.
Minha leitura
Eu colocaria isso no CI de um time, sim. O que muda é o peso do resultado. Em ambiente de desenvolvimento, a revisão da IA pode comentar e seguir. Em ambiente crítico, regulado, ou que guarda dado de cliente, ela comenta, o Conftest bloqueia o que é regra, e o apply continua sendo assinado por uma pessoa.
Mais do que o 9 de 9, o que pesa é o nível 1 ter explicado, sem ninguém pedir, por que o rename do bucket ia falhar no meio do apply. É o tipo de linha que passa batido numa revisão no olho. A IA lê essa linha com a mesma atenção que leu a primeira, mas a decisão sobre o risco continua sendo de uma pessoa.








