AWS Emulator vs LocalStack: AWS lanza su propio emulador local, gratis y sin token

Desarrollo
, , , , , ,
1

AWS Emulator es el emulador local y gratuito de AWS: corre más de 200 servicios de AWS en tu máquina, sin cuenta ni token. AWS lo lanzó el 11 de noviembre de 2026. La AWS CLI y los SDK de AWS se conectan a él con unas cuantas variables de entorno, así que tu código no cambia. Es la primera respuesta oficial de AWS al hueco que se abrió en marzo, cuando LocalStack empezó a exigir una cuenta y un token de autenticación.

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

¿Qué es AWS Emulator?

AWS Emulator es un emulador local de las APIs de AWS: un proceso sin interfaz gráfica que sirve un endpoint de la API de AWS. Las peticiones que irían a AWS van a él. Puedes correrlo en tu portátil, en un servidor de desarrollo o en CI.

Según el post de lanzamiento de Swami Sivasubramanian en el blog de Werner Vogels, cubre más de 200 servicios y está construido a partir de más de 400 modelos de API. Esos modelos están escritos en Smithy, el formato que AWS usa para describir las operaciones, entradas, salidas y errores de cada servicio.

Tienes cuatro formas de ejecutarlo:

  • Linux: un paquete RPM o Debian, para x86_64 o arm64.
  • macOS y Windows: un contenedor Docker que construyes a partir de un Dockerfile corto.
  • Tests en Rust: el modo embebido, que ejecuta el emulador dentro del proceso de test para que cada test tenga su propio estado aislado.
  • Desde tu agente de código: una skill aws-emulator que se instala con la AWS CLI.

¿AWS Emulator es gratis?

Sí. No tiene tarifa de servicio y solo pagas los recursos reales cuando despliegas en AWS. El código se publica bajo CC0 1.0, una dedicación al dominio público, salvo el directorio vendor/, que va con Apache 2.0. Es una licencia inusualmente permisiva para un proyecto de AWS.

Antes de adoptarlo conviene saber dos cosas:

  • La telemetría viene activada por defecto. El emulador envía datos anónimos de uso y de errores. AWS afirma que no envía tus peticiones, tus respuestas ni los datos de tus recursos. Más abajo te explicamos cómo desactivarla.
  • El repositorio no acepta pull requests. Los bugs y las diferencias de fidelidad se reportan en GitHub Issues.

¿AWS Emulator es la alternativa gratuita a LocalStack?

Para quien quiere probar sin cuenta, sí: esa es la diferencia principal. El 23 de marzo de 2026 LocalStack dejó de dar soporte a su edición Community. La imagen localstack/localstack:latest ahora exige una cuenta y un LOCALSTACK_AUTH_TOKEN, y el uso comercial requiere un plan de pago. LocalStack sigue ofreciendo un plan gratuito para uso no comercial, y los tags antiguos de Community todavía arrancan sin token, aunque ya no reciben actualizaciones de seguridad. Los detalles, y qué revisar antes de migrar, están en nuestra guía Floci vs LocalStack.

AWS Emulator no necesita cuenta ni token. Genera sus propias credenciales en local cada vez que arranca.

Eso sí, migrar no es cambiar una imagen por otra. AWS Emulator sirve HTTPS en el puerto 9297 con un certificado autofirmado, así que cada SDK tiene que confiar en su archivo de CA (lo ves en la tabla más abajo). Si tus tests asumen un endpoint HTTP plano en otro puerto, tendrás que ajustar esa configuración.

Si buscas localstack alternatives en inglés, esta es la novedad que cambia la lista: la primera opción que viene del propio AWS.

¿AWS Emulator, Floci o MiniStack?

Floci, MiniStack y otros proyectos de la comunidad llenaron el hueco de LocalStack durante este año. Floci se presenta como un reemplazo gratuito de LocalStack, con licencia MIT y sin token. Ya los cubrimos: Floci vs LocalStack y MiniStack.

Lo que aporta AWS Emulator es el origen: viene de AWS, está construido con los modelos de API del propio AWS y sus fidelity tests se verifican contra AWS real. Lo que todavía no puedes hacer es comparar cobertura servicio por servicio, porque AWS no publica la lista de los más de 200 servicios (lo explicamos abajo).

¿Cómo instalar AWS Emulator en Linux?

Instala el paquete de tu distribución y arquitectura.

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

Confirma la instalación y arráncalo:

aws-emulator -v
aws-emulator

Escucha en 127.0.0.1:9297 y se queda en primer plano. Usa -p 9300 para otro puerto, o -p 0 para que el sistema operativo elija uno libre (lo lees en el campo endpoint_url del log de arranque). Para detenerlo, pulsa Ctrl+C: no hay comando de parada.

La documentación también describe una verificación GPG opcional del paquete antes de instalarlo.

No hay cargo install. El repositorio es un workspace de Rust, pero los crates no están publicados en crates.io. Compilar desde el código fuente solo funciona en Linux y necesita al menos 100 GB libres para target/, un compilador de C y una máquina multinúcleo.

¿AWS Emulator funciona en Windows o Mac?

Solo con Docker: no hay paquete nativo para ninguno de los dos. Guarda este Dockerfile, tomado de la documentación 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"]

En Apple Silicon u otras máquinas Arm, cambia aws-emulator-x86_64.rpm por aws-emulator-aarch64.rpm en la línea ADD.

Constrúyelo y arráncalo en 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

