Saltar a contenido

Sesión 04 – HDFS + formatos y diseño de almacenamiento

Propósito

Diseñar el almacenamiento de un pipeline batch usando formato columnar y particionado, leyendo y escribiendo datos desde la zona de trabajo del laboratorio para simular el flujo de almacenamiento distribuido.

Producto

Dataset almacenado en Parquet con particionado y una justificación técnica del diseño elegido.

Contexto de la sesión

En la sesión anterior ya construimos el ETL con Spark.
Ahora toca cerrar la unidad desde el lado del almacenamiento: cómo queda organizada la salida del pipeline, cómo se vuelve a leer y qué decisiones de diseño ayudan a la performance.

En este laboratorio todavía no se está desplegando un HDFS real con NameNode y DataNode.
Sin embargo, trabajaremos la lógica correcta del flujo: leer datos desde la zona de almacenamiento, procesarlos con Spark y persistir la salida en Parquet con particionado.

Paso 1: Crear la SparkSession

Inicializamos el entorno de trabajo en modo local dentro del contenedor Docker.
El puerto 4040 queda disponible para revisar la interfaz de Spark si se desea observar jobs, stages y tareas.

También fijamos una cantidad moderada de particiones de shuffle para que la práctica sea más predecible.

from pyspark.sql import SparkSession

spark = (
    SparkSession.builder
    .appName("sesion4-hdfs-formatos")
    .master("local[*]")
    .config("spark.ui.port", "4040")
    .config("spark.sql.shuffle.partitions", "8")
    .getOrCreate()
)

spark

Paso 2: Revisar el dataset

El dataset fue diseñado con algunos errores intencionales para que el estudiante no solo ejecute código, sino que también detecte problemas de calidad y tome decisiones antes de almacenar la salida final.

Paso 3: Leer los datasets desde la zona de datos

En esta práctica la carpeta /opt/data representa la zona de almacenamiento de entrada del laboratorio.

Desde la perspectiva del flujo Big Data, la idea es esta:

  1. el dato vive en una zona de almacenamiento,
  2. Spark lo lee,
  3. lo transforma,
  4. y publica una salida optimizada.

Por eso aquí sí estamos trabajando la lógica de “leer desde almacenamiento y procesar con Spark”, pero sin adelantar una infraestructura HDFS real.

ventas = spark.read.csv("/opt/data/ventas_s4.csv", header=True, inferSchema=True)
clientes = spark.read.csv("/opt/data/clientes_s4.csv", header=True, inferSchema=True)

ventas.show(5, truncate=False)
clientes.show(5, truncate=False)

Paso 4: Explorar estructura y tipos de datos

Antes de transformar y almacenar, verificamos esquema, tipos y volumen básico.

Esto responde una pregunta importante de ingeniería:

¿Estoy leyendo el dato con la estructura esperada antes de diseñar la salida?

Si el esquema ya viene mal desde el inicio, el problema se arrastra al join, al particionado y al almacenamiento final.

print("Total de registros en ventas:", ventas.count())
print("Total de registros en clientes:", clientes.count())

print("\nEsquema de ventas")
ventas.printSchema()

print("\nEsquema de clientes")
clientes.printSchema()

Paso 5: Exploración rápida de calidad

Antes de limpiar, revisamos los primeros síntomas:

  • valores nulos,
  • montos inválidos,
  • posibles duplicados,
  • dimensiones repetidas.

No se trata todavía de corregir; primero buscamos entender el problema.

ventas.show(10, truncate=False)

Paso 6: Detectar errores intencionales en el dataset

En esta parte el estudiante debe identificar los problemas que afectarían al pipeline:

  • un cliente_id vacío,
  • un monto negativo,
  • registros repetidos a nivel de negocio,
  • un cliente duplicado en la tabla de referencia.

Este paso es clave porque no todo problema de calidad se resuelve igual.

print("Ventas con cliente_id nulo o vacío")
ventas.filter("cliente_id IS NULL OR cliente_id = ''").show(truncate=False)

print("Ventas con monto negativo")
ventas.filter("monto < 0").show(truncate=False)

print("Posibles duplicados exactos de negocio en ventas")
ventas.groupBy(
    "cliente_id", "fecha", "categoria", "producto", "monto", "canal", "region"
).count().filter("count > 1").show(truncate=False)

print("Clientes duplicados en la dimensión")
clientes.groupBy("cliente_id").count().filter("count > 1").show(truncate=False)

🔎 Pregunta guiada

