Cómo ejecutar Notebooks de Jupyter en Spark

Jupyter Notebook es una aplicación web de código abierto que permite crear y compartir documentos que contienen código vivo, ecuaciones, visualizaciones y texto narrativo. Debido a la mezcla de elementos de código y texto, los cuadernos Jupyter son ideales para el análisis de datos on-line y colaborativo. Los casos de uso incluyen: limpieza y transformación de datos, simulación numérica, modelado estadístico, visualización de datos, aprendizaje automático y mucho más.

Jupyter Notebook tiene soporte para más de 40 lenguajes de programación (a través de lo que se denomina "núcleo"); de hecho, "Jupyter" es un acrónimo de Julia, Python y R. Estos tres lenguajes de programación fueron los primeros lenguajes que soportó Jupyter, pero hoy en día también soporta muchos otros lenguajes como Java, Scala, Go, Perl, C/C++.

IPython es el kernel por defecto y, en su versión actual, soporta versiones de Python igual o superiores a la 3.5.

Jupyter también aprovecha las estructuras y herramientas de Big Data como Apache Spark y también es empaquetable en contenedores siendo posible utilizar Docker o Kubernetes para escalar el desarrollo y despliegue de la aplicación, aislar los procesos de los usuarios o simplificar la gestión del ciclo de vida del software.

Para mas información echa un vistazo en https://jupyter.org/

Hay algunas maneras de ejecutar PySpark en un Notebook de Jupyter:

1. Configurar el driver de PySpark para utilizar el Jupyter Notebook (al ejecutar pyspark se abrirá un Jupyter Notebook).
2. Cargar un kernel convencional IPython en Jupyter y utilizar la biblioteca findSpark para que el contexto de Spark esté disponible en el kernel de Jupyter. Esto se utiliza a menudo para conseguir que PySpark esté disponible en un IDE para el desarrollo y las pruebas a nivel local. Más información en https://github.com/minrk/findspark
3. Utilizar el paquete SparkMagic para trabajar interactivamente con clústeres remotos de Spark a través de Livy, el servidor REST API de Spark, en Notebooks Jupyter. Más información en https://github.com/jupyter-incubator/sparkmagic  

Esta entrada de blog se centra en la primera opción, lo que significa que el driver de PySpark será ejecutado por el núcleo del Jupyter Notebook.

Para ello, configuraremos Jupyter para ejecutar Python sobre Spark (PySpark API) utilizando un clúster de Hadoop y Spark como backend de procesamiento distribuido de Big Bata. Es posible emplear la misma aproximación para utilizar un kernel de Scala y ejecutar los Notebooks de Jupyter en el modo distribuido de Spark.

PASO 1: Instalar Anaconda

Lo primero es descargar Anaconda de https://www.anaconda.com/distribution. La recomendación es descargar la última versión de Anaconda basada en Python 3 (Anaconda3). El siguiente paso es instalar el Anaconda3 que fue descargado, siguiendo las instrucciones de la página de descargas.

Para descargar la última distribución de Anaconda (desde un sistema Linux) haz un:

# wget https://repo.anaconda.com/archive/Anaconda3-2019.03-Linux-x86_64.sh

Para proceder con la instalación:

# bash Anaconda3-2019.03-Linux-x86_64.sh

Es posible utilizar el directorio de instalación alternativo recomendado y predeterminado (dentro del directorio raíz del usuario) si sólo un usuario específico va a utilizar Anaconda.

Si respondemos "no" cuando se nos pregunta si queremos que el instalador inicialice Anaconda, no se añadirán las correspondientes variables de entorno en el fichero .bashrc del usuario. Para añadirlas (o inicializarlas) manualmente, ejecutar source <ruta_a_anaconda>/bin/activate y luego ejecutar un conda init.

PASO 2: Configurar el servidor de Notebooks de Jupyter

El siguiente paso es configurar las opciones con las que se ejecuta el servidor de Notebook creando el archivo jupyter_notebook_config.py en la carpeta Jupyter y luego configurando manualmente algunos parámetros específicos que podemos necesitar cambiar.

Para ello, ejecutamos el siguiente comando:

# jupyter notebook --generate-config --allow-root

(el --allow-root se usa para evitar la advertencia generada al ejecutar Jupyter como root).

Es posible que haya que modificar la dirección IP en la que el servidor de Notebook escuchará (el parámetro c.NotebookApp.ip). Si este es el caso, editar el archivo /root/.jupyter/jupyter_notebook_config.py y cambiar lo siguiente:

## The IP address the notebook server will listen on.

#c.NotebookApp.ip = 'localhost'

c.NotebookApp.ip = '192.168.189.11'

Arrancamos el servidor de Notebooks de Jupyter y comprobamos:

# jupyter notebook --allow-root

Llegados a este punto paramos el servidor mediante Control+C.

PASO 3: Configurar PySpark para que su driver corra en un Notebook de Jupyter

Para ello hemos de actualizar las variables de entorno de PySpark relacionadas en el cliente de Spark instalado en el servidor o sistema desde donde ejecutamos los Notebooks de Jupyter.

La manera de hacerlo online es mediante los siguientes comandos:

# export PYSPARK_DRIVER_PYTHON="jupyter"

# export PYSPARK_DRIVER_PYTHON_OPTS="notebook --allow-root"

Además, añadimos estas líneas al .bashrc o .profile del usuario. En mi caso, el fichero .bashrc de cada usuario al que quiro permitir que Anaconda3 y Jupyter Notebook se ejecuten contiene lo siguiente:

# >>> conda initialize >>>

# !! Contents within this block are managed by 'conda init' !!

__conda_setup="$('/opt/anaconda3/bin/conda' 'shell.bash' 'hook' 2> /dev/null)"

if [ $? -eq 0 ]; then

    eval "$__conda_setup"

else

    if [ -f "/opt/anaconda3/etc/profile.d/conda.sh" ]; then

        . "/opt/anaconda3/etc/profile.d/conda.sh"

    else

        export PATH="/opt/anaconda3/bin:$PATH"

    fi

fi

unset __conda_setup

# <<< conda initialize <<<

export PYSPARK_DRIVER_PYTHON="jupyter"

export PYSPARK_DRIVER_PYTHON_OPTS="notebook --allow-root"

Ahora, al iniciar PySpark, el servidor de Jupyter Notebook debe estar en funcionamiento:

El último paso es arrancar un nuevo Notebook con el kernel de Python desde el WebUI de Jupyter:

Esto hará que YARN planifique y ejecute una nueva aplicación de PySparkShell. Para comprobarlo, vamos al WebUI del ResourceManager de YARN para ver que nuestra aplicación PySparkShell está corriendo con 12 ejecutores alocados:

Este es el ejemplo de código que se ha ejecutado bajo Spark en mi primer Notebook: