DEV Community: Dani Sancas

Aprendiendo Spark: #2 Hola mundo

Dani Sancas — Sat, 20 Feb 2021 18:55:29 +0000

¡Saludos, camaradas! 👋

En este artículo vamos a analizar el código del "Hola mundo" que expusimos en el artículo anterior. Antes de nada, vamos a recordarlo:

from pyspark.sql import SparkSession

# Iniciamos Spark de manera local
spark = (SparkSession
         .builder
         .master("local[*]")
         .appName("Hola Mundo")
         .getOrCreate())

# Paralelizamos una lista del 0 al 9 (incluido)
# Computamos la suma de los números
# Obtenemos el resultado en una variable
result = (spark
          .sparkContext
          .parallelize(range(10))
          .reduce(lambda x, y: x + y))

# Imprimimos el resultado
print(f"La suma es {result}")

Al ejecutarlo a través del IDE o mediante una terminal escribiendo python hola_mundo.py veremos el siguiente output tras una serie de warnings:

La suma es 45

Process finished with exit code 0

Vale, muy bonito todo pero, ¿qué es cada cosa?

Creando la sesión de Spark

Para continuar vamos a dar una vuelta por nuestro código anotando los tipos de nuestras variables.

Friendly reminder: Anotar con tipos en Python es meramente informativo de cara a quien desarrolla el código, no tiene el efecto que pueda tener en lenguajes como Java.

Vamos a anotar con su tipo la variable spark y también vamos a poner un comentario en cada una de las llamadas encadenadas durante la creación de dicho objeto, para que veamos de qué tipo es cada una.

spark: SparkSession = (SparkSession             # SparkSession
                       .builder                 # Builder
                       .master("local[*]")      # Builder
                       .appName("Hola Mundo")   # Builder
                       .getOrCreate())          # SparkSession

Todo empieza con la referencia a la clase SparkSession, ésta nos permite crear un objeto Builder al cual le iremos indicando qué configuración queremos.

En primer lugar, indicaremos que el master() es local usando todos los cores que dispongamos. Esto es típico para hacer pruebas en local, cuando no disponemos de un clúster donde ejecutar código productivo (y de momento nos sirve perfectamente).

En segundo lugar especificamos el nombre de nuestra ejecución mediante appName(). Como no podía ser de otra manera, se llama "Hola mundo" (cuánta imaginación, ¿verdad? 🙄).

Tanto las llamadas a master() como a appName() devuelven un objeto Builder, que indica que está a medio construir, nos faltaría un paso más.

Por último le indicamos a Spark que nos devuelva (en caso de existir) o que nos cree (en caso contrario) una SparkSession con la que podamos hacer computación distribuida.

La SparkSession que nos devuelve la plasmamos en la variable spark para que podamos utilizarla más adelante.

¡Llegados a este punto ya podemos empezar a hacer computación distribuida!

Pinto y coloreo mis primeras operaciones distribuidas 🤓

Ahora vamos a hacer lo mismo con el segundo bloque de código, anotando el tipo de la variable result y comentando cada paso.

result: int = (spark                          # SparkSession
               .sparkContext                  # SparkContext
               .parallelize(range(10))        # RDD[int]
               .reduce(lambda x, y: x + y))   # int

Primero partimos de la variable spark creada previamente. Y a partir de ella obtenemos un objeto SparkContext. Podemos entender este objeto como un helper de Spark para realizar ciertas maniobras. En este caso nos facilita la creación de un RDD a través de su método parallelize, que toma una lista como argumento.

Con parallelize() tomamos una lista clásica (un array de toda la vida, si queréis verlo así) y crea un RDD a partir de ella, del mismo tipo de la lista. Nosotros le hemos pasado la lista [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] resultante de invocar range(10), que es de tipo int. Por lo tanto el RDD será también de tipo int.

Explícame un poco los RDDs, porfa 🥺

Los RDDs son las unidades básicas de Spark a partir de las cuales podemos hacer computación distribuida. En próximos artículos entraremos en más profundidad, de momento nos sirve pensar en ellos como listas cuyo contenido está troceado y repartido por diferentes servidores de Spark.

De esta manera, evitamos cargar a un único servidor con todo el trabajo, ya que todos los nodos que tengamos trabajarán a la par. ¿Y cuál es ese trabajo tan tedioso que va a requerir computación distribuida? 🤔

¡Nada más y nada menos que la acción reduce()! 🤩

Importante: Este reduce() no es el del módulo functools pero se comporta parecido, solo que de manera distribuida.

Acción `reduce()`

Vale, ¿entonces qué hace exactamente el reduce() de un RDD?

Esta función coge una lista distribuida (RDD) y va combinando sus valores mediante la función que le indiquemos. En este caso ha sido una simple función anónima que suma 2 números que le pase reduce().

