DEV Community

Cover image for Plan verde, apply vermelho: as seis coisas que o `terraform plan` não verifica e como checá-las antes
Gonzalo Gjuka
Gonzalo Gjuka

Posted on Originally published at controlcloud.dev

Plan verde, apply vermelho: as seis coisas que o `terraform plan` não verifica e como checá-las antes

terraform plan faz três coisas bem: valida a sintaxe, resolve as referências entre recursos e atualiza o state contra o provedor para os recursos que ele já administra. O que ele não faz é chamar o provedor para perguntar se aquilo que a configuração dá por certo existe, é permitido ou tem lugar. Essa é a lacuna entre o plan verde e o apply vermelho, e é mais larga do que parece: uma subnet digitada à mão, uma credencial que só pode ler, uma cota de vCPU que já está no limite. Nenhuma dessas coisas aparece no plan.

Estas são as seis coisas que o plan não verifica. Para cada uma: o que o plan vê, em que o apply bate e um comando somente leitura por provedor para perguntar antes. Os comandos foram tirados da referência oficial de cada CLI.

1. A subnet referenciada por nome ou por ID digitado à mão

O que o plan vê: uma string. subnet_id = "subnet-0abc..." ou um var.subnet_name que chega de um tfvars. Se a string tem a forma certa, o plan aceita; ele não confere que a subnet existe naquela região nem naquela conta.

Em que o apply bate: InvalidSubnetID.NotFound, um 404 do provedor ou, pior, uma subnet que existe mas em outra VPC, e a VM sobe na rede errada.

# AWS
aws ec2 describe-subnets --filters "Name=tag:Name,Values=snet-app" "Name=vpc-id,Values=$VPC"
# Azure
az network vnet subnet show -g rg-app --vnet-name vnet-app -n snet-app
# OCI
oci network subnet list --compartment-id "$C" --vcn-id "$VCN" --display-name snet-app
# GCP
gcloud compute networks subnets describe snet-app --region us-central1
Enter fullscreen mode Exit fullscreen mode

Correção parcial: um data source com filtros (data "aws_subnet" com filter, data "azurerm_subnet", data "oci_core_subnets", data "google_compute_subnetwork") leva a verificação para o plan, porque o data source chama a API de verdade. Parcial porque só cobre o que foi declarado como data source; o ID colado num tfvars continua sem verificação.

2. O alcance da credencial

O que o plan vê: uma credencial que pode ler. O plan precisa de permissões de leitura para atualizar o state e, se as tem, termina verde. Ele não simula o Create que vem depois.

Em que o apply bate: UnauthorizedOperation, AuthorizationFailed, NotAuthorizedOrNotFound (a OCI mistura os dois casos de propósito) ou um 403 do GCP no meio do apply, com metade dos recursos já criados.

# AWS: quem sou eu e se posso criar a instância
aws sts get-caller-identity
aws iam simulate-principal-policy --policy-source-arn "$ROLE_ARN" --action-names ec2:RunInstances ec2:CreateTags
# Azure: roles efetivas, incluindo as herdadas de escopos superiores
az role assignment list --assignee "$SP_ID" --include-inherited --all
# OCI: as policies do compartimento (a tenancy é o compartimento raiz)
oci iam policy list --compartment-id "$C" --all
# GCP: bindings do projeto
gcloud projects get-iam-policy "$PROJECT"
Enter fullscreen mode Exit fullscreen mode

Na OCI a leitura é manual: a própria referência da CLI diz que, para saber quais policies se aplicam a um grupo, é preciso ler as sentenças uma por uma, não há API que responda isso. O simulador da AWS responde allow ou deny por ação, e é o único dos quatro que faz isso sem tentar a operação.

3. A cota

O que o plan vê: nada. Cotas não são atributo de recurso nenhum, então não há de onde atualizá-las.

Em que o apply bate: InstanceLimitExceeded na AWS, um OperationNotAllowed que fala da cota de cores no Azure, LimitExceeded na OCI, Quota 'CPUS' exceeded no GCP.

# AWS: vCPU on-demand padrão (L-1216C47A) na região
aws service-quotas get-service-quota --service-code ec2 --quota-code L-1216C47A
# Azure: uso e limite por família na região
az vm list-usage -l brazilsouth -o table
# OCI: disponível e usado para um limite específico
oci limits resource-availability get --compartment-id "$T" --service-name compute --limit-name standard-a1-core-count --availability-domain "$AD"
# GCP: a lista quotas da região, com usage e limit
gcloud compute regions describe us-central1 --format="yaml(quotas)"
Enter fullscreen mode Exit fullscreen mode

As quatro respostas trazem o limite e o uso. Se a diferença for menor do que o plan vai criar, o apply vai falhar e o plan não sabe.

4. A capacidade, que não é a cota

O que o plan vê: também nada, e aqui nem um data source ajuda. Ter cota para 8 vCPU não significa que exista um host livre para aquele shape naquele availability domain neste momento.

Em que o apply bate: InsufficientInstanceCapacity na AWS, AllocationFailed ou SkuNotAvailable no Azure, Out of host capacity na OCI. A diferença em relação à cota importa porque a solução é outra: cota se pede; capacidade se espera, ou se troca de zona ou de tamanho.

A única coisa que dá para ler antes é a lista de SKUs com restrições para a assinatura; para a capacidade do momento não há API de leitura, só a tentativa:

# Azure: tamanhos com restrições por zona para esta assinatura
az vm list-skus -l brazilsouth --resource-type virtualMachines --zone --all -o table
Enter fullscreen mode Exit fullscreen mode

