Apache Spark

Spark Core es la base del proyecto general. Proporciona despacho de tareas distribuidas, programación y funcionalidades básicas de E/S , expuestas a través de una interfaz de programación de aplicaciones (para Java , Python , Scala , .NET ^{[ 16 ]} y R ) centrada en la abstracción RDD (la API de Java está disponible para otros lenguajes de JVM, pero también es utilizable para algunos otros lenguajes que no son de JVM que pueden conectarse a la JVM, como Julia ^{[ 17 ]} ). Esta interfaz refleja un modelo de programación funcional / de orden superior : un programa "controlador" invoca operaciones paralelas como map, filter o reduce en un RDD pasando una función a Spark, que luego programa la ejecución de la función en paralelo en el clúster. ^{[ 2 ]} Estas operaciones, y otras adicionales como joins , toman RDDs como entrada y producen nuevos RDDs. Los RDDs son inmutables y sus operaciones son perezosas ; La tolerancia a fallos se logra mediante el seguimiento del "linaje" de cada RDD (la secuencia de operaciones que lo generaron) para que pueda reconstruirse en caso de pérdida de datos. Los RDD pueden contener cualquier tipo de objeto de Python, .NET, Java o Scala.

Además del estilo de programación funcional orientado a RDD, Spark proporciona dos formas restringidas de variables compartidas: las variables de difusión hacen referencia a datos de solo lectura que deben estar disponibles en todos los nodos, mientras que los acumuladores se pueden usar para programar reducciones en un estilo imperativo . ^{[ 2 ]}

Un ejemplo típico de programación funcional centrada en RDD es el siguiente programa en Scala que calcula las frecuencias de todas las palabras que aparecen en un conjunto de archivos de texto e imprime las más comunes. Cada map , flatMap (una variante de map ) y reduceByKey toma una función anónima que realiza una operación simple sobre un solo elemento de datos (o un par de elementos) y aplica su argumento para transformar un RDD en un nuevo RDD.

organización de importación . apache . chispa .{ SparkConf , SparkContext }import org.apache.spark.rdd.RDD​​​​​​​​val conf : SparkConf = new SparkConf (). setAppName ( "wiki_test" ) // crea un objeto de configuración de Sparkval sc : SparkContext = new SparkContext ( conf ) // Crea un contexto de Sparkval data : RDD [ String ] = sc . textFile ( "/path/to/somedir" ) // Lee los archivos de "somedir" en un RDD de pares (nombre de archivo, contenido).val tokens : RDD [ String ] = data . flatMap ( _ . split ( " " )) // Divide cada archivo en una lista de tokens (palabras).val wordFreq : RDD [( String , Int )] = tokens . map (( _ , 1 )). reduceByKey ( _ + _ ) // Agrega un conteo de uno a cada token, luego suma los conteos por tipo de palabra.val topWords : Array [( Int , String )] = wordFreq . sortBy ( s => - s . _2 ). map ( x => ( x . _2 , x . _1 )). top ( 10 ) // Obtener las 10 palabras principales. Intercambiar palabra y recuento para ordenar por recuento.

PySpark es la API de Python para Apache Spark, introducida en Spark 0.7, publicada en febrero de 2013. ^{[ 18 ]} Permite escribir aplicaciones Spark en Python y proporciona una consola interactiva para análisis exploratorio. El código PySpark se ejecuta bajo el entorno de ejecución estándar CPython y puede llamar a bibliotecas nativas de Python como NumPy y SciPy ; la comunicación entre el código de usuario de Python y el núcleo de Spark basado en JVM se ha gestionado históricamente mediante la biblioteca Py4J . ^{[ 18 ] [ 19 ]}

PySpark proporciona interfaces de Python para la mayoría de los componentes de Spark, incluidos Spark Core, Spark SQL y la API de DataFrame, Structured Streaming y MLlib ; desde Spark 4.1 también expone la API de Spark Declarative Pipelines. ^{[ 19 ]}

