Data & Big Data

AWS Data Engineering Bootcamp explicado de forma sencilla (con diagramas y código real)

AWS Data Engineering Bootcamp : lo esencial en un artículo — código real, diagramas y pasos concretos, extractos de un curso de 17 lecciones.

REHOUMA Haythem

• 13 min read
AWS Data Engineering Bootcamp explicado de forma sencilla (con diagramas y código real)

Una guía que va al grano: AWS Data Engineering Bootcamp diseccionada con diagramas, ejemplos concretos y comandos probados. Todo proviene de un curso estructurado de 5 capítulos — aquí lo mejor.

tl;dr
  • Introducción a la Ingeniería de Datos AWS
  • Particionamiento y Bucketización
  • Athena y Glue en Acción
  • Cardinalidad y Optimización Avanzada
  • Laboratorio guiado de Athena
~$ cat ./parcours.md # AWS Data Engineering Bootcamp — 5 capítulos
01
Introducción a la Ingeniería de Datos AWS
→ Capítulo 00 – Lección 1 : Conceptos Clave en Ingeniería de Datos→ Capítulo 00 – Lección 2 : Data Warehouses y sus Equivalencias Cloud+ 1 más lecciones
02
Particionamiento y Bucketización
→ Capítulo 01 – Lección 1 : Particionamiento y Bucketización en un Data Lake→ Capítulo 01 – Lección 2 : La Bucketización en los Data Warehouses+ 1 más lecciones
03
Athena y Glue en Acción
→ Capítulo 02 – Lección 1 : Amazon Athena — Conceptos Clave y Arquitectura→ Capítulo 02 – Lección 2 : Configurar Athena y Crear una Base de Datos Glue+ 2 más lecciones
04
Cardinalidad y Optimización Avanzada
→ Capítulo 03 – Lección 1 : Vistas SQL, Consultas Nombradas y AWS CloudFormation→ Capítulo 03 – Lección 2 : Permisos IAM para Athena y Glue — Buenas Prácticas+ 2 más lecciones
05
Laboratorio guiado Athena
→ Capítulo 04 (OPCIONAL) – Lab 1 : Crear una Base de Datos y una Tabla AWS Glue en Athena→ Capítulo 04 (OPCIONAL) – Lab 2 : Bucketización, Particionamiento y Formato Parquet+ 1 más lecciones
🏁
Proyecto final
→ Te marchas con un proyecto concreto y demostrable

Capítulo 02 – Lección 3 : Optimización mediante Bucketización y Particionamiento en Athena

NOTEObjetivo — Aplicar bucketización y particionamiento sobre datos reales en Athena y medir la mejora del rendimiento y la reducción de costes.

Optimización mediante Bucketización en Athena

¿Por qué la Bucketización?

El bucketing distribuye los datos en varios archivos según una clave de hash. Mejora considerablemente el rendimiento cuando se trabaja con columnas de alta cardinalidad.

Reducir el escaneo

Athena solo apunta a los buckets necesarios durante una consulta.

Mejorar las uniones

Cuando dos tablas están bucketizadas con la misma clave, Athena realiza "bucket joins" muy rápidos.

Alta cardinalidad

Ideal para user_id, transaction_id, device_id.

Ejemplo Práctico : Transacciones E-Commerce Bucketizadas

output
-- Paso 1 : Configurar el bucketing al crear la tabla
-- Reemplaza user_id por tu columna de alta cardinalidad
CLUSTERED BY (user_id) INTO 8 BUCKETS

-- Ejemplo completo con CTAS (Create Table As Select)
CREATE TABLE taxidata.transactions_bucketized
WITH (
    format = 'PARQUET',
    external_location = 's3://mon-bucket/transactions-bucketized/',
    bucketed_by = ARRAY['user_id'],
    bucket_count = 8
) AS
SELECT *
FROM taxidata.transactions_source;
TIPVerificación en S3 — Tras la creación, deberías ver 8 archivos en S3 : 
s3://mon-bucket/transactions-bucketized/
├── 000000_0.parquet
├── 000001_0.parquet
├── ...
└── 000007_0.parquet

Pasos para Configurar el Bucketing

Optimización mediante Particionamiento en Athena

Estructura de las Particiones en S3

El particionamiento organiza los datos en directorios distintos en S3 según los valores de una columna de baja cardinalidad :

bash
# Estructura de las particiones en S3 (formato Hive)
s3://taxi-datalake/yellow/
├── year=2015/month=01/
│   └── data.parquet
├── year=2015/month=02/
│   └── data.parquet
├── year=2016/month=01/
│   └── data.parquet
└── year=2017/month=01/
    └── data.parquet

