---
title: "AWS Emulator: el emulador local oficial de AWS frente a LocalStack"
excerpt: "AWS publicó AWS Emulator, un emulador local de sus APIs, gratis y open source. Qué hace, cómo se instala, qué tan fiel es según sus propios tests y cómo se compara con LocalStack, Floci, MiniStack y Moto."
date: "2026-11-15T14:00:00.000Z"
category: "DevOps"
tech_article: true
author:
  name: "angel cruz"
  picture: "/images/me/angel-cruz.png"
ogImage:
  url: "/images/open-graph/og-image.png"
seo_title: "AWS Emulator vs LocalStack: el emulador local oficial de AWS"
seo_description: "AWS Emulator emula las APIs de AWS en tu máquina, gratis y con licencia CC0. Instalación, fidelidad por servicio y comparativa con LocalStack, Floci, MiniStack y Moto."
---

**AWS Emulator es el emulador local oficial de AWS: un programa escrito en Rust que sirve las APIs de AWS en tu máquina para que tus tests, tu CLI y tu SDK trabajen contra recursos emulados en vez de la nube.** No pide cuenta de AWS, [no tiene costo adicional](https://github.com/aws/aws-emulator) y el código está en GitHub con licencia CC0. Para el caso de uso más común (tests de integración y CI sin pagar nada) es competencia directa del plan gratis de LocalStack y de los clones open source que nacieron este año. Para lo que LocalStack cobra (estado persistente, IAM que de verdad se evalúa, snapshots compartidos) todavía no lo es.

## Qué es AWS Emulator

AWS Emulator es un binario local que expone un único endpoint para todos los servicios de AWS. Según [la guía oficial](https://docs.aws.amazon.com/emulator/latest/userguide/what-is-service.html), no tiene interfaz gráfica: lo arrancas, apuntas el AWS CLI o un SDK a su endpoint con variables de entorno, y tu código corre como siempre.

Los datos del proyecto:

- Lenguaje: Rust.
- Licencia: CC0 1.0, excepto la carpeta `vendor/`, que va con Apache 2.0, como dice [el README](https://github.com/aws/aws-emulator).
- Estructura: un crate por servicio. La carpeta `services/` del repo tiene 436 crates `service-*`, cada uno generado a partir del modelo Smithy de su API.
- Contribuciones: "This repository does not take PRs". Los bugs y diferencias con AWS se reportan como issues.
- Ritmo: el 14 de noviembre salieron al menos cinco releases, de la [v1.0.365 a la v1.0.385](https://github.com/aws/aws-emulator/releases).

Tiene dos modos. El **modo servidor** es el que te interesa si usas Node, PHP, Python o la CLI: un proceso que escucha en un puerto. El **modo embebido** es solo para Rust: el emulador se compila dentro del binario de tus tests, una instancia aislada por test, sin endpoint ni certificados.

## Cómo instalar AWS Emulator en Linux, macOS y Windows

AWS Emulator se instala con paquete nativo solo en Linux. En macOS y Windows corre en Docker, con una imagen que construyes tú: [la doc de Docker](https://docs.aws.amazon.com/emulator/latest/userguide/getting-started-docker.html) dice "We don't publish a prebuilt image".

En Linux con Debian o Ubuntu, según [la guía de Linux](https://docs.aws.amazon.com/emulator/latest/userguide/getting-started-linux.html):

```bash
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
```

Hay paquete RPM para Fedora y Amazon Linux, y variantes `arm64`/`aarch64` de los dos.

En macOS y Windows copias el Dockerfile de la documentación (parte de `amazonlinux:2023-minimal` e instala el RPM), lo construyes con `docker build -t aws-emulator .` y lo corres así:

```bash
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
```

El README también propone instalarlo a través de un agente de código: `aws agent-toolkit add-skill --skill-name aws-emulator --region us-east-1`, que requiere AWS CLI 2.35.0 o superior. Compilarlo desde el código fuente pide, según el mismo README, "at least 100 GB of free disk for `target/`".

## Apuntar el AWS CLI o el SDK a AWS Emulator

AWS Emulator sirve HTTPS en `127.0.0.1:9297` con un certificado propio que [se regenera en cada arranque](https://docs.aws.amazon.com/emulator/latest/userguide/point-sdk-to-emulator.html). Por eso no basta con cambiar el endpoint: también hay que confiar en su CA y usar las credenciales que genera. En macOS y Linux:

```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
```

La doc pide además hacer `unset` de `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, `AWS_SESSION_TOKEN` y `AWS_PROFILE`, para que nada apunte por accidente a tu cuenta real. Con Node.js el certificado va en `NODE_EXTRA_CA_CERTS`. La prueba de que funciona es `aws sts get-caller-identity`, que tiene que devolver la cuenta `000000000000`.

Es más ceremonia que el `http://localhost:4566` con credenciales `test` al que te acostumbró LocalStack. A cambio, las peticiones van firmadas con SigV4 como en AWS.

## Qué tan fiel es AWS Emulator: los fidelity scores

AWS publica con cada release un archivo `scores.json.gz` con el resultado de sus "fidelity tests". [La documentación de fidelidad](https://docs.aws.amazon.com/emulator/latest/userguide/fidelity.md) los define como "a short program that uses an AWS SDK to run a workflow against an AWS service and assert how AWS behaves". El score de un servicio es cuántos de esos tests pasa.

Bajé el de la release v1.0.385 y conté. De 43.548 tests, pasan 28.505: el 65,45%. Por servicio, contando solo los tests que tocan un único servicio:

| Servicio | Tests | Pasan | % |
| --- | ---: | ---: | ---: |
| SNS | 284 | 268 | 94,4% |
| Secrets Manager | 220 | 203 | 92,3% |
| SQS | 335 | 302 | 90,1% |
| S3 | 1.226 | 1.042 | 85,0% |
| Step Functions | 589 | 462 | 78,4% |
| DynamoDB | 1.481 | 1.093 | 73,8% |
| Lambda | 788 | 428 | 54,3% |
| CloudFormation | 2.612 | 449 | 17,2% |

Saqué los tests que cruzan varios servicios (un stack de CloudFormation que crea una Lambda, por ejemplo) para no contarlos dos veces, así que el total por fila no suma el global. Ese recorte puede mover algún porcentaje unos puntos.

Si tu app vive de colas, buckets y secretos, el emulador va bastante bien. Si despliegas con CloudFormation o CDK y esperas que el stack quede como en AWS, hoy no. La propia doc lo reconoce: el soporte de herramientas como CloudFormation, Terraform y CDK "varies by service".

**La lección:** antes de migrar tus tests, busca en el `scores.json` las operaciones que usa tu app. AWS lo recomienda así en [cómo comprobar si tu proyecto funciona](https://docs.aws.amazon.com/emulator/latest/userguide/check-project.html).

## Lo que AWS Emulator no hace

AWS Emulator es para construir y probar, y [su guía](https://docs.aws.amazon.com/emulator/latest/userguide/what-is-service.html) deja escritos estos límites:

- No persiste nada: "The emulator keeps all state in memory" y borra todo al detenerse. Para empezar limpio, lo reinicias.
- Cada emulador atiende una sola región y una sola cuenta.
- Las políticas de IAM no se evalúan como en AWS, así que no sirve para probar permisos: "Don't use it to test security".
- Cuando ejecuta código por ti, como el de una función, [la página de seguridad](https://docs.aws.amazon.com/emulator/latest/userguide/security.html) avisa que "it doesn't isolate that code from your machine".
- Las operaciones sin implementar responden HTTP 501 con `NotImplemented`.
- La telemetría viene activada. Se apaga con `aws-emulator --telemetry off` o `EMULATOR_TELEMETRY=off`, según [el README](https://github.com/aws/aws-emulator).

Lo de la telemetría conviene apagarlo en CI desde el primer día, aunque la doc diga que no recoge ni payloads ni credenciales.

## ¿AWS Emulator es competencia de LocalStack?

Sí, en el tramo gratis. LocalStack dice que no. En [su post del 13 de noviembre](https://blog.localstack.cloud/aws-emulator-is-here-what-you-need-to-know/) cuentan que AWS los invitó a colaborar en el anuncio, y a la pregunta de si AWS Emulator reemplaza a LocalStack responden: "No. AWS Emulator is focused on running AWS services locally". Según ellos, AWS Emulator apuesta por amplitud de servicios y LocalStack por profundidad en los que más se usan, incluido IAM.

El matiz técnico es cierto, pero el plan de entrada de LocalStack ya no es el de hace un año:

- El repo open source de LocalStack quedó [archivado el 23 de marzo de 2026](https://github.com/localstack/localstack), con un README que manda a los usuarios a la imagen unificada.
- Esa imagen pide un auth token: "a mandatory credential required to start the LocalStack container", según [su documentación](https://docs.localstack.cloud/aws/getting-started/auth-token/).
- El plan Hobby es gratis pero ["for hobbyists & other non-commercial usage"](https://www.localstack.cloud/pricing), con 30+ servicios y sin persistencia local.
- Para uso comercial, Base cuesta 39 USD por licencia al mes con facturación anual (45 USD mensual) y Ultimate, 89 USD anual.

El equipo que usaba LocalStack Community gratis en el CI de su empresa hoy tiene que pagar licencias, migrar a otra herramienta o quedarse con una imagen vieja. AWS Emulator llega a ese hueco sin pedir cuenta ni licencia, y con el logo de AWS.

Donde LocalStack sigue solo es en lo que cobra: estado persistente entre reinicios, Cloud Pods para compartir snapshots, e IAM evaluado de verdad. Si pagas Base o Ultimate por eso, AWS Emulator no te resuelve nada hoy.

## Alternativas a LocalStack: Floci, MiniStack y Moto

El archivado de LocalStack Community dejó espacio para otras herramientas. Floci y MiniStack nacieron este año para ocuparlo; Moto llevaba más de una década ahí.

**Floci** es un emulador en Java con licencia MIT, [creado en febrero de 2026](https://github.com/floci-io/floci), con más de 30.000 estrellas. Su README dice ser "a drop-in replacement for LocalStack Community": mismo puerto `4566`, credenciales cualquiera y "No account. No auth token. No feature gates". Si tu `docker-compose.yml` ya apuntaba a LocalStack, es el cambio que menos toca.

**MiniStack** es Python, MIT, [creado el 24 de marzo de 2026](https://github.com/ministackorg/ministack), un día después del archivado de LocalStack. Declara "60+ AWS services" en el puerto `4566` y tiene algo que AWS Emulator no: con el socket de Docker montado, RDS levanta un Postgres o MySQL real, ElastiCache un Redis real y ECS contenedores reales. También guarda estado en disco con `PERSIST_STATE=1`.

**Moto** es el veterano: una librería de Python, Apache 2.0, que [existe desde 2013](https://github.com/getmoto/moto) y va por la [5.2.5](https://pypi.org/project/moto/). Su uso natural es el decorador `@mock_aws` alrededor de tests con boto3, sin proceso aparte. Para otros lenguajes tiene un [modo servidor](https://docs.getmoto.org/en/latest/docs/server_mode.html) con `moto_server`, en el puerto `5000`.

Para un solo servicio, AWS ya tenía piezas sueltas: [DynamoDB Local](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBLocal.html) en el puerto `8000` y [`sam local`](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/using-sam-cli-local-start-api.html) para Lambda con API Gateway. Step Functions Local, en cambio, [figura como "unsupported"](https://docs.aws.amazon.com/step-functions/latest/dg/sfn-local.html).

## Comparativa: AWS Emulator vs LocalStack vs Floci vs MiniStack vs Moto

| | AWS Emulator | LocalStack | Floci | MiniStack | Moto |
| --- | --- | --- | --- | --- | --- |
| Licencia | CC0 1.0 | Planes de pago y Hobby (repo abierto archivado) | MIT | MIT | Apache 2.0 |
| Lenguaje | Rust | Python (repo archivado) | Java | Python | Python |
| Puerto por defecto | 9297 (HTTPS) | 4566 | 4566 | 4566 | 5000 (modo servidor) |
| Cuenta o token | No | Sí, auth token | No | No | No |
| Uso comercial gratis | Sí | No (desde 39 USD por licencia) | Sí | Sí | Sí |
| Respaldo | AWS | Empresa comercial | Comunidad | Comunidad | Comunidad |

Ventajas y desventajas, en corto:

- **AWS Emulator.** A favor: lo mantiene AWS, publica su fidelidad servicio por servicio y cubre cualquier API con modelo Smithy. En contra: sin imagen Docker oficial en macOS y Windows, sin persistencia, configuración de TLS más pesada, telemetría activa por defecto y CloudFormation todavía flojo.
- **LocalStack.** A favor: el más maduro, con persistencia, Cloud Pods, IAM evaluado y documentación de integración con Terraform, CDK y Pulumi. En contra: token obligatorio y uso comercial solo pagando.
- **Floci.** A favor: reemplazo directo de LocalStack Community, sin cuenta. En contra: proyecto de nueve meses que depende de su comunidad.
- **MiniStack.** A favor: bases de datos y contenedores reales, persistencia en disco. En contra: el proyecto más joven de la lista.
- **Moto.** A favor: el más probado y el más simple si tus tests son Python. En contra: fuera de Python pierde su gracia, porque hay que levantar el servidor igual.

## Cuál usar

Para tests de integración en un CI empresarial que hoy dependen de LocalStack Community, prueba AWS Emulator primero en los servicios donde su score es alto (SQS, SNS, S3, Secrets Manager). Es gratis, no pide cuenta y su fidelidad se puede auditar release por release.

Si tu infraestructura se despliega con CloudFormation o CDK dentro del emulador, o necesitas que el estado sobreviva a un reinicio, AWS Emulator todavía no te sirve. Ahí la elección es pagar LocalStack o probar MiniStack, que persiste en disco y levanta bases de datos reales.

Si tus tests son Python y boto3, Moto sigue siendo lo más simple: no hay proceso que levantar. Y si solo quieres cambiar la imagen del `docker-compose.yml` sin tocar endpoints, Floci escucha en el mismo `4566`.

Lo primero que correría con AWS Emulator es `aws sts get-caller-identity` contra el endpoint, y después la suite de integración entera con `--telemetry off`. Los tests que fallen son la lista de lo que el emulador todavía no cubre en tu app.

Si te interesa por qué una suite en verde no garantiza nada, lo conté en [Bugs que los tests en verde no detectan](/post/bugs-que-los-tests-en-verde-no-detectan).

## Preguntas frecuentes

### ¿AWS Emulator es gratis?

Sí. Según su documentación, AWS Emulator "has no additional service fee": solo pagas los recursos cuando despliegas en AWS de verdad. No pide cuenta de AWS y el código tiene licencia CC0.

### ¿AWS Emulator reemplaza a LocalStack?

Para tests de integración gratis en CI, puede reemplazar al plan Hobby o a LocalStack Community. Para persistencia de estado, Cloud Pods o evaluación de políticas IAM, no: esas funciones solo están en los planes de pago de LocalStack.

### ¿AWS Emulator funciona en macOS y Windows?

Sí, pero dentro de Docker y con una imagen que construyes tú desde el Dockerfile de la documentación. AWS no publica una imagen prebuilt. Solo Linux tiene paquetes nativos RPM y Debian.

### ¿Qué puerto usa AWS Emulator?

Por defecto sirve HTTPS en `127.0.0.1:9297`, con un certificado autofirmado que se regenera en cada arranque. Se cambia con `-p` o `--port`.

### ¿AWS Emulator guarda los datos al reiniciar?

No. Mantiene todo el estado en memoria y borra los recursos al detenerse. Si necesitas persistencia, MiniStack la ofrece con `PERSIST_STATE=1` y LocalStack en sus planes de pago.

### ¿Qué alternativas gratis a LocalStack existen?

AWS Emulator (oficial de AWS, CC0), Floci (Java, MIT, compatible con LocalStack Community), MiniStack (Python, MIT, con bases de datos reales) y Moto (Python, Apache 2.0, ideal para tests con boto3).

## Fuentes

- [aws/aws-emulator](https://github.com/aws/aws-emulator) (README: licencia, modos, compilación, telemetría)
- [aws/aws-emulator releases](https://github.com/aws/aws-emulator/releases) (`scores.json.gz` de la v1.0.385)
- [What is AWS Emulator?](https://docs.aws.amazon.com/emulator/latest/userguide/what-is-service.html) (documentación oficial: estado en memoria, límites)
- [Getting started with Docker](https://docs.aws.amazon.com/emulator/latest/userguide/getting-started-docker.html) (documentación oficial)
- [Getting started on Linux](https://docs.aws.amazon.com/emulator/latest/userguide/getting-started-linux.html) (documentación oficial)
- [Pointing your AWS SDK at AWS Emulator](https://docs.aws.amazon.com/emulator/latest/userguide/point-sdk-to-emulator.html) (documentación oficial: variables de entorno)
- [Fidelity in AWS Emulator](https://docs.aws.amazon.com/emulator/latest/userguide/fidelity.md) (documentación oficial)
- [Checking whether your project works with AWS Emulator](https://docs.aws.amazon.com/emulator/latest/userguide/check-project.html) (documentación oficial)
- [Security in AWS Emulator](https://docs.aws.amazon.com/emulator/latest/userguide/security.html) (documentación oficial)
- [AWS Emulator Is Here: What You Need to Know](https://blog.localstack.cloud/aws-emulator-is-here-what-you-need-to-know/) (blog de LocalStack, 13 de noviembre de 2026)
- [LocalStack Pricing](https://www.localstack.cloud/pricing) (planes y precios)
- [Auth Token](https://docs.localstack.cloud/aws/getting-started/auth-token/) (documentación de LocalStack)
- [localstack/localstack](https://github.com/localstack/localstack) (repo archivado)
- [floci-io/floci](https://github.com/floci-io/floci) (README)
- [ministackorg/ministack](https://github.com/ministackorg/ministack) (README)
- [getmoto/moto](https://github.com/getmoto/moto) y [Moto server mode](https://docs.getmoto.org/en/latest/docs/server_mode.html)
- [DynamoDB local](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBLocal.html) (documentación oficial)
- [Step Functions Local](https://docs.aws.amazon.com/step-functions/latest/dg/sfn-local.html) (documentación oficial)

---

## Sitemap

Índice completo del sitio: [/sitemap.md](https://www.angelcruz.dev/sitemap.md)

Canónico HTML: [https://www.angelcruz.dev/post/aws-emulator-localstack-alternativas](https://www.angelcruz.dev/post/aws-emulator-localstack-alternativas)