Una API compatible con pandas, conocida como pandas API on Spark , se integró en PySpark en Apache Spark 3.2.0, lanzado en octubre de 2021. Proporciona equivalentes a la API de análisis de datos de pandas que se ejecutan en el motor Spark, lo que permite ejecutar código al estilo de pandas en datos distribuidos. ^{[ 20 ] [ 21 ]} El componente se originó como Koalas, un proyecto independiente de código abierto publicado por Databricks en 2019, que posteriormente se fusionó con PySpark. ^{[ 21 ]}

PySpark también proporciona un cliente para Spark Connect, una arquitectura cliente-servidor que permite la conectividad remota a clústeres de Spark desde aplicaciones PySpark. ^{[ 19 ]}

Un programa típico de PySpark utiliza una SparkSession para cargar datos como un DataFrame y aplicar transformaciones:

from pyspark.sql import SparkSessionspark = SparkSession . builder . appName ( "example" ) . getOrCreate ()df = spark.read.json ( " path / to/people.json" ) df.groupBy ( " age " ) . count () . show ( )

Spark SQL es un componente sobre Spark Core que introdujo una abstracción de datos llamada DataFrames, ^{[ a ]} que proporciona soporte para datos estructurados y semiestructurados . Spark SQL proporciona un lenguaje específico de dominio (DSL) para manipular DataFrames en Scala , Java , Python o .NET . ^{[ 16 ]} También proporciona soporte para el lenguaje SQL, con interfaces de línea de comandos y servidor ODBC / JDBC . Aunque los DataFrames carecen de la comprobación de tipos en tiempo de compilación que ofrecen los RDD, a partir de Spark 2.0, el DataSet fuertemente tipado también es totalmente compatible con Spark SQL.

import org.apache.spark.sql . { DataFrame , SparkSession }​​​​​val url : String = "jdbc:mysql://tuIP:tuPuerto/test?user=tuNombreDeUsuario;password=tuContraseña" // URL para tu servidor de base de datos. val spark : SparkSession = SparkSession.builder (). getOrCreate ( ) // Crea un objeto de sesión de Sparkval df : DataFrame = spark . read . format ( "jdbc" ) . option ( "url" , url ) . option ( "dbtable" , "people" ) . load ()df.printSchema () // Examina el esquema de este DataFrame. val countsByAge : DataFrame = df.groupBy ( " age " ) . count () // Cuenta personas por edad

O alternativamente mediante SQL:

df . createOrReplaceTempView ( "people" ) val countsByAge : DataFrame = spark . sql ( "SELECT age, count(*) FROM people GROUP BY age" )

Spark Declarative Pipelines (SDP) es un marco declarativo para definir y ejecutar pipelines de extracción, transformación y carga (ETL) de datos, añadido en Apache Spark 4.1.0, que se publicó el 16 de diciembre de 2025. ^{[ 23 ] [ 24 ]} Los desarrolladores declaran los conjuntos de datos que debe producir un pipeline y las consultas que los definen, en lugar de escribir código imperativo que especifique cómo se calcula cada conjunto de datos y en qué orden; Spark construye un grafo de flujo de datos y gestiona el orden de dependencias, el paralelismo, los puntos de control y los reintentos. ^{[ 23 ] [ 25 ]}

El marco extiende el modelo de ejecución declarativa y perezosa de Spark, aplicado previamente a consultas individuales mediante Spark SQL , a canalizaciones que abarcan múltiples conjuntos de datos. ^{[ 25 ]} Las canalizaciones se definen en SQL o Python y se organizan en torno a tablas de transmisión y vistas materializadas, con las transformaciones subyacentes expresadas como "flujos"; los cálculos por lotes y de transmisión se pueden combinar dentro de una única canalización. ^{[ 25 ] [ 26 ]}

Una canalización que utiliza la sintaxis puede declarar una tabla de transmisión que ingiere registros y una vista materializada que los agrega, utilizando la API de Python: ^{[ 26 ]}

