Pruebas con el emulador de AWS: 5 mitos peligrosos
El emulador oficial de AWS es real, pero sus mitos te pasarán factura. Descubre dónde falla la fidelidad y qué debe seguir ejecutándose en AWS real.

El peor fallo de pruebas de integración que he tenido fue en verde. Todas las comprobaciones pasaron en CI, el despliegue salió y veinte minutos después un ingeniero de guardia miraba una cola llena de mensajes envenenados porque el comportamiento real de SQS difería del stub en una única forma que nadie había pensado comprobar. Así que cuando AWS lanzó su propio emulador (un workspace de Rust con un crate por servicio, generado a partir de los mismos modelos Smithy que alimentan los SDK reales), mi primera reacción no fue entusiasmo. Fue: bien, ahora veamos dónde miente. Porque todo emulador miente en algún punto, y las pruebas con el emulador de AWS solo funcionan si sabes dónde están sus mentiras.
Mito 1: «Si las pruebas contra un emulador de AWS pasan, funciona en AWS»
Es la creencia que hace daño a la gente, y la propia documentación del proyecto es inusualmente honesta al respecto. AWS publica puntuaciones de fidelidad por servicio con cada versión y registra los huecos en un directorio literal issues/things-that-do-not-work/ dentro del repositorio. Ese directorio es lo primero que deberías leer antes de escribir una sola prueba. Los primeros adoptantes ya se han topado con los muros: las definiciones de Step Functions que usan el campo Assign no funcionan, y el soporte de Lambda para código Python está lo bastante incompleto como para que un flujo que corre bien en MiniStack se quede parado en el emulador oficial. Nada de esto es un escándalo; es el estado normal de un emulador joven. El escándalo es tratar una suite en verde como prueba de algo más allá de «tu código funciona contra la interpretación que hace el emulador de la API».
El modelo mental correcto es cobertura, no verdad. El emulador cubre las formas de petición que envía tu SDK y devuelve respuestas plausibles. No cubre el comportamiento de throttling, los retrasos de propagación entre servicios ni las mil peculiaridades no documentadas de un sistema distribuido a escala global. Es la misma brecha entre especificación e implementación que aparece en todas partes en infraestructura: el modelo Smithy te dice cuál es el formato en el cable, pero no puede decirte que el SQS real a veces entrega un mensaje dos veces dentro del visibility timeout, ni que la propagación de IAM real tarda segundos y que el rol que acabas de crear fallará sus tres primeras invocaciones. Tus pruebas pasaron porque el emulador nunca tuvo la oportunidad de ser eventual.
Mito 2: «Puedo validar políticas de IAM y controles de seguridad en local»
No, y AWS lo dice en lenguaje claro en la página de seguridad del emulador. No lo uses para probar políticas de IAM ni límites de permisos, políticas basadas en recursos como las políticas de bucket, políticas de claves KMS, acceso entre cuentas o entre regiones, ni ningún otro control de seguridad. Algunos servicios evalúan IAM para usuarios y roles que creas dentro del emulador, pero no de la forma en que lo hace AWS. El emulador nunca deniega una petición firmada con su propia clave. Una petición que AWS rechazaría puede tener éxito en local, lo que significa que el emulador no solo es inútil para pruebas de seguridad, sino que induce a error activamente. Te dará un falso negativo con total naturalidad.
He visto a equipos aprender esto por las malas. Un desarrollador endurece una política de bucket, ejecuta la suite local, ve verde, lo despliega, y el job nocturno contra la cuenta sandbox muere porque la política ahora bloquea el rol de replicación. O lo contrario, mucho peor: la política es demasiado permisiva, todo pasa en todas partes, y te enteras meses después, durante una auditoría, de que tu bucket «privado» era legible por cualquier principal autenticado. La lógica de políticas es uno de los puntos donde la autenticación en la nube tiene puntos ciegos reales, y ningún emulador va a salvarte de ellos. Si quieres verificar el comportamiento de las políticas, necesitas evaluación real de IAM. Eso implica una cuenta real, idealmente un sandbox dedicado con SCP que limiten a qué puede acceder, y pruebas que afirmen denegaciones, no solo éxitos:
import boto3
import pytest
from botocore import UNSIGNED
from botocore.config import Config
from botocore.exceptions import ClientError
def test_private_bucket_denies_anonymous_read():
# Runs only in the nightly job, against a dedicated sandbox account.
s3 = boto3.client("s3")
s3.put_object(Bucket=SANDBOX_BUCKET, Key="probe.txt", Body=b"x")
anon = boto3.client("s3", config=Config(signature_version=UNSIGNED))
with pytest.raises(ClientError) as err:
anon.get_object(Bucket=SANDBOX_BUCKET, Key="probe.txt")
assert err.value.response["Error"]["Code"] == "AccessDenied"
Una cosa más antes de apuntar toda tu flota de CI a esta herramienta: la telemetría está activada por defecto. AWS dice que está minimizada y que nunca incluye el contenido de las peticiones ni credenciales, y no tengo motivos para dudarlo, pero mi regla es que las herramientas de desarrollo no llaman a casa a menos que yo lo haya indicado. Ejecútalo con --telemetry off o define EMULATOR_TELEMETRY=off en el entorno de CI y sigue adelante.
Mito 3: «La fidelidad del protocolo de red es lo difícil»

Acertar con el formato en el cable es lo mínimo, y es la parte que AWS siempre iba a clavar. Sus SDK se generan a partir de modelos Smithy, el emulador se genera a partir de los mismos modelos, así que cada operación, cada campo opcional y cada forma de error coincide con la API documentada. Un comentarista de HN lo resumió bien: la generación basada en especificación cubre cada variante de cada endpoint, mientras que los emuladores comunitarios históricamente implementan el subconjunto más usado y aproximan el resto. Es una ventaja genuina de la herramienta oficial.
Pero la fidelidad de red es la parte fácil. La difícil es la fidelidad de comportamiento, y nadie la tiene: ni el emulador de AWS, ni LocalStack, ni moto, ni Floci. La fidelidad de comportamiento es lo que no aparece en ningún modelo: ¿un arranque en frío de Lambda cambia el tiempo observable lo suficiente como para disparar el timeout de tu cliente? ¿El throttling de DynamoDB se manifiesta como error reintentable al ritmo al que llega tu tráfico de producción? ¿El teardown de CloudFormation se queda colgado veinte minutos cuando los recursos se crearon en un orden legal pero desafortunado? Un profesional preguntó si podía apuntar todo un proyecto CDK al emulador y probar cdk deploy de extremo a extremo, y mi respuesta es: puedes, y deberías, pero solo para detectar errores de síntesis y de forma de la API. La dinámica del despliegue (comportamiento de rollback, orden de reemplazo de recursos, detección de drift) es justo lo que peor hace un emulador, porque son propiedades emergentes del plano de control real.
- Fidelidad de red — formas de petición y respuesta, códigos de error, serialización. Los emuladores son buenos en esto, y el generado con Smithy debería ser de los mejores de su clase.
- Fidelidad de estado — ciclos CRUD, listados, filtrado, paginación. En general bien entre emuladores, con huecos por servicio que debes comprobar.
- Fidelidad de comportamiento — tiempos de consistencia, throttling, fallos parciales, peculiaridades del ciclo de vida de los recursos. Nadie la tiene. Planifícalo en consecuencia.
Mito 4: «Los emuladores son drop-in: basta con cambiar el endpoint»
El argumento de marketing de cualquier emulador es «define una variable de entorno y listo». Para una prueba rápida de humo, es cierto. El modo servidor escucha en 127.0.0.1:9297 sobre HTTPS con un certificado autofirmado, y apuntar la CLI hacia él se ve así:
export AWS_ENDPOINT_URL=https://localhost:9297
export AWS_ACCESS_KEY_ID=emulator
export AWS_SECRET_ACCESS_KEY=emulator
export AWS_REGION=us-east-1
# self-signed cert: don't disable verification globally, scope it
aws s3 ls --no-verify-ssl
La historia de «drop-in» se viene abajo a escala de suite de pruebas. Los problemas prácticos con que la gente se topa en la primera semana: no hay un reseteo rápido de estado. Si tu suite necesita una pizarra limpia entre pruebas (y los usuarios de moto están acostumbrados exactamente a eso: un decorador y el mundo se reinicia), tu opción actual es reiniciar el proceso. Eso sirve para diez pruebas y es doloroso para diez mil. Tampoco hay emulación de múltiples cuentas ni de Organizations, lo que descarta cualquier prueba que modele la estructura real de tu cuenta. Y si te tienta el modo Rust embebido (una instancia aislada en el propio proceso por prueba, sin endpoints ni certificados que gestionar, un diseño realmente agradable), lee antes la sección de coste de compilación. El workspace tiene un crate por servicio de AWS, una compilación de depuración completa necesita del orden de 100 GB de espacio en target/, y tu primer cargo test compila el emulador junto con tu propio código. Su consejo de compartir un CARGO_TARGET_DIR, cachear target/ en CI y fijar un commit de release no es decoración opcional. Es la diferencia entre un job de CI de cinco minutos y uno de cincuenta.
use aws_emulator_embedded::{AwsEmulatorEmbedded, EmbeddedOptions, Telemetry};
let emulator = AwsEmulatorEmbedded::new(
EmbeddedOptions::default().telemetry(Telemetry::Off),
);
let http_client = emulator.http_client();
// wire http_client into your SDK client config — no endpoint,
// no env vars, one isolated instance per test
Mito 5: «El emulador oficial de AWS acaba con LocalStack, moto y el resto»
Escuché versiones de esto a las pocas horas del anuncio, y malinterpreta lo que venden realmente los veteranos. El valor de LocalStack nunca fue simplemente «reimplementamos la API de S3». Son años de ajuste de comportamiento por servicio, gestión de estado, integración con testcontainers, ergonomía en CI y una comunidad que ya registró el bug con el que vas a topar. El reseteo de estado por prueba de moto mediante decoradores es una funcionalidad de flujo de trabajo, no de API, y el emulador de AWS todavía no tiene respuesta para ello. Los fans de Floci señalaron que también cubre GCP y Azure: si tu infraestructura es multinube, un entorno local unificado vale más que uno de mayor fidelidad pero de una sola nube.
También hay una cuestión legítima de confianza a largo plazo. El primer comentario del hilo preguntaba lo que todos pensaban: ¿es un producto real que AWS va a mantener o un ejercicio? El repositorio acepta reportes de issues pero no pull requests, una decisión defendible para una base de código basada en especificación, pero que también significa que la comunidad no puede parchear los huecos por sí misma. Si el equipo es reasignado, te quedas con una instantánea con licencia CC0. Mi postura: evalúalo como cualquier dependencia con un solo mantenedor. Adoptarlo está bien, apostar todo a ello es temerario. El mismo escepticismo aplica al comentario eufórico de «los agentes escribieron esto en Rust, el foso ya no existe». El foso nunca fue la superficie de la API; es la excelencia operativa, y emular la API siempre fue la parte barata. Vimos esta dinámica con SQLite distribuido y raft también: copiar la interfaz son semanas de trabajo, igualar la semántica de fallos son años.
Lo que debe seguir ejecutándose contra infraestructura real de AWS

