JupyterLab · 8 min read · Oct 21, 2025

Como Instalar e Configurar um Ambiente JupyterLab no Rocky Linux 9

JupyterLab é um ambiente de desenvolvimento baseado na web de próxima geração para o Projeto Jupyter. O Projeto Jupyter foi desenvolvido com o objetivo de criar software livre, padrões abertos e serviços para computação interativa em várias linguagens de programação. O JupyterLab oferece uma interface flexível que permite aos desenvolvedores trabalhar com documentos e atividades como notebooks Jupyter, editores de texto, terminais e componentes personalizados de maneira flexível, integrada e extensível. O JupyterLab é a próxima geração do Jupyter Notebook e deve eventualmente substituí-lo. Ele suporta mais de 40 linguagens de programação, incluindo R, Python, Scala e Julia.

Este tutorial ensinará como instalar e configurar o JupyterLab em um servidor Rocky Linux 9.

Pré-requisitos

  • Um servidor rodando Rocky Linux 9.
  • Um usuário não-root com privilégios sudo.
  • Um nome de domínio totalmente qualificado (FQDN) apontando para seu servidor. Para nossos propósitos, usaremos jupyterlab.example.com como o nome de domínio.
  • O SELinux está desativado.
  • Certifique-se de que tudo está atualizado. $ sudo dnf update
  • Instale pacotes utilitários básicos. Alguns deles podem já estar instalados. $ sudo dnf install wget curl nano unzip yum-utils -y

Passo 1 - Configurar o Firewall

O primeiro passo é configurar o firewall. O Rocky Linux usa o Firewalld Firewall. Verifique o status do firewall.

$ sudo firewall-cmd --state
running

O firewall funciona com diferentes zonas, e a zona pública é a padrão que usaremos. Liste todos os serviços e portas ativos no firewall.

$ sudo firewall-cmd --permanent --list-services

Deve mostrar a seguinte saída.

cockpit dhcpv6-client ssh

O Wiki.js precisa das portas HTTP e HTTPS para funcionar. Abra-as.

$ sudo firewall-cmd --add-service=http --permanent
$ sudo firewall-cmd --add-service=https --permanent

Recarregue o firewall para aplicar as alterações.

$ sudo firewall-cmd --reload

Passo 2 - Instalar o Nginx

O Rocky Linux 9 vem com uma versão mais antiga do Nginx. Você precisa baixar o repositório oficial do Nginx para instalar a versão mais recente.

Crie e abra o arquivo /etc/yum.repos.d/nginx.repo para criar o repositório oficial do Nginx.

$ sudo nano /etc/yum.repos.d/nginx.repo

Cole o seguinte código nele.

[nginx-stable]
name=nginx stable repo
baseurl=http://nginx.org/packages/centos/$releasever/$basearch/
gpgcheck=1
enabled=1
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=true

[nginx-mainline]
name=nginx mainline repo
baseurl=http://nginx.org/packages/mainline/centos/$releasever/$basearch/
gpgcheck=1
enabled=0
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=true

Salve o arquivo pressionando Ctrl + X e digitando Y quando solicitado.

Instale o servidor Nginx.

$ sudo dnf install nginx -y

Verifique a instalação.

$ nginx -v
nginx version: nginx/1.22.1

Ative e inicie o servidor Nginx.

$ sudo systemctl enable nginx --now

Verifique o status do servidor.

$ sudo systemctl status nginx
? nginx.service - nginx - servidor web de alto desempenho
     Loaded: loaded (/usr/lib/systemd/system/nginx.service; enabled; vendor preset: disabled)
     Active: active (running) since Tue 2022-12-13 06:07:05 UTC; 31s ago
       Docs: http://nginx.org/en/docs/
    Process: 146475 ExecStart=/usr/sbin/nginx -c /etc/nginx/nginx.conf (code=exited, status=0/SUCCESS)
   Main PID: 146476 (nginx)
      Tasks: 2 (limit: 5911)
     Memory: 1.9M
        CPU: 15ms
     CGroup: /system.slice/nginx.service
             ??146476 "nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf"
             ??146477 "nginx: worker process"

Passo 3 - Instalar o JupyterLab

Vamos verificar a versão do python primeiro.

$ python -V
Python 3.9.14

Instale o gerenciador de pacotes PIP.

$ sudo dnf install python3-pip

Crie um diretório para o JupyterLab.

$ mkdir jupyterlab

Mude para o diretório recém-criado.

$ cd ~/jupyterlab

Configure um ambiente virtual chamado jupyterlab_env.

$ python3 -m venv --system-site-packages jupyterlab_env

Ative o ambiente.

$ source jupyterlab_env/bin/activate

Atualize o gerenciador de pacotes Pip.

(jupyterlab_env) $ pip install --upgrade pip

Instale o JupyterLab.

(jupyterlab_env) $ pip install jupyterlab

Passo 4 - Configurar o JupyterLab

Por padrão, o JupyterLab gera um novo token toda vez que você o inicia para conceder acesso à interface. Vamos substituí-lo por autenticação por senha.

Gere um hash de senha. Substitua YOUR_PASSWORD por uma senha forte de sua escolha.

(jupyterlab_env) $ python3 -c "from jupyter_server.auth import passwd; print(passwd('YOUR_PASSWORD'))"

O comando acima gerará um longo hash de senha. Ele usa a função de hash de senha Argon2. Anote o hash.

Crie um arquivo de configuração do JupyterLab.

(jupyterlab_env) $ jupyter lab --generate-config

O comando acima gerará um arquivo de configuração com valores padrão e o salvará no diretório ~/.jupyter.

Abra o arquivo para edição.

(jupyterlab_env) $ nano ~/.jupyter/jupyter_lab_config.py

Encontre as seguintes variáveis, descomente-as e altere seus valores conforme abaixo. Substitua PASSWORD_HASH pelo hash gerado acima.

c.ServerApp.allow_remote_access = True

c.ServerApp.password = 'PASSWORD_HASH'

Salve o arquivo pressionando Ctrl + X e digitando Y quando solicitado.

Abra a porta 8888 no firewall.

$ sudo firewall-cmd --add-port=8888/tcp --permanent
$ sudo firewall-cmd --reload

Execute o servidor JupyterLab. O parâmetro --ip 0.0.0.0 permite que ele escute qualquer endereço IP e não apenas localhost.

$ jupyter lab --ip 0.0.0.0

O comando acima inicia um servidor JupyterLab na porta padrão 8888 que abrimos. Inicie a URL http://:8888/ em seu navegador e você verá a seguinte tela.

Tela de Login do JupyterLab

Digite sua senha e clique no botão Login para abrir a interface do JupyterLab.

Página Inicial do JupyterLab

Agora que o acesso foi confirmado, pressione Ctrl + C para parar o servidor e digite y quando solicitado para parar.

Passo 5 - Criar arquivo de serviço do JupyterLab

Saia do ambiente virtual.

(jupyterlab_env) $ deactivate

Crie um novo arquivo de serviço para o JupyterLab.

$ sudo nano /lib/systemd/system/jupyterlab.service

Cole o seguinte código nele.

[Unit]
Description=Servidor JupyterLab

[Service]
User=USER
Group=USER
Type=simple
WorkingDirectory=/home/USER/jupyterlab
ExecStart=/home/USER/jupyterlab/jupyterlab_env/bin/jupyter-lab --config=/home/USER/.jupyter/jupyter_lab_config.py
StandardOutput=null
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target

Salve o arquivo pressionando Ctrl + X e digitando Y quando solicitado.

Substitua USER pelo usuário atualmente logado em seu sistema.

Inicialize o serviço JupyterLab.

$ sudo systemctl daemon-reload

Ative e inicie o serviço JupyterLab.

$ sudo systemctl enable jupyterlab --now

Verifique o status do serviço.

$ sudo systemctl status jupyterlab
? jupyterlab.service - Servidor JupyterLab
     Loaded: loaded (/usr/lib/systemd/system/jupyterlab.service; disabled; vendor preset: disabled)
     Active: active (running) since Tue 2022-12-13 11:45:26 UTC; 5s ago
   Main PID: 151675 (jupyter-lab)
      Tasks: 1 (limit: 5911)
     Memory: 59.0M
        CPU: 1.943s
     CGroup: /system.slice/jupyterlab.service
             ??151675 /home/navjot/jupyterlab/jupyterlab_env/bin/python3 /home/navjot/jupyterlab/jupyterlab_env/bin/jupyter-lab --config=/home/navjot/.jupyter/jupyter_lab_config.py

Dec 13 11:45:26 jupyter.example.com systemd[1]: Started Servidor JupyterLab.

Passo 6 - Instalar SSL

Antes de prosseguir, precisamos instalar a ferramenta Certbot e um certificado SSL para nosso domínio.

Para instalar o Certbot, usaremos o instalador de pacotes Snapd. O Snapd sempre carrega a versão estável mais recente do Certbot e você deve usar isso.

A ferramenta Snapd requer o repositório Epel para funcionar.

$ sudo dnf install epel-release -y

Usaremos o Snapd para instalar o Certbot. Instale o Snapd.

$ sudo dnf install snapd -y

Ative e inicie o serviço Snap.

$ sudo systemctl enable snapd.socket --now

Crie os links necessários para o Snapd funcionar.

$ sudo ln -s /var/lib/snapd/snap /snap
$ echo 'export PATH=$PATH:/var/lib/snapd/snap/bin' | sudo tee -a /etc/profile.d/snapd.sh

Certifique-se de que sua versão do snapd está atualizada.

$ sudo snap install core 
$ sudo snap refresh core

Instale o Certbot.

$ sudo snap install --classic certbot

