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

Primeiros passosComunidade

Nível de dificuldade: Introdutório (1 de 5)

AWS Emulator deixa testar S3, DynamoDB e outros serviços da AWS sem abrir conta

Por AWS Hub7 min de leitura

Quem está começando na AWS conhece o medo: criar uma conta, cadastrar o cartão de crédito e torcer para não esquecer um recurso ligado que estoura o Free Tier. Em novembro de 2026 a AWS lançou uma alternativa para a fase de aprendizado: o AWS Emulator, um programa que roda inteiramente na sua máquina e responde às chamadas da API da AWS como se fosse a nuvem de verdade, sem jamais tocar numa conta real.

O artigo de Irtaza Zahid, estudante de cibersegurança e AWS Cloud Learner, publicado no AWS Builder Center em 20 de novembro de 2026, é o relato mais detalhado em português (traduzido aqui) de como a ferramenta funciona na prática, da instalação aos limites que todo iniciante precisa conhecer antes de confiar nela.

O que é, de fato, o AWS Emulator

O AWS Emulator é um servidor local que fala o mesmo protocolo da API da AWS. Quando seu código Python, Node.js ou Java pede para "criar uma tabela no DynamoDB" ou "subir um arquivo no S3", a chamada vai para o emulador em vez de ir para us-east-1 ou sa-east-1. O emulador cria o recurso na memória do seu computador, deixa você listar, ler e apagar, e some com tudo assim que o processo é encerrado.

Três características definem a ferramenta para quem está estudando:

  • É gratuita de verdade: não existe tarifa de uso, só cobrança se você depois decidir publicar na AWS real.
  • Não exige conta: dá para instalar e rodar sem nunca ter se cadastrado na AWS.
  • É open source, escrito em Rust, o que explica por que é leve mesmo em notebooks mais fracos.

Como ele conversa com seu código

O truque é que você não reescreve nada do seu script. O SDK da AWS (boto3, AWS SDK for JavaScript, AWS SDK for Java) já sabe para onde mandar as chamadas: basta apontar isso via variáveis de ambiente, sem tocar numa linha de código de aplicação.

Após iniciar o emulador, ele fica ouvindo em https://127.0.0.1:9297 (porta configurável). O fluxo é:

  1. Você inicia o aws-emulator na sua máquina.
  2. Define AWS_ENDPOINT_URL apontando para o endereço local.
  3. Roda seu script como se fosse produção.
  4. O SDK manda a chamada para o emulador, não para a nuvem.
  5. O emulador processa e devolve a resposta, exatamente no formato que a AWS devolveria.

Para confirmar que está no ambiente certo, rode aws sts get-caller-identity. No emulador a resposta sempre traz a conta fictícia 000000000000 e o usuário emulator. Se aparecer o seu ID de conta real, as variáveis de ambiente não foram aplicadas e as chamadas estão indo para a AWS de verdade.

Instalando: Linux ganha pacote nativo, macOS e Windows dependem de Docker

Em distribuições Linux (Ubuntu, Debian, Amazon Linux), a instalação é direta via pacote:

bash
# Debian ou Ubuntu
sudo dpkg -i aws-emulator-x86_64.deb

# Amazon Linux ou RHEL
sudo rpm -i aws-emulator-x86_64.rpm

# iniciar
aws-emulator -p 9297

Em macOS e Windows não existe instalador pronto: o caminho é Docker. O Dockerfile publicado parte da imagem amazonlinux:2023-minimal, baixa o pacote .rpm do emulador e expõe a porta 9297:

bash
docker build -t aws-emulator .
docker run --rm --memory=2g --memory-swap=2g \
  -p "127.0.0.1:9297:9297" \
  -v "$HOME/.aws/emulator:/home/emulator/.aws/emulator" \
  aws-emulator -p 9297

O detalhe que não dá para pular: o mapeamento de porta usa 127.0.0.1:9297:9297, amarrando o serviço só à própria máquina. Expor isso na rede local é desnecessário e arriscado, mesmo sendo um ambiente de teste.

Depois de subir o emulador, as variáveis de ambiente fazem a ponte entre o SDK e o servidor local:

bash
unset AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_SESSION_TOKEN AWS_PROFILE

export AWS_ENDPOINT_URL="https://127.0.0.1:9297"
export AWS_SHARED_CREDENTIALS_FILE="$HOME/.aws/emulator/9297/emulator_credentials"
export AWS_CONFIG_FILE="$HOME/.aws/emulator/9297/config"
export AWS_CA_BUNDLE="$HOME/.aws/emulator/9297/ca.pem"
export AWS_EC2_METADATA_DISABLED="true"
export AWS_REGION="us-east-1"

O unset inicial importa tanto quanto o export: se sobrar uma credencial real no terminal, o risco de um comando ir parar na conta de verdade por engano continua existindo.

Testando na prática: S3 e DynamoDB sem gastar um centavo

Com o emulador no ar, os comandos da AWS CLI funcionam normalmente. Criar um bucket e subir um arquivo:

bash
aws s3 mb s3://my-test-bucket
echo "Hello from AWS Emulator" > test.txt
aws s3 cp test.txt s3://my-test-bucket/
aws s3 ls s3://my-test-bucket/