from pyspark import pipelines as dp@dp . table def orders (): return spark . readStream . table ( "orders_source" )@dp . materialized_view def daily_orders_by_state (): return ( spark . table ( "orders" ) . groupBy ( "state" , "order_date" ) . count ())

Los mismos conjuntos de datos se pueden definir en SQL: ^{[ 26 ]}

CREATE STREAMING TABLE orders AS SELECT * FROM STREAM orders_source ;CREATE MATERIALIZED VIEW daily_orders_by_state AS SELECT state , order_date , count ( * ) AS order_count FROM orders GROUP BY state , order_date ;

Spark Structured Streaming utiliza la capacidad de programación rápida de Spark Core para realizar análisis de transmisión . Ingiere datos en micro-lotes y realiza transformaciones RDD en esos micro-lotes de datos. Este diseño permite que el mismo conjunto de código de aplicación escrito para análisis por lotes se utilice en análisis de transmisión, lo que facilita la implementación de la arquitectura lambda . ^{[ 27 ] [ 28 ]} Sin embargo, esta conveniencia conlleva la penalización de una latencia igual a la duración del mini-lote. Otros motores de datos de transmisión que procesan evento por evento en lugar de en micro-lotes incluyen Storm y el componente de transmisión de Flink . ^{[ 29 ]} Spark Streaming tiene soporte integrado para consumir desde Kafka , Flume , Twitter , ZeroMQ , Kinesis y sockets TCP/IP . ^{[ 30 ]}

En Spark 2.x, también se proporciona una tecnología separada basada en Datasets, llamada Structured Streaming, que tiene una interfaz de nivel superior para admitir el streaming. ^{[ 31 ]}

Apache Spark 4.x añadió un modelo de ejecución en modo de tiempo real (RTM) para Structured Streaming, con el objetivo declarado de reducir la latencia de extremo a extremo para admitir cargas de trabajo operativas y por lotes en un solo motor. ^{[ 23 ] [ 24 ] [ 32 ]} Las consultas de Structured Streaming existentes escritas contra las API de DataFrame y Dataset se pueden ejecutar en el nuevo modo sin modificar la consulta. ^{[ 32 ]}

Spark se puede implementar tanto en un centro de datos local tradicional como en la nube . ^{[ 33 ]}

Spark Connect es una arquitectura cliente-servidor desacoplada para Apache Spark que permite que las aplicaciones remotas se conecten a un clúster de Spark desde cualquier entorno. Se introdujo en Apache Spark 3.4, lanzado en abril de 2023. ^{[ 34 ]} Esta arquitectura separa la aplicación cliente del controlador de Spark, que históricamente se ejecutaban en el mismo proceso. Con Spark Connect, el cliente es una biblioteca ligera que se puede integrar en servidores de aplicaciones, IDE , notebooks y otros entornos de programación. ^{[ 34 ]}

El cliente Spark Connect traduce las operaciones de DataFrame en planes de consulta lógica sin resolver, los codifica usando Protocol Buffers y los transmite al servidor Spark a través del marco gRPC ; el servidor traduce estos planes a los operadores de planes lógicos de Spark y los ejecuta a través de la canalización de ejecución estándar de Spark. Los resultados se envían de vuelta al cliente como lotes de filas codificados en Apache Arrow . ^{[ 34 ] [ 35 ]}

Las aplicaciones PySpark se conectan a un servidor Spark Connect especificando una URL remota al crear una sesión de Spark:

from pyspark.sql import SparkSessionspark = SparkSession . builder . remote ( "sc://localhost:15002" ) . getOrCreate ()

La compatibilidad de PySpark con Spark Connect se añadió en Spark 3.4, y la compatibilidad con clientes Scala se añadió en Spark 3.5; en versiones posteriores se han desarrollado clientes adicionales para lenguajes como Go , Swift y Rust . ^{[ 34 ]}

