Tema 4 · 1 · Crear el Data Lake (stack de CloudFormation)

Presentación del Tema 4: «Laboratorios en AWS» (objetivo, checklist, preparación y Paso 1 · desplegar el entorno), «Estimación de costes» (con su «Ejercicio») y «Limpieza y comprobación (obligatoria)». Duración: 15 a 20 minutos para crear el stack (unos 3 minutos con la instancia EC2 y menos de 1 sin ella) más la limpieza final, de 5 a 10 minutos. Coste: céntimos; solo la instancia EC2 del panel Streamlit (opcional) puede costar de verdad si te la dejas encendida.

¿Dudas con un script? Todos los scripts de esta carpeta traen su propia ayuda: ./gestionar-datalake.sh --ayuda (también vale --help o -h) explica los pasos y las opciones. Este README.md es el paso a paso de la actividad: tenlo a mano y consúltalo antes de preguntar.

Etiquetas de lo que creas. ./gestionar-datalake.sh crear etiqueta el stack y todo lo que contiene (bucket, Glue, Athena, roles, EC2) con curso = G214, universidad = CUNEF, actividad = 04.01-creardatalake y script = gestionar-datalake.sh. Las verás en la consola (pestaña Tags del recurso) y, si hiciera falta borrar a mano, se localizan con aws resourcegroupstaggingapi get-resources --region eu-north-1 --tag-filters Key=actividad,Values=04.01-creardatalake. Más detalle (cómo etiquetar con la CLI, cómo buscar y qué hacer en una emergencia): README principal, sección «Etiquetas».

Qué vas a hacer

Vas a crear el Data Lake en tu propia cuenta de AWS con una plantilla de CloudFormation (una lista de recursos de AWS que se crean juntos y se borran juntos) que viene dentro del script gestionar-datalake.sh: un solo archivo que sabe crear, comprobar y eliminar el laboratorio. Después comprobarás que todo está y, al final del Tema 4, lo borrarás con el mismo script. Esta carpeta es la base de todas las demás (04.02 a 04.07).

Qué se crea en AWS. Al crear el stack g214-datalake-demo en la región eu-north-1 (Estocolmo), AWS crea:

Athena no guarda datos: lee los ficheros de S3 usando las descripciones del catálogo de Glue. Por eso «crear una tabla» en un Data Lake solo crea una descripción, y borrar una tabla no borra los ficheros.

Qué contiene esta carpeta

Dónde está la plantilla de CloudFormation. Va embebida en el propio script, entre las marcas INICIO ARCHIVO EMBEBIDO y FIN ARCHIVO EMBEBIDO. Para leerla o editarla: ./gestionar-datalake.sh extraer la vuelca a la carpeta actual como plantilla-datalake.yaml (idéntica byte a byte a la embebida; si ya existe te pregunta antes de sobrescribirla, o usa --si). Para probar tu versión editada sin tocar el script: TEMPLATE_FILE=plantilla-datalake.yaml ./gestionar-datalake.sh crear. extraer no usa AWS (el fichero que genera se ha comparado con cmp con la plantilla original: es idéntico); crear el stack con TEMPLATE_FILE.

Antes de empezar

No depende de ninguna carpeta anterior: es la primera. Requisitos:

