Curso de Spark para Empresas — Procesado en streaming y rendimiento

Arquitectura de una aplicación Spark y relación entre Driver, Executors, recursos y datos distribuidos.

Introducción a las APIs de Spark y diferencias entre DataFrames, Datasets, SQL y RDD.

Iniciando Spark desde aplicaciones, notebooks, shells y procesos enviados mediante `spark-submit`.

SparkSession como punto de entrada principal para las APIs estructuradas.

SparkContext y su relación actual con SparkSession y las APIs de bajo nivel.

Introducción a los DataFrames como abstracción principal para datos estructurados y semiestructurados.

Introducción a las particiones como unidad básica de paralelismo y distribución del trabajo.

Introducción a las transformaciones y diferencia entre transformaciones y acciones.

Lazy Evaluation y construcción del plan de ejecución antes de materializar los resultados.

Ejecución de la aplicación y lanzamiento de cálculos cuando una acción requiere obtener un resultado.

Ciclo de vida fuera de las aplicaciones: petición, asignación de recursos, lanzamiento, ejecución y finalización.

Ciclo de vida dentro de las aplicaciones: instrucciones lógicas, dependencias y planificación del trabajo.

Job de Spark como ejecución originada por una acción.

Stages como grupos de tareas separados habitualmente por operaciones de shuffle.

Task como unidad mínima enviada a un executor para procesar una partición.

Transmisión estructurada mediante Structured Streaming para procesamiento incremental y continuo basado en DataFrames.

Diferencias entre Structured Streaming y Spark Streaming basado en DStreams, considerado actualmente una API legacy.

Ejecución de aplicaciones en producción y separación entre desarrollo local, empaquetado y despliegue distribuido.

Datasets como API tipada disponible principalmente para Scala y Java.

APIs de bajo nivel mediante Spark Core y RDD cuando el problema requiere control que no ofrecen las APIs estructuradas.

Spark SQL para procesamiento estructurado mediante SQL y DataFrames sobre un mismo motor.

MLlib mediante la API moderna basada en DataFrames para Machine Learning distribuido.

GraphX para procesamiento de grafos y algoritmos distribuidos.

PySpark como API Python para DataFrames, SQL, Structured Streaming, MLlib y Spark Core.

Pandas API on Spark para determinados workflows procedentes del ecosistema pandas.

Spark Connect como arquitectura cliente-servidor para trabajar con Spark desde aplicaciones desacopladas del Driver.

Spark Declarative Pipelines como framework actual para definir pipelines batch y streaming de forma declarativa.

Ecosistema y paquetes de Spark para integrar conectores, fuentes, formatos y tecnologías externas.

SparkR y procesamiento con R como funcionalidad heredada actualmente deprecada.

Criterios para elegir una API sin utilizar RDD, Dataset o cualquier otra abstracción por costumbre.

DataFrames y su representación de datos distribuidos mediante columnas y esquema.

DataSets y tipado en Scala y Java.

DataFrames vs DataSets y criterios para seleccionar cada abstracción.

Relación entre `DataFrame` y `Dataset[Row]` dentro de la API JVM.

Esquemas inferidos frente a esquemas definidos explícitamente.

`StructType`, `StructField` y representación programática de esquemas.

Columnas y filas como elementos fundamentales de los datos estructurados.

Tipos en Spark y correspondencia con tipos SQL, Python, Java y Scala.

Transformaciones estructuradas frente a operaciones basadas en objetos de lenguaje.

Planificación lógica de una consulta o cadena de transformaciones.

Resolución del esquema y de las expresiones antes de ejecutar la consulta.

Planificación física y selección de operadores para materializar el resultado.

Ejecución distribuida de consultas DataFrame y SQL sobre el mismo motor.

Ventajas de proporcionar a Spark información estructural sobre los datos.

Elección entre DataFrame, Dataset, SQL y RDD según lenguaje, problema y necesidad de optimización.

Operaciones sobre esquemas e inspección de columnas y tipos.

Columnas y expresiones mediante la API de funciones de Spark.

Creación de filas y construcción de estructuras compatibles con un esquema.

