Compartir comentarios
Las respuestas se generan en base a la documentación.

Ciencia de datos con JupyterLab

Tabla de contenidos

Docker y JupyterLab son dos herramientas potentes que pueden mejorar tu flujo de trabajo en la ciencia de datos. En esta guía, aprenderás a usarlas juntas para crear y ejecutar entornos de ciencia de datos reproducibles. Esta guía se basa en Supercharging AI/ML Development with JupyterLab and Docker.

En esta guía, aprenderás a:

  • Ejecutar un Servidor Jupyter personal con JupyterLab en tu máquina local
  • Personalizar tu entorno de JupyterLab
  • Compartir tu cuaderno y entorno de JupyterLab con otros científicos de datos

¿Qué es JupyterLab?

JupyterLab es una aplicación de código abierto construida en torno al concepto de un documento de cuaderno computacional. Permite compartir y ejecutar código, procesar datos, visualizar y ofrece una variedad de características interactivas para crear gráficos.

¿Por qué usar Docker y JupyterLab juntos?

Al combinar Docker y JupyterLab, puedes beneficiarte de las ventajas de ambas herramientas, como:

  • La contenerización asegura un entorno de JupyterLab coherente en todos los despliegues, eliminando los problemas de compatibilidad.
  • JupyterLab contenerizado simplifica el intercambio y la colaboración al eliminar la necesidad de configurar el entorno de forma manual.
  • Los contenedores ofrecen escalabilidad para JupyterLab, admitiendo la distribución de cargas de trabajo y la gestión eficiente de recursos con plataformas como Kubernetes.

Requisitos previos

Para seguir esta guía, debes instalar la última versión de Docker Desktop.

Ejecutar y acceder a un contenedor JupyterLab

En una terminal, ejecuta el siguiente comando para iniciar tu contenedor JupyterLab.

$ docker run --rm -p 8889:8888 quay.io/jupyter/base-notebook start-notebook.py --NotebookApp.token='my-token'

A continuación se detallan las partes más destacables del comando:

  • -p 8889:8888: Mapea el puerto 8889 del host al puerto 8888 del contenedor.
  • start-notebook.py --NotebookApp.token='my-token': Establece un token de acceso en lugar de utilizar uno aleatorio.

Para más detalles, consulta las opciones del Servidor Jupyter y la referencia de CLI de docker run.

Si es la primera vez que ejecutas la imagen, Docker la descargará y la iniciará. El tiempo que tarde en descargarse variará en función de tu conexión de red.

Una vez que la imagen se descargue y se ejecute, podrás acceder al contenedor. Para hacerlo, abre un navegador web y navega a localhost:8889/lab?token=my-token.

Para detener el contenedor, presiona ctrl+c en la terminal.

Para acceder a un cuaderno existente en tu sistema, puedes usar un montaje de tipo bind. Abre una terminal y cambia al directorio donde se encuentra tu cuaderno. Luego, ejecuta el comando correspondiente según tu sistema operativo.

$ docker run --rm -p 8889:8888 -v "$(pwd):/home/jovyan/work" quay.io/jupyter/base-notebook start-notebook.py --NotebookApp.token='my-token'

$ docker run --rm -p 8889:8888 -v "%cd%":/home/jovyan/work quay.io/jupyter/base-notebook start-notebook.py --NotebookApp.token='my-token'

$ docker run --rm -p 8889:8888 -v "$(pwd):/home/jovyan/work" quay.io/jupyter/base-notebook start-notebook.py --NotebookApp.token='my-token'

$ docker run --rm -p 8889:8888 -v "/$(pwd):/home/jovyan/work" quay.io/jupyter/base-notebook start-notebook.py --NotebookApp.token='my-token'

La opción -v le indica a Docker que monte tu directorio de trabajo actual en /home/jovyan/work dentro del contenedor. Por defecto, el directorio raíz de la imagen de Jupyter es /home/jovyan y solo puedes acceder o guardar cuadernos en ese directorio en el contenedor.

Ahora puedes acceder a localhost:8889/lab?token=my-token y abrir cuadernos incluidos en el directorio montado.

Para detener el contenedor, presiona ctrl+c en la terminal.

Docker también tiene volúmenes, que son el mecanismo preferido para persistir los datos generados y utilizados por los contenedores de Docker. Mientras que los montajes de tipo bind dependen de la estructura de directorios y del sistema operativo de la máquina host, los volúmenes son gestionados completamente por Docker.

