INTERMEDIO · 8 MÓDULOS · 64 LECCIONES

Spark y procesamiento distribuido

Descubre cuándo tus datos dejan de caber en una sola máquina y procésalos con Spark en tu laptop, leyendo el plan de ejecución para saber qué cuesta.

Es para ti si
Dominas Python y SQL en un solo nodo y te preguntas si de verdad necesitas Spark.
Al terminar
Sabrás leer el costo de un shuffle o un join, cuándo cachear y cuándo Spark no hace falta.
Necesitas
Python intermedio con DataFrames, SQL con funciones de ventana y Java 17 instalado. Sin clúster ni nube.
  1. 01Why Distribute The Single Node Ceiling8 LECCIONES
    1. Presentación del módulo: por qué distribuir y el techo de un solo nodo
    2. El techo de un solo nodo: lo que DuckDB y Polars ya resolvieron
    3. Un criterio de costo real para cuándo distribuir
    4. Instalando PySpark y Java localmente
    5. Tu primera SparkSession
    6. Leyendo las órdenes de Kiosko con Spark
    7. Verificando que llegan las mismas cuarenta filas
    8. Mini-proyecto: la primera sesión de Spark de Kiosko
  2. 02The Spark Execution Model8 LECCIONES
    1. Presentación del módulo: el modelo de ejecución de Spark
    2. El driver y los executors
    3. RDDs: la abstracción original, vista una vez y dejada atrás
    4. La DataFrame API como la interfaz moderna
    5. Evaluación perezosa: transformations vs actions
    6. Construyendo una cadena de transformaciones sin ejecutarla
    7. Disparando la ejecución con una acción
    8. Mini-proyecto: la primera cadena de transformación de Kiosko
  3. 03Rebuilding Fact Orders With The Dataframe Api8 LECCIONES
    1. Presentación del módulo: reconstruyendo `fact_orders` con la DataFrame API
    2. Leyendo `orders`, `dim_store` y `dim_product` con esquema explícito
    3. Uniendo hechos y dimensiones con la DataFrame API
    4. Calculando revenue, de la misma forma, cuatro motores después
    5. Agrupando por tienda y por producto
    6. Verificando el mismo total de 106.15
    7. Escribiendo `fact_orders` como Parquet
    8. Mini-proyecto: `fact_orders` de Kiosko en Spark
  4. 04Partitions And The Cost Of Shuffle8 LECCIONES
    1. Presentación del módulo: particiones y el costo del shuffle
    2. Qué es, en realidad, una partición
    3. Por qué `groupBy`, `join` y `distinct` disparan un shuffle
    4. Generando `kiosko_orders_at_scale`, de forma determinista
    5. Leyendo el shuffle en `.explain()` y en la Spark UI
    6. `repartition()` contra `coalesce()`
    7. `spark.sql.shuffle.partitions` y Adaptive Query Execution
    8. Mini-proyecto: Kiosko a escala, particionado
  5. 05Joins And Window Functions At Scale8 LECCIONES
    1. Presentación del módulo: joins y funciones de ventana a escala
    2. Broadcast join vs shuffle join
    3. Leyendo un broadcast join en `.explain()`
    4. Forzando y leyendo un `SortMergeJoin`
    5. Funciones de ventana: `partitionBy` y `orderBy`
    6. Un total de revenue acumulado por tienda
    7. Ranking de producto top por tienda y por día
    8. Mini-proyecto: joins y rankings de Kiosko a escala
  6. 06Catalyst Explain And Caching8 LECCIONES
    1. Presentación del módulo: Catalyst, `.explain()` y caché
    2. Las fases del optimizador Catalyst
    3. Leyendo `.explain()` en sus distintos modos
    4. Adaptive Query Execution
    5. Cuándo cachear ayuda de verdad
    6. `persist()` y los storage levels
    7. Cuándo cachear solo cuesta memoria
    8. Mini-proyecto: el plan de consulta optimizado de Kiosko
  7. 07Parquet At Scale And Python Udfs8 LECCIONES
    1. Presentación del módulo: Parquet a escala y UDFs de Python
    2. Parquet a escala: escritura particionada
    3. Predicate y column pushdown
    4. Por qué un UDF de Python normal es lento: `cloudpickle` y el executor
    5. `pandas_udf` y vectorización con Arrow
    6. Reescribiendo `margin_category` como `pandas_udf`
    7. Nombrando Structured Streaming, sin construirlo
    8. Mini-proyecto: Parquet particionado y un UDF vectorizado
  8. 08Project Kioskos Distributed Pipeline8 LECCIONES
    1. Presentación del módulo: el capstone distribuido de Kiosko
    2. El brief: Kiosko a escala
    3. Ensamblando el pipeline distribuido, de punta a punta
    4. Verificando correctitud contra el `106.15` original
    5. Eligiendo particionamiento, caché y estrategia de `JOIN`, con criterio
    6. El árbol de decisión: ¿Kiosko de verdad necesita Spark?
    7. Qué le falta todavía a Kiosko
    8. Mini-proyecto: el primer pipeline distribuido de Kiosko
Reseñas

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!

SEC. 06 · EL ESTUDIO

Por qué existe este estudio

Durante décadas, construir software fue cosa de perfiles técnicos con años de formación, y llevar un producto digital a la vida real le tomaba a las empresas meses o años. El no-code y la inteligencia artificial han acortado esa brecha, pero el conocimiento sigue en manos de unos cuantos.

Tech Benders existe para abrir ese conocimiento, para que los equipos de negocio y los perfiles no técnicos puedan poner sus ideas en producción con las decisiones técnicas correctas detrás. La IA hace lo que le pides. Sin una base técnica, lo que construye puede no escalar con el ecosistema de tu empresa, y sus costos se disparan con el tiempo.

El equipo conoce los dolores de las organizaciones grandes y la velocidad a la que tienen que moverse. Trae arquitectura de soluciones, ingeniería de datos, producto construido de punta a punta, del backend al frontend, y trabajo diario con IA. Software que resuelve lo que necesitas en días, no en meses, con los costos de la IA bajo control.

Fundadores

El estudioConoce Tech Benders →

Escríbenoshi@techbenders.io

Hecho con Wislab