• [ ] Cuenta de AWS propia con sesión iniciada en la consola.
• [ ] La región de la consola es Europa (Estocolmo) eu-north-1 (arriba a la derecha). Hazlo ANTES de abrir CloudShell.
• [ ] Sabes abrir AWS CloudShell (el icono >_ de la barra superior de la consola). Es una terminal Linux en el navegador que ya trae aws, jq, curl, unzip y nano.
• [ ] Recomendado: un presupuesto en AWS Budgets con alerta por correo (Billing and Cost Management > Budgets).
• [ ] No hay ya un stack g214-datalake-demo en tu cuenta (si lo hay y está bien, crear lo dice y no hace nada; si está fallido, lo borra y lo recrea).
• [ ] Tu usuario de AWS puede crear y borrar recursos de CloudFormation, IAM (roles con nombre: el script usa CAPABILITY_NAMED_IAM), S3, Glue, Athena y EC2, y borrar grupos de CloudWatch Logs. El laboratorio se ha probado con permisos de administrador; no se ha probado con permisos restringidos (por ejemplo una cuenta educativa sin iam:CreateRole: ahí el stack falla al crear el rol del Crawler; pide a tu docente que te dé esos permisos).
• [ ] Si usas una red con filtro web (empresa, universidad), comprueba que puedes abrir una dirección http://...:8501: si la bloquea, el panel de 04.07 no cargará (el resto del laboratorio no lo necesita).
• [ ] Sabes que la instancia EC2 se apaga sola a las 4 horas (ver «Apagado automático») y que eliminar borra todo el laboratorio cuando termines.

Usa CloudShell. Si ejecutas los scripts desde tu PC, necesitas la AWS CLI versión 2 con credenciales válidas (aws sts get-caller-identity) y bash 4 o superior (Git Bash en Windows sirve); si algo falla, usa CloudShell o crea el stack por la consola (opción B del paso 2). Región: eu-north-1 (el script la fuerza, no depende de la de tu sesión). Antes de hacer nada, el script comprueba que aws está instalado, que es la versión 2 y que tus credenciales son válidas, y si no es así te dice qué hacer.

Cómo llevar los ficheros a CloudShell

1. En tu PC, comprime esta carpeta entera (no solo su contenido): clic derecho sobre 04.01-creardatalake y Comprimir en archivo ZIP (Windows 11), Enviar a > Carpeta comprimida en zip (Windows 10) o Comprimir (Mac). No la descomprimas: se sube tal cual.
2. Abre CloudShell con la región eu-north-1 en la consola, pulsa Actions > Upload file y sube 04.01-creardatalake.zip.
3. Descomprime, entra y da permisos:

unzip -o 04.01-creardatalake.zip && cd 04.01-creardatalake && chmod -R u+rwX . && chmod +x *.sh
ls
echo "$AWS_REGION"

Si ya subiste g214-materiales.zip (README principal), no necesitas este zip: entra con cd ~/g214-materiales/tema4/04.01-creardatalake y, si algún fichero da Permission denied, ejecuta allí chmod -R u+rwX . && chmod +x *.sh.

Qué verás: ls muestra gestionar-datalake.sh y README.md. echo "$AWS_REGION" debe imprimir eu-north-1; si imprime otra cosa (por ejemplo us-east-1), cierra CloudShell, cambia la región de la consola a Estocolmo y ábrelo de nuevo. Aunque el script crea el stack siempre en eu-north-1, conviene que la consola también esté en Estocolmo: si no, no verás los recursos en las pantallas de Glue, Athena y S3. Ejecuta el script desde dentro de la carpeta (así datos.txt se guarda ahí). Si al ejecutarlo ves bad interpreter o errores raros con \r, el zip ha dejado finales de línea de Windows: sed -i 's/\r$//' *.sh y repite.

Paso a paso

Paso 1 · Lee qué vas a crear

Repasa la tabla de recursos de arriba y el checklist de «Antes de empezar». No hay nada que ejecutar.

Paso 2 · Crear el stack

Opción A · script (recomendada). Todo está en un único archivo, gestionar-datalake.sh. Se usa de dos formas:

./gestionar-datalake.sh            # abre un menú numerado
./gestionar-datalake.sh crear      # o una orden directa: crear | estado | eliminar

El menú (solo si lo abres sin órdenes y desde una terminal; sin terminal solo imprime la ayuda):

./gestionar-datalake.sh ayuda lista todas las órdenes y opciones (también valen --create, --status y --delete). El script solo te pide datos por teclado en el menú (el número de la opción), un Enter tras cada acción («Pulsa Enter para continuar») y la confirmación s de eliminar (con --si no pregunta).

Apagado automático de la EC2