Creación de DataFrames desde colecciones, RDD, archivos, tablas y fuentes externas.

Selección con `select` y `selectExpr`.

Uso de `expr` para combinar expresiones SQL con la API DataFrame.

Conversión de tipos y tratamiento de incompatibilidades.

Añadir columnas mediante `withColumn` y operaciones equivalentes.

Renombrado de columnas.

Casteo del tipo de las columnas mediante `cast`.

Obtención de filas con `show`, `take`, `head` y otras acciones.

Filtrado de filas mediante `filter` y `where`.

Muestreo aleatorio mediante `sample`.

Divisiones aleatorias mediante `randomSplit`.

Uniones de filas mediante `union` y `unionByName`.

Eliminación de duplicados mediante `distinct` y `dropDuplicates`.

Aplicación de límites mediante `limit`.

Ordenación de filas con `sort` y `orderBy`.

Repartición mediante `repartition` y reducción de particiones con `coalesce`.

Riesgos de utilizar `collect` o conversiones locales sobre datasets demasiado grandes para el Driver.

Conversión a tipos de Spark y definición explícita de tipos cuando la inferencia no es suficiente.

Trabajando con números enteros, decimales y tipos de precisión fija.

Trabajando con cadenas de texto y funciones integradas de manipulación.

Trabajando con expresiones regulares.

Trabajando con fechas y horas.

Diferencia entre fechas, timestamps y representación temporal.

Trabajando con booleanos y expresiones condicionales.

Trabajando con datos nulos y semántica SQL de `NULL`.

Uso de `coalesce`, `fill`, `drop` y otras estrategias para valores ausentes.

Trabajando con arrays, maps, estructuras y otros datos complejos.

Higher-order functions para transformar arrays y maps mediante expresiones nativas.

Trabajando con JSON y estructuras anidadas.

Uso del tipo `VARIANT` para determinados datos semiestructurados en las versiones modernas de Spark.

Ordenación de datos y gestión explícita de valores nulos durante la ordenación.

Uso de funciones definidas por el usuario cuando las funciones integradas no permiten expresar la transformación.

Diferencias entre UDF Python, Pandas UDF y funciones nativas desde la perspectiva de rendimiento.

Funciones de agregación disponibles en Spark.

`count`, `sum`, `avg`, `min`, `max`, `first`, `last` y funciones estadísticas habituales.

Agrupaciones con expresiones mediante `groupBy`.

Agrupaciones con maps y expresiones dinámicas.

Agrupación de sets mediante grouping sets, `rollup` y `cube`.

Agregaciones sobre varias columnas y múltiples métricas.

Funciones ventana para cálculos sobre filas relacionadas.

`row_number`, `rank`, `dense_rank`, `lag` y `lead`.

Uso de funciones de agregación definidas por el usuario cuando resulta necesario.

Expresiones de unión y construcción de condiciones entre DataFrames.

Tipos de Joins: inner, left, right, full, cross, left semi y left anti.

Equi-joins frente a condiciones de unión más complejas.

¿Cómo realiza Spark los joins? Introducción a estrategias de ejecución físicas.

Broadcast Join como estrategia útil cuando una de las relaciones es suficientemente pequeña.

Shuffle y redistribución de datos provocados por determinados joins y agregaciones.

Data skew y consecuencias de distribuir de manera desigual las claves.

Adaptive Query Execution como mecanismo actual que permite reajustar determinados aspectos de una consulta durante su ejecución.

Lectura inicial de un plan físico para reconocer joins y exchanges.

Las bases de la API de lectura de datos mediante `DataFrameReader`.

Las bases de la API de escritura de datos mediante `DataFrameWriter`.

Lectura y escritura de archivos CSV.

Lectura y escritura de archivos JSON.

Lectura y escritura de archivos Parquet como formato columnar de referencia en numerosas arquitecturas analíticas.

Lectura y escritura de archivos ORC.

Lectura y escritura de Avro cuando el formato y el conector forman parte de la solución.

Lectura y escritura de archivos TXT.

Lectura y escritura de bases de datos SQL mediante JDBC.

Paralelización de lecturas JDBC y precauciones sobre carga en el sistema origen.

