1. Apache Spark

Big Data
Fundamentals
Apache Spark
Big Data Fundamentals
Apache Spark
Índice
1. Introducción a Apache Spark ..................................................... 3

1.1. Necesidad .............................................................................. 3
2. ¿Cómo funciona Spark? ............................................................ 6
3. Ejecución de Spark .............................................................. 15
4. pr ................................................. ¡Error! Marcador no definido.
5. imer nivel ....................................... ¡Error! Marcador no definido.
© Copyright Universidad Europea. Todos los derechos reservados. 2

Apache Spark
1. Introducción a Apache Spark

Apache Spark es un framework opensource de computación de datos en cluster, con
paralelismo de datos implícito y tolerancia a fallos.
Esto es, un framework que permite realizar programación distribuida, sobre un grupo
de máquinas interconectadas que se reparten el trabajo y procesan los datos
simultáneamente, aunque también podemos ejecutar Spark de manera local o en un
solo nodo.
En la arquitectura está además incluída un sistema de recuperación automática de

fallos.
El framework expone unas APIs para Java, Python, Scala y R, además de tener varios
proyectos relacionados, de los que hablaremos más adelante:
1.1. Necesidad
Spark surge de la necesidad de procesar un gran volumen de datos para el cual una
sola máquina no es suficiente.

Apache Spark
Hemos visto previamente la solución que aporta el ecosistema Hadoop: MapReduce
Que consistía en:
• El almacenamiento de datos en sistema de archivos distribuido (HDFS)
• Una serie de operaciones de mapeo y reducción con los que íbamos

realizando los cálculo que buscábamos (MapReduce)
• Intercambio de información entre nodos del cluster a través del envío por
red
Este sistema tiene varios inconvenientes, el más importante de todos la cantidad de

accesos a disco que requiere, para buscar, acceder y escribir información
Iteratio Iteratio
…
n1 n2

Apache Spark
En cada iteración se realizan multitud de operaciones sobre los mismos datos, que
implican acceder a disco:
• Descubrir en qué discos de HDFS se encuentran los datos que necesita una etapa
• Recuperar esos datos
• Escribir las salidas del procesado
• Actualizar la información de dónde se localizan estas salidas
Spark plantea una alternativa a estos accesos a disco: usar la memoria de los distintos
nodos del cluster:
Haciendo solo dos accesos a disco: al principio para leer la información, y al final de
todo el proceso, para escribir las salidas.
Esto tiene muchas ventajas:
• La lectura/escritura a memoria es mucho más rápida que la lectura/escritura

a disco
• Almacenamos en HDFS solo entradas iniciales y salidas últimas, pero no

resultados temporales de etapas intermedias.
• Al tener datos en memoria local de cada nodo, mantenemos más información

de datos disponibles y cacheados de datos, acelerando muchas operaciones.
• Incluso habrá tareas que podremos operar de forma local, sin accesos a disco
ni conexiones con otros nodos, acelerando de nuevo.

Apache Spark
Por supuesto, también hay algunos contras:
• Seguimos necesitando envío de datos por red para intercambiar información

entre los nodos
• Es más susceptible a errores de memoria
• Habrá determinados escenarios en los que tengamos que seguir recurriendo a

almacenar los datos a disco, porque sean tan masivos que no entren en
memoria.
Este enfoque ha demostrado ser muchísimo más eficiente que MapReduce. En esta
tabla vemos la comparativa entre Hadoop y Spark al realizar una regresión logística.
Salvo la primera iteración, en la que Spark hace la lectura de HDFS y la escritura a
memoria de los datos, las siguientes operaciones son dramáticamente más rápidas en
Spark, al no tener que volver a realizar ninguna acción sobre HDFS hasta la última
iteración, donde escribe los resultados finales.
Es por esto que Spark se considera como el sucesor de MapReduce para el

procesamiento de datos, porque conceptualmente comparte muchas ideas, pero
aporta bastantes ventajas.
2. ¿Cómo funciona Spark?