Crear una Tabla Particionada mediante CTAS

output
-- CTAS (Create Table As Select) con particionamiento
-- Conversión CSV → Parquet CON particionamiento
CREATE TABLE taxidata.yellow_partitioned
WITH (
    format = 'PARQUET',
    external_location = 's3://taxi-datalake/yellow-partitioned/',
    partitioned_by = ARRAY['year', 'month']
) AS
SELECT
    vendor, pickup, dropoff, count,
    distance, ratecode, storeflag, pulocid, dolocid,
    paytype, fare, extra, mta_tax, tip, tolls, surcharge, total,
    YEAR(pickup) AS year,
    MONTH(pickup) AS month
FROM taxidata.yellow;
NOTEImportante — Las columnas de partición (year, month) deben listarse en último lugar en el SELECT y en la matriz partitioned_by.

Descubrir las Particiones

output
-- Tras añadir datos, descubrir las nuevas particiones
MSCK REPAIR TABLE taxidata.yellow_partitioned;

-- Añadir manualmente una partición específica
ALTER TABLE taxidata.yellow_partitioned
ADD PARTITION (year='2017', month='02')
LOCATION 's3://taxi-datalake/yellow-partitioned/year=2017/month=02/';

Consultas Optimizadas con el Particionamiento

output
-- Consulta SIN particionamiento : escaneo de TODA la tabla
SELECT COUNT(*), SUM(fare) AS total_fares
FROM taxidata.yellow
WHERE YEAR(pickup) = 2017 AND MONTH(pickup) = 1;
-- → Escaneo : 100% de los datos (ej: 1 TB)

-- Consulta CON particionamiento : escaneo solo de la partición correspondiente
SELECT COUNT(*), SUM(fare) AS total_fares
FROM taxidata.yellow_partitioned
WHERE year = 2017 AND month = 1;
-- → Escaneo : ~1/36 de los datos (si 3 años × 12 meses)
-- → ¡Reducción de ~97% de los datos escaneados!

Combinación Óptima : Particionamiento + Bucketización

Capítulo 02 – Lección 2 : Configurar Athena y Crear una Base de Datos Glue

NOTEObjetivo — Configurar el entorno Athena, crear una base de datos AWS Glue, definir una tabla externa sobre datos S3 y ejecutar las primeras consultas SQL.

Paso 1 — Configurar el Entorno Athena

WARNINGRequisito previo obligatorio — Antes de cualquier consulta Athena, configura el bucket S3 para los resultados. Sin ello, Athena rechazará ejecutar tus consultas.
bash
# Alternativa : configurar mediante AWS CLI
aws athena update-work-group \
  --work-group primary \
  --configuration-updates "ResultConfigurationUpdates={OutputLocation=s3://mon-bucket-athena-results/}"

Paso 2 — Crear una Base de Datos Glue

En el editor de Athena, ejecuta :

output
-- Crear la base de datos taxidata en AWS Glue Data Catalog
CREATE DATABASE taxidata;
TIPResultado — Este comando crea una base de datos taxidata en AWS Glue Data Catalog. Puedes verla en la consola de Glue bajo "Databases".
bash
# Verificar la creación mediante AWS CLI
aws glue get-database --name taxidata

# Listar todas las bases de datos
aws glue get-databases

Paso 3 — Definir el Esquema de la Tabla (Dataset Taxis NYC)

Creamos la tabla externa yellow sobre los datos de taxis de Nueva York almacenados en S3 :

output
-- Crear la tabla externa yellow sobre los datos S3
CREATE EXTERNAL TABLE IF NOT EXISTS taxidata.yellow (
   `vendor`    string,
   `pickup`    timestamp,
   `dropoff`   timestamp,
   `count`     int,
   `distance`  int,
   `ratecode`  string,
   `storeflag` string,
   `pulocid`   string,
   `dolocid`   string,
   `paytype`   string,
   `fare`      decimal,
   `extra`     decimal,
   `mta_tax`   decimal,
   `tip`       decimal,
   `tolls`     decimal,
   `surcharge` decimal,
   `total`     decimal
)
ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe'
WITH SERDEPROPERTIES (
   'serialization.format' = ',',
   'field.delim' = ','
) LOCATION 's3://aws-tc-largeobjects/CUR-TF-200-ACDSCI-1/Lab2/yellow/'
TBLPROPERTIES ('has_encrypted_data'='false');
NOTEExplicación de los parámetros clave :
  • CREATE EXTERNAL TABLE — la tabla apunta a S3, Athena no copia los datos
  • LazySimpleSerDe — serializador/deserializador para archivos CSV delimitados
  • field.delim = ',' — los campos están separados por comas
  • LOCATION — ruta S3 que contiene los archivos de datos
  • has_encrypted_data='false' — los datos no están cifrados

