AWS Emulator es el emulador local oficial de AWS. Levanta un endpoint HTTPS en tu propia máquina, y el AWS CLI, los SDK de AWS y los agentes de código lo llaman con las mismas API que usan en la nube. No necesitas cuenta de AWS, y nada de lo que crea es un recurso real en la nube. Según el blog AWS News, pasó a disponibilidad general (GA) el 11 de noviembre de 2026 (hora de EE. UU.), es decir, hacia las 2:00 del 12 de noviembre en hora de Pekín.
El 13 de noviembre de 2026 (hora de Pekín, UTC+8) instalamos AWS Emulator 1.0.322, la versión del canal LTS en ese momento, en una máquina Debian 13 x86_64. Con AWS CLI 2.40.1 creamos un bucket de S3, una tabla de DynamoDB, una cola de SQS y una función Lambda. Después pedimos a Claude Code 2.1.319 y a Codex CLI 0.167.0 que escribieran código y ejecutaran pruebas contra el emulador. Todos los comandos, tiempos y salidas de abajo salen de esa ejecución.
La respuesta corta
| Pregunta | Respuesta |
|---|---|
| ¿Qué es AWS Emulator? | El emulador local oficial de las API de AWS, escrito en Rust y sin interfaz gráfica. Según AWS, está construido a partir de más de 400 modelos de API y cubre más de 200 servicios de AWS. |
| ¿Tiene cargo? ¿Necesito una cuenta de AWS? | Según AWS, no hay cargo adicional por el servicio ni hace falta cuenta de AWS. El código está en GitHub bajo la dedicación al dominio público CC0. |
| ¿Cómo se instala? | En Linux, instala el paquete RPM o Debian. En macOS y Windows, construye una imagen con el Dockerfile de la documentación oficial (AWS no publica una imagen lista). Los proyectos en Rust también pueden usar el modo embebido. |
| ¿Cómo se usa? | Ejecuta aws-emulator. Escucha por defecto en https://127.0.0.1:9297. Define unas pocas variables de entorno para que el AWS CLI y los SDK apunten a él; el código de tu aplicación no cambia. |
| Resultado de nuestra prueba | Descarga e instalación en unos 6 segundos, y el health check devolvió ok unos 0,3 segundos después de arrancar. S3, DynamoDB, SQS y Lambda funcionaron. Claude Code terminó la misma tarea «S3 + DynamoDB + pytest» en unos 32 segundos y Codex en unos 81 segundos, con 2 passed en ambos. |
| Lo más importante a vigilar | No evalúa las políticas de IAM como AWS y emula una sola cuenta en una sola Región. Prueba permisos y seguridad en AWS real antes de producción. |
Qué es AWS Emulator
Según el blog AWS News, AWS Emulator genera al arrancar sus propias credenciales, un archivo de configuración y un certificado, y los escribe en ~/.aws/emulator/9297/. Cuando las variables de entorno de tu SDK apuntan ahí, las peticiones van a tu máquina en lugar de a AWS. Está construido con los mismos modelos de API que usan los SDK de AWS, así que los datos y errores que devuelve tienen la misma forma que en la nube.
El caso de uso principal son los agentes de código. Según @AWSNewsroom, cada línea del código de AWS Emulator la escribieron agentes de IA autónomos que corren en Amazon Bedrock AgentCore: cientos de agentes, organizados en tres equipos, escriben las pruebas, implementan las funciones y revisan los cambios. Según Swami Sivasubramanian, de AWS, en su artículo invitado en All Things Distributed, los agentes primero escriben «pruebas de fidelidad» y las hacen pasar contra AWS real, y luego construyen el emulador hasta que pasa esas mismas pruebas. El CTO de AWS, @Werner, afirma que fue escrito y probado íntegramente por agentes y que ofrece un entorno de pruebas de alta fidelidad para más de 200 servicios de AWS.
El lanzamiento generó mucha conversación. Según las métricas públicas de X, a primera hora del 13 de noviembre (hora de Pekín), la publicación de lanzamiento de @AWSNewsroom tenía unas 111.000 visualizaciones, 705 me gusta y 206 reposts, y la publicación de lanzamiento de @awsdevelopers unas 78.000 visualizaciones, 1.203 me gusta y 758 guardados. El repositorio de GitHub aws/aws-emulator tenía entonces unas 4.400 estrellas.
Cronología
| Fecha (hora de Pekín) | Evento |
|---|---|
| 11 de noviembre | Sale 1.0.322 (aws-emulator -v muestra la fecha de publicación 2026.11.10) |
| 12 de noviembre, hacia las 02:00 | El blog AWS News, Werner y las cuentas oficiales de AWS anuncian la GA |
| 13 de noviembre, 00:16 | El paquete LTS/latest que descargamos seguía siendo 1.0.322; a la misma hora apareció v1.0.336 en GitHub Releases |
AWS Emulator publica versiones muy a menudo, y el skill oficial pide usar siempre la última, así que probablemente tu número de versión sea más nuevo que el nuestro.
Instalar AWS Emulator
La documentación oficial ofrece cuatro caminos (ver Getting started): dejar que un agente de código con IA lo instale, el paquete de Linux, Docker o el modo embebido de Rust.
Linux: paquete RPM o Debian
# Debian / Ubuntu (x86_64)
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 / Fedora / RHEL (x86_64)
sudo dnf install -y https://downloads.aws.com/aws-emulator/packages/aws-emulator/LTS/latest/aws-emulator-x86_64.rpm
# Comprobar la versión
aws-emulator -v
En máquinas ARM, usa aws-emulator_arm64.deb o aws-emulator-aarch64.rpm. El paquete se instala en /opt/aws-emulator/ y pone el comando aws-emulator en /usr/bin/.
Nuestra salida:
Version: 1.0.322
Release date: 2026.11.10
Commit: 7753983c6e495ec3612695b1336bf4936fc7b7fd
El paquete deb ocupa unos 171 MB. La descarga tardó 1,7 segundos, y descarga más apt-get install unos 6 segundos en total. La documentación también describe una verificación GPG: cada paquete tiene al lado un archivo .sig, y tras importar https://downloads.aws.com/keys/gpg/current.asc la huella debe ser 98BC F336 A3BE 53B7 34E9 67C5 2E5B F49B D940 F624. Seguimos esos pasos y obtuvimos Good signature from "SSM Publishing <ssm-publishing@amazon.com>".
macOS / Windows: construir la imagen con el Dockerfile
Según la guía de Docker, AWS no publica una imagen ya construida; la construyes con este Dockerfile. En Apple silicon, cambia x86_64.rpm por aarch64.rpm:
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"]
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
Publica el puerto como -p 127.0.0.1:9297:9297, no como -p 9297:9297; la forma corta abre el emulador a todas las máquinas de tu red. Nuestra máquina de prueba no tiene Docker, así que la ruta de Docker la recogimos de la documentación oficial sin ejecutarla.
Arrancarlo y apuntar el AWS CLI hacia él
En una primera terminal, arranca el emulador (-t off desactiva la telemetría anónima, activa por defecto):
aws-emulator -t off
El registro está en formato JSON lines. Una línea indica el endpoint, la configuración y el certificado:
"endpoint_url":"https://127.0.0.1:9297","health_check_url":"https://127.0.0.1:9297/__admin/health","config_file":"/home/box/.aws/emulator/9297/config","ca_file":"/home/box/.aws/emulator/9297/ca.pem"
En una segunda terminal, define las variables de entorno. Este conjunto viene del blog AWS News; la última línea borra las credenciales reales de AWS:
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_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
Primero confirma que hablas con el emulador:
curl --cacert ~/.aws/emulator/9297/ca.pem https://127.0.0.1:9297/__admin/health
aws sts get-caller-identity
En nuestra prueba, el health check devolvió ok unos 0,27 segundos después de arrancar. get-caller-identity devolvió la cuenta fija del emulador, 000000000000, con el ARN arn:aws:iam::000000000000:user/emulator. Si ves esa cuenta, tus peticiones no van a AWS real. En reposo, el emulador usaba unos 283 MB de memoria residente.
Prueba: S3, DynamoDB, SQS, Lambda
aws s3 mb s3://aicodewith-emu-demo
echo "hello from the emulator" > hello.txt
aws s3 cp hello.txt s3://aicodewith-emu-demo/
aws s3 ls s3://aicodewith-emu-demo/
aws dynamodb create-table --table-name notes \
--attribute-definitions AttributeName=id,AttributeType=S \
--key-schema AttributeName=id,KeyType=HASH --billing-mode PAY_PER_REQUEST
aws dynamodb wait table-exists --table-name notes
aws dynamodb put-item --table-name notes --item '{"id":{"S":"n1"},"msg":{"S":"hello"}}'
aws dynamodb get-item --table-name notes --key '{"id":{"S":"n1"}}'
| Operación | Resultado | Tiempo por comando |
|---|---|---|
| s3 mb / s3 cp / s3 ls | make_bucket: aicodewith-emu-demo, 24 bytes subidos, hello.txt listado | unos 0,55–0,6 s |
| dynamodb create-table | Estado CREATING | unos 0,5 s |
| put-item justo después de crear la tabla | ResourceNotFoundException: Requested resource not found | unos 0,5 s |
| put-item / get-item tras wait table-exists | Escritura correcta; leído {"id":"n1","msg":"hello"} | unos 0,5 s |
| sqs create-queue / send-message / receive-message | Se recibió el cuerpo del mensaje "hi" | unos 0,5 s |
| lambda create-function (Python 3.13) + invoke | StatusCode: 200; la función devolvió {"ok": true, "echo": {"a": 1}} | unos 0,6 s |
Casi todo el medio segundo por comando es el arranque del propio AWS CLI; el emulador responde rápido.
Conviene conocer dos comportamientos, y ambos coinciden con AWS real:
- No se puede escribir enseguida en una tabla de DynamoDB recién creada. Tras crearla, su estado es
CREATING, y unput-iteminmediato falla conResourceNotFoundException. Ejecutaaws dynamodb wait table-exists, o usa un waiter en el código, antes de escribir. Aquí es donde más tropiezan las pruebas escritas por agentes. - Lambda revisa la política de confianza del rol. Nuestro primer intento usó un rol con el Statement vacío y falló con
The role defined for the function cannot be assumed by Lambda. Al añadirsts:AssumeRoleparalambda.amazonaws.coma la política de confianza, la función se creó.
Poner a Claude Code, Codex y Cursor a trabajar contra el emulador
Opción 1: instalar el skill oficial aws-emulator
Según la guía para agentes de código con IA, AWS CLI 2.35.0 o posterior instala el skill oficial con un solo comando. Después basta con decirle a tu agente «Install AWS Emulator and point my project at it»:
aws agent-toolkit add-skill --skill-name aws-emulator --region us-east-1
El comando instala el skill para cada agente que detecta en la máquina y no necesita cuenta de AWS. Con AWS CLI 2.40.1, cada ejecución tardó unos 0,6 segundos y escribió en el directorio de cada agente encontrado:
- Claude Code:
~/.claude/skills/aws-emulator/ - Codex:
~/.agents/skills/aws-emulator/ - Cursor:
~/.cursor/skills/aws-emulator/
Ojo: no ejecutes este comando en una shell con AWS_ENDPOINT_URL definido. Nuestro primer intento se hizo en una terminal que ya apuntaba al emulador y falló con UnknownService ... GetLatestSkillVersion, porque la petición de descarga del skill también fue al emulador. Una terminal limpia lo resolvió.
El skill solo contiene documentos, sin scripts: pasos de instalación para Linux, Docker y el modo embebido de Rust, cómo conectar cada SDK, una tabla de errores y una comprobación de «¿funcionará mi proyecto en el emulador?». Para saber cómo funcionan los skills en general, consulta Cómo usar Agent Skills.
Opción 2: definir las variables de entorno y darle una tarea al agente
Los agentes de Claude Code, Codex y Cursor ejecutan comandos en una terminal, así que lo más sencillo es definir las variables de la sección anterior en la terminal donde arrancas el agente. Los comandos aws y las pruebas con boto3 que ejecute el agente irán automáticamente al emulador, y aunque el agente se equivoque, no puede tocar una cuenta real. La terminal de Cursor lee las mismas variables; en esta prueba solo instalamos el skill para Cursor y no ejecutamos ninguna tarea en él.
Dimos la misma tarea a Claude Code y a Codex. El proyecto era un repositorio de Python vacío con boto3 1.44.1 y pytest 9.2.0 preinstalados en .venv:
The shell already points the AWS CLI and SDKs at a local AWS Emulator (AWS_ENDPOINT_URL=https://127.0.0.1:9297); never use a real AWS account.
1. Write notes.py with save_note(bucket, table, note_id, text): put the text in S3 at notes/<note_id>.txt and put an item {id, s3_key} in the DynamoDB table; and get_note(bucket, table, note_id) that returns the text by reading the item and then the S3 object.
2. Write tests/test_notes.py with pytest: create a uniquely named bucket and table (string key "id", PAY_PER_REQUEST, wait until the table exists) against the emulator, then test save/get round trip and that get_note of a missing id raises KeyError.
3. Run .venv/bin/pytest -q until it passes, then verify with the aws CLI that the object and item exist. Finish with a 3-line summary.
| Cliente | Modelo | Tiempo real | Resultado |
|---|---|---|---|
| Claude Code 2.1.319 (claude -p) | claude-opus-5-5 | unos 32,3 s, 5 turnos | Escribió notes.py y tests/test_notes.py, 2 passed; confirmó el objeto notes/n1.txt y su ítem con el aws CLI |
| Codex CLI 0.167.0 (codex exec) | gpt-6.1-sol | unos 80,9 s | Escribió notes.py y tests/test_notes.py y añadió un pytest.ini; 2 passed in 3.36s, y luego confirmó el objeto y el ítem con un script |
Los dos agentes usaron por su cuenta get_waiter("table_exists") y evitaron la trampa de «escribir justo después de crear». Después volvimos a ejecutar nosotros .venv/bin/pytest -q en el directorio de Claude Code y obtuvimos de nuevo 2 passed in 3.24s, y aws s3 ls mostraba los buckets notes-test-* creados por ambas ejecuciones. Lee el resumen del agente, pero fíate de tu propia ejecución.
Ejecutamos ambos en modo no interactivo: Claude Code con --permission-mode bypassPermissions y Codex con --dangerously-bypass-approvals-and-sandbox. Eso solo es adecuado para un directorio de pruebas desechable. En un repositorio real, bloquea los comandos peligrosos con hooks; consulta Configurar Agent Hooks en Claude Code / Codex / Cursor. Si quieres manejar Claude Code y Codex desde una sola interfaz, consulta T3 Code con Claude Code y Codex.
Conectar Claude Code y Codex a una API Key de AICodeWith
En las pruebas anteriores, ambos clientes usaron una API Key de AICodeWith. Si prefieres no iniciar sesión con una suscripción oficial, escribe la configuración global de cada CLI.
Para Claude Code, escribe ~/.claude/settings.json (guía completa: Configurar una API de terceros en Claude Code):
{
"env": {
"ANTHROPIC_BASE_URL": "https://api.aicodewith.ai",
"ANTHROPIC_AUTH_TOKEN": "tu API Key de AICodeWith"
}
}
Para Codex, escribe ~/.codex/config.toml (descarga e instalación: Descargar Codex; referencia de campos: Guía de config.toml de Codex):
model_provider = "aicodewith"
model = "gpt-6.1-sol"
[model_providers.aicodewith]
name = "aicodewith"
base_url = "https://api.aicodewith.ai/chatgpt/v1"
wire_api = "responses"
experimental_bearer_token = "tu API Key de AICodeWith"
Comprueba primero cada uno por separado: claude -p "Reply with exactly: pong" y codex exec --skip-git-repo-check "Reply with exactly: pong". En nuestra prueba ambos devolvieron pong, en unos 4,3 segundos Claude Code y 4,8 segundos Codex.
No mezcles los dos juegos de credenciales. La Key de AICodeWith solo sirve para que el agente llame al modelo. En el lado de AWS, el emulador usa claves temporales que empiezan por EMULATOR... y que genera en cada arranque; no tienen nada que ver con tu Key del modelo.
Llevarlo a CI
Según la documentación, el emulador guarda el estado solo en memoria, y /__admin/health existe para que scripts y contenedores esperen a que esté listo. Aquí tienes un ejemplo de GitHub Actions; los comandos de instalación y arranque son los que ejecutamos arriba en Debian:
jobs:
test:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Install and start AWS Emulator
run: |
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
aws-emulator -t off &
until curl -sf --cacert ~/.aws/emulator/9297/ca.pem https://127.0.0.1:9297/__admin/health; do sleep 0.2; done
- name: Run tests against the emulator
run: |
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_EC2_METADATA_DISABLED=true AWS_DISABLE_HOST_PREFIX_INJECTION=true
export AWS_REGION=us-east-1 AWS_DEFAULT_REGION=us-east-1
pytest -q
No pongas credenciales reales de AWS en el entorno de los jobs de CI; AWS también lo recomienda.
Límites: lo que no puede hacer
Según el blog AWS News y la documentación de fidelidad:
- No evalúa políticas de IAM. Una petición que AWS rechazaría puede funcionar en el emulador, así que no lo uses para probar seguridad.
- Una cuenta, una Región. No hay comportamiento entre cuentas ni entre Regiones.
- Las operaciones aún no implementadas devuelven HTTP 501 (`NotImplemented`). Tu prueba falla al momento en lugar de pasar en silencio.
- La fidelidad varía según el servicio. Las API del plano de control (crear, describir y borrar recursos) son las más cercanas a AWS; las API del plano de datos y las herramientas IaC como CloudFormation, Terraform y el CDK varían más según el servicio. Las puntuaciones de fidelidad por servicio se publican con cada versión en GitHub Releases, y las pruebas son públicas en el repositorio aws-emulator-evaluation-suite.
- Reiniciar lo borra todo. Al pararlo y volver a arrancarlo, los buckets y tablas anteriores habían desaparecido, y la Access Key de
emulator_credentialscambió deEMULATORC3...aEMULATOR1D.... Vuelve a leer el archivo de credenciales tras cada reinicio.
Errores comunes y soluciones
| Error / síntoma | Causa | Solución |
|---|---|---|
| AccessDenied: Sign the request with the emulator credentials | Firmado con otras claves, por ejemplo claves reales de AWS en variables de entorno (lo vimos con una clave falsa) | unset AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_SESSION_TOKEN AWS_PROFILE y apuntar AWS_SHARED_CREDENTIALS_FILE al emulator_credentials de esta ejecución |
| ResourceNotFoundException justo después de crear una tabla de DynamoDB | La tabla sigue en CREATING (lo vimos) | aws dynamodb wait table-exists, o un waiter en el código |
| UnknownService: could not resolve a target service | Una petición que no era para el emulador fue a él, por ejemplo instalar el skill en una terminal con AWS_ENDPOINT_URL definido (lo vimos) | Ejecutarlo en una terminal sin AWS_ENDPOINT_URL |
| SSL: CERTIFICATE_VERIFY_FAILED | El cliente no confía en el ca.pem de esta ejecución | Definir AWS_CONFIG_FILE; en Node NODE_EXTRA_CA_CERTS, en Java truststore.p12; nunca desactivar la verificación de certificados |
| sts get-caller-identity muestra una cuenta real | Ese comando se ejecutó sin AWS_ENDPOINT_URL y fue a AWS | Ejecutarlo en la terminal o el script con las variables definidas |
| Address already in use | El puerto está ocupado | Usar otro puerto, por ejemplo aws-emulator -p 9300, y cambiarlo también en las variables |
| NotImplemented / HTTP 501 | La versión instalada aún no implementa esa operación | Actualizar a la última versión y revisar la puntuación de fidelidad del servicio en Releases |
FAQ
¿Las API de AWS Emulator son las mismas que las de AWS real?
Según AWS, está construido con los mismos modelos de API Smithy que usan los SDK de AWS, así que las peticiones y los errores tienen la misma forma que en AWS. Que el comportamiento coincida depende de la puntuación de fidelidad de cada servicio. El estado CREATING de DynamoDB y la revisión de la política de confianza de Lambda que encontramos coincidieron con AWS.
¿Se puede instalar directamente en macOS?
No; se usa Docker. AWS solo publica paquetes para Linux; en macOS y Windows construyes una imagen con el Dockerfile oficial.
¿Sirve para producción o para pruebas de seguridad?
No. AWS indica que es solo para desarrollar y probar. No evalúa políticas de IAM ni está pensado para cargas de producción.
¿Podría el agente cambiar por error mis recursos reales de AWS?
Mientras la terminal donde arrancas el agente tenga AWS_ENDPOINT_URL definido y las credenciales reales eliminadas, las peticiones solo van a tu máquina. Además, el emulador solo acepta peticiones firmadas con las claves EMULATOR... que él mismo generó. Antes de empezar, ejecuta una vez aws sts get-caller-identity y comprueba que la cuenta es 000000000000.
¿Qué conviene más aquí: Claude Code, Codex o Cursor?
Los tres sirven: cada uno puede instalar el skill oficial y hereda las variables de entorno de su terminal. En esta prueba, Claude Code y Codex completaron la misma tarea a la primera. Elige el que ya uses.
Fuentes
- Blog AWS News: Test your applications against AWS locally with AWS Emulator
- Swami Sivasubramanian: AWS Emulator and the engineer's job when agents write the code
- GitHub: aws/aws-emulator
- Guía de usuario de AWS Emulator: Getting started
- Getting started on Linux
- Getting started with Docker
- Fidelity in AWS Emulator
- Publicación de lanzamiento de @AWSNewsroom
- Publicación de lanzamiento de @awsdevelopers
- Publicación de @Werner