En Windows PowerShell (después del mismo 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

Dos detalles de la documentación que importan:

  • Mantén el prefijo 127.0.0.1:. La forma corta -p 9297:9297 expone el emulador a toda tu red.
  • El puerto del host y el del contenedor deben coincidir con el valor de -p del emulador, porque el emulador escribe su puerto en los archivos que crea. Por la misma razón, -p 0 no funciona en un contenedor.

El volumen montado es lo que permite que tu SDK lea las credenciales y el certificado que genera el emulador.

¿Cómo instalar AWS Emulator desde Claude Code, Cursor o Kiro?

Con una skill para agentes. Necesitas la AWS CLI 2.35.0 o posterior (compruébalo con aws --version):

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

El comando instala la skill en todos los agentes de código que la AWS CLI encuentre en tu máquina; la documentación menciona Kiro, Cursor y Claude Code como ejemplos. Después pídele a tu agente: “Install AWS Emulator and point my project at it.”

¿Cómo conectar la AWS CLI y los SDK al emulador?

Define estas variables de entorno en la terminal donde ejecutas tu código (macOS y 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"

Si cambiaste el puerto, reemplaza 9297 en todos los valores.

El emulador genera una clave de acceso y un secreto nuevos cada vez que arranca, y solo sirven para esa ejecución. Elimina cualquier variable que pueda aportar credenciales reales de AWS, o tu SDK podría usarlas en su lugar:

unset AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_SESSION_TOKEN AWS_PROFILE

En 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 cubre la AWS CLI v2, Boto3 y el AWS SDK for Go v2. Los demás SDK necesitan su propio ajuste:

SDK Ajuste
JavaScript v3 (Node.js) NODE_EXTRA_CA_CERTS apuntando a ca.pem
Java 2.x JAVA_TOOL_OPTIONS apuntando al truststore.p12 del emulador
Rust SSL_CERT_FILE apuntando a ca.pem
.NET SSL_CERT_FILE apuntando a ca.pem

Para Java, la documentación da este valor en macOS y Linux:

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

Ojo: ese trust store reemplaza al de la JVM, así que las llamadas a AWS real fallarán en ese mismo proceso salvo que añadas ca.pem a un bundle que también incluya los certificados de tu sistema.

Comprueba que funciona:

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

Contra el emulador, Account devuelve 000000000000 y el ARN es arn:aws:iam::000000000000:user/emulator.

¿Cómo desactivar la telemetría de AWS Emulator?

Con cualquiera de estas tres opciones:

  • Flag: aws-emulator --telemetry off (o -t off). En Docker, ponlo después del nombre de la imagen.
  • Variable de entorno: EMULATOR_TELEMETRY=off.
  • Archivo de configuración: en la sección [telemetry], define enabled = false en ~/.aws/emulator/config.toml (en Windows, %USERPROFILE%\.aws\emulator\config.toml).

¿Qué no hace AWS Emulator?

AWS es directo con sus límites:

  • No es para producción ni para pruebas de seguridad. Las políticas de IAM y las basadas en recursos no se evalúan como lo hace AWS, así que un test que pasa en local no dice nada de tus permisos.
  • Una región y una cuenta por emulador. Acepta cualquier región o ID de cuenta, pero no separa los recursos entre ellos. Para varias regiones, ejecuta un emulador por región, cada uno en su puerto.
  • Nada persiste. Los recursos viven en memoria y desaparecen cuando el emulador se detiene.
  • No está probado para uso prolongado ni para pruebas de carga. Reinícialo para empezar con un estado limpio.
  • La fidelidad varía según el servicio. Solo está verificado en us-west-2 (los servicios globales, en us-east-1). El repositorio mantiene una carpeta “things-that-do-not-work” con los comportamientos que todavía no coinciden con AWS real.
  • No hay lista pública de servicios. Al momento de publicar esta nota, AWS no había publicado cuáles son los más de 200 servicios cubiertos ni puntuaciones numéricas de fidelidad. La página de releases (último tag v1.0.322, del 11 de noviembre) anuncia puntuaciones por release, y las releases anteriores indican que no están disponibles.

La división práctica: usa el emulador para el ciclo rápido de desarrollo y para CI, y mantén una batería más pequeña contra AWS real para todo lo que dependa de IAM, del comportamiento entre regiones o de la carga.

¿Quién escribió AWS Emulator?

Lo escribieron agentes, y AWS lo dice abiertamente. Según el post de lanzamiento, equipos de agentes escribieron primero los fidelity tests (escenarios de extremo a extremo derivados de los modelos de API) y los corrigieron hasta que pasaron contra AWS real. Después construyeron el emulador hasta que pasó esos mismos tests. Cada cambio atraviesa un merge gate: varios agentes de seguridad hacen revisiones adversariales, un revisor general evalúa el cambio y unos checks deterministas impiden que los agentes toquen código que no deben modificar. El historial completo de commits y los issues abiertos por los agentes son públicos.

Es un proyecto oficial de AWS, con documentación publicada en docs.aws.amazon.com. Qué dice esto sobre el trabajo del ingeniero cuando los agentes escriben el código es tema para una columna aparte.

¿Y tú? ¿Cuál es el primer servicio de AWS que probarías en el emulador antes de confiarle tu CI?

¿Qué usas hoy para probar código de AWS en local?
  • LocalStack
  • Floci, MiniStack u otro emulador de la comunidad
  • Nada: pruebo directamente contra AWS
  • Prefiero otra opción (cuéntanos cuál)
0 votantes

Comenta abajo o, si este artículo te llegó por correo, responde directamente al email: tu respuesta se publica aquí.

Relacionado: Floci vs LocalStack: emular AWS en local sin cuenta ni token, y qué revisar antes de migrar