Para entender el funcionamiento de Spark, necesitamos ir haciendo un repaso de sus
componentes:
2.1. Redundant Distributed Dataset (RDD)
Como hemos comentado, Apache Spark surge para procesar datos de forma distribuida
entre varias máquinas de un cluster. En Spark, esos datos se encuentran en un formato
llamado Redundant Distributed Dataser: RDD

Apache Spark
Un RDD es una colección de registros tolerante a fallos, de solo lectura y particionada.

Desde una perspectiva de diseño, se buscaba una abstracción de estructura de datos
única, que ocultase la complejidad de tratar con una amplia variedad de fuentes de
datos, ya sea HDFS, sistemas de archivos, RDBMS, estructuras de datos NoSQL o
cualquier otra fuente de datos.
El usuario debería ser capaz de definir el RDD a partir de cualquiera de estas fuentes,
incluso combinándolas en un único RDD.
Cada partición del RDD sabe cómo recrearse en caso de falla, puesto que tiene el
registro de transformaciones, o un histórico que le permite recrearse desde un
almacenamiento estable u otro RDD.
Por lo tanto, cualquier programa que use Spark tiene garantizada la tolerancia a fallos,
independientemente de la fuente de datos subyacente y del tipo de RDD.
Como hemos dicho anteriormente, estos RDDs realmente se almacenan en la memoria

de los nodos del cluster (generamente, como resultados intermedios de las etapas de
transformación de los datos), salvo que no entren en la memoria, en cuyo caso la
porción restante se almacenará en el disco duro automáticamente. La salida última
final, así como las entradas iniciales de los datos, pueden leerse/escribirse de
múltiples fuentes (típicamente, HDFS).

Apache Spark
Sobre estos RDDs se realizan operaciones y transiciones que van transformándolos

hasta el resultado final.
2.2. Operaciones en Spark
Existen dos tipos de operaciones en Spark:
• Transformaciones: Reciben un RDD y generan otro RDD como resultado. Tienen

además una ejecución diferida (lazy execution): no se ejecutan inmediatamente
en el momento que aparecen, si no que se van “anotando” en un listado de
pasos a ejecutar cuando llegue el momento (una acción)
• Acciones: Reciben un RDD y devuelven un valor concreto. Se ejecutan en el

momento que aparecen (eager execution), desencadenando la ejecución de
todas las transformaciones previsa que fueron “anotadas” hasta ese momento.
Ésta acción es la que

realmente desencadena la
ejecución desde el inicio
Los RDDs son estructuras de datos inmutables (de solo lectura), por lo que las
transformaciones dan como resultado la creación de nuevos RDDs. La ejecución
diferida permite además optimizar muchísimo los pasos de transformación. Por
ejemplo, si la acción es devolver una única línea, Spark solo computa una partición e
ignora el resto de información.
Veamos un ejemplo de código, sobre pySpark (con la API de Python):

Apache Spark
even_names_rdd = clients_rdd. \
filter(lambda c: c[0] % 2 == 0). \
map(lambda c: c[1])
Filter y map son transformaciones, así que este código, que selecciona los nombres en
posición impar y genera un nuevo RDD, se ejecuta en milisegundos ya que realmente
no ejecuta nada aún (no hay acciones, sólo transformaciones). Sólo registra los pasos
en el plan de ejecución del rdd pero sin llevarlas a cabo. Cada transformación retorna
otro RDD.
En vez de generar otro RDD, contemos el número de nombres:
even_names_count = clients_rdd. \
map(lambda c: c[1]). \
count()
print(even_names_count)
Al llegar a la acción del count, se desencadenan todas las operaciones pendientes.

‘Filter’ y ‘map’ se realizarán de forma distribuida (cada nodo las ejecuta sobre sus
datos disponibles). El ‘count’ (acción) se realiza en el driver, recolectando en su
memoria local el resultado de la acción. Ojo: la ejecución la desencadena al llegar al
‘count’, no en el print.

Apache Spark
2.3. Transformaciones
Echémosle un ojo a las operaciones de transformación más comunes ofrecidas por el