Paso 4 — Previsualizar los Datos

output
-- Previsualizar las 10 primeras filas
SELECT * FROM taxidata.yellow LIMIT 10;

-- Contar el número total de trayectos
SELECT COUNT(*) AS total_trayectos FROM taxidata.yellow;

-- Verificar los tipos de pago disponibles
SELECT DISTINCT paytype, COUNT(*) AS nb_trayectos
FROM taxidata.yellow
GROUP BY paytype
ORDER BY nb_trayectos DESC;

Paso 5 — Crear una Tabla Optimizada (Enero 2017)

output
-- Crear una tabla para los datos de enero de 2017 únicamente
-- Más rápida para pruebas y validación
CREATE EXTERNAL TABLE IF NOT EXISTS taxidata.jan (
   `vendor`    string,
   `pickup`    timestamp,
   `dropoff`   timestamp,
   `count`     int,
   `distance`  int,
   `ratecode`  string,
   `storeflag` string,
   `pulocid`   string,
   `dolocid`   string,
   `paytype`   string,
   `fare`      decimal,
   `extra`     decimal,
   `mta_tax`   decimal,
   `tip`       decimal,
   `tolls`     decimal,
   `surcharge` decimal,
   `total`     decimal
)
ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe'
WITH SERDEPROPERTIES (
   'serialization.format' = ',',
   'field.delim' = ','
) LOCATION 's3://aws-tc-largeobjects/CUR-TF-200-ACDSCI-1/Lab2/January2017/'
TBLPROPERTIES ('has_encrypted_data'='false');

Capítulo 03 – Lección 1 : Vistas SQL, Consultas Nombradas y AWS CloudFormation

NOTEObjetivo — Crear vistas SQL en Athena para simplificar los análisis, definir consultas nombradas reutilizables y automatizar su despliegue con AWS CloudFormation.

Las Vistas SQL en Athena

Una vista SQL es una consulta guardada que puedes usar como una tabla. No almacena datos — ejecuta la consulta subyacente en cada llamada.

TIPVentaja de las vistas — Simplifica las consultas complejas, crea capas de abstracción y comparte análisis estandarizados con tu equipo.

Ejemplo 1 : Vista de los Trayectos por Tarjeta de Crédito

output
-- Crear una vista para los pagos con tarjeta de crédito
-- paytype = '1' significa pago con tarjeta
CREATE VIEW taxidata.cctrips AS
SELECT
    vendor,
    SUM(fare)  AS total_fares_cc,
    COUNT(*)   AS nb_trayectos_cc,
    AVG(fare)  AS tarifa_media_cc
FROM taxidata.yellow
WHERE paytype = '1'
GROUP BY vendor;

-- Usar la vista
SELECT * FROM taxidata.cctrips;

Ejemplo 2 : Vista de los Trayectos en Efectivo

output
-- Crear una vista para los pagos en efectivo
-- paytype = '2' significa pago en efectivo
CREATE VIEW taxidata.cashtrips AS
SELECT
    vendor,
    SUM(fare)  AS total_fares_cash,
    COUNT(*)   AS nb_trayectos_cash,
    AVG(fare)  AS tarifa_media_cash
FROM taxidata.yellow
WHERE paytype = '2'
GROUP BY vendor;

-- Usar la vista
SELECT * FROM taxidata.cashtrips;

Ejemplo 3 : Vista de Comparación con CTE (WITH)

output
-- Vista de comparación combinando tarjeta de crédito y efectivo
-- Uso de CTE (Common Table Expressions) con WITH
CREATE VIEW taxidata.comparepay AS
WITH
    cc AS (
        SELECT
            vendor,
            SUM(fare) AS cctotal,
            COUNT(*)  AS nb_cc
        FROM taxidata.yellow
        WHERE paytype = '1'
        GROUP BY vendor
    ),
    cash AS (
        SELECT
            vendor,
            SUM(fare) AS cashtotal,
            COUNT(*)  AS nb_cash
        FROM taxidata.yellow
        WHERE paytype = '2'
        GROUP BY vendor
    )