La instancia EC2 del panel Streamlit (m7i-flex.large, unos 4,6 USD al día encendida) se apaga sola a las 4 horas de quedar lista. Se apaga (stop), no se borra: el disco, el stack y todo lo demás siguen ahí; solo eliminar lo borra. El resto del stack (S3, Glue, Athena) no consume si se deja, por eso no se apaga.

Al volver a ejecutar crear con la EC2 parada, el script la arranca y renueva el plazo. La dirección pública cambia en cada arranque (la fila StreamlitURL de los Outputs queda desfasada): estado y crear muestran la dirección actual. El panel tarda cerca de 1 minuto en responder tras arrancar. Con --sin-ec2 no hay nada que se apague solo.

Si no quieres la instancia EC2 (no necesitas el panel Streamlit), crea el stack así:

./gestionar-datalake.sh crear --sin-ec2

(equivale a CREATE_EC2=false ./gestionar-datalake.sh crear). Si quieres el panel pero que solo se pueda abrir desde tu ordenador, pasa tu IP pública (la de tu PC, que ves en https://checkip.amazonaws.com desde tu navegador; no la de CloudShell): ./gestionar-datalake.sh crear --cidr <tu-ip>/32 (o STREAMLIT_CIDR=<tu-ip>/32). Por defecto el puerto 8501 queda abierto a cualquiera (0.0.0.0/0), sin contraseña; el puerto 22 (SSH) no se abre, porque la instancia no tiene clave y no hace falta.

Qué hace crear: comprueba aws, tus credenciales y la plantilla (validate-template); si el stack ya existe y está bien, termina diciéndolo (se puede repetir sin problema); busca restos de un intento anterior sin stack (workgroup, base demo_datalake_db, buckets g214-datalake-demo-datalakebucket-..., roles del laboratorio y, si existiera de una versión antigua, el usuario DataLakeAdmin) y los borra; lanza create-stack; vigila el estado cada 10 segundos (máximo 40 minutos); y al terminar muestra los Outputs y los guarda en datos.txt. Si AWS limita las peticiones o la red falla un momento, reintenta solo con esperas crecientes. Si la creación falla por un motivo que parece transitorio (por ejemplo already exists), limpia y reintenta una vez; si falla en la instancia EC2, te sugiere crear --sin-ec2.

Qué verás, de seguido: Verificando recursos huérfanos de ejecuciones previas..., No se encontraron recursos huérfanos., Creando stack g214-datalake-demo..., líneas con la hora y CREATE_IN_PROGRESS, después CREATE_COMPLETE, Estado final: CREATE_COMPLETE, Creación completada., una tabla de Outputs y Datos guardados en datos.txt. Tarda unos 3 o 4 minutos con la instancia EC2 y alrededor de 1 minuto con --sin-ec2. Con la EC2 verás además Apagado automático: la EC2 se apagará sola (stop, no se borra) a las HH:MM UTC. La tabla de Outputs trae 6 filas (5 sin la EC2). (Mensajes y tiempos comprobados en AWS real.) Si el stack ya existía, verás El stack g214-datalake-demo ya existe y está en CREATE_COMPLETE: no hay nada que crear., arranca la EC2 si estaba parada y renueva su plazo de apagado (ver «Apagado automático»), y muestra los Outputs. Con el menú, después pulsa Enter y elige 0 para salir.

Copia el valor de S3Bucket a un bloc de notas: lo usarás en todo el laboratorio.

Opción B · consola de AWS: primero saca la plantilla del script: en CloudShell, ./gestionar-datalake.sh extraer crea plantilla-datalake.yaml y lo llevas a tu PC con Actions > Download file. Después: CloudFormation > Create stack > With new resources > Upload a template file > ese .yaml > nombre del stack g214-datalake-demo (los scripts de los ejercicios buscan justo este nombre) > deja CreateEC2 como quieras (true o false), StreamlitAllowedCidr en 0.0.0.0/0 (o pon <tu-ip>/32 para limitar el panel a tu ordenador) y CreateDemoAdminUser en false > marca la casilla de reconocimiento de que se crean recursos de IAM > Submit. Cuando el estado sea CREATE_COMPLETE, mira la pestaña Outputs. La región de la consola debe ser eu-north-1.

Si repites: con el stack ya creado, crear lo dice y no toca nada. No hay nada que repetir.

Si el stack termina en ROLLBACK_COMPLETE, el script imprime «Recursos que fallaron» con el motivo. Vuelve a lanzar crear: borra el stack fallido y lo intenta de nuevo (o eliminar si solo quieres borrarlo). Si el motivo menciona la instancia EC2, crea el stack sin ella con crear --sin-ec2.

Paso 3 · Comprobar que todo está

# nombre del bucket creado por el stack
aws cloudformation describe-stacks \
  --stack-name g214-datalake-demo \
  --region eu-north-1 \
  --query "Stacks[0].Outputs"

# la base de datos del catálogo existe?
aws glue get-database \
  --name demo_datalake_db \
  --region eu-north-1

# qué tablas hay (al principio, ninguna)
aws glue get-tables \
  --database-name demo_datalake_db \
  --region eu-north-1 \
  --query "TableList[].Name"

Qué verás: la primera orden lista los Outputs (S3Bucket, GlueDatabaseName, GlueCrawlerName, GlueCrawlerRoleArn, AthenaWorkgroupName y, si creaste la EC2, StreamlitURL; los DataLakeAdmin... solo aparecen si activaste ese usuario); la segunda devuelve un JSON con "Name": "demo_datalake_db"; la tercera devuelve []. Si las tres funcionan, puedes empezar. Guarda el bucket en una variable para los comandos siguientes:

BUCKET=$(aws cloudformation describe-stacks --stack-name g214-datalake-demo --region eu-north-1 \
  --query "Stacks[0].Outputs[?OutputKey=='S3Bucket'].OutputValue" --output text)
echo "$BUCKET"

(CloudShell pierde las variables si se cierra la sesión: repite este comando si vuelves más tarde. En las carpetas 04.02 a 04.06 se vuelve a explicar.)

Paso 4 · Ejercicio de la presentación: estimar el coste de un Data Lake (solución orientativa)

Enunciado, con los datos que el ejercicio da por supuestos: S3 con 500 GB almacenados, 100.000 peticiones PUT y 100.000 GET; Glue con 2 sesiones interactivas de 2 DPU y 20 horas cada una al mes; Athena con 100 consultas al día (mes de 30 días) y 400 MB escaneados por consulta. Región eu-north-1, sin capa gratuita. Precios leídos con la API de precios de AWS el 2026-10-03 (compruébalos en calculator.aws: cambian). Intenta calcularlo tú antes de mirar la solución.

Si lees «20 horas en total» en vez de «20 horas por sesión», Glue baja a 17,60 USD y el total a unos 35 USD: por eso la diapositiva lo aclara. Lo que importa es que Glue domina la factura y que Athena, con datos pequeños, casi no pesa. La captura de la calculadora de la diapositiva es solo un ejemplo de cómo se ve; su importe no es la solución.

Coste real de este laboratorio

• S3 y Athena con estos datos cuestan céntimos (en la prueba completa del laboratorio, con 142 consultas y unos 6 GB escaneados, Athena costó unos 0,03 USD). Athena cobra 5 USD por TB leído, con un mínimo de 10 MB por consulta (unos 0,00005 USD).
• Cada ejecución de un Crawler de Glue cuesta entre 7 y 15 céntimos: se factura como mínimo 10 minutos de proceso a 0,44 USD por DPU-hora (con 1 o 2 DPU), aunque el Crawler tarde menos de un minuto. En este laboratorio los Crawlers son lo que más pesa en la factura: ejecútalos solo las veces que indica la guía y no ejecutes el Crawler que trae el stack (g214-datalake-demo-crawler).
• Lo que puede costar de verdad es la instancia EC2 del panel Streamlit si te la dejas encendida: unos 0,19 USD por hora si tu cuenta no la cubre con el plan gratuito, es decir, unos 4,6 USD al día. Por eso el script la apaga sola a las 4 horas (ver «Apagado automático»). Un laboratorio completo (stack, Crawlers, consultas y panel encendido una hora) cuesta del orden de medio dólar.
• Tu cuenta es la que paga. Borra el laboratorio al terminar (sección «Limpieza final»).

Errores frecuentes

Limpieza final (para no dejar nada facturando)

Esta carpeta es la que borra el stack, y el borrado va el ÚLTIMO de todo el Tema 4: las carpetas 04.02 a 04.07 dependen del bucket, la base de datos y el workgroup que crea el stack. Haz primero la limpieza específica de cada actividad que hayas hecho (cada README tiene la suya) y, cuando hayas terminado todas, vuelve aquí.

Antes de borrar: el Tema 5 y la Práctica 2 reutilizan la base demo_datalake_db, el workgroup y a veces el bucket de este stack. Si vas a hacerlos en los próximos días, no borres el stack todavía: la EC2 ya se apaga sola a las 4 horas (o párala ya con EC2 > Instances > Instance state > Stop); para volver a usarla, ./gestionar-datalake.sh crear. Si prefieres recrear el stack más adelante, sigue estos pasos y bórralo ahora.

Orden exacto:

1. Borra lo que creaste a mano en Glue: tus Crawlers (Glue > Crawlers), el clasificador (Glue > Data Catalog > Classifiers) y, si el asistente creó un rol nuevo, en IAM > Roles el rol AWSGlueServiceRole-.... El stack no los borra (solo gestiona su propio Crawler y su rol). (Los comandos de la presentación y los de 04.02 hacen esto por CLI.)
2. En CloudShell, dentro de esta carpeta:

./gestionar-datalake.sh eliminar

(o la opción 3) Eliminar TODO del menú). Primero lista lo que existe y se va a borrar y te pide confirmar con s (añade --si para no preguntar). Fuerza el borrado, sea cual sea el estado del stack (CREATE_COMPLETE, ROLLBACK_COMPLETE, CREATE_FAILED, DELETE_FAILED, UPDATE_ROLLBACK_FAILED...) y también si el stack ya no existe pero quedan restos con los nombres del laboratorio. Hace, en este orden: detiene las consultas de Athena en curso; borra tus Crawlers, el clasificador csv-titanic, y las tablas y vistas de demo_datalake_db; vacía el bucket (objetos, versiones antiguas y marcadores de borrado, por lotes de 1.000); pide el borrado del stack y espera (hasta 30 minutos, con mensajes de progreso); si el stack queda en DELETE_FAILED, intenta desbloquear lo que falle (vaciar el bucket otra vez, borrar el workgroup...) y reintenta hasta 3 veces; si aun así no se borra, vuelve a pedirlo reteniendo solo los recursos que bloquean (--retain-resources) y después intenta borrarlos a mano; y al final verifica y lista lo que quede (stack, bucket, base de Glue, workgroup, crawlers, roles de IAM, instancias EC2). Si no hay nada que borrar lo dice y termina bien: se puede repetir sin problema. No borra tu grupo de logs /aws-glue/crawlers salvo que añadas --con-logs (ver el paso 5).