Guardar y acceder a cuadernos

Al eliminar un contenedor, se borran todos los datos que contiene. Para guardar cuadernos fuera del contenedor, puedes usar un volumen.

Ejecutar un contenedor JupyterLab con un volumen

Para iniciar el contenedor con un volumen, abre una terminal y ejecuta el siguiente comando:

$ docker run --rm -p 8889:8888 -v jupyter-data:/home/jovyan/work quay.io/jupyter/base-notebook start-notebook.py --NotebookApp.token='my-token'

La opción -v le indica a Docker que cree un volumen llamado jupyter-data y lo monte en el contenedor en /home/jovyan/work.

Para acceder al contenedor, abre un navegador web y navega a localhost:8889/lab?token=my-token. Ahora los cuadernos se pueden guardar en el volumen y estarán accesibles incluso si se elimina el contenedor.

Guardar un cuaderno en el volumen

Para este ejemplo, utilizarás el ejemplo del Conjunto de datos Iris de scikit-learn.

  1. Abre un navegador web y accede a tu contenedor JupyterLab en localhost:8889/lab?token=my-token.

  2. En el Launcher (Lanzador), en Notebook, selecciona Python 3.

  3. En el cuaderno, especifica lo siguiente para instalar los paquetes necesarios:

    !pip install matplotlib scikit-learn

  4. Selecciona el botón de reproducción (play) para ejecutar el código.

  5. En el cuaderno, especifica el siguiente código:

    from sklearn import datasets

iris = datasets.load_iris()
import matplotlib.pyplot as plt

_, ax = plt.subplots()
scatter = ax.scatter(iris.data[:, 0], iris.data[:, 1], c=iris.target)
ax.set(xlabel=iris.feature_names[0], ylabel=iris.feature_names[1])
_ = ax.legend(
   scatter.legend_elements()[0], iris.target_names, loc="lower right", title="Classes"
)

  6. Selecciona el botón de reproducción para ejecutar el código. Deberías ver un gráfico de dispersión del conjunto de datos Iris.

  7. En el menú superior, selecciona File (Archivo) y luego Save Notebook (Guardar cuaderno).

  8. Especifica un nombre en el directorio work para guardar el cuaderno en el volumen. Por ejemplo, work/mynotebook.ipynb.

  9. Selecciona Rename (Renombrar) para guardar el cuaderno.

El cuaderno ya está guardado en el volumen.

En la terminal, presiona ctrl+ c para detener el contenedor.

Ahora, cada vez que ejecutes un contenedor Jupyter con el volumen, tendrás acceso al cuaderno guardado.

Cuando inicies un contenedor nuevo y vuelvas a ejecutar el código del gráfico de datos, será necesario ejecutar !pip install matplotlib scikit-learn y descargar los paquetes. Puedes evitar reinstalar los paquetes cada vez que ejecutes un nuevo contenedor creando tu propia imagen con los paquetes ya instalados.

Personalizar tu entorno de JupyterLab

Puedes crear tu propio entorno de JupyterLab y construirlo en una imagen utilizando Docker. Al construir tu propia imagen, puedes personalizar tu entorno de JupyterLab con los paquetes y herramientas que necesitas, y asegurarte de que sea coherente y reproducible en diferentes despliegues. Construir tu propia imagen también facilita compartir tu entorno de JupyterLab con otros o usarlo como base para un desarrollo posterior.

Definir tu entorno en un Dockerfile

En el ejemplo anterior del conjunto de datos Iris de Guardar un cuaderno en el volumen, tuviste que instalar las dependencias matplotlib y scikit-learn cada vez que ejecutabas un nuevo contenedor. Aunque las dependencias de ese pequeño ejemplo se descargan e instalan rápidamente, esto puede convertirse en un problema a medida que crezca tu lista de dependencias. También es posible que desees tener siempre otras herramientas, paquetes o archivos en tu entorno.

En este caso, puedes instalar las dependencias como parte del entorno en la imagen. De este modo, cada vez que ejecutes el contenedor, las dependencias ya estarán instaladas.

Puedes definir tu entorno en un Dockerfile. Un Dockerfile es un archivo de texto que indica a Docker cómo crear una imagen de tu entorno de JupyterLab. Una imagen contiene todo lo que quieres y necesitas al ejecutar JupyterLab, como archivos, paquetes y herramientas.

