Saltar a contenido

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

  1. Filtrar solo ventas mayores a 150 antes del join.
  2. Agregar una columna de categoría de monto: bajo, medio, alto.
  3. 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:

  1. Leer sus datasets reales del proyecto.
  2. Aplicar limpieza de datos:
  3. manejo de nulos
  4. eliminación de duplicados
  5. Integrar al menos dos fuentes mediante join.
  6. Aplicar al menos:
  7. una función ventana (ranking o acumulado)
  8. Validar resultados:
  9. conteo de registros
  10. verificación de nulos
  11. Guardar salida en formato Parquet.
  12. 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