AWS HubAWS HubSão Paulo operando · 2 eventos no mundo

TerraformComunidade

Nível de dificuldade: Avançado (4 de 5)

AWS Emulator passa em 66 de 72 testes práticos, mas esbarra no Terraform

Por AWS Hub9 min de leitura

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: .deb para Debian, Ubuntu ou WSL; .rpm para Amazon Linux 2023 (guia oficial testado nessa distribuição)
  • AWS CLI v2 (a v1 ignora a variável AWS_ENDPOINT_URL para RDS em us-east-1 e 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 000000000000 e chaves de acesso que começam com EMULATOR
  • 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

  1. Instale o pacote, em um primeiro terminal:
bash
# 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
  1. Inicie o emulador:
bash
aws-emulator

Ele passa a escutar em 127.0.0.1:9297 via HTTPS e gera credenciais, config e certificado em ~/.aws/emulator/9297/.

  1. Em um segundo terminal, aponte o AWS CLI para o emulador:
bash
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
  1. Confirme a identidade e crie um bucket de teste:
bash
aws sts get-caller-identity
aws s3 mb s3://local-getting-started
  1. Suba a aplicação Carnet (ou um equivalente seu) com Docker Compose, apontando para o mesmo endpoint:
bash
docker compose up --build

Na 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.

  1. Tente provisionar o equivalente em Terraform (31 recursos no teste original), com o provider fixado em 5.x:
hcl
terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.100.0"
    }
  }
}
  1. Espere travar em três pontos específicos antes de rodar terraform apply sem ajuste, documentados pela fonte entre 13 e 16 de novembro sem mudança:
BloqueioO que aconteceContorno
Provider AWS 6.x e S3Criar bucket trava: o provider lê tags pela API S3 Control, cujas chamadas não chegam ao emuladorFicar no provider 5.x (testado com 5.100.0)
Security groupsO Terraform revoga a regra padrão de egress na criação; o emulador responde que ela não existe, mesmo listando-aNenhum contorno encontrado: os 3 grupos e suas 3 regras não são criados
RDS sem versãoSem engine_version, a criação é rejeitada ("Cannot find version for postgres")Definir engine_version explicitamente
  1. Com os dois primeiros contornos aplicados e engine_version definido, rode o restante do plano:
bash
terraform plan
terraform apply

Testando

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.

BlocoO que funcionaO que diverge
CognitoPool, cliente, usuário, login, senha errada rejeitada, tokens RS256 verificáveis via JWKSO emissor do token é o endereço do emulador
RDS PostgreSQLInstância criada, porta local falando o protocolo PostgreSQL, SQL comum, transações, jsonbNão é um PostgreSQL real: now(), serial, identity e gen_random_uuid() falham
ElastiCacheCriado pela API, porta local falando o protocolo Redis: PING, SET, GET, INCRRedis parcial: HSET e LPUSH são desconhecidos, e só o protocolo RESP2 é aceito
S3, SQS, Secrets Manager, CloudWatch LogsTodo o roteiro, incluindo URL pré-assinada do S3 e fila de dead-letter do SQSNada neste escopo
VPC, security groups, ACM, ALBTodas as criações; regra duplicada e ALB público sem internet gateway rejeitados como na AWS realNenhum 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 destroy antes de encerrar, para remover os 25 recursos criados e confirmar que o plan final fica vazio
  • Pare a aplicação com docker compose down (ou docker compose down -v se quiser descartar volumes)
  • Encerre o processo aws-emulator no 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ório aws/aws-emulator, mudam de uma semana para outra
  • Use a skill para agentes de código e o arquivo manifest.jsonl para 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(), serial ou 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:

UsoVereditoPor quê
Testes de integração de aplicação (S3, SQS, Secrets Manager, Cognito, logs)Sim, já agoraO roteiro completo passa, com código de aplicação inalterado
Aplicações que dependem de banco ou cacheSim, com container real ao ladoO PostgreSQL do RDS e o Redis do ElastiCache emulados são parciais
Sandbox para agentes de código e CISimInstâncias isoladas, sem credenciais reais em circulação
Infraestrutura como código completa com TerraformAinda nãoSecurity groups falham e o provider recente trava na criação de S3
Testes de segurança e permissão IAMNãoPolíticas não são avaliadas como a AWS real avalia
Validação final antes de produçãoParcialFidelidade 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ã?

Newsletter semanal

A semana da AWS, em português

Os lançamentos que importam, o que chegou à região São Paulo e o melhor tutorial da semana. Toda sexta, gratuita.