Na OCI o loop de retentativas do post anterior é a resposta honesta; na AWS o guia de troubleshooting do EC2 sugere o mesmo: retentar, reduzir a quantidade ou tirar a zona do pedido.

5. A saída para a internet: NAT, gateway e rota

O que o plan vê: a VM e, se estiverem na mesma configuração, a subnet e a tabela de rotas. O que ele não vê é se essa tabela tem uma rota 0.0.0.0/0 para algum lugar quando a rede foi criada por outro time ou por outro state.

Em que o apply bate: em nada, e por isso é o pior caso. A VM é criada, o apply segue verde até o provisioner ou o user_data que roda apt-get update, e aí trava ou falha por timeout. O Terraform marca o recurso como tainted e o apply seguinte o recria, para falhar do mesmo jeito.

# AWS: a tabela associada à subnet e se ela tem 0.0.0.0/0 (igw-* ou nat-*)
aws ec2 describe-route-tables --filters "Name=association.subnet-id,Values=$SUBNET" --query "RouteTables[].Routes[?DestinationCidrBlock=='0.0.0.0/0']"
# Azure: route table (null = rotas do sistema), NAT gateway e se a subnet é privada
az network vnet subnet show -g rg-app --vnet-name vnet-app -n snet-app --query "{routeTable:routeTable.id, natGateway:natGateway.id, defaultOutboundAccess:defaultOutboundAccess}"
# OCI: regras de rota e service gateways da VCN
oci network route-table list --compartment-id "$C" --vcn-id "$VCN" --query 'data[*]."route-rules"'
oci network service-gateway list --compartment-id "$C" --vcn-id "$VCN"
# GCP: os NATs do Cloud Router da região
gcloud compute routers nats list --router "$ROUTER" --region us-central1
Enter fullscreen mode Exit fullscreen mode

No Azure há uma data: segundo a página Default Outbound Access, para a versão de API posterior a 31 de março de 2026 as subnets de VNets novas nascem com defaultOutboundAccess em false, e uma VM ali precisa de NAT Gateway, IP público ou load balancer com regras de saída para chegar à internet. Uma configuração que saía bem numa VNet antiga deixa de sair numa nova, e o plan é idêntico.

6. O que vive em outro state

O que o plan vê: terraform_remote_state ou outputs de outro módulo, resolvidos na hora do plan. Mas se o valor depende de um recurso que ainda não existe (o outro state não foi aplicado, ou um count depende de algo criado neste mesmo apply), o plan mostra (known after apply) e segue.

Em que o apply bate: o recurso do outro state não está lá, ou está com outro ID porque alguém o recriou, e o erro vem do provedor, não do Terraform. O que dá para fazer é inventariar quanto do plan está em (known after apply) antes de aprová-lo:

terraform plan -out plan.out
terraform show -json plan.out | jq -r '.resource_changes[] | select(.change.actions | index("create")) | "\(.address): \(.change.after_unknown | keys | join(","))"'
# e o que o outro state exporta hoje, não o que exportava quando o módulo foi escrito
terraform state list
terraform output -json
Enter fullscreen mode Exit fullscreen mode

after_unknown é um campo documentado do formato JSON do Terraform: lista cada atributo que não será conhecido até o apply. Se subnet_id ou network_interface_ids estiverem entre eles, os pontos 1 e 5 desta lista não puderam ser verificados no plan por construção.

O que já dá para automatizar hoje

Tudo isso cabe num script que roda antes do apply, sem ferramenta nova. O esqueleto, com a AWS como exemplo:

#!/usr/bin/env bash
set -euo pipefail
terraform plan -out plan.out -input=false
PLAN=$(terraform show -json plan.out)

# 1. cada create com atributos desconhecidos
echo "$PLAN" | jq -r '.resource_changes[] | select(.change.actions|index("create")) | "\(.address) unknown: \(.change.after_unknown|keys|join(","))"'

# 2. as subnets que o plan referencia por ID, contra a API
for s in $(echo "$PLAN" | jq -r '.resource_changes[].change.after.subnet_id? // empty' | sort -u); do
  aws ec2 describe-subnets --subnet-ids "$s" --query 'Subnets[0].SubnetId' --output text >/dev/null || { echo "subnet $s not found"; exit 1; }
done

# 3. cota contra o que vai ser criado
NEED=$(echo "$PLAN" | jq '[.resource_changes[] | select(.type=="aws_instance" and (.change.actions|index("create")))] | length')
echo "instances to create: $NEED"
aws service-quotas get-service-quota --service-code ec2 --quota-code L-1216C47A --query 'Quota.Value'

# 4. credencial (simulate-principal-policy) e 5. rotas (describe-route-tables) entram aqui
terraform apply plan.out
Enter fullscreen mode Exit fullscreen mode

Dois limites. O script conhece um provedor por vez e lê o que o plan já decidiu: uma subnet que entra por variável sem passar pelo JSON do plan ele não enxerga. E a capacidade (ponto 4) não tem leitura prévia em provedor nenhum.

O Control Cloud roda essas verificações a partir do app, contra a tenancy em vivo e com a credencial somente leitura que já está conectada: alcance da credencial, subnet e saída para a internet, dependências do template e hosts, antes de o Terraform existir, porque o Terraform é gerado a partir do canvas depois da checagem. O que ele não faz: cotas reais (só limiares suaves na IONOS) e não há hook de CI nem API pública; roda a partir do canvas e do Pre-Deploy. O vídeo de pre-flight mostra o percurso completo.

Qual das seis quebrou o seu último apply com o plan em verde?

Top comments (0)