TerraformComunidade
Nível de dificuldade: Avançado (4 de 5)
AWS Emulator passa em 66 de 72 testes práticos, mas esbarra no Terraform
Em números
- 69,4% foi a taxa de fidelidade geral do AWS Emulator em 16 de novembro de 2026, contra 56,5% no lançamento, cinco dias antes
- 200+ serviços da AWS aparecem cobertos pelo emulador, segundo a imprensa especializada, porque ele é gerado a partir dos modelos de API que a própria AWS publica
- 66 de 72 checagens passaram no teste prático relatado pela fonte, rodando uma aplicação fictícia completa contra a versão 1.0.471
- 25 de 31 recursos Terraform foram criados com sucesso no mesmo teste, em cerca de 4 minutos de
apply
O AWS Emulator foi lançado em 11 de novembro de 2026: um programa local, escrito em Rust, que expõe um endpoint compatível com as APIs da AWS, sem exigir conta nem credenciais reais. O desenvolvedor Patrice T. publicou na DEV Community um teste de ponta a ponta com uma aplicação completa, primeiro via AWS CLI, depois via Terraform, e o resultado interessa diretamente a quem desenha e opera ambientes AWS: onde esse emulador já encurta o ciclo de teste e onde ele ainda não substitui um ambiente de pré-produção de verdade.
O que você vai construir
Este passo a passo reproduz o essencial do teste da fonte: subir o AWS Emulator localmente, apontar o AWS CLI para ele, criar um bucket S3 de teste e, na sequência, tentar provisionar parte de uma infraestrutura via Terraform para sentir na mão os três bloqueios que o autor documentou. A aplicação de referência é o Carnet, um app fictício com front-end React, back-end Python, autenticação via Cognito, banco em RDS PostgreSQL, cache em ElastiCache, exportação para S3, fila SQS e logs no CloudWatch Logs. O código está publicado em PatriceT/aws-emulator-carnet-demo, como instantâneo de teste, não como projeto mantido.
Quem trabalha com Terraform e CloudWatch no dia a dia vai reconhecer o cenário: validar um módulo de infraestrutura sem subir custo em sa-east-1 nem esperar fila de pipeline, e ainda assim poder checar os logs localmente antes de levar qualquer coisa para produção.
Pré-requisitos
- Máquina com Docker instalado: o teste original rodou em Windows 11 com WSL 2 e Docker (Linux e macOS também funcionam, seguindo os pacotes oficiais)
- Pacote
aws-emulator:.debpara Debian, Ubuntu ou WSL;.rpmpara Amazon Linux 2023 (guia oficial testado nessa distribuição) - AWS CLI v2 (a v1 ignora a variável
AWS_ENDPOINT_URLpara RDS emus-east-1e envia a chamada para a AWS real por engano) - Terraform 1.17.2 e o provider AWS fixado em 5.x (a faixa 5.100.0 foi a testada; a 6.x trava na criação de bucket S3, ver adiante)
- Nenhuma conta AWS é necessária para o emulador: ele cria sozinho uma conta fixa
000000000000e chaves de acesso que começam comEMULATOR - Permissões IAM: nenhuma a configurar, porque o emulador não avalia políticas IAM nem políticas baseadas em recurso como a AWS real faz. É a limitação mais importante para quem pensa em usar isso como substituto de teste de segurança
Passo a passo
- Instale o pacote, em um primeiro terminal:
# Debian, Ubuntu, WSL
curl -fsSLo aws-emulator.deb https://downloads.aws.com/aws-emulator/packages/aws-emulator/LTS/latest/aws-emulator_amd64.deb
sudo apt-get install -y ./aws-emulator.deb
# Amazon Linux 2023
sudo dnf install -y https://downloads.aws.com/aws-emulator/packages/aws-emulator/LTS/latest/aws-emulator-x86_64.rpm- Inicie o emulador:
aws-emulatorEle passa a escutar em 127.0.0.1:9297 via HTTPS e gera credenciais, config e certificado em ~/.aws/emulator/9297/.
- Em um segundo terminal, aponte o AWS CLI para o emulador:
export AWS_ENDPOINT_URL=https://127.0.0.1:9297
export AWS_SHARED_CREDENTIALS_FILE=~/.aws/emulator/9297/emulator_credentials
export AWS_CONFIG_FILE=~/.aws/emulator/9297/config
export AWS_CA_BUNDLE=~/.aws/emulator/9297/ca.pem
export AWS_EC2_METADATA_DISABLED=true
export AWS_DISABLE_HOST_PREFIX_INJECTION=true
export AWS_REGION=us-east-1
export AWS_DEFAULT_REGION=us-east-1
unset AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_SESSION_TOKEN AWS_PROFILE- Confirme a identidade e crie um bucket de teste:
aws sts get-caller-identity
aws s3 mb s3://local-getting-started- Suba a aplicação Carnet (ou um equivalente seu) com Docker Compose, apontando para o mesmo endpoint:
docker compose up --buildNa fonte, esse passo encadeia Cognito, RDS, ElastiCache, S3, SQS e CloudWatch Logs em uma única jornada: login, criação de nota, leitura de volta via cache.
- Tente provisionar o equivalente em Terraform (31 recursos no teste original), com o provider fixado em 5.x:
terraform {
required_providers {
aws = {
source = "hashicorp/aws"
version = "~> 5.100.0"
}
}
}- Espere travar em três pontos específicos antes de rodar
terraform applysem ajuste, documentados pela fonte entre 13 e 16 de novembro sem mudança:
| Bloqueio | O que acontece | Contorno |
|---|---|---|
| Provider AWS 6.x e S3 | Criar bucket trava: o provider lê tags pela API S3 Control, cujas chamadas não chegam ao emulador | Ficar no provider 5.x (testado com 5.100.0) |
| Security groups | O Terraform revoga a regra padrão de egress na criação; o emulador responde que ela não existe, mesmo listando-a | Nenhum contorno encontrado: os 3 grupos e suas 3 regras não são criados |
| RDS sem versão | Sem engine_version, a criação é rejeitada ("Cannot find version for postgres") | Definir engine_version explicitamente |
- Com os dois primeiros contornos aplicados e
engine_versiondefinido, rode o restante do plano:
terraform plan
terraform applyTestando
O teste da fonte classificou 72 checagens de um roteiro de shell script contra a versão 1.0.471, em 16 de novembro de 2026: 66 passaram, 6 falharam, nenhuma retornou 501 (não implementado). O plano de controle inteiro, da autenticação até a fila, funcionou com código boto3 inalterado.
| Bloco | O que funciona | O que diverge |
|---|---|---|
| Cognito | Pool, cliente, usuário, login, senha errada rejeitada, tokens RS256 verificáveis via JWKS | O emissor do token é o endereço do emulador |
| RDS PostgreSQL | Instância criada, porta local falando o protocolo PostgreSQL, SQL comum, transações, jsonb | Não é um PostgreSQL real: now(), serial, identity e gen_random_uuid() falham |
| ElastiCache | Criado pela API, porta local falando o protocolo Redis: PING, SET, GET, INCR | Redis parcial: HSET e LPUSH são desconhecidos, e só o protocolo RESP2 é aceito |
| S3, SQS, Secrets Manager, CloudWatch Logs | Todo o roteiro, incluindo URL pré-assinada do S3 e fila de dead-letter do SQS | Nada neste escopo |
| VPC, security groups, ACM, ALB | Todas as criações; regra duplicada e ALB público sem internet gateway rejeitados como na AWS real | Nenhum tráfego passa pelo ALB emulado |
Trecho do log do script (rótulos traduzidos pela fonte):
OK Cognito Sign-in (InitiateAuth)
OK Cognito Wrong password rejected
OK RDS (SQL) INSERT ... RETURNING
FAIL RDS (SQL) now() function
FAIL RDS (SQL) Auto-incrementing serial column
OK ElastiCache (Redis) SET with expiry
FAIL ElastiCache (Redis) HSET (hash)Um cuidado documentado: o emulador avança alguns estados sozinho, como a AWS real faz. Na versão 1.0.341, uma identidade SES só ficava verificada meio segundo depois de criada, e um certificado ACM saía de PENDING_VALIDATION para FAILED em cerca de 3 segundos. O script precisou esperar o estado estável antes de checar; depois disso, os resultados ficaram reprodutíveis em duas máquinas diferentes. Quem automatiza verificação via CloudWatch em pipelines reais reconhece esse padrão: é o mesmo cuidado que se toma com qualquer recurso assíncrono da AWS.
No lado do Terraform, com os três contornos aplicados, 25 dos 31 recursos foram criados (S3, SQS, Secrets Manager, Cognito, VPC, ACM, ALB, RDS, ElastiCache, SES, CloudWatch), um plano de controle vazio (sem drift na releitura) e um destroy completo, tudo em cerca de 4 minutos, com 1 min 20 s de espera no RDS e 1 min no ALB.
Limpando os recursos
Como tudo roda localmente, não há cobrança da AWS enquanto você ficar dentro do emulador; o aviso de custo só vale se você repetir o teste contra uma conta AWS real. Para não deixar processos ou estado residual na máquina:
- Rode
terraform destroyantes de encerrar, para remover os 25 recursos criados e confirmar que oplanfinal fica vazio - Pare a aplicação com
docker compose down(oudocker compose down -vse quiser descartar volumes) - Encerre o processo
aws-emulatorno terminal onde ele está rodando (Ctrl+C); o estado é mantido em memória e se perde ao parar - Apague a pasta
~/.aws/emulator/9297/se não for reiniciar o emulador na mesma porta, para gerar credenciais novas na próxima vez - Se você rodou algo além deste teste contra uma conta AWS real (por exemplo, para comparar comportamento), confira manualmente recursos esquecidos no console da região usada
Próximos passos
O placar de fidelidade sobe rápido: 56,5% em 11 de novembro, 69,4% cinco dias depois, com ganhos desiguais por serviço (AWS KMS foi de 71% a 86%; AWS CloudFormation, de 19% a 24%). Isso muda o que compensa automatizar:
- Reexecute os testes de fidelidade do seu próprio projeto periodicamente: os escores em
scores.json.gz, publicados a cada release no repositórioaws/aws-emulator, mudam de uma semana para outra - Use a skill para agentes de código e o arquivo
manifest.jsonlpara checar, antes de investir tempo, se as operações que seu projeto usa já estão cobertas - Para aplicações que dependem de banco ou cache com comportamento real (como
now(),serialou listas Redis), mantenha um container real ao lado do emulador em vez de confiar só nele - Não use o emulador para validar políticas IAM: ele não avalia políticas baseadas em recurso da mesma forma que a AWS real, e uma chamada negada em produção pode passar localmente sem aviso
A tabela abaixo resume o veredito da fonte por tipo de uso, útil para decidir onde encaixar o emulador num pipeline real:
| Uso | Veredito | Por quê |
|---|---|---|
| Testes de integração de aplicação (S3, SQS, Secrets Manager, Cognito, logs) | Sim, já agora | O roteiro completo passa, com código de aplicação inalterado |
| Aplicações que dependem de banco ou cache | Sim, com container real ao lado | O PostgreSQL do RDS e o Redis do ElastiCache emulados são parciais |
| Sandbox para agentes de código e CI | Sim | Instâncias isoladas, sem credenciais reais em circulação |
| Infraestrutura como código completa com Terraform | Ainda não | Security groups falham e o provider recente trava na criação de S3 |
| Testes de segurança e permissão IAM | Não | Políticas não são avaliadas como a AWS real avalia |
| Validação final antes de produção | Parcial | Fidelidade ainda incompleta, sem tráfego real passando pelos recursos emulados |
Para um arquiteto ou time de DevOps/SRE que já usa Terraform e CloudWatch na rotina, o recado prático é direto: vale trocar parte do ambiente de teste de integração por este emulador agora, mas o módulo que cria security groups, ou seja, quase todo módulo de rede, ainda não passa sem ajuste manual. Essas conclusões valem para a versão 1.0.471, de 16 de novembro de 2026, e merecem ser reconferidas em poucas semanas, dado o ritmo de várias releases por dia.
Fonte: DEV Community — #aws
Serviços neste textoTerraformCloudWatch
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: "AWS Emulator passa em 66 de 72 testes práticos, mas esbarra no Terraform" (https://awshub.com.br/comunidade/aws-emulator-passa-em-66-de-72-testes-praticos-mas-esbarra-no-terraform). Resumo: Lançado em 11 de novembro de 2026, o AWS Emulator roda local, sem conta na AWS, e chegou a 69,4% de fidelidade em cinco dias. Um teste prático com CLI e Terraform mostra onde ele já serve para CI e onde ainda trava. Serviços: Terraform, CloudWatch 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ã?