Spark MLlib es un marco de aprendizaje automático distribuido sobre Spark Core que, debido en gran parte a la arquitectura Spark basada en memoria distribuida, es hasta nueve veces más rápido que la implementación basada en disco utilizada por Apache Mahout (según las pruebas comparativas realizadas por los desarrolladores de MLlib contra las implementaciones de mínimos cuadrados alternos (ALS), y antes de que Mahout obtuviera una interfaz Spark), y escala mejor que Vowpal Wabbit . ^{[ 36 ]} Muchos algoritmos comunes de aprendizaje automático y estadísticos se han implementado y se incluyen con MLlib, lo que simplifica las canalizaciones de aprendizaje automático a gran escala , incluyendo:

• estadísticas descriptivas , correlaciones , muestreo estratificado , prueba de hipótesis , generación aleatoria de datos ^{[ 37 ]}
• Clasificación y regresión : máquinas de vectores de soporte , regresión logística , regresión lineal , clasificación bayesiana ingenua , árbol de decisión , bosque aleatorio , árbol potenciado por gradiente
• técnicas de filtrado colaborativo , incluyendo mínimos cuadrados alternados (ALS)
• métodos de análisis de clústeres, incluidos k-means y la asignación latente de Dirichlet (LDA).
• técnicas de reducción de dimensionalidad como la descomposición en valores singulares (SVD) y el análisis de componentes principales (PCA)
• funciones de extracción y transformación de características
• algoritmos de optimización como el descenso de gradiente estocástico , BFGS de memoria limitada (L-BFGS)

GraphX ​​es un marco de procesamiento de grafos distribuidos sobre Apache Spark. Debido a que se basa en RDD, que son inmutables, los grafos también lo son y, por lo tanto, GraphX ​​no es adecuado para grafos que necesitan ser actualizados, y mucho menos de manera transaccional como una base de datos de grafos . ^{[ 38 ]} GraphX ​​proporciona dos API separadas para la implementación de algoritmos masivamente paralelos (como PageRank ): una abstracción Pregel y una API más general de estilo MapReduce. ^{[ 39 ]} A diferencia de su predecesor Bagel, que fue formalmente obsoleto en Spark 1.6, GraphX ​​tiene soporte completo para grafos de propiedades (grafos donde las propiedades pueden adjuntarse a aristas y vértices). ^{[ 40 ]}

Al igual que Apache Spark, GraphX ​​comenzó inicialmente como un proyecto de investigación en AMPLab y Databricks de UC Berkeley, y posteriormente fue donado a la Apache Software Foundation y al proyecto Spark. ^{[ 41 ]}

Apache Spark tiene soporte integrado para Scala, Java, SQL, R, Python y Swift con soporte de terceros para .NET CLR, ^{[ 42 ]} Julia, ^{[ 43 ]} y más.

Spark 3.5.2 se basa en Scala 2.13 (y por lo tanto funciona con Scala 2.12 y 2.13 sin necesidad de configuración adicional), pero también se puede hacer que funcione con Scala 3. ^{[ 59 ]}

Apache Spark es desarrollado por una comunidad. El proyecto es administrado por un grupo llamado "Comité de Gestión de Proyectos" (PMC). ^{[ 60 ]}

Las ramas de lanzamiento de nuevas funcionalidades, por lo general, recibirán mantenimiento junto con las correcciones de errores durante un período de 18 meses. Por ejemplo, la rama 2.3.x dejó de recibir mantenimiento en septiembre de 2019, 18 meses después del lanzamiento de la versión 2.3.0 en febrero de 2018. No se esperan más lanzamientos de la versión 2.3.x después de esa fecha, ni siquiera para correcciones de errores.

La última versión menor dentro de una versión principal a normalmente se mantendrá durante más tiempo como una versión "LTS". Por ejemplo, la versión 2.4.0 se lanzó el 2 de noviembre de 2018 y se mantuvo durante 31 meses hasta que se lanzó la versión 2.4.8 en mayo de 2021. La versión 2.4.8 es la última y no se esperan más versiones 2.4.x, ni siquiera para correcciones de errores. ^{[ 61 ]}