Lectura desde HDFS.

Lectura y escritura sobre almacenamiento de objetos como S3, Azure Data Lake Storage o Google Cloud Storage mediante la configuración correspondiente.

Definición explícita del esquema frente a inferencia automática.

Modos de escritura `append`, `overwrite`, `ignore` y error.

Particionado de archivos al escribir datasets.

Predicate pushdown y column pruning como mecanismos para reducir datos leídos cuando el formato y la fuente lo permiten.

Problema de los archivos pequeños y consecuencias sobre planificación e I/O.

Introducción a formatos de tabla como Iceberg, Delta Lake o Hudi como tecnologías complementarias a Spark, sin profundizar todavía en su arquitectura.

Introducción a Spark SQL como módulo para datos estructurados.

Relación entre Spark SQL y DataFrames.

Introducción a Apache Hive y relación con Spark.

Integración con Hive Metastore cuando forma parte de la arquitectura existente.

Introducción a Spark SQL CLI.

Introducción a la interfaz programática de SQL de Spark mediante `spark.sql`.

Operaciones SQL y combinación de SQL con transformaciones DataFrame.

Opciones de Entrada/Salida.

Catálogo y resolución de tablas, vistas y namespaces.

Introducción de las tablas de Spark SQL.

Creación de tablas.

Creación de tablas externas.

Diferencia conceptual entre tablas gestionadas y externas.

Inserción de datos en tablas mediante `INSERT INTO` e `INSERT OVERWRITE`.

`CREATE TABLE AS SELECT`.

Metadatos de tablas y uso de `DESCRIBE`.

Borrado de tablas.

Cacheado de tablas.

Introducción a las vistas de Spark SQL.

Creación de vistas temporales y globales.

Borrado de vistas.

Introducción a las bases de datos y namespaces de Spark SQL.

Creación, selección y borrado de bases de datos.

Selects con `CASE`, `WHEN` y `THEN`.

Funciones escalares, agregadas y de ventana.

Tipos complejos y estructuras anidadas.

Subqueries.

Common Table Expressions mediante `WITH`.

Configuraciones generales.

Establecimiento de valores de configuración en SQL mediante `SET`.

Introducción a ANSI SQL y comportamiento estricto ante determinadas operaciones inválidas.

Introducción a SQL Scripting actual para flujos SQL con variables y control de ejecución, dejando sus capacidades avanzadas para niveles posteriores.

¿Cuándo debemos usar Datasets?

Diferencias entre Dataset tipado y DataFrame.

Disponibilidad principalmente en Scala y Java.

Creación de DataSets desde colecciones JVM.

Encoders y conversión entre objetos JVM y representación interna de Spark.

Creación de DataSets a partir de DataFrames.

Acciones.

Transformaciones, filtrado y mapeo.

Operaciones tipadas frente a expresiones DataFrame.

Joins de DataSets.

Agrupaciones y agregaciones.

Conversión entre Dataset y DataFrame.

Ventajas del tipado durante compilación.

Limitaciones y coste de utilizar transformaciones basadas en objetos frente a expresiones estructuradas.

Criterios para decidir entre DataFrame y Dataset en nuevos desarrollos.

Introducción a los RDD en Spark.

Qué significa Resilient Distributed Dataset.

Tipos de RDDs y relación con las fuentes que los originan.

¿Cuándo es conveniente usar RDDs?

Ventajas de DataFrames vs RDD.

Limitaciones de los RDD al no proporcionar al optimizador el mismo conocimiento estructural.

Creación de un RDD.

Interoperabilidad entre RDDs, DataSets y DataFrames.

Creación de un RDD a partir de una colección local.

Creación de un RDD desde distintos orígenes.

Manipulación de RDDs.

Transformaciones como `map`, `flatMap` y `filter`.

Acciones como `count`, `take`, `reduce` y `collect`.

Guardado en archivos de texto.

Guardado en archivos Hadoop.

Otros tipos de guardado mediante APIs y conectores compatibles.

Cacheo y persistencia de RDDs.

Storage Levels.

Establecimiento de puntos de control mediante checkpoint.

Lineage y recuperación ante pérdida de particiones.