Qué verás: Esto es lo que existe ahora y se va a ELIMINAR... con la lista, ¿Eliminar todo? [s/N], 1/3 Preparando el borrado..., Vaciando s3://<tu-bucket> completamente..., Pasada 1: N versión(es) y marcador(es) por borrar con una línea ... 1000/N por lote, Solicitando borrado de g214-datalake-demo..., líneas con DELETE_IN_PROGRESS y DELETE_COMPLETE, Stack eliminado correctamente., Archivo datos.txt eliminado., Verificación final y Todo eliminado en N s: no queda ningún recurso del laboratorio. Con pocos datos tarda 1 o 2 minutos (1 min 40 s con unas 50 versiones, medido con la versión anterior del script). (Probado en AWS real: también con la EC2 parada, con el stack en ROLLBACK_COMPLETE o DELETE_FAILED, con la creación interrumpida y con una interfaz de red suelta que bloquea el Security Group.) 3. Si lo borras desde la consola de CloudFormation, el bucket tiene versionado y probablemente contenga ficheros: Delete stack fallará a los pocos segundos (DELETE_FAILED: The bucket you tried to delete is not empty) hasta que lo vacíes con «Show versions» y borres todas las versiones. Es más fácil usar eliminar. 4. Si el stack se queda en DELETE_FAILED no hace falta ningún otro script: vuelve a ejecutar ./gestionar-datalake.sh eliminar --si. Ya incluye el borrado reforzado del paso 2. Si al final aparece Todavía queda algo en tu cuenta, el mensaje lista qué es: repite el comando pasados unos minutos (a veces AWS tarda en liberar dependencias) o bórralo a mano en la consola. 5. El grupo de logs que crea Glue y que el stack no borra: ./gestionar-datalake.sh eliminar --si --con-logs (también lo borra aunque el stack ya no exista) o, a mano:

aws logs delete-log-group --log-group-name /aws-glue/crawlers --region eu-north-1

El grupo /aws-glue/crawlers lo crea Glue la primera vez que ejecutas un Crawler, no tiene retención y no desaparece con el stack. Si dice ResourceNotFoundException, no existía: no pasa nada. Ojo: es el grupo de TODOS los Crawlers de la cuenta; bórralo solo si no lo usas para otra cosa. datos.txt ya lo borra eliminar; si queda alguno: rm -f datos.txt. 6. Comprueba que no queda nada:

./gestionar-datalake.sh estado
aws cloudformation describe-stacks --stack-name g214-datalake-demo --region eu-north-1
aws s3 ls | grep g214-datalake-demo
aws logs describe-log-groups --log-group-name-prefix /aws-glue --region eu-north-1 --query "logGroups[].logGroupName"

estado debe decir Estado: NO EXISTE y (ninguno) en «Recursos del laboratorio en tu cuenta»; la segunda orden debe fallar con Stack with id g214-datalake-demo does not exist; la tercera no debe devolver nada; la cuarta debe devolver []. En la consola: EC2 > Instances sin instancias en ejecución, e, si lo habías activado, IAM > Users sin DataLakeAdmin. Si creaste un presupuesto en AWS Budgets solo para el ejercicio de 04.06 y no lo quieres, bórralo (es de toda la cuenta).

Si hiciste los ejercicios adicionales (04.04, 04.05, 04.06), sus datos y tablas están dentro del bucket y de la base del stack: se van con él (también los ficheros de las tablas CTAS, que están en athena-results/tables/, y cualquier regla de ciclo de vida del bucket). Si no vas a borrar el stack, vacía raw/aire/, raw/euribor/ y raw/ipc/ con aws s3 rm ... --recursive, borra las tablas que creaste (DROP TABLE) y sus ficheros de athena-results/tables/ (nyc_taxi_csv ocupa unos 400 MB con 5 meses).

Cómo sabes que has terminado

• [ ] ./gestionar-datalake.sh crear terminó con CREATE_COMPLETE y la tabla de Outputs (y estado lo confirma).
• [ ] aws glue get-database --name demo_datalake_db devuelve la base y aws glue get-tables devuelve [].
• [ ] Tienes anotado el nombre de tu bucket (S3Bucket).
• [ ] Has hecho el ejercicio de la presentación y sabes explicar por qué Glue domina la factura.
• [ ] (Al final del Tema 4) Has ejecutado eliminar, comprobado con estado que no queda nada y borrado el grupo de logs /aws-glue/crawlers (--con-logs).

Anterior: (ninguna, es la primera) · Siguiente: 04.02 Titanic