AWS Emulator vs LocalStack: AWS lança seu próprio emulador local, gratuito e sem token

Desenvolvimento
, , , , , ,
1

AWS Emulator é o emulador local e gratuito da AWS: executa mais de 200 serviços da AWS na sua máquina, sem conta nem token. A AWS lançou em 11 de novembro de 2026. A AWS CLI e os SDKs da AWS se conectam a ele com apenas algumas variáveis de ambiente, então seu código não muda. É a primeira resposta oficial da AWS à lacuna que se abriu em março, quando o LocalStack começou a exigir uma conta e um token de autenticação.

Screenshot 2026-11-12 at 1.38.11 PM
Screenshot 2026-11-12 at 1.38.11 PM3188×1802 404 KB

O que é AWS Emulator?

AWS Emulator é um emulador local das APIs da AWS: um processo sem interface gráfica que serve um endpoint da API da AWS. As requisições que iriam para a AWS vão para ele. Você pode executá-lo no seu laptop, em um servidor de desenvolvimento ou em CI.

Segundo o post de lançamento de Swami Sivasubramanian no blog de Werner Vogels, cobre mais de 200 serviços e é construído a partir de mais de 400 modelos de API. Esses modelos estão escritos em Smithy, o formato que a AWS usa para descrever as operações, entradas, saídas e erros de cada serviço.

Você tem quatro formas de executá-lo:

  • Linux: um pacote RPM ou Debian, para x86_64 ou arm64.
  • macOS e Windows: um contêiner Docker que você constrói a partir de um Dockerfile curto.
  • Tests em Rust: o modo embarcado, que executa o emulador dentro do processo de teste para que cada teste tenha seu próprio estado isolado.
  • Do seu agente de código: uma skill aws-emulator que se instala com a AWS CLI.

AWS Emulator é gratuito?

Sim. Não tem taxa de serviço e você só paga pelos recursos reais quando faz o deploy na AWS. O código é publicado sob CC0 1.0, uma dedicação ao domínio público, exceto o diretório vendor/, que vem com Apache 2.0. É uma licença inusitadamente permissiva para um projeto da AWS.

Antes de adotá-lo, convém saber duas coisas:

  • A telemetria vem ativada por padrão. O emulador envia dados anônimos de uso e de erros. A AWS afirma que não envia suas requisições, suas respostas nem os dados de seus recursos. Mais abaixo explicamos como desativá-la.
  • O repositório não aceita pull requests. Os bugs e as diferenças de fidelidade são reportados em GitHub Issues.

AWS Emulator é a alternativa gratuita ao LocalStack?

Para quem quer testar sem conta, sim: essa é a diferença principal. Em 23 de março de 2026, o LocalStack deixou de dar suporte a sua edição Community. A imagem localstack/localstack:latest agora exige uma conta e um LOCALSTACK_AUTH_TOKEN, e o uso comercial requer um plano pago. O LocalStack continua oferecendo um plano gratuito para uso não comercial, e as tags antigas de Community ainda iniciam sem token, embora já não recebam atualizações de segurança. Os detalhes, e o que revisar antes de migrar, estão no nosso guia Floci vs LocalStack.

AWS Emulator não precisa de conta nem token. Gera suas próprias credenciais localmente cada vez que inicia.

Mas migrar não é trocar uma imagem por outra. AWS Emulator serve HTTPS na porta 9297 com um certificado auto-assinado, então cada SDK precisa confiar em seu arquivo de CA (você vê isso na tabela mais abaixo). Se seus testes assumem um endpoint HTTP simples em outra porta, você terá que ajustar essa configuração.

Se você procurar localstack alternatives em inglês, essa é a novidade que muda a lista: a primeira opção que vem da própria AWS.

AWS Emulator, Floci ou MiniStack?

Floci, MiniStack e outros projetos da comunidade preencheram a lacuna do LocalStack durante este ano. Floci se apresenta como um substituto gratuito do LocalStack, com licença MIT e sem token. Já os cobrimos: Floci vs LocalStack e MiniStack.

O que AWS Emulator traz é a origem: vem da AWS, é construído com os modelos de API da própria AWS e seus fidelity tests são verificados contra a AWS real. O que você ainda não pode fazer é comparar cobertura serviço por serviço, porque a AWS não publica a lista dos mais de 200 serviços (explicamos isso abaixo).

Como instalar AWS Emulator no Linux?

Instale o pacote de sua distribuição e arquitetura.

RPM (x86_64):

sudo dnf install -y https://downloads.aws.com/aws-emulator/packages/aws-emulator/LTS/latest/aws-emulator-x86_64.rpm

RPM (aarch64):

sudo dnf install -y https://downloads.aws.com/aws-emulator/packages/aws-emulator/LTS/latest/aws-emulator-aarch64.rpm