Si no estáis familiarizados con funciones combinatorias de programación funcional, os dejo una breve explicación del reduce() del módulo functools. Recordad que no es lo mismo, pero nos sirve para hacernos una idea general de cuál es su mecánica.

Así pues, lo que hará es sumar todos los valores de la lista y devolverá un resultado, un simple int de toda la vida. En este proceso intervendrían todos nuestros servidores de Spark, comunicándose entre ellos para ir sumando los diferentes valores, hasta tener completada la suma de todos ellos y devolver el resultado.

Una vez tenemos ese número en nuestro poder, lo imprimimos por pantalla para conocer el resultado de tamaña operación. ¡Buen trabajo! 😎

Espero que os haya sido útil este artículo. En el próximo hablaremos en más profundidad de las operaciones de Spark, que se dividen en transformaciones y acciones.

Es muy importante entender bien el rol y efectos que las diferencian, ¡así que os espero en el próximo artículo! 🤗

¡Nos vemos, equipo! 🙌

Aprendiendo Spark: #1 Introducción

Dani Sancas — Sat, 06 Feb 2021 19:43:05 +0000

¡Saludos, camaradas! 👋

En esta serie de artículos entraremos en el mundillo de Apache Spark, el framework por excelencia de computación distribuida desde hace ya unos años.

¿Qué es Apache Spark? 💥

Es un framework de computación distribuida escrito en Scala, que posee APIs en otros lenguajes como Python, Java y R.

En esta serie de tutoriales escribiremos código en Python por ser un lenguaje más popular que Scala, y por ser el lenguaje con el que trabajo habitualmente desde hace ya un tiempo.

Scala siempre estarás en mi ❤️, ¡no te olvido!

¿Qué es esto de la computación distribuida? ¿Es muy complicado? 🤔

Internamente la computación distribuida tiene su complejidad, no nos vamos a engañar.

La buena noticia es que Spark nos abstrae de un montón de problemáticas (computación en paralelo, sincronización de nodos, orquestación de operaciones, tolerancia a fallos y un largo etc) y nos permite centrarnos en lo importante: escribir el código con la funcionalidad que queremos desarrollar.

Por lo tanto, siempre será interesante conocer los entresijos de la maquinaria que estamos dirigiendo, pero de momento no nos hará falta.

Vale, ¿entonces qué necesitamos para empezar?

Lo ideal sería contar un algo de experiencia en programación (si es con Python sería magnífico) y algo de experiencia utilizando un IDE (PyCharm, VSCode) o un editor de textos acompañado de una terminal si es ese tu arsenal habitual ⚔️

Necesitaremos Python, así como un JDK, ya que el código Python que escribamos se traducirá a bytecode y se ejecutará en la JVM.

En caso de que estéis desde Windows, existen algunos problemas conocidos, y seguramente sea necesario instalar (WinUtils). Os dejo un enlace con 5 pasos para poner a punto la instalación en Windows.

Con esta breve introducción vamos dando por finalizado el primer artículo de esta serie...

¡Un momento! ¿No nos vas a dar algo para probar? Porfi... 🥺

Bueeeeeeno, vale 😇 Para que podáis comprobar si habéis instalado correctamente todo lo necesario o necesitáis ajustar algo, os pongo un ejemplo para que creéis un nuevo proyecto en vuestro IDE de cabecera.

Primero habrá que instalar el paquete pyspark (a día de hoy la última versión es la 3.0.1). Lo podemos instalar a través de pip y yo siempre recomiendo usar el fichero requirements.txt para garantizar que no nos olvidamos de ninguna dependencia. Por lo tanto, nuestro fichero requirements.txt quedaría de la siguiente manera:

pyspark==3.0.1

Y lo instalaríamos ejecutando pip install -r requirements.txt.

Una vez instalado pyspark, crearemos un fichero hola_mundo.py en el que pegaremos el siguiente código.

from pyspark.sql import SparkSession

# Iniciamos Spark de manera local
spark = (SparkSession
         .builder
         .master("local[*]")
         .appName("Hola Mundo")
         .getOrCreate())

# Paralelizamos una lista del 0 al 9 (incluido)
# Computamos la suma de los números
# Obtenemos el resultado en una variable
result = (spark
          .sparkContext
          .parallelize(range(10))
          .reduce(lambda x, y: x + y))

# Imprimimos el resultado
print(f"La suma es {result}")

Finalmente lo ejecutaremos, ya sea a través del IDE, o mediante una terminal invocando el intérprete de Python y pasándole nuestro fichero hola_mundo.py como argumento.

Aparecerán unos cuantos warnings (ni caso) y finalmente veréis el siguiente output:

La suma es 45

Process finished with exit code 0

Si no habéis tenido tanta suerte, ya tenéis deberes para vuestro tiempo libre 😬

Espero que os haya gustado esta primera entrega. Se aceptan todo tipo de críticas constructivas 🧐