Use o seguinte comando para garantir que o comando Certbot possa ser executado criando um link simbólico para o diretório /usr/bin.

$ sudo ln -s /snap/bin/certbot /usr/bin/certbot

Gere um certificado SSL.

$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d jupyterlab.example.com

O comando acima fará o download de um certificado para o diretório /etc/letsencrypt/live/jupyterlab.example.com em seu servidor.

Gere um certificado de grupo Diffie-Hellman.

$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096

Faça um teste do processo para verificar se a renovação do SSL está funcionando corretamente.

$ sudo certbot renew --dry-run

Se você não ver erros, está tudo pronto. Seu certificado será renovado automaticamente.

Passo 7 - Configurar o Nginx

Crie e abra o arquivo /etc/nginx/conf.d/jupyterlab.conf para edição.

$ sudo nano /etc/nginx/conf.d/jupyterlab.conf

Cole o seguinte código no arquivo jupyterlab.conf. Substitua todas as instâncias de jupyterlab.example.com pelo seu domínio.

## impor HTTPS
server {
  listen 80;
  listen [::]:80;
  server_name jupyterlab.example.com;
  return 301 https://$server_name$request_uri;
}

server {
  listen 443 ssl http2;
  listen [::]:443 ssl http2;
  server_name jupyterlab.example.com;

  access_log /var/log/nginx/jupyterlab.access.log;
  error_log /var/log/nginx/jupyterlab.error.log;
  client_max_body_size 20m;

  http2_push_preload on; # Habilitar HTTP/2 Server Push

  ssl_certificate     /etc/letsencrypt/live/jupyterlab.example.com/fullchain.pem;
  ssl_certificate_key /etc/letsencrypt/live/jupyterlab.example.com/privkey.pem;
  ssl_trusted_certificate /etc/letsencrypt/live/jupyterlab.example.com/chain.pem;
  ssl_session_timeout 1d;

  # Habilitar versões TLS (TLSv1.3 é necessário para o próximo HTTP/3 QUIC).
  ssl_protocols TLSv1.2 TLSv1.3;

  # Habilitar 0-RTT do TLSv1.3. Use $ssl_early_data ao reverter o proxy para
  # evitar ataques de repetição.
  #
  # @see: https://nginx.org/en/docs/http/ngx_http_ssl_module.html#ssl_early_data
  ssl_early_data on;

  ssl_ciphers 'ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA384';
  ssl_prefer_server_ciphers on;
  ssl_ecdh_curve X25519:prime256v1:secp384r1:secp521r1;
  ssl_session_cache shared:SSL:50m;
  ssl_session_tickets off;

  # OCSP Stapling ---
  # buscar registros OCSP da URL no ssl_certificate e armazená-los em cache
  ssl_stapling on;
  ssl_stapling_verify on;
  ssl_dhparam /etc/ssl/certs/dhparam.pem;

  add_header X-Early-Data $tls1_3_early_data;

  location / {
    proxy_set_header Host $http_host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header Host $host;
    proxy_http_version 1.1;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection $connection_upgrade;
    proxy_set_header X-Scheme $scheme;
    proxy_buffering off;
    proxy_set_header X-Forwarded-Proto https;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_pass http://127.0.0.1:8888;
  }
}

# Este bloco é útil para depurar TLS v1.3. Sinta-se à vontade para remover isso
# e usar a variável `$ssl_early_data` exposta pelo NGINX diretamente, se desejar.
map $ssl_early_data $tls1_3_early_data {
  "~." $ssl_early_data;
  default "";
}
map $http_upgrade $connection_upgrade {
  default upgrade;
  '' close;
}

A configuração acima redirecionará todas as solicitações HTTP para HTTPS e servirá como um proxy para o serviço JupyterLab para servi-lo através do seu domínio.

Salve o arquivo pressionando Ctrl + X e digitando Y quando solicitado.

Abra o arquivo /etc/nginx/nginx.conf para edição.

$ sudo nano /etc/nginx/nginx.conf

Adicione a seguinte linha antes da linha include /etc/nginx/conf.d/*.conf;.

server_names_hash_bucket_size  64;

Salve o arquivo pressionando Ctrl + X e digitando Y quando solicitado.

Verifique sua configuração do Nginx.

$ sudo nginx -t

Se você não ver erros, significa que está tudo certo. Recarregue o servidor Nginx.

$ sudo systemctl reload nginx

Agora você pode acessar o JupyterLab visitando a URL https://jupyterlab.example.com em seu navegador.

Conclusão

Isso conclui nosso tutorial sobre como instalar e configurar o JupyterLab em um servidor Rocky Linux 9 e servi-lo usando o servidor proxy Nginx. Se você tiver alguma dúvida, poste nos comentários abaixo.

Share: X/Twitter LinkedIn
#JupyterLab

Receba novas postagens na sua caixa de entrada

Sem spam. Cancele a assinatura a qualquer momento.