Antes de continuar, responde:

  1. ¿Qué registros sí deben eliminarse obligatoriamente?
  2. ¿Qué registros podrían tratarse de otra forma según el negocio?
  3. ¿Por qué conviene detectar duplicados en la dimensión antes de hacer el join?

Paso 7: Limpieza básica para construir una salida confiable

Aplicamos una limpieza mínima orientada a esta práctica:

  • eliminamos registros sin cliente_id, fecha o monto,
  • filtramos montos negativos,
  • deduplicamos clientes por cliente_id.

En ventas, además de revisar duplicados por negocio, generaremos una salida sin duplicados exactos por todas las columnas relevantes.

from pyspark.sql.functions import col

ventas_limpio = (
    ventas
    .dropna(subset=["cliente_id", "fecha", "monto"])
    .filter(col("monto") > 0)
    .dropDuplicates([
        "cliente_id", "fecha", "categoria", "producto", "monto", "canal", "region"
    ])
)

clientes_limpio = clientes.dropDuplicates(["cliente_id"])

print("Ventas limpias:", ventas_limpio.count())
print("Clientes limpios:", clientes_limpio.count())

Paso 8: Verificar el efecto de la limpieza

Después de limpiar, volvemos a revisar los DataFrames para comprobar que:

  • desaparecieron los nulos críticos,
  • ya no hay montos inválidos,
  • la dimensión de clientes quedó estable.

Este control evita seguir avanzando sobre supuestos incorrectos.

ventas_limpio.show(10, truncate=False)
clientes_limpio.show(10, truncate=False)

Paso 9: Join distribuido entre ventas y clientes

Ahora integramos la información transaccional con la información descriptiva del cliente.

Este join tiene sentido de negocio porque nos permite responder preguntas como:

  • ¿qué segmento compra más?
  • ¿qué tipo de cliente concentra mayor monto?
  • ¿qué regiones tienen mejor desempeño por tipo de cliente?

Además, esta tabla integrada será la base del almacenamiento final en Parquet.

df_join = ventas_limpio.join(clientes_limpio, "cliente_id", "inner")

df_join.show(10, truncate=False)
print("Total después del join:", df_join.count())

Paso 10: Preparar columnas para particionado

Para almacenar con criterio, no basta con guardar el archivo.
Primero debemos preparar columnas útiles para organizar la salida.

En esta práctica derivamos:

  • anio
  • mes

Estas columnas ayudarán a estructurar la carpeta de salida y a optimizar consultas frecuentes por periodo.

from pyspark.sql.functions import to_date, year, month

df_final = (
    df_join
    .withColumn("fecha", to_date("fecha"))
    .withColumn("anio", year("fecha"))
    .withColumn("mes", month("fecha"))
)

df_final.printSchema()
df_final.show(10, truncate=False)

Paso 11: Antes de escribir, pensar como ingenieros de datos

Aquí viene la parte central de la sesión.

La pregunta ya no es solo:

¿cómo guardo el DataFrame?

La pregunta correcta es:

¿cómo diseño el almacenamiento para que futuras consultas lean menos datos y respondan más rápido?

Por eso debemos justificar dos decisiones:

  1. Formato
  2. Particionado

Paso 12: Comparar dos estrategias de salida

Vamos a escribir la misma salida en dos formatos:

  • CSV
  • Parquet

Luego compararemos tamaño y organización para discutir por qué Parquet es más adecuado en este contexto.

ruta_base = "/opt/artifacts/u1_s4"
ruta_csv = f"{ruta_base}/ventas_csv"
ruta_parquet = f"{ruta_base}/ventas_parquet"

import shutil
shutil.rmtree(ruta_base, ignore_errors=True)

(
    df_final.write
    .mode("overwrite")
    .option("header", True)
    .csv(ruta_csv)
)

print("CSV generado en:", ruta_csv)

Paso 13: Escribir la salida optimizada en Parquet con particionado

Ahora escribimos la salida en Parquet.

Elegimos particionar por:

  • anio
  • mes
  • region

Esta propuesta es útil cuando las consultas suelen filtrar por periodo y región.
Más adelante discutiremos también cuándo este diseño podría dejar de ser conveniente.

(
    df_final.write
    .mode("overwrite")
    .partitionBy("anio", "mes", "region")
    .parquet(ruta_parquet)
)

print("Parquet generado en:", ruta_parquet)

Paso 14: Leer nuevamente la salida Parquet

Este paso cierra el flujo lógico de la sesión:

  1. el dato se leyó desde almacenamiento,
  2. se procesó con Spark,
  3. se persistió en formato optimizado,
  4. y ahora se vuelve a leer como salida del pipeline.

Así el estudiante entiende que el almacenamiento no es un tema aislado: forma parte del ciclo completo de datos.

