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:
- el dato vive en una zona de almacenamiento,
- Spark lo lee,
- lo transforma,
- 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_idvacío, - un
montonegativo, - 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:
- ¿Qué registros sí deben eliminarse obligatoriamente?
- ¿Qué registros podrían tratarse de otra forma según el negocio?
- ¿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,fechaomonto, - 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:
aniomes
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:
- Formato
- 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:
aniomesregion
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:
- el dato se leyó desde almacenamiento,
- se procesó con Spark,
- se persistió en formato optimizado,
- 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:
- había un
cliente_idnulo, - había un
montonegativo, - había duplicado lógico en ventas,
- había duplicado en la tabla de clientes,
- 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¶
- Captura de la estructura de carpetas generada.
- Evidencia de lectura desde Parquet.
- Justificación del formato y particionado.
- Una consulta que se beneficie del diseño propuesto.