RDDs numéricos y operaciones estadísticas básicas.

Riesgos de enviar grandes cantidades de información al Driver.

Introducción a los RDD Clave-Valor en Spark.

Creación de RDD Clave-Valor.

Introducción a las bases del uso de Clave-Valor.

Transformación `filter`.

`mapValues`.

`flatMapValues`.

`reduceByKey`.

`aggregateByKey`.

`combineByKey`.

`groupByKey`.

Diferencias de tráfico y agregación entre `reduceByKey` y `groupByKey`.

`sortByKey`.

CoGrupos.

Control de particionamiento de datos.

HashPartitioner y particionadores personalizados.

Preservación del particionamiento entre determinadas transformaciones.

Operaciones Join.

Shuffles provocados por operaciones Clave-Valor.

Serialización personalizada.

Casos donde un DataFrame agregado proporciona una solución más optimizable que un Pair RDD.

Introducción a GraphX y al procesamiento distribuido de grafos.

Conceptos de vértice, arista, propiedades y grafo dirigido.

Operadores GraphX.

Usos reales de GraphX.

Configuración y puesta en marcha.

Construcción de grafos desde colecciones y RDD.

Algoritmos de GraphX.

PageRank.

Connected Components.

Triangle Count.

Pregel API para procesamiento iterativo de grafos.

GraphX builders.

VertexRDD.

EdgeRDD.

Transformación y filtrado de grafos.

Agregación de mensajes entre vértices.

Subgrafos y operaciones estructurales.

Integración de resultados de GraphX con otras APIs de Spark.

Buenas prácticas y criterios para valorar librerías de grafos externas cuando GraphX no cubre el caso de uso.

Por qué no se comparten variables locales de forma convencional entre Driver y Executors.

Serialización de closures y variables utilizadas dentro de funciones distribuidas.

Transmisión de variables mediante Broadcast Variables.

Casos de uso apropiados para variables broadcast.

Distribución eficiente de información de solo lectura a los executors.

Diferencias entre una Broadcast Variable y un Broadcast Join.

Liberación de recursos asociados a variables broadcast.

Acumuladores.

Acumuladores numéricos.

Uso de acumuladores para métricas y contadores distribuidos.

Limitaciones de los acumuladores dentro de transformaciones reejecutables.

Accumulators en tareas que pueden volver a ejecutarse.

Acumuladores personalizados.

Visibilidad de acumuladores desde herramientas de monitorización cuando corresponda.

Buenas prácticas para evitar utilizar variables compartidas como sustituto de un diseño distribuido correcto.

Modos de ejecución y diferencias entre local y cluster.

Introducción al ciclo de vida de una aplicación Spark desde fuera.

Fase de petición de cliente.

Comunicación con el Cluster Manager.

Fases de iniciación y asignación de recursos.

Creación del Driver.

Creación de Executors.

Envío del código de la aplicación a los executors.

Fase de ejecución.

Fase de terminación y liberación de recursos.

Introducción al ciclo de vida de una aplicación Spark desde dentro de Spark.

La sesión de Spark.

Las instrucciones lógicas y Lazy Evaluation.

El Job de Spark.

Las fases o Stages.

Las Tasks.

Particiones y correspondencia habitual con Tasks.

Shuffles como fronteras habituales entre Stages.

Detalles de ejecución visibles desde Spark UI.

Diferencias entre Driver y Executor failures.

Introducción a Dynamic Resource Allocation sin entrar todavía en tuning avanzado.

Estructura de los proyectos.

Estructura de proyectos PySpark.

Maven y SBT en proyectos Scala o Java.

¿Dónde se pueden desplegar las aplicaciones de Spark?

`spark-submit`.

Parámetros principales de `spark-submit`.

Empaquetado de aplicaciones.

Distribución de dependencias Python y JVM.

On-premise Clusters vs Cloud.

Introducción a los cluster managers.

Modo Standalone.

Spark con YARN.

Configuración de Spark con aplicaciones YARN.

Spark sobre Kubernetes.

Diferencias generales entre YARN y Kubernetes.

Eliminación de Apache Mesos del planteamiento actual al no formar parte de los cluster managers documentados para Spark moderno.

Client Mode frente a Cluster Mode.

Configuraciones para desarrollo seguro.

Configuraciones para redes de clusters.

Autenticación, autorización y cifrado a nivel introductorio.

Estrategias de replicación asociadas al almacenamiento y no al motor Spark en sí.

Creación o aprovisionamiento de un cluster.

Lanzamiento de trabajos.

Monitorización de clusters.

Particionamiento y distribución del trabajo.

Buenas prácticas de despliegue y externalización de configuración.

Monitorización de Spark jobs.

Interfaz Web de Spark.

Acceso a la UI del Driver durante la ejecución.

Jobs.

Stages.

Tasks y distribución de tiempos de ejecución.

Executors.

Storage.

SQL.

Structured Streaming.

Environment y comprobación de configuración efectiva.

Visualizando aplicaciones de Spark con interfaces web.

DAG Visualization.

Análisis de tareas fallidas.

Shuffle Read y Shuffle Write.

Input y Output metrics.

Los logs en las aplicaciones de Spark.

Log4j2 en Spark.

Event Logs.

Spark History Server para consultar aplicaciones finalizadas.

Introducción a los sistemas de métricas de Spark y su integración con herramientas externas.

Diferencia entre observar la aplicación Spark y observar también la infraestructura subyacente.

Técnicas de optimización y necesidad de medir antes de modificar configuraciones.

Uso y gestión de la memoria.

Almacenamiento de datos en caché de memoria.

Cuándo utilizar `cache` y `persist`.

Eliminación del cache mediante `unpersist`.

Selección adecuada del número de particiones.

Evitar particiones excesivamente pequeñas o excesivamente grandes.

Reducción de datos lo antes posible mediante filtros y selección de columnas.

Predicate pushdown y column pruning.

Sugerencias combinadas para consultas SQL.

Broadcast de tablas pequeñas en joins adecuados.

Evitar UDF cuando una función nativa permite expresar la misma lógica.

Adaptive Query Execution.

Coalescing adaptativo de particiones después de un shuffle.

Tratamiento automático básico de skew.

Ejecución de consultas adaptables.

Formatos columnares como Parquet y ORC para cargas analíticas.

Efecto del tamaño y número de archivos sobre planificación y lectura.

Uso razonado de `repartition` y `coalesce`.

Interpretación inicial de `explain` antes de realizar cambios de rendimiento.

Entorno distribuido y diferencias respecto a depurar una aplicación local convencional.

Pruebas en un entorno distribuido.

Problemas característicos de un entorno distribuido.

Separación de lógica pura y lógica dependiente de Spark para facilitar el testing.

Testing en aplicaciones Spark.

Tipos de test.

Tests unitarios sobre funciones y transformaciones.

Tests de integración mediante SparkSession local.

Creación de DataFrames pequeños y deterministas para pruebas.

Comparación de esquemas.

Comparación de resultados.

Testing de lectura y escritura.

Testing de pipelines de datos.

Testing básico de Structured Streaming.

Métodos de test en Spark.

Debugging en aplicaciones Spark.

Diferencia entre errores producidos en Driver y Executors.

Stack traces distribuidos.

Errores de serialización.

Errores de memoria.

Errores derivados de datos problemáticos.

Uso de logs, Spark UI y planes de ejecución durante el diagnóstico.

Reproducibilidad de fallos antes de modificar la aplicación.

Introducción a MLlib.

Diferencia entre la API moderna `spark.ml` basada en DataFrames y las APIs RDD de `spark.mllib` en modo mantenimiento.

Fundamentos de MLlib.

Features y labels.

Transformers.

Estimators.

Models.

Pipelines.

Preparación de características con VectorAssembler y otros transformers.

Entrenamiento y evaluación.

Persistencia y aplicación de modelos.

Creación de un sistema de Machine Learning con MLlib.

Regresión Lineal con MLlib.

Regresión logística.

Árboles de decisión.

Bosques aleatorios.

Gradient-Boosted Trees.

Clustering mediante algoritmos disponibles en MLlib.

DataFrames con MLlib.

Métricas para clasificación y regresión.

