Executando Jupyter Lab com Docker e Docker Compose
Published: 2021-08-03 16:01:40

## Introdução

Atualmente temos opções online para o Jupyter Notebook/Lab como Google Colab, Kaggle, SageMaker e etc., mas ainda é comum precisarmos executar esta aplicação em nossa máquina local. Em um setup inicial, é necessário preparar todo o ambiente antes de começar a trabalhar e caso utilize um notebook compartilhado, podemos ter problemas de compatibilidade de pacotes ou versões.

O Docker fornece um ambiente isolado e que pode ser compartilhado por diferentes máquinas sem necessidade de dependências externas, podendo ajudar no setup de ambiente do Jupyter Lab.

## Preparação

Para seguir os passos apresentados neste artigo, é necessário ter instalado em sua máquina o Docker e Docker Compose, o tutorial de cada um pode ser encontrado em seus respectivos sites.

https://docs.docker.com/engine/install/ubuntu/
https://docs.docker.com/compose/install/

Caso esteja utilizando o Windows, é recomendável instalá-los via WSL2. Recomendo seguir os passos informados no repositório abaixo:

https://github.com/codeedu/wsl2-docker-quickstart

## Criação da imagem Docker

Após a instalação das ferramentas, o primeiro passo necessário é criar um imagem do Docker para o Jupyter Lab. Neste artigo não será abordado com detalhes a utilização do Docker, mas é recomendado estudá-lo posteriormente.

É comum termos imagens já prontas, criadas e disponibilizadas por outros desenvolvedores, com o Jupyter não é diferente, o projeto **Docker Stacks** disponibiliza diferentes imagens com determinado setup inicial.

Para este artigo será utilizado uma imagem específica para Data Science com Python chamada `jupyter/scipy-notebook` que já vem pré-instalado diversos pacotes comuns como numpy, pandas, scikit-learn. Caso você deseja começar do zero a instalação, então é recomendado utilizar a `jupyter/minimal-notebook`. Abaixo tem o link com todas as imagens disponíveis:

https://jupyter-docker-stacks.readthedocs.io/en/latest/using/selecting.html

Com a imagem definida, podemos começar criando nosso Dockerfile informando o seguinte código:

```
FROM jupyter/scipy-notebook
```

Por enquanto é só isso mesmo, como dito antes esta imagem já possui as bibliotecas tradicionais já instaladas, e assim não é necessário realizar algum comando inicial, caso você queira instalar alguma biblioteca adicional, basta executar o `pip` conforme abaixo:

```
FROM jupyter/scipy-notebook
RUN pip install requests feature_engine
```

## Executando a imagem com Docker

Após a criação do arquivo, é necessário "buildar" a imagem para o Docker utilizá-la quando for necessário:

```
docker build -t jupyter_lab .
```

Para a imagem pode ser qualquer nome desejado, como `jupyter_lab`, certifique-se de executar o comando no diretório do Dockerfile. Por fim, crie um container com a nova imagem:

```
docker run -p 8888:8888 -v $(pwd):/home/jovyan/work -e JUPYTER_ENABLE_LAB=yes jupyter_lab
```

Alguns comentários a respeito deste comando:
* O argumento em `-v` informa o volume do container, é importante informá-lo para que os notebooks criados não sejam perdidos caso o container seja removido. Este comando permite o Docker compartilhar o volume com o diretório atual, assim tudo que for criado dentro ou fora do Docker estará disponível em sua máquina.
* Esta variável de ambiente com o valor `yes` diz que queremos usar o Jupyter Lab ao invés do Jupyter Notebook.

Após executá-lo você irá observar no seu terminal o Jupyter sendo executado e disponibilizando a url para você acessá-lo. Desta forma atual, o Jupyter já está funcionando normalmente, mas optei por trazer um conteúdo adicional caso tenha interesse.

## Executando a imagem com Docker Compose

Basicamente o Docker Compose é uma ferramenta para definir e executar múltiplos containers. Para este artigo, sua utilidade mais importante é que possível definir no próprio código o volume, porta, variáveis de ambiente do seu container, ao invés de passar por linha de código conforme mostrado anteriormente.

Crie um arquivo `docker-compose.yml` no diretório atual e insira os seguintes comandos:

```shell
version: "3"

services: 
  jupyter_lab:
    container_name: jupyter_lab
    build: .
    ports: 
      - "8888:8888"
    environment: 
      - JUPYTER_ENABLE_LAB=yes
    volumes: 
      - .:/home/jovyan/work
```

Basicamente pegamos o comando passado por linha de comando para o Docker e trouxemos para um arquivo `.yml`. Assim, facilitando a fácil reusabilidade do container. Agora só é necessário executar os comandos:

```
docker-compose build
```
```
docker-compose up
```

Este primeiro comando de `build` só é necessário na primeira vez que você executar, após isto basta informar o `up` ou o `down` para parar o container. Com o Docker Compose fica mais produtivo executar seu Jupyter Lab mais rapidamente.

Apenas algumas considerações finais:
* Para executar o comando `docker-compose` você precisa estar no diretório onde se encontra o arquivo.
* Neste artigo utilizamos como o volume o diretório atual, caso você precise acessar um notebook em outra pasta, o Jupyter não irá encontrá-lo. Para isso seria interessante informar um caminho que agregue todos os seus notebooks no volume.
* Por curiosidade: `jovyan` é o nome de usuário padrão, usado para descrever os membros da [comunidade](https://jupyter.readthedocs.io/en/latest/community/content-community.html#what-is-a-jovyan).


## Palavras Finais
Muito obrigado pela sua atenção! Este foi meu primeiro artigo então com certeza tem muita coisa para melhorar, então se possível pode deixar seu feedback ou alguma dúvida :).
Repositório deste artigo:
https://github.com/llucasreis/docker_jupyterlab