Criar uma tabela no DynamoDB e gravar um item segue o mesmo padrão de qualquer tutorial de iniciante:

bash
aws dynamodb create-table \
  --table-name TestTable \
  --attribute-definitions AttributeName=id,AttributeType=S \
  --key-schema AttributeName=id,KeyType=HASH \
  --billing-mode PAY_PER_REQUEST

aws dynamodb put-item \
  --table-name TestTable \
  --item '{"id": {"S": "1"}, "name": {"S": "Test Item"}}'

Para quem está estudando para o Cloud Practitioner ou o Solutions Architect Associate, isso é valioso: dá para repetir o mesmo comando dez vezes, errar, apagar a tabela e recomeçar, sem nunca se aproximar de um limite do Free Tier real.

O que já funciona bem (e o que ainda não)

A AWS publica "fidelity scores" por serviço, baseados em bateria de testes que compara o comportamento do emulador com a AWS real. Na versão 1.0.322, citada pelo artigo original:

ServiçoTestes aprovados
Amazon S3763 / 924
Amazon DynamoDB661 / 808
Amazon SQS286 / 304
AWS IAM359 / 463
AWS Lambda293 / 616
Amazon EC2576 / 1.299

S3 e SQS estão com fidelidade alta; Lambda e EC2, bem mais baixa, o que significa comportamento divergente da AWS real em boa parte dos casos de uso mais avançados desses dois serviços.

Cinco limitações merecem atenção antes de confiar no emulador para qualquer coisa além de aprendizado:

  • IAM não é avaliado de verdade: uma chamada que a AWS bloquearia por falta de permissão pode passar no emulador sem erro. Nunca use o emulador para validar política de segurança.
  • Uma conta, uma região por instância: não há simulação de múltiplas contas nem de múltiplas regiões ao mesmo tempo; para testar duas regiões, é preciso subir dois emuladores em portas diferentes.
  • Nada é persistido: tudo fica em memória; parar o processo apaga todos os recursos criados.
  • API não implementada retorna HTTP 501: isso facilita identificar lacunas, mas também significa que um teste pode falhar só porque aquele endpoint específico ainda não foi coberto.
  • Sem simulação de falha: não há throttling, outage simulado nem diferença de comportamento entre regiões, então o emulador não serve para testar como sua aplicação reage a erro da AWS.

Escrito inteiramente por agentes de IA, segundo a AWS

O detalhe mais chamativo do lançamento, segundo o relato de Zahid, é quem escreveu o código. Matt Goldberg, Senior Principal Engineer da AWS, afirmou que agentes de IA projetaram e implementaram o emulador inteiro, sem revisão humana linha a linha:

Agentes de IA projetaram e escreveram o serviço inteiro. Nenhum engenheiro humano escreveu ou revisou uma única linha de código.

AI agents designed and wrote the entire service. No human engineers wrote or reviewed a single line of code.Matt Goldberg, Senior Principal Engineer na AWS

Segundo o artigo, os agentes usaram os modelos Smithy (a especificação que descreve as APIs da AWS) como referência e compararam o resultado com o comportamento real dos serviços para verificar acerto. O exemplo citado: pedir para a IA recriar o Amazon SQS e receber uma réplica funcional em 15 minutos.

Os fidelity scores públicos funcionam, na prática, como a prestação de contas desse processo: é a evidência de que o código gerado por IA realmente se comporta como deveria, serviço por serviço.

Para quem está começando: onde isso encaixa no seu estudo

Em resumo: o AWS Emulator não substitui uma conta AWS, substitui a fase de tatear no escuro antes dela. Serve para treinar o comando certo, entender a resposta da API e só então abrir a conta real (ou usar o Free Tier) para o que o emulador não cobre: política de IAM, Lambda em cenários mais complexos, e qualquer coisa que dependa de múltiplas regiões ou de simular falha.

Um roteiro razoável para quem estuda para o Cloud Practitioner: pratique os comandos de S3, DynamoDB e SQS no emulador até errar menos; depois, abra uma conta real no Free Tier só para repetir os mesmos exercícios na região sa-east-1 e ver a diferença entre o que o emulador simula e o que a AWS de fato responde, inclusive nas negativas de permissão que o emulador não reproduz. É nessa lacuna, aliás, que mora boa parte do que a certificação cobra.

O código e os fidelity scores estão públicos no GitHub do projeto, e vale olhar o número do serviço que você pretende estudar antes de montar o exercício em cima dele.

Fonte: AWS Builder Center

Serviços neste textoPrimeiros passos

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 deixa testar S3, DynamoDB e outros serviços da AWS sem abrir conta" (https://awshub.com.br/comunidade/aws-emulator-deixa-testar-s3-dynamodb-e-outros-servicos-da-aws-sem-abrir-conta).
Resumo: Lançado em novembro de 2026, o AWS Emulator simula a API da AWS localmente, sem conta, sem cartão de crédito e sem risco de cobrança. Veja como instalar, testar e onde ele ainda falha.
Serviços: Primeiros passos

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.