modelo de programación de Apache Spark. Entre paréntesis, los parámetros de entrada
que necesitan (entre corchetes si son opcionales):
• Map (func)
Devolución de un nuevo conjunto de datos distribuido formado a través de aplicar a

cada elemento de la fuente la función func.
• Filter (func)
Devuelve un nuevo conjunto de datos formado por la selección de aquellos elementos

de la fuente en la que func devuelve true.
• FlatMap (func)
Al igual que en map, pero cada elemento de entrada se puede asignar a 0 o más
elementos de salida (func debe devolver una Sec en lugar de un solo elemento).
• MapPartitions (func)
Similar a map, pero corre por separado en cada partición (bloque) del RDD, por lo que
func debe ser de tipo Iterator < T> = > Iterator < U> cuando se ejecuta en un RDD
(Redundant Distributed Dataset) de tipo T.
• MapPartitionsWithIndex (func)
Similar a mapPartitions, pero también proporciona func con un valor entero que
representa el índice de la partición, así que func debe ser de tipo (Int , Iterator < T>)
= > Iterator < U> cuando se ejecuta en un RDD de tipo T.
• Sample (withReplacement, fraction, seed)
Muestra una fracción de los datos, con o sin sustitución, utilizando una semilla de
números aleatorios dado. Siguiendo con las operaciones de transformación, se pueden
destacar las siguientes:
• Union (otherDataset)
Devuelve un nuevo conjunto de datos que contiene la unión de los elementos en el

conjunto de datos de origen y el argumento pasado.
• Intersection (otherDataset)
Devolución de un nuevo RDD que contiene la intersección de elementos en el conjunto

de datos de origen y el argumento.
• Distinct ([numTasks])
Devuelve un nuevo conjunto de datos que contiene los elementos distintos del
conjunto de datos de origen.

Apache Spark
• GroupByKey ([numTasks])
Cuando se llama sobre un conjunto de pares (K, V), devuelve un conjunto de datos de
pares (K, iterable < V >). Si se está agrupando a fin de realizar una agregación (como
una suma o promedio) sobre cada clave, usando reduceByKey o combineByKey, se
obtendrá mucho mejor rendimiento. Por defecto, el nivel de paralelismo en la salida
depende del número de particiones de la RDD (Redundant Distributed Dataset) padre.
Se puede pasar un argumento numTasks opcionales para establecer un número
diferente de tareas.
• ReduceByKey(func, [numTasks])
Cuando se llama sobre un conjunto de datos de pares (K, V), devuelve un conjunto de
datos de pares (K, V), donde los valores con la misma clave K de cada tupla, se aplica
una operación de reducción (por ejemplo, suma) utilizando la función func, que debe
ser del tipo (V, V) => V. Como en groupByKey, el número de reduciones en las tareas
se puede configurar a través de un segundo argumento opcional.
• AggregateByKey (zeroValue) (seqOp, combOp, [numTasks])
Cuando se llama a un conjunto de pares (K, V), devuelve un conjunto de pares (K, T),
donde los valores para cada clave se agregan utilizando las funciones dadas de
combinación y un neutral valor cero. Permite un tipo de valor agregado que es
diferente al tipo de valor de entrada, evitando al mismo tiempo las asignaciones
innecesarias. Al igual que en groupByKey, el número de tareas de reducción se pueden
configurar a través de un segundo argumento opcional.
Otras operaciones de transformación del modelo de programación Apache Spark son:
• SortByKey ([ascending], [numTasks])
Cuando se llama sobre un conjunto de pares (K, V), donde K establece el orden, se
devuelve un conjunto de pares (K, V) ordenados por claves en orden ascendente o
descendente, según se especifica en el argumento ascendente boolean. • Join
(otherDataset, [numTasks]) Cuando se llama sobre conjuntos de datos de tipo (k, V) y
(K, W), devuelve un conjunto de datos de pares con todos los pares de elementos para
cada tupla (K, (V, W)). Las combinaciones externas son apoyadas a través de
leftOuterJoin, rightOuterJoin y fullOuterJoin.
• Cogroup (otherDataset, [numTasks])
Cuando se invoca sobre los conjuntos de datos de tipo (K, V) y (K, W), devuelve un
conjunto de datos de pares (K, Iterable < V >, < Iterable W>). Esta operación también
se llama groupWith.
• Cartesian (otherDataset)
Cuando se invoca sobre los conjuntos de datos de los tipos T y U, devuelve un conjunto
de pares (T, U) calculado entre todos los pares de elementos.

