AWS Emulator in Practice · Parte 02 · 5 minutos de lectura
En el primer artículo de esta serie os contaba cómo había probado AWS Emulator con S3, DynamoDB y SQS. La instalación nativa funcionó bien, pero mi primer intento con Docker no salió como esperaba.
El contenedor arrancaba, el puerto estaba publicado y, sin embargo, no podía conectar con el emulador. Obtenía un error TLS. La causa no estaba en el certificado, sino en la configuración de red.
En este artículo quiero compartir lo que aprendí durante esas pruebas y cómo terminé ejecutando AWS Emulator en Docker sin exponer su endpoint a toda la red.
El problema: ¿de quién es localhost?
Por defecto, AWS Emulator escucha en 127.0.0.1:9297. Es una decisión razonable para una aplicación que se ejecuta localmente.
Dentro de un contenedor, sin embargo, 127.0.0.1 pertenece al propio contenedor. Docker puede publicar un puerto del host y redirigir tráfico hacia la interfaz de red del contenedor, pero eso no hace que un servicio que escucha únicamente en su loopback acepte esas conexiones.
Mi primer Dockerfile omitía un parámetro que AWS ya incluye en su documentación oficial:
ENTRYPOINT ["aws-emulator", "-b", "0.0.0.0"]
Con esta opción, el emulador escucha en todas las interfaces dentro del contenedor. Docker ya puede reenviar las conexiones a su endpoint.
Pero aquí aparece una segunda decisión: ¿a qué interfaces del host queremos publicar el puerto?
Utilizar -p 9298:9298 puede exponerlo a otros equipos. En cambio, -p 127.0.0.1:9298:9298 restringe la publicación al loopback del host en una configuración bridge convencional.
Escuchar en todas las interfaces del contenedor no equivale a publicar el servicio en todas las interfaces del host. Esa distinción resolvió el problema sin recurrir a --network host.
Construir y ejecutar la imagen
AWS documenta cómo construir la imagen a partir de Amazon Linux 2023. He preparado una variante del Dockerfile que utiliza el paquete RPM oficial de AWS Emulator v1.0.341, una versión concreta, e incorpora una comprobación de su firma antes de instalarlo. La imagen ejecuta el emulador con un usuario no root.
Para reproducir mi instalación en Linux x86-64, con Docker actualizado y sin credenciales AWS reales en la máquina, podemos utilizar el Dockerfile del repositorio:
git clone https://github.com/pacosepulveda/aws-emulator-in-practice-labs.git
cd aws-emulator-in-practice-labs
docker build -t aws-emulator:local \
labs/01-getting-started/docker
En mi laboratorio utilizo el puerto 9298 para Docker y dejo el 9297 disponible para una instancia nativa. Arrancamos el contenedor:
PORT=9298
mkdir -p "$HOME/.aws/emulator"
docker run --rm --name aws-emulator-lab \
--memory=2g --memory-swap=2g \
--user "$(id -u):$(id -g)" \
-e HOME="$HOME" \
-v "$HOME/.aws/emulator:$HOME/.aws/emulator" \
-p "127.0.0.1:$PORT:$PORT" \
aws-emulator:local -p "$PORT" -t off
Hay dos detalles importantes. El volumen comparte exclusivamente el directorio donde se generan los certificados y credenciales del emulador, no toda nuestra carpeta ~/.aws. Además, conservamos el mismo puerto dentro y fuera del contenedor: AWS utiliza ese número para generar los archivos de configuración.
El límite de memoria de 2 GiB forma parte del procedimiento documentado, no una medición del consumo real.
Primera comprobación: TLS y credenciales
En otra terminal, con AWS CLI instalado, podemos abrir una sesión limpia y utilizar los archivos generados por esa instancia:
env -i HOME="$HOME" PATH="$PATH" bash --noprofile --norc
export PORT=9298
export AWS_ENDPOINT_URL="https://127.0.0.1:$PORT"
export AWS_SHARED_CREDENTIALS_FILE="$HOME/.aws/emulator/$PORT/emulator_credentials"
export AWS_CONFIG_FILE="$HOME/.aws/emulator/$PORT/config"
export AWS_CA_BUNDLE="$HOME/.aws/emulator/$PORT/ca.pem"
export AWS_EC2_METADATA_DISABLED=true
export AWS_DISABLE_HOST_PREFIX_INJECTION=true
export AWS_DEFAULT_REGION=us-east-1
curl --fail --cacert "$AWS_CA_BUNDLE" \
"$AWS_ENDPOINT_URL/__admin/health"
aws sts get-caller-identity \
--endpoint-url "$AWS_ENDPOINT_URL"
La respuesta del health check debe ser ok y la cuenta devuelta por STS debe ser 000000000000. Si alguna de estas comprobaciones falla, no debemos continuar creando recursos.
Una vez configurado el entorno, repetí las operaciones con S3, DynamoDB y SQS y las pruebas de Python/Boto3. Funcionaron correctamente. No fue necesario desactivar la validación TLS ni utilizar credenciales de AWS real.
Dos aprendizajes adicionales del laboratorio
La CPU virtual también importa
En mi VM sobre Proxmox, Amazon Linux 2023 no arrancaba con el modelo de CPU virtual inicial: la biblioteca de sistema exigía instrucciones x86-64-v2 que no estaban expuestas a la VM. Cambiar el modelo a host resolvió el problema en mi entorno.
No era un fallo del emulador ni de Docker. Era una incompatibilidad entre la imagen base y las características de CPU presentadas por el hipervisor.
Verificar paquetes en una imagen mínima
También encontré problemas al intentar utilizar GnuPG en Amazon Linux 2023-minimal. La solución de nuestro Dockerfile utiliza la verificación de paquetes RPM mediante rpmkeys y rpm -K. En una prueba negativa, alteramos un byte del paquete y comprobamos que la verificación lo rechazaba. Los detalles están en el repositorio.
Una precaución de seguridad que merece atención
La documentación de Docker advierte de un comportamiento en versiones anteriores a la 28.0.0: otros equipos del mismo segmento de red podrían alcanzar puertos publicados en localhost bajo determinadas condiciones.
Actualicé Docker en la VM del laboratorio y comprobé desde otro equipo de la LAN que la conexión TCP al puerto publicado era rechazada. No me limité a consultar las interfaces de escucha del host.
Esto confirma el resultado de nuestra configuración concreta, no el aislamiento universal de cualquier red Docker. Es necesario tener en cuenta las rutas, las reglas de firewall y las opciones de red utilizadas.
Y no olvidemos que AWS desaconseja usar el emulador para validar la seguridad. Ejecutarlo como usuario no root en un contenedor reduce privilegios, pero no lo convierte en un entorno seguro para código no confiable.
Resultado final y próximos pasos
La ejecución de referencia con AWS Emulator v1.0.341 y Docker 29.9.3 superó las 9 comprobaciones del experimento Docker. Incluyó la construcción de la imagen, las operaciones con AWS CLI y Boto3, el acceso desde el host, el aislamiento observado respecto a la LAN y la coexistencia de instancias nativa y Docker.
En una revisión posterior del script automatizado, reforzamos la comprobación de salud, la validación de identidad STS y la gestión de errores y limpieza. La nueva batería de regresión superó 13/13 comprobaciones. Los resultados originales y esta revisión corresponden a baterías distintas.
Para mí, la conclusión es que Docker proporciona una base muy interesante para crear entornos efímeros de desarrollo y pruebas de integración. Pero conviene entender la red, las credenciales y el estado de la aplicación antes de llevarla a un pipeline CI/CD.
En el próximo artículo cambiaremos de perspectiva: ¿qué ocurre cuando desplegamos infraestructura con Terraform contra el emulador? Ya hemos encontrado un comportamiento de DynamoDB que merece un análisis propio.
Reproduce el laboratorio
El repositorio público de la serie incluye el Dockerfile, los experimentos, las incidencias originales y el informe de resultados. La ejecución de referencia se realizó el 13 de noviembre de 2026 en una VM Debian 13.
Referencias
- AWS Emulator: Getting started with Docker
- Docker: Port publishing and mapping
- Security in AWS Emulator
¿Te interesa la seguridad en Cloud?
Comparto análisis técnicos, laboratorios prácticos y experiencias reales sobre Cloud Security.