# Ciencia de datos con JupyterLab 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](https://www.docker.com/blog/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](https://jupyterlab.readthedocs.io/en/stable/) 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](/get-started/get-docker/). ## Ejecutar y acceder a un contenedor JupyterLab En una terminal, ejecuta el siguiente comando para iniciar tu contenedor JupyterLab. ```console $ 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](https://jupyter-docker-stacks.readthedocs.io/en/latest/using/common.html#jupyter-server-options) y la [referencia de CLI de docker run](/reference/cli/docker/container/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](http://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](/storage/bind-mounts/). Abre una terminal y cambia al directorio donde se encuentra tu cuaderno. Luego, ejecuta el comando correspondiente según tu sistema operativo. **Mac / Linux** ```console $ docker run --rm -p 8889:8888 -v "$(pwd):/home/jovyan/work" quay.io/jupyter/base-notebook start-notebook.py --NotebookApp.token='my-token' ``` **Windows (Símbolo del sistema)** ```console $ docker run --rm -p 8889:8888 -v "%cd%":/home/jovyan/work quay.io/jupyter/base-notebook start-notebook.py --NotebookApp.token='my-token' ``` **Windows (PowerShell)** ```console $ docker run --rm -p 8889:8888 -v "$(pwd):/home/jovyan/work" quay.io/jupyter/base-notebook start-notebook.py --NotebookApp.token='my-token' ``` **Windows (Git Bash)** ```console $ 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](http://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](/engine/storage/volumes/). ### Ejecutar un contenedor JupyterLab con un volumen Para iniciar el contenedor con un volumen, abre una terminal y ejecuta el siguiente comando: ```console $ 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](http://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](https://scikit-learn.org/stable/auto_examples/datasets/plot_iris_dataset.html) de scikit-learn. 1. Abre un navegador web y accede a tu contenedor JupyterLab en [localhost:8889/lab?token=my-token](http://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: ```console !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: ```python 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](#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. ```dockerfile # 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](/reference/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: ```console $ 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. ```console $ 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](http://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: ```python 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. ```yaml 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](/reference/compose-file/). 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: ```console $ 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](http://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](https://hub.docker.com/). 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](https://www.docker.com/pricing?ref=Docs&refAction=DocsGuidesJupyter) o inicia sesión en [Docker Hub](https://hub.docker.com). 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. ```console $ 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. ```console $ docker push TU-ID-DOCKER/my-jupyter-image ``` 4. Verifica que hayas subido la imagen a Docker Hub. 1. Ve a [Docker Hub](https://hub.docker.com). 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. ```console $ 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](/engine/storage/volumes/#back-up-a-volume) y luego [subirlo usando la CLI de ORAS](/docker-hub/repos/manage/hub-images/oci-artifacts/#push-a-volume). 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](https://hub.docker.com). 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. ```console $ 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: - [Referencia de Dockerfile](/reference/dockerfile/) - [Referencia del archivo Compose](/reference/compose-file/) - [Referencia de la CLI de Docker](/guides/jupyter/reference/cli/docker) - [Docs de Jupyter Docker Stacks](https://jupyter-docker-stacks.readthedocs.io/en/latest/)