Debian (amd64):

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

Debian (arm64):

curl -fsSLo aws-emulator.deb https://downloads.aws.com/aws-emulator/packages/aws-emulator/LTS/latest/aws-emulator_arm64.deb
sudo apt-get install -y ./aws-emulator.deb

Confirme a instalação e inicie-a:

aws-emulator -v
aws-emulator

Ele escuta em 127.0.0.1:9297 e fica em primeiro plano. Use -p 9300 para outra porta, ou -p 0 para que o sistema operacional escolha uma livre (você lê isso no campo endpoint_url do log de inicialização). Para detê-lo, pressione Ctrl+C: não há comando de parada.

A documentação também descreve uma verificação GPG opcional do pacote antes de instalá-lo.

Não há cargo install. O repositório é um workspace de Rust, mas os crates não estão publicados em crates.io. Compilar do código-fonte apenas funciona no Linux e precisa de pelo menos 100 GB livres para target/, um compilador de C e uma máquina multicore.

AWS Emulator funciona no Windows ou Mac?

Apenas com Docker: não há pacote nativo para nenhum dos dois. Guarde este Dockerfile, retirado da documentação oficial:

FROM public.ecr.aws/amazonlinux/amazonlinux:2023-minimal
ADD https://downloads.aws.com/aws-emulator/packages/aws-emulator/LTS/latest/aws-emulator-x86_64.rpm /tmp/aws-emulator.rpm
RUN rpm -i /tmp/aws-emulator.rpm && rm /tmp/aws-emulator.rpm \
    && mkdir -p /home/emulator && chown 1000 /home/emulator
USER 1000
ENV HOME=/home/emulator
EXPOSE 9297
ENTRYPOINT ["aws-emulator", "-b", "0.0.0.0"]

Em Apple Silicon ou outras máquinas Arm, mude aws-emulator-x86_64.rpm para aws-emulator-aarch64.rpm na linha ADD.

Constructa-o e inicie-o no macOS:

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

No Windows PowerShell (depois do mesmo docker build -t aws-emulator .):

New-Item -ItemType Directory -Force "$env:USERPROFILE\.aws\emulator"
$port = 9297
docker run --rm --memory=2g --memory-swap=2g -p "127.0.0.1:${port}:${port}" `
  -v "$env:USERPROFILE\.aws\emulator:/home/emulator/.aws/emulator" `
  aws-emulator -p $port

Dois detalhes da documentação que importam:

  • Mantenha o prefixo 127.0.0.1:. A forma curta -p 9297:9297 expõe o emulador a toda sua rede.
  • A porta do host e a do contêiner devem coincidir com o valor de -p do emulador, porque o emulador escreve sua porta nos arquivos que cria. Pela mesma razão, -p 0 não funciona em um contêiner.

O volume montado é o que permite que seu SDK leia as credenciais e o certificado que o emulador gera.

Como instalar AWS Emulator do Claude Code, Cursor ou Kiro?

Com uma skill para agentes. Você precisa da AWS CLI 2.35.0 ou posterior (verifique com aws --version):

aws agent-toolkit add-skill --skill-name aws-emulator --region us-east-1

O comando instala a skill em todos os agentes de código que a AWS CLI encontrar na sua máquina; a documentação menciona Kiro, Cursor e Claude Code como exemplos. Depois peça ao seu agente: “Install AWS Emulator and point my project at it.”

Como conectar a AWS CLI e os SDKs ao emulador?

Defina essas variáveis de ambiente no terminal onde você executa seu código (macOS e Linux):

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

Windows PowerShell:

$env:AWS_ENDPOINT_URL = "https://127.0.0.1:9297"
$env:AWS_SHARED_CREDENTIALS_FILE = "$env:USERPROFILE\.aws\emulator\9297\emulator_credentials"
$env:AWS_CONFIG_FILE = "$env:USERPROFILE\.aws\emulator\9297\config"
$env:AWS_CA_BUNDLE = "$env:USERPROFILE\.aws\emulator\9297\ca.pem"
$env:AWS_EC2_METADATA_DISABLED = "true"
$env:AWS_DISABLE_HOST_PREFIX_INJECTION = "true"
$env:AWS_REGION = "us-east-1"
$env:AWS_DEFAULT_REGION = "us-east-1"

Se você mudou a porta, substitua 9297 em todos os valores.

O emulador gera uma chave de acesso e um segredo novos cada vez que inicia, e só servem para essa execução. Remova qualquer variável que possa fornecer credenciais reais da AWS, ou seu SDK poderia usá-las em seu lugar:

unset AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_SESSION_TOKEN AWS_PROFILE

No PowerShell:

Remove-Item Env:AWS_ACCESS_KEY_ID, Env:AWS_SECRET_ACCESS_KEY, Env:AWS_SESSION_TOKEN, Env:AWS_PROFILE -ErrorAction SilentlyContinue

AWS_CA_BUNDLE cobre a AWS CLI v2, Boto3 e o AWS SDK for Go v2. Os demais SDKs precisam de seu próprio ajuste:

SDK Ajuste
JavaScript v3 (Node.js) NODE_EXTRA_CA_CERTS apontando para ca.pem
Java 2.x JAVA_TOOL_OPTIONS apontando para o truststore.p12 do emulador
Rust SSL_CERT_FILE apontando para ca.pem
.NET SSL_CERT_FILE apontando para ca.pem

Para Java, a documentação fornece este valor no macOS e Linux:

export JAVA_TOOL_OPTIONS="-Djavax.net.ssl.trustStore=$HOME/.aws/emulator/9297/truststore.p12 -Djavax.net.ssl.trustStoreType=PKCS12"

Atençao: esse trust store substitui o da JVM, portanto as chamadas para a AWS real falharão nesse mesmo processo a menos que você adicione ca.pem a um bundle que também inclua os certificados do seu sistema.

Verifique que funciona:

curl --cacert ~/.aws/emulator/9297/ca.pem https://127.0.0.1:9297/__admin/health
aws sts get-caller-identity

Contra o emulador, Account retorna 000000000000 e o ARN é arn:aws:iam::000000000000:user/emulator.

Como desativar a telemetria de AWS Emulator?

Com qualquer uma dessas três opções:

  • Flag: aws-emulator --telemetry off (ou -t off). No Docker, coloque-o depois do nome da imagem.
  • Variável de ambiente: EMULATOR_TELEMETRY=off.
  • Arquivo de configuração: na seção [telemetry], defina enabled = false em ~/.aws/emulator/config.toml (no Windows, %USERPROFILE%\.aws\emulator\config.toml).

O que AWS Emulator não faz?

A AWS é clara sobre seus limites:

  • Não é para produção nem para testes de segurança. As políticas de IAM e as baseadas em recursos não são avaliadas como a AWS faz, então um teste que passa em local não diz nada sobre suas permissões.
  • Uma região e uma conta por emulador. Aceita qualquer região ou ID de conta, mas não separa os recursos entre eles. Para várias regiões, execute um emulador por região, cada um em sua porta.
  • Nada persiste. Os recursos vivem na memória e desaparecem quando o emulador é parado.
  • Não está testado para uso prolongado nem para testes de carga. Reinicie-o para começar com um estado limpo.
  • A fidelidade varia conforme o serviço. Apenas está verificado em us-west-2 (os serviços globais, em us-east-1). O repositório mantém uma pasta “things-that-do-not-work” com os comportamentos que ainda não coincidem com a AWS real.
  • Não há lista pública de serviços. No momento desta publicação, a AWS não havia publicado quais são os mais de 200 serviços cobertos nem pontuações numéricas de fidelidade. A página de releases (última tag v1.0.322, de 11 de novembro) anuncia pontuações por release, e as releases anteriores indicam que não estão disponíveis.

A divisão prática: use o emulador para o ciclo rápido de desenvolvimento e para CI, e mantenha uma bateria menor contra a AWS real para tudo o que dependa de IAM, do comportamento entre regiões ou da carga.

Quem escreveu AWS Emulator?

Foi escrito por agentes, e a AWS diz isso abertamente. Segundo o post de lançamento, times de agentes escreveram primeiro os fidelity tests (cenários de ponta a ponta derivados dos modelos de API) e os corrigiram até que passassem contra a AWS real. Depois construíram o emulador até que passou esses mesmos testes. Cada mudança atravessa um merge gate: vários agentes de segurança fazem revisões adversariais, um revisor geral avalia a mudança e uns checks determinísticos impedem que os agentes toquem código que não devem modificar. O histórico completo de commits e as issues abertas pelos agentes são públicos.

É um projeto oficial da AWS, com documentação publicada em docs.aws.amazon.com. O que isso diz sobre o trabalho do engenheiro quando agentes escrevem o código é tema para uma coluna separada.

E você? Qual é o primeiro serviço da AWS que você testaria no emulador antes de confiá-lo ao seu CI?

O que você usa hoje para testar código da AWS em local?
  • LocalStack
  • Floci, MiniStack ou outro emulador da comunidade
  • Nada: testo direto contra a AWS
  • Prefiro outra opção (conte-nos qual)
0 votantes

Comente abaixo ou, se este artigo chegou por email, responda diretamente: sua resposta é publicada aqui.

Relacionado: Floci vs LocalStack: emular AWS em local sem conta nem token, e o que revisar antes de migrar