En el directorio de tu elección, crea un nuevo archivo de texto llamado Dockerfile. Abre el Dockerfile en un IDE o editor de texto y agrega el siguiente contenido.

# syntax=docker/dockerfile:1

FROM quay.io/jupyter/base-notebook
RUN pip install --no-cache-dir matplotlib scikit-learn

Este Dockerfile utiliza la imagen quay.io/jupyter/base-notebook como base y luego ejecuta pip para instalar las dependencias. Para obtener más detalles sobre las instrucciones del Dockerfile, consulta la referencia de Dockerfile.

Antes de continuar, guarda tus cambios en el Dockerfile.

Construir tu entorno en una imagen

Una vez que tengas un Dockerfile para definir tu entorno, puedes usar docker build para construir una imagen con él.

Abre una terminal, cambia al directorio donde se encuentra tu Dockerfile y ejecuta el siguiente comando:

$ docker build -t my-jupyter-image .

El comando construye una imagen de Docker a partir de tu Dockerfile y un contexto. El opción -t especifica el nombre y la etiqueta de la imagen, en este caso my-jupyter-image. El . indica que el directorio actual es el contexto, lo que significa que los archivos de ese directorio se pueden usar en el proceso de creación de la imagen.

Puedes verificar que la imagen se construyó viendo la vista Images (Imágenes) en Docker Desktop, o ejecutando el comando docker image ls en una terminal. Deberías ver una imagen llamada my-jupyter-image.

Ejecutar tu imagen como un contenedor

Para ejecutar tu imagen como un contenedor, utiliza el comando docker run. En el comando docker run, especificarás tu propio nombre de imagen.

$ docker run --rm -p 8889:8888 my-jupyter-image start-notebook.py --NotebookApp.token='my-token'

Para acceder al contenedor, abre un navegador web y navega a localhost:8889/lab?token=my-token.

Ahora puedes usar los paquetes sin tener que instalarlos en tu cuaderno.

  1. En el Launcher (Lanzador), en Notebook, selecciona Python 3.

  2. En el cuaderno, especifica el siguiente código:

    from sklearn import datasets

iris = datasets.load_iris()
import matplotlib.pyplot as plt

_, ax = plt.subplots()
scatter = ax.scatter(iris.data[:, 0], iris.data[:, 1], c=iris.target)
ax.set(xlabel=iris.feature_names[0], ylabel=iris.feature_names[1])
_ = ax.legend(
   scatter.legend_elements()[0], iris.target_names, loc="lower right", title="Classes"
)

  3. Selecciona el botón de reproducción para ejecutar el código. Deberías ver un gráfico de dispersión del conjunto de datos Iris.

En la terminal, presiona ctrl+ c para detener el contenedor.

Usar Compose para ejecutar tu contenedor

Docker Compose es una herramienta para definir y ejecutar aplicaciones multi-contenedor. En este caso, la aplicación no es una aplicación de múltiples contenedores, pero Docker Compose puede facilitar su ejecución al definir todas las opciones de docker run en un archivo.

Crear un archivo Compose

Para usar Compose, necesitas un archivo compose.yaml. En el mismo directorio que tu Dockerfile, crea un nuevo archivo llamado compose.yaml.

Abre el archivo compose.yaml en un IDE o editor de texto y agrega el siguiente contenido.

services:
  jupyter:
    build:
      context: .
    ports:
      - 8889:8888
    volumes:
      - jupyter-data:/home/jovyan/work
    command: start-notebook.py --NotebookApp.token='my-token'

volumes:
  jupyter-data:
    name: jupyter-data

Este archivo Compose especifica todas las opciones que utilizaste en el comando docker run. Para más detalles sobre las instrucciones de Compose, consulta la referencia del archivo Compose.

Antes de continuar, guarda tus cambios en el archivo compose.yaml.

Ejecutar tu contenedor usando Compose

Abre una terminal, cambia al directorio donde se encuentra tu archivo compose.yaml y ejecuta el siguiente comando:

$ docker compose up --build

Este comando construye tu imagen y la ejecuta como un contenedor utilizando las instrucciones especificadas en el archivo compose.yaml. La opción --build asegura que tu imagen se reconstruya, lo cual es necesario si realizaste cambios en tu Dockerfile.

Para acceder al contenedor, abre un navegador web y navega a localhost:8889/lab?token=my-token.

En la terminal, presiona ctrl+ c para detener el contenedor.

Compartir tu trabajo