SELECT
    cc.vendor,
    cc.cctotal,
    cc.nb_cc,
    cash.cashtotal,
    cash.nb_cash,
    ROUND(cc.cctotal / cash.cashtotal, 2) AS ratio_cc_cash
FROM cc
JOIN cash ON cc.vendor = cash.vendor;

-- Consulta sobre la vista
SELECT * FROM taxidata.comparepay ORDER BY ratio_cc_cash DESC;

Gestión de Vistas

output
-- Listar las vistas disponibles
SHOW VIEWS IN taxidata;

-- Ver la definición de una vista
SHOW CREATE VIEW taxidata.comparepay;

-- Reemplazar una vista existente
CREATE OR REPLACE VIEW taxidata.cctrips AS
SELECT
    vendor,
    SUM(fare) AS total_fares_cc,
    COUNT(*) AS nb_trayectos_cc
FROM taxidata.yellow
WHERE paytype = '1'
GROUP BY vendor;

-- Eliminar una vista
DROP VIEW taxidata.cashtrips;

Las Consultas Nombradas en Athena

Las consultas nombradas (Named Queries) permiten guardar consultas SQL usadas frecuentemente directamente en Athena. Se comparten dentro de tu cuenta AWS.

Ventajas

Limitación

Automatizar con AWS CloudFormation

En lugar de crear manualmente las consultas nombradas mediante la consola, puedes desplegarlas como código con AWS CloudFormation.

Plantilla CloudFormation para una Consulta Nombrada

Crea un archivo llamado athenaquery.cf.yml :

output
AWSTemplateFormatVersion: 2010-09-09
Description: "Consulta Athena nombrada para el análisis de taxis NYC"

Resources:
  AthenaNamedQuery:
    Type: AWS::Athena::NamedQuery
    Properties:
      Database: "taxidata"
      Description: "Selección de trayectos cuyo importe supera los 100 $"
      Name: "FaresOver100DollarsUS"
      QueryString: >
        SELECT
            distance,
            paytype,
            fare,
            tip,
            tolls,
            surcharge,
            total
        FROM yellow
        WHERE total >= 100.0
        ORDER BY total DESC

Outputs:
  AthenaNamedQuery:
    Description: "El ID de la consulta nombrada Athena creada"
    Value: !Ref AthenaNamedQuery

Desplegar la Plantilla CloudFormation mediante AWS CLI

bash
# Paso 1 : Validar la plantilla antes del despliegue
aws cloudformation validate-template \
    --template-body file://athenaquery.cf.yml

# Paso 2 : Crear la stack CloudFormation
aws cloudformation create-stack \
    --stack-name mon-athena-stack \
    --template-body file://athenaquery.cf.yml \
    --capabilities CAPABILITY_IAM

# Paso 3 : Verificar el estado de la creación
aws cloudformation describe-stacks \
    --stack-name mon-athena-stack \
    --query 'Stacks[0].StackStatus'

# Paso 4 : Listar las consultas nombradas creadas
aws athena list-named-queries \
    --work-group primary

# Paso 5 : Obtener los detalles de una consulta nombrada
aws athena get-named-query \
    --named-query-id "ID_RETOURNÉ_PAR_LIST"
va-plus-loin

Este artículo cubre los extractos más útiles — el curso completo AWS Data Engineering Bootcamp (5 capítulos, 17 lecciones, ejercicios corregidos y proyecto final) te lleva hasta el final.

./acceder-al-curso-completo curso gratuito : Dominar Claude Code

FAQ

¿Cuánto tiempo se necesita para aprender AWS Data Engineering Bootcamp?
Con una progresión estructurada (5 capítulos, 17 lecciones cortas y prácticas), se alcanza un nivel operativo en pocas semanas a razón de 30 a 60 minutos al día. Lo importante es practicar cada concepto inmediatamente.
¿Se necesitan requisitos previos?
Unos conocimientos básicos de informática bastan. Si sabes usar un terminal y leer código simple, estás listo.
¿Por dónde empezar concretamente?
Reproduce los comandos de este artículo y sigue el curso completo AWS Data Engineering Bootcamp : encadena las 17 lecciones en orden, con ejercicios y proyecto final.
./a-lire-aussi
→ Lánzate a AWS Datos en Tiempo Real : tu primer paso concreto hoy→ Python Data Science : los 9 pasos clave para pasar de cero a operativo→ Python NumPy en la práctica : el código y los comandos que realmente importan

📬 ¿Quieres recibir este tipo de guía cada semana? Suscríbete gratis — código real, cero rodeos.

Stay up to date

Enter your email
Subscribe