Pruebas locales de infraestructura en la nube: el emulador oficial de APIs de AWS sin facturas de cloudArtículo · digest del 17 de noviembre
Fotografía macro de un servidor hardware compacto con puerto local 9297 e indicador de emulación autónoma de AWS.
Artículo3 secciones≈ 7 min

Pruebas locales de infraestructura en la nube: el emulador oficial de APIs de AWS sin facturas de cloud

En el repositorio aws-emulator me llamó la atención de inmediato un detalle poco habitual en un gigante del cloud. Amazon, cuyo negocio se basa en cobrar por cada llamada y cada recurso, ha publicado un emulador local de sus propias APIs en dominio público bajo licencia CC0-1.0, con 34 127 commits, 8800 estrellas y una carpeta tan honesta como issues/things-that-do-not-work/, donde el equipo anota las operaciones que divergen de la nube real. Eso sí, el README avisa desde el principio: el proyecto no acepta pull requests y todos los cambios llegan desde dentro de AWS.

Para quien desarrolla, detrás de esto hay una pregunta práctica directa: ¿cómo ejecutar pruebas de integración de un servicio que guarda archivos multimedia en S3 y encola tareas en SQS tanto en local como en CI, sin cuenta en la nube ni sustos en la factura? El emulador intercepta las peticiones de los SDK estándar en un socket local y simula el comportamiento de los servicios principales en tu propia máquina. Pero esa comodidad tiene sus peajes, y conviene conocerlos antes de mover el pipeline.

Por qué las pruebas contra un AWS real se atascan y cómo intercepta peticiones sobre Smithy

Probar integraciones cloud contra una cuenta real de pruebas genera fricción constante: hay que aislar credenciales en CI, limpiar recursos tras ejecuciones fallidas para no disparar el tráfico y asumir la latencia de red de las APIs. Durante años ese hueco lo cubrió LocalStack, aunque buena parte de sus servicios y funciones avanzadas quedan tras la licencia de pago Pro.

El planteamiento de aws-emulator es distinto: todo el código es dominio público (salvo las carpetas en vendor/, bajo Apache License 2.0) y está escrito en Rust sobre los modelos oficiales de Smithy. Cada servicio vive en su propio crate services/service-<name>/ con el esquema smithy-model/<name>.json, el generador build.rs, los manejadores en ops/ y el estado en memoria en state.rs. El módulo core/router/ reúne todo bajo una única dirección HTTPS local 127.0.0.1:9297 con certificado autofirmado. Al generarse directamente desde las especificaciones Smithy, el emulador mantiene una alta fidelidad de protocolo en los servicios clave sin suscripción.

Modo servidor y modo embebido: levantando S3 y SQS en un puerto local

La herramienta ofrece dos modos de trabajo: modo servidor para cualquier lenguaje y modo embebido para tests en Rust. Si programas en Python, Node.js, Go o Java, lo más directo es arrancar el contenedor oficial de Docker (en Linux también hay paquetes RPM y DEB).

Levantemos el emulador local en el puerto 9297 con la telemetría desactivada para probar nuestro servicio de subida de archivos sin salir a internet:

docker run -d --name aws-emulator -p 9297:9297 public.ecr.aws/aws-emulator/aws-emulator:latest --telemetry off

El contenedor arranca un demonio HTTPS local en 127.0.0.1:9297 sin interfaz gráfica. El flag --telemetry off justo después del nombre de la imagen desactiva el envío de estadísticas, y todos los buckets y colas creados viven en la memoria del contenedor.

Ahora apuntamos AWS CLI al puerto local, fijamos unas claves ficticias y creamos un bucket S3 junto con una cola SQS para recibir archivos:

export AWS_ENDPOINT_URL=https://127.0.0.1:9297
export AWS_ACCESS_KEY_ID=dummy-test-key
export AWS_SECRET_ACCESS_KEY=dummy-test-secret
export AWS_DEFAULT_REGION=us-east-1

aws s3 mb s3://my-local-bucket --endpoint-url https://127.0.0.1:9297 --no-verify-ssl
aws sqs create-queue --queue-name local-tasks --endpoint-url https://127.0.0.1:9297 --no-verify-ssl

El emulador acepta cualquier par de claves de prueba no vacías, así que ya no hacen falta secretos reales de AWS en CI. El parámetro --no-verify-ssl aquí es obligatorio: permite que el cliente acepte el certificado autofirmado del socket local (como alternativa en el entorno puedes vaciar AWS_CA_BUNDLE="").

A continuación conectamos un test de integración en Python con boto3 que sube los metadatos de un archivo procesado al bucket local y comprueba la lectura del objeto:

import boto3

s3 = boto3.client(
    "s3",
    endpoint_url="https://127.0.0.1:9297",
    aws_access_key_id="test",
    aws_secret_access_key="test",
    region_name="us-east-1",
    verify=False,
)

s3.put_object(Bucket="my-local-bucket", Key="data.json", Body=b'{"status":"ok"}')
response = s3.get_object(Bucket="my-local-bucket", Key="data.json")
assert response["Body"].read() == b'{"status":"ok"}'

La lógica de negocio no cambia: solo varían endpoint_url y el flag verify=False para el TLS local. Ese mismo paso con el contenedor se traslada tal cual a GitHub Actions. Y si usas agentes de programación (Claude Code, Cursor o Kiro) con AWS CLI 2.35.0 o superior, puedes delegar la configuración del entorno al agente:

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

Este comando instala la skill oficial de Agent Toolkit, tras lo cual el agente levanta el emulador y redirige las peticiones por su cuenta al depurar.

El modo Embedded para proyectos en Rust funciona de manera muy distinta: el emulador se añade como dev-dependency y arranca dentro del propio proceso de pruebas.

use aws_emulator_embedded::{AwsEmulatorEmbedded, EmbeddedOptions, Telemetry};

fn main() {
    let emulator = AwsEmulatorEmbedded::new(
        EmbeddedOptions::default().telemetry(Telemetry::Off),
    );
    let _http_client = emulator.http_client();
}

El modo embebido no ocupa el puerto 9297, no necesita certificados ni variables de entorno: pasas emulator.http_client() al cliente del SDK y obtienes una instancia aislada del emulador para cada test en paralelo.

El precio de la comodidad: 100 GB de compilación, telemetría y límites de emulación

A cambio de facturas a cero en AWS, el emulador exige un coste muy tangible en recursos y atención al detalle. De las tres limitaciones que yo comprobaría antes de migrar pruebas a CI, la primera es la pesada compilación desde fuentes: como cada servicio vive en un crate de Rust independiente, una compilación en frío con cargo build -p aws-emulator-router o la primera ejecución de cargo test en modo embebido requiere un compilador de C, procesador multinúcleo y al menos 100 GB en disco para la carpeta target/. En el día a día sale mucho más a cuenta usar la imagen Docker o el paquete binario, y en CI de Rust conviene cachear target/, compartir un CARGO_TARGET_DIR, usar sccache y fijar el commit de release.

El segundo matiz es la telemetría por defecto. El emulador envía a AWS estadísticas de uso anonimizadas (sin cuerpos de petición, código, claves ni datos personales). Si la política de seguridad de tu equipo prohíbe ese tráfico, se desactiva con el flag --telemetry off (-t off), la variable EMULATOR_TELEMETRY=off (o false, 0), la opción Telemetry::Off o el archivo ~/.aws/emulator/config.toml con la sección [telemetry] y enabled = false.

El tercero son los límites de fidelidad. La guía oficial de AWS Emulator prohíbe expresamente usar la herramienta en producción o para validar seguridad como políticas IAM. Antes de fiarte del emulador en un escenario complejo, conviene revisar las puntuaciones de fidelidad (fidelity scores) de cada release y asomarse a issues/things-that-do-not-work/.

No hay ningún botón mágico que sustituya al cien por cien a la nube real, pero ahora las reglas están claras. Las pruebas rápidas de integración de S3, SQS y contratos del SDK compensa moverlas al aws-emulator local en 127.0.0.1:9297 con presupuesto cero, dejando una cuenta real de pruebas de AWS para verificar permisos antes de lanzar a producción. Si quieres comparar este enfoque con una alternativa más ligera, echa un vistazo al análisis del emulador Kumo en Go y al repaso de herramientas de desarrollo con AWS Emulator.

Quiero un análisis detalladoLos votos ayudan a elegir qué analizar a fondo. Este material tiene 0 votos.
Fuentes · 2