Al compartir tu imagen y cuaderno, creas un entorno de investigación portátil y replicable al que otros científicos de datos pueden acceder y utilizar fácilmente. Este proceso no solo facilita la colaboración, sino que también asegura que tu trabajo se conserve en un entorno donde se pueda ejecutar sin problemas de compatibilidad.

Para compartir tu imagen y tus datos, utilizarás Docker Hub. Docker Hub es un servicio de registro en la nube que te permite compartir y distribuir imágenes de contenedores.

Compartir tu imagen

  1. Regístrate o inicia sesión en Docker Hub.

  2. Renombra tu imagen para que Docker sepa a qué repositorio debe subirla. Abre una terminal y ejecuta el siguiente comando docker tag. Reemplaza TU-ID-DOCKER con tu ID de Docker.

    $ docker tag my-jupyter-image TU-ID-DOCKER/my-jupyter-image

  3. Ejecuta el siguiente comando docker push para subir la imagen a Docker Hub. Reemplaza TU-ID-DOCKER con tu ID de Docker.

    $ docker push TU-ID-DOCKER/my-jupyter-image

  4. Verifica que hayas subido la imagen a Docker Hub.

    1. Ve a Docker Hub.
    2. Selecciona My Hub > Repositories.
    3. Revisa la hora de Last pushed (Última publicación) de tu repositorio.

Otros usuarios ahora pueden descargar y ejecutar tu imagen usando el comando docker run. Deben reemplazar TU-ID-DOCKER con tu ID de Docker.

$ docker run --rm -p 8889:8888 TU-ID-DOCKER/my-jupyter-image start-notebook.py --NotebookApp.token='my-token'

Compartir tu volumen

Este ejemplo utiliza la interfaz gráfica de usuario de Docker Desktop. Alternativamente, en la interfaz de línea de comandos puedes respaldar el volumen y luego subirlo usando la CLI de ORAS.

  1. Inicia sesión en Docker Desktop.
  2. En el panel de control (Dashboard) de Docker, selecciona Volumes.
  3. Selecciona el volumen jupyter-data haciendo clic en su nombre.
  4. Selecciona la pestaña Exports (Exportaciones).
  5. Selecciona Quick export (Exportación rápida).
  6. En Location (Ubicación), selecciona Registry (Registro).
  7. En el cuadro de texto bajo Registry, especifica tu ID de Docker, un nombre para el volumen y una etiqueta. Por ejemplo, TU-ID-DOCKER/jupyter-data:latest.
  8. Selecciona Save (Guardar).
  9. Verifica que hayas exportado el volumen a Docker Hub.
    1. Go to Docker Hub.
    2. Selecciona My Hub > Repositories.
    3. Revisa la hora de Last pushed (Última publicación) de tu repositorio.

Otros usuarios ahora pueden descargar e importar tu volumen. Para importar el volumen y luego ejecutarlo con tu imagen:

  1. Inicia sesión en Docker Desktop.

  2. En el panel de control (Dashboard) de Docker, selecciona Volumes.

  3. Selecciona Create (Crear) para crear un nuevo volumen.

  4. Especifica un nombre para el nuevo volumen. Para este ejemplo, usa jupyter-data-2.

  5. Selecciona Create.

  6. En la lista de volúmenes, selecciona el volumen jupyter-data-2 haciendo clic en su nombre.

  7. Selecciona Import (Importar).

  8. En Location, selecciona Registry.

  9. En el cuadro de texto bajo Registry, especifica el mismo nombre del repositorio al que exportaste tu volumen. Por ejemplo, TU-ID-DOCKER/jupyter-data:latest.

  10. Selecciona Import.

  11. En una terminal, ejecuta docker run para iniciar tu imagen con el volumen importado. Reemplaza TU-ID-DOCKER con tu ID de Docker.

    $ docker run --rm -p 8889:8888 -v jupyter-data-2:/home/jovyan/work TU-ID-DOCKER/my-jupyter-image start-notebook.py --NotebookApp.token='my-token'

Resumen

En esta guía, aprendiste cómo aprovechar Docker y JupyterLab para crear entornos de ciencia de datos reproducibles, facilitando el desarrollo y el intercambio de proyectos de ciencia de datos. Esto incluyó la ejecución de un servidor personal de JupyterLab, la personalización del entorno con las herramientas y paquetes necesarios, y el intercambio de cuadernos y entornos con otros científicos de datos.

Información relacionada: