Sesión 03 – ETL escalable con Spark¶
Propósito¶
Construir un flujo ETL en Apache Spark aplicando transformaciones encadenadas, joins distribuidos y funciones ventana, validando la calidad de los datos y analizando decisiones iniciales de rendimiento.
Caso¶
Se dispone de dos datasets: - ventas: transacciones - clientes: información de clientes
Se requiere integrar, transformar y analizar estos datos.
Paso 1: Crear SparkSession¶
Inicializamos el entorno de trabajo en modo local.
from pyspark.sql import SparkSession
spark = (
SparkSession.builder
.appName("sesion3-etl")
.master("local[*]")
.config("spark.ui.port", "4040")
.config("spark.sql.shuffle.partitions", "8")
.getOrCreate()
)
spark
2. Extract – Leer datasets¶
Se cargan los archivos desde la carpeta /opt/data.
Para la sesión 3 se trabaja con dos datasets relacionados: ventas.csv y clientes.csv.
ventas = spark.read.csv("/opt/data/ventas.csv", header=True, inferSchema=True)
clientes = spark.read.csv("/opt/data/clientes.csv", header=True, inferSchema=True)
ventas.show()
clientes.show()
3. Explorar estructura¶
Antes de transformar, verificamos esquema (estructura) y tipos de datos.
ventas.printSchema()
clientes.printSchema()
4. Transform – Limpieza básica¶
Aplicamos limpieza inicial: - eliminar nulos críticos - remover duplicados en clientes - registros inconsistentes.
#ventas_limpio = ventas.dropna(subset=["id", "cliente_id", "fecha", "monto"])
from pyspark.sql.functions import col
ventas_limpio = (
ventas
.dropna(subset=["cliente_id", "fecha", "monto"]) # “Elimina registros donde falte cliente_id, fecha o monto”
.filter(col("monto") > 0)
)
clientes_limpio = clientes.dropDuplicates(["cliente_id"])
ventas_limpio.show()
clientes_limpio.show()
🔎 Pregunta: ¿Por qué es importante limpiar datos antes de hacer un join?
5. Join distribuido¶
Integramos ventas con clientes mediante cliente_id. Este paso permite conectar información transaccional con atributos descriptivos.
df_join = ventas_limpio.join(clientes_limpio, "cliente_id", "inner")
df_join.show()
🔎 Pregunta: ¿Qué ocurre internamente en Spark cuando se realiza este join?
(Shuffle = redistribución de datos entre nodos) Spark mueve datos entre máquinas (o particiones) para poder agruparlos o combinarlos correctamente.
🔥 Problema:
Los datos del mismo cliente están en diferentes grupos (particiones)
💥 Solución (shuffle):
👉 Spark dice:
“Muevan todos los datos del cliente 101 al mismo lugar”
Alternativa optimizada : from pyspark.sql.functions import broadcast
df = ventas_limpio.join(broadcast(clientes_limpio), "cliente_id")
6. Función ventana¶
Se calculan métricas por cliente:
- ranking: orden de compra por cliente
- total_acumulado: monto acumulado por cliente
from pyspark.sql.window import Window
from pyspark.sql.functions import row_number, sum
window_spec = Window.partitionBy("cliente_id").orderBy("fecha")
df_window = df_join.withColumn("ranking", row_number().over(window_spec))
df_window = df_join.withColumn("total_acumulado", sum("monto").over(window_spec))
#df_window = (
# df_join
# .withColumn("ranking", row_number().over(window_spec))
# .withColumn("total_acumulado", sum("monto").over(window_spec))
#)
df_window.show()
📌 Interpretación:
- partitionBy: agrupa por cliente
- orderBy: ordena las compras
- over: aplica el cálculo sobre ese grupo
A diferencia de groupBy, no se pierden filas.
7. Validación de calidad de datos¶
Revisamos nulos por columna, cantidad de registros y posibles duplicados en el identificador de venta.
from pyspark.sql.functions import count, when
# Nulos
df_window.select([
count(when(col(c).isNull(), c)).alias(c)
for c in df_window.columns
]).show()
# Duplicados
df_window.groupBy("id").count().filter("count > 1").show()
# Conteo total
print("Total registros:", df_window.count())
print("Total de registros:", df_window.count())
df_window.groupBy("id").count().filter("count > 1").show()
8. Revisar decisiones iniciales de performance¶
Primero observamos el plan de ejecución del join y de la transformación con ventana.
df_window.explain(True)
from pyspark.sql.functions import broadcast
df_broadcast = ventas_limpio.join(broadcast(clientes_limpio), "cliente_id")
df_broadcast.explain(True)
print("Particiones ventas:", ventas_limpio.rdd.getNumPartitions())
print("Particiones df final:", df_window.rdd.getNumPartitions())
🔎 Pregunta: ¿Qué operaciones generan mayor costo en el plan de ejecución?
9. Load – Escribir salida en Parquet¶
La salida del ETL se guarda en formato Parquet dentro de /opt/artifacts/output.
df_window.write.mode("overwrite").parquet("/opt/artifacts/output")
10. Verificación de salida¶
Leemos nuevamente el resultado para comprobar que el ETL se generó correctamente.
salida = spark.read.parquet("/opt/artifacts/output")
salida.show()
11. Reto de extensión¶
- Filtrar solo ventas mayores a 150 antes del join.
- Agregar una columna de categoría de monto: bajo, medio, alto.
- Justificar si conviene pensar en broadcast cuando una tabla es muy pequeña.
df_reto = (
ventas_limpio
.filter(col("monto") > 150)
.join(clientes_limpio, "cliente_id", "inner")
.withColumn(
"categoria_monto",
when(col("monto") < 150, "bajo")
.when(col("monto") <= 250, "medio")
.otherwise("alto")
)
)
df_reto.show()
12. Cierre breve¶
Preguntas para reflexión:
- ¿Qué diferencia hay entre una transformación simple y un join distribuido?
- ¿Qué aporta la función ventana frente a un groupBy tradicional?
- ¿Por qué Parquet es una mejor salida que CSV para analítica posterior?
Entregable sugerido: notebook funcional con ETL ejecutado, salida en Parquet y breve interpretación.
Actividad Autónoma – Aplicación al Proyecto Sello (PS)¶
Objetivo¶
Aplicar el flujo ETL desarrollado en clase sobre el dataset real del proyecto grupal.
Instrucciones¶
Cada grupo debe:
- Leer sus datasets reales del proyecto.
- Aplicar limpieza de datos:
- manejo de nulos
- eliminación de duplicados
- Integrar al menos dos fuentes mediante join.
- Aplicar al menos:
- una función ventana (ranking o acumulado)
- Validar resultados:
- conteo de registros
- verificación de nulos
- Guardar salida en formato Parquet.
- Analizar el plan de ejecución (
explain()).
Entregable¶
- Notebook Jupyter (
.ipynb) - Código ejecutable
- Resultados visibles
- Breve interpretación (máx. 1 página):
- qué hicieron
- qué problemas encontraron
- qué decisiones tomaron
Criterios de evaluación¶
- Correcta implementación del ETL
- Uso adecuado de joins y funciones ventana
- Validación de datos
- Interpretación técnica