Apache Spark
• Coalesce (numPartitions)
Disminuye el número de particiones en el RDD a numPartitions, resulta muy útil para

optimizar las operaciones sobre RDD después de filtrar por un gran conjunto de datos.
• Repartition (numPartitions)
Reordena los datos de la RDD (Redundant Distributed Dataset) al azar para crear, ya
sea más o menos particiones, el equilibrio a través de ellas. Esto siempre baraja todos
los datos en la red.
• RepartitionAndSortWithinPartitions (partitioner)
Reparticiona el RDD según el particionador dado y, dentro de cada partición resultante,

ordena los registros por parte de sus claves. Esto es más eficiente que llamar al reparto
y luego la clasificación dentro de cada partición.
2.4. Acciones
Una vez que se ha creado un RDD (Redundant Distributed Dataset), las diversas
transformaciones se ejecutan solo cuando se invoca una acción sobre él. El resultado
de una acción puede ser: escribir datos en el sistema de almacenamiento o, devolver
al programa del controlador el resultado final de una serie de transformaciones.
Algunas de las acciones más representativas son las siguientes. Entre paréntesis, los
parámetros de entrada que necesitan (entre corchetes si son opcionales):
• Reduce (func)
Agrega los elementos del conjunto de datos, usando una función que toma dos
argumentos y devuelve uno. Solo se aplica sobre RDDs compuestos por tipos básicos.
• Collect ()
Devuelve todos los elementos del conjunto de datos como una matriz en el programa
del controlador (driver). Se usa mejor en subconjuntos de datos suficientemente
pequeños, ya que puede llenar la memoria del controlador
• Count ()
Devuelve la cantidad de elementos en el conjunto de datos.
• CountByValue ()
Devuelve el recuento de cada valor único en este RDD como un mapa local de pares
(valor, recuento).
• First ()
Devuelve el primer elemento del conjunto de datos (similar a take (1).

Apache Spark
• Take (n)
Devuelve una matriz con los primeros n elementos del conjunto de datos.
• SaveAsTextFile (path)
Escribe los elementos del conjunto de datos como un texto. Spark llamará a String en
cada elemento para convertirlo a una línea de texto en el archivo o archivos
resultantes. Al igual que en Hadoop, la carpeta no debe existir, de lo contrario,
obtendremos una excepción durante la ejecución de la acción.
• CountByKey()
Solo disponible en RDDs de tipo (K, V). Devuelve un hashmap de pares (K, Int) con el
recuento de cada clave.
• Foreach (func)
Ejecuta una función (func) en cada elemento del conjunto de datos.
2.5. Caché
Otra de las operaciones clave en un procesado con Spark es el cacheado de los datos:
1. Ya sabemos que la ejecución de las transformaciones se posponen hasta

encontrar una acción, que desencadena la ejecución de todo el flujo de datos
desde el origen.
2. Si nos encontrásemos con otra segunda acción después, se vuelve a ejecutar

todo desde el origen de los datos (aunque parte del camino recorrido sea el
mismo):
map(lambda c: c[1])
even_names_rdd.count()
even_names_rdd.foreach(lambda c: print(c))
Count y foreach son acciones. ¡Esto causa dos ejecuciones desde el

principio!

Apache Spark
Clients data
Ejecución 1 Ejecución 2
Filter even ids
Map names
count foreach(print)
¿Cómo podemos evitarlo? Pidiendo explícitamente que se cachee en

memoria lo ejecutado hasta el punto que decidamos:
map(lambda c: c[1]).\
cache()
even_names_rdd.count()
even_names_rdd.foreach(lambda c: print(c))
Ahora la primera parte sólo se ejecuta una vez, guardando su resultado

en memoria:
Clients data
Ejecución Filter even ids

1
Map names
Ejecución 2 Ejecución 3
count foreach(print)

Apache Spark
3. Ejecución de Spark
Pero todas estas transformaciones y acciones sobre RDDs, ¿cómo se ejecutan?
El componente principal de una aplicación de Spark es el programa de controlador o

“driver program”. Es un proceso que se ejecuta en la máquina virtual de Java (JVM) y
ejecuta la función principal del usuario en él. Tiene un objeto, SparkContext, que es
una conexión con el administrador del clúster subyacente, y es el que se encarga de
intermediar entre los datos distribuidos y los nodos.
Una aplicación Spark se inicia, cuando el driver se inicia y se completa, cuando el

driver se detiene. El driver, a través de una instancia de SparkContext, coordina todos
los procesos dentro de una aplicación Spark.
La arquitectura de ejecución de una aplicación spark sobre un cluster es la siguiente:
• Nodo Driver: Es el nodo del cluster que se encarga de ejecutar las acciones y
las operaciones no distribuidas del programa. De igual forma, es el encargado
de mandar la ejecución de las operaciones distribuidas (transformaciones) a los
workers cuando corresponda (es decir, cuando aparezca una acción).
• Nodos Workers: Se encargan de ejecutar las operaciones distribuidas

(transformaciones) que les encarga el driver sobre la porción de datos del RDD
que tienen disponible. Un nodo worker ejecuta uno o más ejecutores que
pertenecen a una o más aplicaciones de Spark. Consiste en un componente de
administrador de bloque, que se encarga de gestionar los bloques de datos. Los
bloques se pueden almacenar en caché datos RDD, datos mezclados intermedios
o datos de difusión. Cuando la RAM disponible no es suficiente, mueve
automáticamente algunos bloques de datos al disco. La replicación de datos en
los nodos es otra responsabilidad del administrador de bloques.

Apache Spark
3.1. Ejecutores (excutors)
Cada aplicación tiene un conjunto de procesos de ejecutor. Los ejecutores residen en

los nodos trabajadores y se comunican directamente con el controlador, una vez que
el administrador del clúster realiza la conexión. Todos los ejecutores son gestionados
por el contexto de Spark (SparkContext). Un ejecutor es una única instancia de JVM,
que sirve a una única aplicación Spark. Un ejecutor es responsable de administrar el
cálculo a través de tareas, almacenamiento y almacenamiento en caché en cada nodo
trabajador. Puede ejecutar múltiples tareas al mismo tiempo, en función del número
de núcleos asignado.
• Diferencias entre MapReduce y Apache Spark
En MapReduce, la unidad de computación de más alto nivel es la tarea. Una tarea carga
datos, aplica una función de map, la mezcla, aplica una función de reducción y vuelve
a escribir los datos en un almacenamiento persistente. En Spark, la unidad de
computación de más alto nivel es una aplicación. Una aplicación Spark se puede utilizar
para un único trabajo por lotes, una sesión interactiva con múltiples trabajos o un
servidor de larga duración que satisface las solicitudes continuamente. Un trabajo
Spark puede consistir en más que un solo mapa y reducir. MapReduce inicia un proceso
para cada tarea. Por el contrario, una aplicación Spark puede tener procesos que se
ejecutan en su nombre, incluso cuando no está ejecutando un trabajo. Además, se
pueden ejecutar múltiples tareas dentro del mismo ejecutor. Ambos se combinan para
permitir un tiempo de arranque de la tarea extremadamente rápido, así como el
almacenamiento de datos en la memoria, lo que da como resultado un rendimiento de
órdenes de magnitud mucho mayor que el de MapReduce.
3.2. Modelo de ejecución
La ejecución de la aplicación Spark implica conceptos de tiempo de ejecución como el

controlador, el ejecutor, la tarea, el trabajo y el escenario. Comprender estos
conceptos es vital para escribir programas Spark rápidos y de recursos eficientes.

Apache Spark
En el tiempo de ejecución, una aplicación Spark se asigna a un único proceso de
controlador y un conjunto de procesos de ejecutor, distribuidos a través de los hosts
en un clúster.
1. Proceso del controlador
El proceso del controlador gestiona el flujo de trabajo y las tareas programadas,

y está disponible todo el tiempo en que se ejecuta la aplicación.
2. Ejecutores
Los ejecutores son responsables de ejecutar el trabajo, en forma de tareas, así

como también de almacenar cualquier información que se guarde en caché. La
vida útil del ejecutor depende de si la asignación dinámica está habilitada. Un
ejecutor tiene una cantidad de ranuras para ejecutar tareas, y ejecutará
muchas al mismo tiempo a lo largo de su vida útil.
4. Instalación y ejecución de Spark

Hay varias vias para instalar Spark, dependiendo además de la APi que utilicemos
(Scala, Python, Java, R). Por ejemplo, si usamos Python, la manera más sencilla es
instalar la librería pySpark con PIP.
Se pueden ejecutar aplicaciones Spark localmente o distribuidas en un clúster, ya sea

mediante el uso de un shell interactivo o mediante el envío de una aplicación. La
ejecución interactiva de las aplicaciones Spark se realiza comúnmente durante la fase
de exploración de datos y para el análisis ad-hoc.
Mediante la consola interactiva:
$ pyspark
Python 3.7.0 (v3.7.0:1bf9cc5093, Jun 26 2018, 20:42:06)
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
21/06/01 19:30:20 WARN Utils: Your hostname, mac-518969.local resolves
to a loopback address: 127.0.0.1; using 192.168.1.40 instead (on
interface en0)
21/06/01 19:30:20 WARN Utils: Set SPARK_LOCAL_IP if you need to bind
to another address
21/06/01 19:30:21 WARN NativeCodeLoader: Unable to load native-hadoop
library for your platform... using builtin-java classes where
applicable
Using Spark's default log4j profile: org/apache/spark/log4j-
defaults.properties
Setting default log level to "WARN".

Apache Spark
To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use
setLogLevel(newLevel).
21/06/01 19:30:24 WARN Utils: Service 'SparkUI' could not bind on port
4040. Attempting port 4041.
Welcome to
____ __
/ __/__ ___ _____/ /__
_\ \/ _ \/ _ `/ __/ '_/
/__ / .__/\_,_/_/ /_/\_\ version 2.4.3
/_/
Using Python version 3.7.0 (v3.7.0:1bf9cc5093, Jun 26 2018 20:42:06)
SparkSession available as 'spark’.
>>>
>>> spark.read.csv(path=f"/Users/xxx/Desktop/customers.csv", sep=",",
header="false").show()
+---+----+---+---+
|_c0| _c1|_c2|_c3| SparkSession ya construida y disponible como “spark”
+---+----+---+---+
| 1| ana| 28| F|
| 2|cris| 38| F|
| 3|alex| 10| M|
| 4|javi| 72| M|
| 5|juan| 62| M|
+---+----+---+---+
>>>
El código anterior simplemente lee un fichero CSV (transformándolo en un RDD) y lo

muestra por consola.
La otra manera de ejecutar Spark es mediante el envío de una aplicación, con el

comando spark-submit
spark-submit
--class project/main.py
--master yarn
--deploy-mode client
--py-files project.zip
project/main.py

Apache Spark
El script main.py tendrá el código de la aplicación, que comenzará
creando el contexto de Spark y la sesión (como hacía automáticamente la
consola interactiva)
if __name__ == '__main__':
sc = SparkContext(appName=“test”)
spark = SparkSession(sc)
...
Como comentábamos antes, podemos ejecutar Spark localmente o de manera

distribuida en un cluster. Es lo que podemos indicar con “deploy-mode”:
• client: el proceso driver (el que ejecuta todo el código no distribuido) se

instancia en la misma máquina desde donde se ejecuta el spark-submit
• cluster: el proceso driver se instancia en una de las máquinas disponibles del

cluster.
Para ejecutar aplicaciones distribuidas en un clúster, Spark requiere un administrador

de clúster, un “master”:
• Spark Standalone: cuando se ejecuta en Spark Standalone, los procesos de la

aplicación Spark son administrados por las funciones Spark Master y Worker
• Gestor de recursos (YARN, Apache Mesos…): el gestor de recursos gestiona los

procesos de la aplicación de Spark.
• Sobre un virtualizador, como Kubernetes.
Normalmente, se ejecutará sobre un gestor de recursos o un virtualizador, en vez de

en modo Standalone, ya que tiene bastantes beneficios:
• Se puede compartir dinámicamente y configurar de forma centralizada el

mismo conjunto de recursos de clúster entre todas las aplicaciones que se
ejecuten
• Existe la opción de escoger la cantidad de ejecutores que usará la aplicación.

Sin embargo, Spark Standalone requiere que cada aplicación ejecute un
ejecutor en cada host del clúster
• Se pueden categorizar, aislar y priorizar aplicaciones

Apache Spark
5. Ejemplos
Veamos algunos ejemplos de código de una aplicación de Spark:
5.1. Setup
Las aplicaciones deben comenzar con la creación de un contexto y sesión
sc = SparkContext(appName=“test”)
spark = SparkSession(sc)
5.2. Lectura de datos
Seguirán con el acceso a datos. En este caso, un fichero CSV con información de varias
personas
customers_rdd = spark.sparkContext.\
textFile("/Users/xxx/Desktop/customers.csv").\
map(lambda line: line.split(","))
Esto generará un RDD con esta estructura:
['1', 'ana', '28', 'F']

['2', 'cris', '38', 'F']
['3', 'alex', '10', 'M']
['4', 'javi', '72', 'M']
['5', 'juan', '62', 'M']

Apache Spark
Imaginemos que queremos obtener la edad más alta. Seleccionamos la columna de la
edad (map, una transformación), y después calculamos el máximo (reduce, una
acción):
customers_rdd. \
map(lambda row: row[2]). \
reduce(max)
Resultado, (‘72’)
¿Y si quiero sacar el máximo según el género?
customers_rdd. \
map(lambda row: (row[3], row[2])). \
reduceByKey(max)
('F', '38')
('M', '72')
6. Librerías sobre Spark

Dentro del ecosistema Spark, existen librerías que nos permiten realizar tareas
comunes y expandir la funcionalidad:

Apache Spark
6.1. SparkSQL
A partir de la versión 1.6 de Spark aparece el concepto de DataFrame (y

posteriormente, el de Dataset) como wrapper sobre los RDDs, aportando operaciones
y transformaciones de datos más similares a las existentes en SQL.
Permite operar sobre sets de datos como si de tablas sql se tratara, directamente con
código SQL:
clients_df.registerTempTable("clients")
spark. \
sql("select count(name) from clients where id % 2 = 0"). \
show()
O mediante la API de funciones de Spark:
clients_df.\
where(clients_df["id"] % 2 == 0).\
agg(count("name")). \
show()
6.2. SparkML
Para la aplicación de algoritmos de Machine Learning de forma distribuida con Spark.
6.3. SparkStreaming
Procesado de datos en tiempo real con Spark (los datos se procesan a medida que van
estando disponibles, en lugar del procesado tradicional en batch, desde ficheros).

Apache Spark

Apache Spark
© Todos los derechos de propiedad intelectual de esta

obra pertenecen en exclusiva a la Universidad Europea
de Madrid, S.L.U. Queda terminantemente prohibida la
reproducción, puesta a disposición del público y en
general cualquier otra forma de explotación de toda o
parte de la misma.
La utilización no autorizada de esta obra, así como los

perjuicios ocasionados en los derechos de propiedad
intelectual e industrial de la Universidad Europea de
Madrid, S.L.U., darán lugar al ejercicio de las acciones
que legalmente le correspondan y, en su caso, a las
responsabilidades que de dicho ejercicio se deriven.

1. Apache Spark

Cargado por

Copyright:

Formatos disponibles

1. Apache Spark

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

1. Apache Spark

Cargado por

Copyright:

Formatos disponibles

Big Data

1. Introducción a Apache Spark ..................................................... 3

© Copyright Universidad Europea. Todos los derechos reservados. 2

1. Introducción a Apache Spark

En la arquitectura está además incluída un sistema de recuperación automática de

© Copyright Universidad Europea. Todos los derechos reservados. 3

Que consistía en:

• El almacenamiento de datos en sistema de archivos distribuido (HDFS)

• Una serie de operaciones de mapeo y reducción con los que íbamos

Este sistema tiene varios inconvenientes, el más importante de todos la cantidad de

© Copyright Universidad Europea. Todos los derechos reservados. 4

• Recuperar esos datos

• Escribir las salidas del procesado

• Actualizar la información de dónde se localizan estas salidas

Esto tiene muchas ventajas:

• La lectura/escritura a memoria es mucho más rápida que la lectura/escritura

• Almacenamos en HDFS solo entradas iniciales y salidas últimas, pero no

• Al tener datos en memoria local de cada nodo, mantenemos más información

© Copyright Universidad Europea. Todos los derechos reservados. 5

• Seguimos necesitando envío de datos por red para intercambiar información

• Es más susceptible a errores de memoria

• Habrá determinados escenarios en los que tengamos que seguir recurriendo a

Es por esto que Spark se considera como el sucesor de MapReduce para el

2. ¿Cómo funciona Spark?

2.1. Redundant Distributed Dataset (RDD)

© Copyright Universidad Europea. Todos los derechos reservados. 6

Un RDD es una colección de registros tolerante a fallos, de solo lectura y particionada.

Como hemos dicho anteriormente, estos RDDs realmente se almacenan en la memoria

© Copyright Universidad Europea. Todos los derechos reservados. 7

Sobre estos RDDs se realizan operaciones y transiciones que van transformándolos

2.2. Operaciones en Spark

Existen dos tipos de operaciones en Spark:

• Transformaciones: Reciben un RDD y generan otro RDD como resultado. Tienen

• Acciones: Reciben un RDD y devuelven un valor concreto. Se ejecutan en el

Ésta acción es la que

Veamos un ejemplo de código, sobre pySpark (con la API de Python):

© Copyright Universidad Europea. Todos los derechos reservados. 8

En vez de generar otro RDD, contemos el número de nombres:

Al llegar a la acción del count, se desencadenan todas las operaciones pendientes.

© Copyright Universidad Europea. Todos los derechos reservados. 9

Echémosle un ojo a las operaciones de transformación más comunes ofrecidas por el

Devolución de un nuevo conjunto de datos distribuido formado a través de aplicar a

Devuelve un nuevo conjunto de datos formado por la selección de aquellos elementos

• Sample (withReplacement, fraction, seed)

Devuelve un nuevo conjunto de datos que contiene la unión de los elementos en el

Devolución de un nuevo RDD que contiene la intersección de elementos en el conjunto

© Copyright Universidad Europea. Todos los derechos reservados. 10

• AggregateByKey (zeroValue) (seqOp, combOp, [numTasks])

Otras operaciones de transformación del modelo de programación Apache Spark son:

• SortByKey ([ascending], [numTasks])

• Cogroup (otherDataset, [numTasks])

© Copyright Universidad Europea. Todos los derechos reservados. 11

Disminuye el número de particiones en el RDD a numPartitions, resulta muy útil para

Reparticiona el RDD según el particionador dado y, dentro de cada partición resultante,

Devuelve la cantidad de elementos en el conjunto de datos.

Devuelve el primer elemento del conjunto de datos (similar a take (1).

© Copyright Universidad Europea. Todos los derechos reservados. 12

Ejecuta una función (func) en cada elemento del conjunto de datos.

1. Ya sabemos que la ejecución de las transformaciones se posponen hasta

2. Si nos encontrásemos con otra segunda acción después, se vuelve a ejecutar