GuíaIntermedio
Guía de Spark y Procesamiento Distribuido
Descubre cuándo tu problema de datos deja de caber en un solo nodo, y qué cambia de verdad cuando lo distribuyes. Esta guía retoma el caso Kiosko (cadena de tiendas de conveniencia) justo donde lo dejaron las guías anteriores del ecosistema — con un warehouse dimensional que corre perfecto en DuckDB — y le agrega un dataset sintético de 10 millones de filas para que particionamiento y shuffle se sientan de verdad en tu laptop. Aprendes Apache Spark en modo local (`local[*]`, $0, sin clúster ni cuenta de nube) con la DataFrame API como vehículo principal: el modelo driver/executors, evaluación perezosa, el costo real de un shuffle en `groupBy`/`join`, broadcast join vs sort-merge join, funciones de ventana a escala, el optimizador Catalyst leído con `.explain()`, cuándo cachear (y cuándo no), Parquet particionado, y por qué un UDF de Python normal es lento frente a un `pandas_udf` vectorizado con Arrow. Ninguna afirmación de rendimiento se mide con cronómetro — todo se sostiene con el plan de ejecución. Cierra con el criterio honesto que la mayoría de guías de Spark del mercado se saltan: cuándo Kiosko (real, 40 filas) NO necesita Spark, y cuándo un Kiosko mucho más grande sí.
- 64
- lecciones
- 8
- módulos
- Inglés · Español
- disponible en
- Sí
- certificado
- Gratis
- acceso
Resultados
Lo que vas a poder hacer
- Instalar y correr PySpark en modo local (Java 17+, `SparkSession.builder.master("local[*]")`) y verificar que lee los mismos datos de Kiosko que las guías anteriores
- Distinguir transformations de actions, entender la evaluación perezosa y leer el DAG lógico/físico de una cadena de operaciones antes de ejecutarla
- Reconstruir `fact_orders` con la DataFrame API (`join`, `withColumn`, `groupBy().agg()`) y verificar que el resultado es idéntico al de motores anteriores del ecosistema
- Generar de forma determinista un dataset sintético a escala (10 millones de filas) y sentir el costo real de un shuffle en `groupBy`/`join`/`distinct`
- Elegir entre `repartition()` y `coalesce()`, y decidir cuándo un broadcast join gana frente a un sort-merge join, leyendo ambos en `.explain()`
- Escribir y leer funciones de ventana (`Window.partitionBy`/`orderBy`) para revenue acumulado y rankings de producto a escala
- Leer las fases del optimizador Catalyst y el efecto de Adaptive Query Execution (AQE) sobre el plan de una consulta
- Decidir con criterio cuándo `.cache()`/`.persist()` ayuda y cuándo solo gasta memoria sin beneficio
- Escribir Parquet particionado a escala y explicar por qué un UDF de Python (`cloudpickle`) es lento frente a un `pandas_udf` vectorizado con Arrow
- Aplicar un árbol de decisión de "¿necesito Spark?" al Kiosko real (40 filas) y a un Kiosko hipotético mucho más grande, con criterio y sin moda
Antes de empezar
Qué necesitas traer
Es para ti si...
- Data engineers que ya dominan Python/SQL/DuckDB en un solo nodo y necesitan saber cuándo ese límite deja de alcanzar
- Devs preparándose para roles o certificaciones que exigen Spark (AWS DEA-C01, Databricks, DP-700) sin querer aprender Scala ni RDDs primero
- Cualquiera que haya escuchado "usa Spark" para un problema que probablemente no lo necesita, y quiere un criterio de costo real para decidir
- Data engineers que ya completaron las guías anteriores del ecosistema NIEVA (foundations, Python, modelado, dbt) y quieren llevar el mismo caso a escala distribuida
Requisitos y materiales
- Python intermedio y comodidad con DataFrames (DuckDB, Polars o pandas)
- SQL: joins, agregaciones y funciones de ventana básicas
- Java 17 o superior instalado localmente (se verifica en el Módulo 1)
- Ideal haber completado `python-for-data-engineering-guide` y `data-modeling-for-analytics-guide` (o equivalente): esta guía retoma directamente el caso y el warehouse dimensional de Kiosko
Contenido
El temario, módulo por módulo
Abre cualquiera para ver sus lecciones.
- Presentación del módulo: por qué distribuir — el techo de un solo nodo
- El techo de un solo nodo: lo que DuckDB y Polars ya resolvieron
- Un criterio de costo real para cuándo distribuir
- Instalando PySpark y Java localmente
- Tu primera SparkSession
- Leyendo las órdenes de Kiosko con Spark
- Verificando que llegan las mismas cuarenta filas
- Mini-proyecto: la primera sesión de Spark de Kiosko
- Presentación del módulo: el modelo de ejecución de Spark
- El driver y los executors
- RDDs: la abstracción original, vista una vez y dejada atrás
- La DataFrame API como la interfaz moderna
- Evaluación perezosa: transformations vs actions
- Construyendo una cadena de transformaciones sin ejecutarla
- Disparando la ejecución con una acción
- Mini-proyecto: la primera cadena de transformación de Kiosko
- Presentación del módulo: reconstruyendo `fact_orders` con la DataFrame API
- Leyendo `orders`, `dim_store` y `dim_product` con esquema explícito
- Uniendo hechos y dimensiones con la DataFrame API
- Calculando revenue, de la misma forma, cuatro motores después
- Agrupando por tienda y por producto
- Verificando el mismo total de 106.15
- Escribiendo `fact_orders` como Parquet
- Mini-proyecto: `fact_orders` de Kiosko en Spark
- Presentación del módulo: particiones y el costo del shuffle
- Qué es, en realidad, una partición
- Por qué `groupBy`, `join` y `distinct` disparan un shuffle
- Generando `kiosko_orders_at_scale`, de forma determinista
- Leyendo el shuffle en `.explain()` y en la Spark UI
- `repartition()` contra `coalesce()`
- `spark.sql.shuffle.partitions` y Adaptive Query Execution
- Mini-proyecto: Kiosko a escala, particionado
- Presentación del módulo: joins y funciones de ventana a escala
- Broadcast join vs shuffle join
- Leyendo un broadcast join en `.explain()`
- Forzando y leyendo un `SortMergeJoin`
- Funciones de ventana: `partitionBy` y `orderBy`
- Un total de revenue acumulado por tienda
- Ranking de producto top por tienda y por día
- Mini-proyecto: joins y rankings de Kiosko a escala
- Presentación del módulo: Catalyst, `.explain()` y caché
- Las fases del optimizador Catalyst
- Leyendo `.explain()` en sus distintos modos
- Adaptive Query Execution
- Cuándo cachear ayuda de verdad
- `persist()` y los storage levels
- Cuándo cachear solo cuesta memoria
- Mini-proyecto: el plan de consulta optimizado de Kiosko
- Presentación del módulo: Parquet a escala y UDFs de Python
- Parquet a escala: escritura particionada
- Predicate y column pushdown
- Por qué un UDF de Python normal es lento: `cloudpickle` y el executor
- `pandas_udf` y vectorización con Arrow
- Reescribiendo `margin_category` como `pandas_udf`
- Nombrando Structured Streaming, sin construirlo
- Mini-proyecto: Parquet particionado y un UDF vectorizado
- Presentación del módulo: el capstone distribuido de Kiosko
- El brief: Kiosko a escala
- Ensamblando el pipeline distribuido, de punta a punta
- Verificando correctitud contra el `106.15` original
- Eligiendo particionamiento, caché y estrategia de `JOIN`, con criterio
- El árbol de decisión: ¿Kiosko de verdad necesita Spark?
- Qué le falta todavía a Kiosko
- Mini-proyecto: el primer pipeline distribuido de Kiosko
Dudas frecuentes
Lo que suele preguntarse
Sin límite. Es una guía gratuita: entras cuando quieras, las veces que quieras.
No. Los módulos están ordenados de menos a más, pero puedes saltar al que necesites. Tu progreso se guarda por lección.
Lo que haga falta está en «Qué necesitas traer», arriba. Si no aparece nada ahí, puedes empezar desde cero.
En el grupo de WhatsApp del Club, y cada quince días hay un live con un instructor donde se resuelven dudas en vivo.
Sí. Al terminar todas las lecciones se emite automáticamente, con un código verificable que puedes compartir en LinkedIn.
Empieza cuando quieras
Lo que dicen los estudiantes
Estas reseñas son de estudiantes inscritos que completaron al menos el 50% del curso. Moderamos las reseñas solo por motivos de contenido (spam, lenguaje ofensivo, datos personales), nunca por ser críticas o negativas.
Aún no hay reseñas aprobadas.
¡Sé el primero en compartir tu experiencia!