df_parquet = spark.read.parquet(ruta_parquet)

df_parquet.show(10, truncate=False)
print("Total registros en Parquet:", df_parquet.count())
df_parquet.printSchema()

Paso 15: Observar la estructura física de carpetas

Una ventaja del particionado es que el layout de carpetas expresa una organización útil para el acceso.

Aquí inspeccionamos la estructura que Spark creó automáticamente.
Esto permite conectar el concepto lógico de partitionBy() con el resultado físico sobre almacenamiento.

import os

for root, dirs, files in os.walk(ruta_parquet):
    nivel = root.replace(ruta_parquet, "").count(os.sep)
    sangria = " " * 2 * nivel
    nombre = os.path.basename(root) if os.path.basename(root) else root
    print(f"{sangria}{nombre}/")
    for f in files[:4]:
        print(f"{sangria}  {f}")

Paso 16: Consulta típica que se beneficia del particionado

Supongamos que un analista necesita consultar ventas de enero en la región Sur.

Si la salida está particionada por anio, mes y region, Spark puede reducir la lectura a una fracción del total.

Aquí no estamos midiendo todavía tiempos de benchmark avanzados, pero sí mostrando la lógica correcta de diseño.

from pyspark.sql.functions import col

consulta_sur = (
    df_parquet
    .filter((col("anio") == 2026) & (col("mes") == 1) & (col("region") == "Sur"))
    .select("fecha", "cliente", "producto", "monto", "region", "segmento")
)

consulta_sur.show(truncate=False)

Paso 17: Comparación simple de tamaño entre CSV y Parquet

Una diferencia importante entre formatos es el tamaño final de almacenamiento.

Con datasets pequeños la diferencia puede no ser enorme, pero el ejercicio sigue siendo útil para introducir dos ideas:

  • compresión,
  • lectura selectiva por columnas.

En escenarios grandes, estas diferencias se vuelven mucho más relevantes.

def size_mb(path):
    total = 0
    for root, _, files in os.walk(path):
        for f in files:
            total += os.path.getsize(os.path.join(root, f))
    return round(total / (1024 * 1024), 6)

print("Tamaño CSV (MB):", size_mb(ruta_csv))
print("Tamaño Parquet (MB):", size_mb(ruta_parquet))

Paso 18: Comparación de lectura selectiva

Cuando se trabaja con CSV, normalmente se lee fila completa.
Con Parquet, Spark puede aprovechar mejor la estructura columnar.

Aquí simulamos una lectura donde solo necesitamos unas pocas columnas para análisis.

df_parquet.select("fecha", "producto", "monto", "region").show(10, truncate=False)

Paso 19: Errores y decisiones que deben detectar los estudiantes

Durante esta práctica el estudiante debería poder reconocer al menos estos puntos:

  1. había un cliente_id nulo,
  2. había un monto negativo,
  3. había duplicado lógico en ventas,
  4. había duplicado en la tabla de clientes,
  5. no todo particionado es bueno por defecto.

Esto convierte la sesión en una práctica de ingeniería y no solo en un ejercicio de sintaxis.

Paso 20: Mini ficha técnica de cierre

Completa esta guía breve con base en lo que observaste en el laboratorio.

Formato elegido

Parquet

Particionado elegido

anio / mes / region

Consulta objetivo

Ventas por periodo y región.

Justificación

Parquet reduce lectura innecesaria por su estructura columnar, y el particionado ayuda cuando se filtra por tiempo y región.

Riesgo

Si una columna de partición tiene cardinalidad muy alta o no se usa en filtros, se pueden crear demasiadas carpetas y empeorar la administración del almacenamiento.

Paso 21: Reflexión final

Preguntas para reflexión:

  • ¿Por qué esta sesión no se reduce a “guardar archivos”?
  • ¿Qué relación existe entre el patrón de consulta y el particionado?
  • ¿En qué caso elegirías otro esquema de partición?
  • ¿Qué diferencia conceptual hay entre “zona de datos” y “formato de salida”?
# Espacio opcional para respuestas o pruebas adicionales

Actividad Autónoma – Aplicación al Producto de la Unidad 1

Objetivo

Tomar la salida ETL de su caso de trabajo y proponer un diseño de almacenamiento justificando:

  • formato,
  • columnas de partición,
  • consulta objetivo,
  • riesgos del diseño.

Entregable breve

  1. Captura de la estructura de carpetas generada.
  2. Evidencia de lectura desde Parquet.
  3. Justificación del formato y particionado.
  4. Una consulta que se beneficie del diseño propuesto.