Como Configurar o Jupyter Notebook com Python 3 no Debian 10

Introdução

O Jupyter Notebook oferece um shell de comando para computação interativa como uma aplicação web, para que você possa compartilhar e se comunicar com código. A ferramenta pode ser usada com várias linguagens, incluindo Python, Julia, R, Haskell e Ruby. É frequentemente utilizado para trabalhar com dados, modelagem estatística e aprendizado de máquina.

Este tutorial o guiará na configuração do Jupyter Notebook para executar em um servidor Debian 10, além de lhe ensinar como se conectar e usar o Notebook. Os Notebooks Jupyter (ou apenas “Notebooks”) são documentos produzidos pelo aplicativo Jupyter Notebook que contêm código de computador e elementos de rich text (parágrafo, equações, figuras, links etc.) que auxiliam na apresentação e compartilhamento de pesquisas reproduzíveis.

Ao final deste guia, você será capaz de executar código Python 3 usando o Jupyter Notebook em um servidor Debian 10 remoto.

Pré-requisitos

Para concluir este guia, você deve ter uma nova instância do servidor Debian 10 com um firewall básico e um usuário não-root com privilégios sudo configurados. Você pode aprender como configurar isso seguindo nosso guia Initial Server Setup with Debian 10.

Passo 1 — Instalar Headers de Pip e Python

Para iniciar o processo, baixaremos e instalaremos todos os itens que precisamos dos repositórios do Debian. Usaremos o gerenciador de pacotes Python pip para instalar componentes adicionais um pouco mais tarde.

Primeiro precisamos atualizar o índice de pacotes local do apt e depois baixar e instalar os pacotes:

sudo apt update

Em seguida, instale o pip e os arquivos de header ou cabeçalho Python, que são usados por algumas das dependências do Jupyter:

sudo apt install python3-pip python3-dev

O Debian 10 (“Buster”) vem com o Python 3.7 pré-instalado.

Agora podemos seguir para a configuração de um ambiente virtual Python no qual instalaremos o Jupyter.

Passo 2 — Criar um Ambiente Virtual Python para o Jupyter

Agora que temos o Python 3, seus arquivos de header e o pip prontos, podemos criar um ambiente virtual Python para facilitar o gerenciamento. Instalaremos o Jupyter neste ambiente virtual.

Para fazer isso, primeiro precisamos de acesso ao comando virtualenv. Podemos instalar isso com o pip.

Atualize o pip e instale o pacote digitando:

sudo -H pip3 install --upgrade pip
sudo -H pip3 install virtualenv

Com o virtualenv instalado, podemos começar a formar nosso ambiente. Crie e mude para um diretório em que possamos manter nossos arquivos de projeto:

mkdir ~/myprojectdir
cd ~/myprojectdir

Dentro do diretório do projeto, crie um ambiente virtual Python digitando:

virtualenv myprojectenv

Isso criará um diretório chamado myprojectenv dentro do seu diretório myprojectdir. Dentro dele, será instalada uma versão local do Python e uma versão local do pip. Podemos usar isso para instalar e configurar um ambiente Python isolado para o Jupyter.

Antes de instalarmos o Jupyter, precisamos ativar o ambiente virtual. Você pode fazer isso digitando:

source myprojectenv/bin/activate

Seu prompt deve mudar para indicar que você está operando agora em um ambiente virtual Python. Vai se parecer com algo assim: (myprojectenv)user@host:~/myprojectdir$.

Agora você está pronto para instalar o Jupyter neste ambiente virtual.

Passo 3 — Instalar o Jupyter

Com seu ambiente virtual ativo, instale o Jupyter com a instância local do pip:

pip install jupyter

Neste ponto, você instalou com êxito todo o software necessário para executar o Jupyter. Agora podemos iniciar o servidor de Notebook.

Passo 4 — Executar o Jupyter Notebook

Agora você tem tudo o que precisa para executar o Jupyter Notebook! Para executá-lo, execute o seguinte comando:

jupyter notebook

Um log das atividades do Jupyter Notebook será impresso no terminal. Quando você executa o Jupyter Notebook, ele é executado em um número de porta específico. O primeiro Notebook que você executa geralmente usa a porta 8888. Para verificar o número da porta específica em que o Jupyter Notebook está sendo executado, consulte a saída do comando usado para iniciá-lo:

Output
[I 21:23:21.198 NotebookApp] Writing notebook server cookie secret to /run/user/1001/jupyter/notebook_cookie_secret
[I 21:23:21.361 NotebookApp] Serving notebooks from local directory: /home/sammy/myprojectdir
[I 21:23:21.361 NotebookApp] The Jupyter Notebook is running at:
[I 21:23:21.361 NotebookApp] http://localhost:8888/?token=1fefa6ab49a498a3f37c959404f7baf16b9a2eda3eaa6d72
[I 21:23:21.361 NotebookApp] Use Control-C to stop this server and shut down all kernels (twice to skip confirmation).
[W 21:23:21.361 NotebookApp] No web browser found: could not locate runnable browser.
[C 21:23:21.361 NotebookApp]

    Copy/paste this URL into your browser when you connect for the first time,
    to login with a token:
        http://localhost:8888/?token=1fefa6ab49a498a3f37c959404f7baf16b9a2eda3eaa6d72

Se você estiver executando o Jupyter Notebook em um computador Debian local (não em um Droplet), você pode simplesmente navegar até a URL exibida para se conectar ao Jupyter Notebook. Se você estiver executando o Jupyter Notebook em um Droplet, precisará se conectar ao servidor usando o tunelamento SSH, conforme descrito na próxima seção.

Nesse ponto, você pode manter a conexão SSH aberta e manter o Jupyter Notebook em execução ou pode sair do aplicativo e executá-lo novamente depois de configurar o tunelamento SSH. Vamos simplificar e interromper o processo do Jupyter Notebook. Vamos executá-lo novamente assim que o tunelamento SSH estiver funcionando. Para interromper o processo do Jupyter Notebook, pressione CTRL+C, digite Y e pressione ENTER para confirmar. O seguinte será exibido:

Output
[C 21:28:28.512 NotebookApp] Shutdown confirmed
[I 21:28:28.512 NotebookApp] Shutting down 0 kernels

Agora vamos configurar um túnel SSH para que possamos acessar o Notebook.

Passo 5 — Conectar ao Servidor Usando o Tunelamento SSH

Nesta seção, aprenderemos como conectar-se à interface web do Jupyter Notebook usando o tunelamento SSH. Como o Jupyter Notebook será executado em uma porta específica no servidor (como :8888, :8889 etc.), o tunelamento SSH lhe permite conectar à porta do servidor com segurança.

As próximas duas subseções descrevem como criar um túnel SSH a partir de 1) um Mac ou Linux e 2) Windows. Consulte a subseção correspondente ao seu computador local.

Tunelamento SSH com um Mac ou Linux

Se você estiver usando um Mac ou Linux, as etapas para criar um tunelamento SSH são semelhantes ao uso do SSH para efetuar login no seu servidor remoto, exceto que existem parâmetros adicionais no comando ssh. Esta subseção descreverá os parâmetros adicionais necessários no comando ssh para fazer o túnel com êxito.

O tunelamento SSH pode ser feito executando o seguinte comando SSH em uma nova janela do terminal local:

ssh -L 8888:localhost:8888 usuário_do_seu_servidor@ip_do_seu_servidor

O comando ssh abre uma conexão SSH, mas o -L especifica que a porta indicada no host local (cliente) deve ser encaminhada para o host e porta especificados no lado remoto (servidor). Isso significa que tudo o que estiver em execução no segundo número da porta (por exemplo, 8888) no servidor aparecerá no primeiro número de porta (por exemplo, 8888) no computador local.

Opcionalmente, altere a porta 8888 para uma de sua escolha, para evitar o uso de uma porta já em uso por outro processo.

usuário_do_seu_servidor é o seu nome de usuário (por exemplo, sammy) no servidor que você criou e ip_do_seu_servidor é o endereço IP do seu servidor.