Este es el reparto que aplico en proyectos reales, y hasta ahora no me ha fallado. Todo lo que es rápido, determinista y orientado a formas se ejecuta contra el emulador en cada commit: serialización, manejo de errores de códigos documentados, lógica de reintentos, máquinas de estado que solo dependen de ciclos CRUD. Eso es el 90% de tu suite por número de pruebas y quizá el 10% por riesgo.
El 10% restante se ejecuta cada noche contra una cuenta sandbox real y aislada, y es la parte que atrapa lo que realmente te despierta de madrugada:
- Políticas de IAM y de recursos. Afirma denegaciones explícitas, no solo caminos permitidos. El emulador es estructuralmente incapaz de esto: nunca deniega una petición firmada con su propia clave.
- Cualquier cosa con retraso de propagación. Roles nuevos, cambios de DNS, concesiones de KMS. Si tu código crea un recurso y lo usa de inmediato, solo AWS real te dirá si necesitas un bucle de reintentos.
- Comportamiento de at-least-once e idempotencia. Entregas duplicadas de SQS, reintentos de Lambda por timeout, fallos parciales en lotes. Los emuladores son educados; la producción no.
- Ciclo de vida de la infraestructura. Ciclos completos de
cdk deploy/terraform applyy destroy, sobre todo el orden de teardown y las rutas de rollback. - Throttling y bordes de cuotas. Si importa con la carga de producción, solo existe con el comportamiento real de la API de producción.
La cuenta sandbox necesita sus propias salvaguardas: políticas de control de servicios que limiten lo que puede hacer, alertas de presupuesto y un barrido que elimine los recursos sobrantes, porque tu job nocturno va a dejar cosas colgadas. Es una sobrecarga operativa real, y justo por eso el emulador tiene valor: mantiene rápido y gratuito el 90% de tu bucle de feedback, para que puedas permitirte hacer honesto el último 10%.
El trabajo de un emulador es hacer rápido tu bucle de feedback. No es darte confianza. La confianza sigue costando llamadas reales a la API.
El emulador oficial de AWS es una herramienta genuinamente buena: cobertura generada a partir de especificaciones, un modo embebido con aislamiento real y una documentación refrescantemente honesta sobre lo que no puede hacer. Adóptalo por lo que es: la forma más rápida posible de estar casi siempre bien. Después decide, deliberadamente y por escrito, qué pruebas tienen derecho a reclamar el otro tipo de acierto: el que solo llega de una infraestructura que puede realmente denegar tu petición, limitar a tu cliente y entregar tu mensaje dos veces.