Evaluators.

TrainValidationSplit y CrossValidator a nivel introductorio.

Guardado y carga de Pipelines y Models.

Criterios para decidir si Spark es necesario para el volumen del problema de Machine Learning.

Planes de ejecución.

Uso de `explain` para comprender cómo Spark pretende resolver una consulta.

Diferencia entre plan lógico y plan físico a nivel introductorio.

Detectando un Shuffle en un procesamiento.

Operadores `Exchange` como señal de redistribución de datos.

Probando operaciones que puedan causar un Shuffle.

Joins como fuente habitual de shuffle.

Agrupaciones y agregaciones como fuente habitual de shuffle.

Repartición y ordenaciones globales.

Cambiando el diseño de trabajos con dependencias amplias.

Uso de agregaciones parciales para reducir movimiento de datos.

Usando operaciones keyBy o estructuras clave-valor cuando el problema realmente lo requiere.

Usando particionadores personalizados en RDD.

Detectando Data Skew.

Tasks significativamente más lentas que el resto.

Particiones desequilibradas.

Detectando problemas de memoria.

Detectando spills a disco.

Detectando problemas de serialización.

Fetch failures y errores relacionados con shuffle.

Detección de exceso de archivos pequeños.

Diferenciación entre problema de aplicación, datos, configuración, almacenamiento e infraestructura.

Serialización de objetos en RDD.

Java Serialization frente a Kryo en aplicaciones JVM cuando resulte apropiado.

Configuraciones de Clusters.

Elección de diseño.

Programación y utilización preferente de funciones optimizables.

Shuffle de configuraciones.

Número de particiones de shuffle.

Recolector de basura.

Gestión de la memoria.

Memoria del Driver.

Memoria de los Executors.

Memory Overhead.

Paralelismo.

Número de cores por executor.

Tamaño de las particiones.

Mejoras en el filtrado.

Repartición.

Uso de `coalesce`.

Funciones definidas por el usuario.

Funciones integradas frente a UDF.

Cacheo de datos de forma temporal.

Uniones.

Agregaciones.

Transmisión de variables.

Broadcast Join frente a Broadcast Variable.

Configuración de recursos según características de CPU, memoria, red e I/O.

Evitar tuning prematuro sin analizar Spark UI, métricas y planes.

Introducción a la relación entre coste, rendimiento y recursos utilizados.

Recomendaciones de programación paralela.

Diseñar transformaciones pensando en datos distribuidos y no como si se tratara de colecciones locales.

Inmutabilidad.

Uso de lambdas.

Evitar closures excesivamente grandes.

Bucles y criterios para sustituir procesamiento local por operaciones distribuidas.

Uso de funciones dentro de DataFrames.

Priorizar funciones nativas de Spark SQL cuando exista una equivalente adecuada.

Evitar `collect` salvo cuando el volumen que llega al Driver está controlado.

Evitar conversiones innecesarias entre RDD y DataFrame.

Gestionar correctamente particiones, persistencia y recursos.

Especificaciones y diferencias de PySpark.

Python 3.10+ en las distribuciones actuales de PySpark.

Integración con pandas mediante Apache Arrow.

Pandas API on Spark y diferencias frente a pandas local.

Cuándo utilizar PySpark frente a pandas.

Especificaciones de Scala y uso de Scala 2.13 en Spark 4.

Particularidades de Java dentro de las APIs Spark.

Datasets tipados en Scala y Java.

Spark Connect como alternativa moderna para determinadas aplicaciones cliente.

Especificaciones y diferencias de R con Spark.

SparkR como tecnología deprecada que debe evitarse como elección principal para nuevos proyectos.

Gestión de dependencias y versiones según Python, Scala o Java.

Configuración externalizada frente a parámetros hardcoded.

Código reproducible, modular y preparado para pasar posteriormente a pruebas, despliegue y operación.

Introducción a Spark Declarative Pipelines como evolución actual para determinados pipelines batch y streaming, dejando su arquitectura profunda para la formación avanzada.

Criterios finales para seleccionar DataFrame, Dataset, SQL o RDD sin perder las capacidades de optimización del motor.