Por exemplo, para o nome de usuário sammy e o endereço do servidor 203.0.113.0, o comando seria:

ssh -L 8888:localhost:8888 sammy@203.0.113.0

Se nenhum erro aparecer após a execução do comando ssh -L, você poderá entrar no seu ambiente de programação e executar o Jupyter Notebook:

jupyter notebook

Você receberá uma saída com uma URL. Em um navegador em sua máquina local, abra a interface web do Jupyter Notebook com a URL que começa com http://localhost:8888. Certifique-se de que o número do token esteja incluído ou digite a string do número do token quando solicitado em http://localhost:8888.

Tunelamento SSH com Windows e Putty

Se você estiver usando o Windows, poderá criar um túnel SSH usando o Putty.

Primeiro, digite a URL ou o endereço IP do servidor como o nome do host, como mostrado:

Em seguida, clique em SSH na parte inferior do painel esquerdo para expandir o menu e clique em Tunnels. Digite o número da porta local a ser usada para acessar o Jupyter em sua máquina local. Escolha 8000 ou superior para evitar portas usadas por outros serviços e defina o destino como localhost:8888 onde :8888 é o número da porta em que o Jupyter Notebook está sendo executado.

Agora clique no botão Add e as portas devem aparecer na lista Forwarded ports:

Por fim, clique no botão Open para conectar-se ao servidor via SSH e tunelar as portas desejadas. Navegue para http://localhost:8000 (ou qualquer porta que você escolher) em um navegador web para conectar-se ao Jupyter Notebook em execução no servidor. Certifique-se de que o número do token esteja incluído ou insira a string do número do token quando solicitado em http://localhost:8000.

Passo 6 — Usando o Jupyter Notebook

Esta seção aborda os conceitos básicos do uso do Jupyter Notebook. Se você não possui o Jupyter Notebook atualmente em execução, inicie-o com o comando jupyter notebook.

Agora você deve estar conectado a ele usando um navegador. O Jupyter Notebook é uma ferramenta muito poderosa com muitos recursos. Esta seção descreverá alguns dos recursos básicos para você começar a usar o Notebook. O Jupyter Notebook mostrará todos os arquivos e pastas no diretório em que é executado, portanto, quando você estiver trabalhando em um projeto, certifique-se de iniciá-lo a partir do diretório do projeto.

Para criar um novo arquivo do Notebook, selecione New > Python 3 no menu suspenso superior direito:

Isso abrirá um notebook. Agora podemos executar o código Python na célula ou alterá-la para markdown. Por exemplo, altere a primeira célula para aceitar o Markdown clicando em Cell > Cell Type > Markdown na barra de navegação superior. Agora podemos escrever notas usando o Markdown e até incluir equações escritas em LaTeX colocando-as entre os símbolos $$. Por exemplo, digite o seguinte na célula depois de alterá-la para markdown:

# First Equation

Let us now implement the following equation:
$$ y = x^2$$

where $x = 2$

Para transformar o markdown em rich text, pressione CTRL+ENTER, e o resultado deve ser o seguinte:

Você pode usar as células markdown para fazer anotações e documentar seu código. Vamos implementar essa equação e imprimir o resultado. Clique na célula superior e pressione ALT+ENTER para adicionar uma célula abaixo dela. Digite o seguinte código na nova célula.

x = 2
y = x**2
print(y)

Para executar o código, pressione CTRL+ENTER. Você receberá os seguintes resultados:

Agora você tem a capacidade de importar módulos e usar o Notebook como faria com qualquer outro ambiente de desenvolvimento Python!

Conclusão

Nesse ponto, você deve poder escrever código e notas Python reproduzíveis no Markdown usando o Jupyter Notebook. Para obter um tour rápido pelo Jupyter Notebook de dentro da interface, selecione Help > User Interface Tour no menu de navegação superior para saber mais.

A partir daqui, você pode iniciar um projeto de análise e visualização de dados lendo o tutorial Data Analysis and Visualization with pandas and Jupyter Notebook in Python 3.