Segurança — JupyterLab

ChartVersion3.0.1TypeapplicationAppVersion5.3.0

CompatibilidadeKubernetes1.32+OpenShift4.19+Rancher2.10.x+

Suporte a recursosLDAPsuportado

O chart tdp-jupyter usa por padrão autenticação DummyAuthenticator (usuário e senha definidos nos valores) e permite LDAP opcional via ldapauthenticator.LDAPAuthenticator.

Autenticação padrão

tdp-jupyter:
  hub:
    config:
      JupyterHub:
        authenticator_class: dummy
      DummyAuthenticator:
        username: admin
        password: tdp-password

warning

Adequado apenas para desenvolvimento. Altere a senha ou o método de autenticação em produção.

LDAP

A autenticação LDAP é opcional. Para habilitá-la, crie o Secret com a senha de bind e aplique a configuração de overlay.

Credenciais e Secrets

Terminal input

kubectl create secret generic tdp-jupyter-ldap-bind \
  --from-literal=LDAP_BIND_PASSWORD='<LDAP_BIND_PASSWORD>' \
  -n <NAMESPACE>

Configuração LDAP

tdp-jupyter:
  hub:
    config:
      JupyterHub:
        authenticator_class: ldapauthenticator.LDAPAuthenticator
      LDAPAuthenticator:
        server_address: "<LDAP_HOST>"
        server_port: 389
        tls_strategy: "insecure"
        user_attribute: "uid"
        bind_dn_template:
          - "uid={username},cn=users,cn=accounts,dc=<LDAP_DOMAIN>,dc=<TLD>"
    extraConfig:
      ldap-config: |
        c.Authenticator.allow_all = True

O bloco allow_all é opcional e serve para facilitar testes. Em produção, restrinja com as políticas suportadas pelo LDAPAuthenticator da sua versão do JupyterHub (consulte a documentação oficial para allowed_groups e listas de usuários).

Parâmetros

Parâmetro	Descrição
LDAPAuthenticator.server_address	Endereço do servidor LDAP
LDAPAuthenticator.server_port	Porta do servidor LDAP
tls_strategy	Modo TLS (ex.: insecure para desenvolvimento)
bind_dn_template	Template do DN do usuário
user_attribute	Atributo de login (ex.: uid)

NetworkPolicy do servidor single-user

O chart aplica uma NetworkPolicy aos pods single-user que restringe tanto ingress quanto egress.

Egress

O bloco singleuser.networkPolicy controla o tráfego de saída (egress) permitido para os pods de notebook do usuário. Por padrão (enabled: true), as regras de egress liberam:

tdp-jupyter:
  singleuser:
    networkPolicy:
      enabled: true
      egress:
        # Resolução DNS
        - to:
          - namespaceSelector:
              matchLabels:
                kubernetes.io/metadata.name: kube-system
          ports:
          - protocol: UDP
            port: 53
          - protocol: TCP
            port: 53
        # Comunicação com o Hub (mesmo namespace)
        - to:
          - namespaceSelector: {}
        # Acesso a IPs externos ao cluster (ex.: Ozone S3, serviços externos)
        - to:
          - ipBlock:
              cidr: 0.0.0.0/0
        # Spark Master no mesmo namespace
        - to:
          - podSelector:
              matchLabels:
                app.kubernetes.io/component: master
                app.kubernetes.io/name: spark
          ports:
          - protocol: TCP
            port: 7077

Regra	Finalidade
DNS (kube-system, portas 53 UDP/TCP)	Resolução de nomes
namespaceSelector: {}	Comunicação com o Hub e demais pods do namespace
ipBlock: 0.0.0.0/0	Acesso a serviços externos ao cluster (Ozone S3G, Trino, Kafka, Hive Metastore, etc.)
podSelector Spark master (porta 7077)	Conexão com o cluster Spark quando tdpSparkIntegration.enabled: true

Ajuste ou restrinja egress conforme a política de rede do ambiente — por exemplo, substituindo 0.0.0.0/0 por ipBlock.cidr mais específicos para os serviços S3/Ozone, Trino ou Hive Metastore usados pelo notebook.

Ingress (Workers Spark → driver)

Em modo de cluster distribuído, o driver Spark roda dentro do pod do notebook — são os Workers que precisam abrir conexão de volta para ele, não o contrário.
Por isso é necessário permitir ingress dos pods Worker nas portas do driver (2222) e do block manager (7777) do notebook, para que os Workers consigam entregar os resultados ao driver:

tdp-jupyter:
  singleuser:
    networkPolicy:
      enabled: true
      # Permite que os Workers Spark se conectem de volta ao driver do notebook
      ingress:
        - from:
            - podSelector:
                matchLabels:
                  app.kubernetes.io/component: worker
                  app.kubernetes.io/instance: tdp-spark
                  app.kubernetes.io/name: spark
          ports:
            - protocol: TCP
              port: 2222   # spark.driver.port
            - protocol: TCP
              port: 7777   # spark.blockManager.port

warning

Sem essa regra de ingress, os Workers entram em timeout ao tentar alcançar o driver e a aplicação Spark falha com Connecting to /<pod-ip>:2222 timed out.

Solução de problemas

Problema	Solução
Falha de login LDAP	Verifique bind_dn_template, conectividade e atributos do servidor LDAP
Hub não inicia	Valide a sintaxe de extraConfig e o YAML
Falha de conexão Spark/S3/Trino a partir do notebook	Verifique singleuser.networkPolicy.egress — tráfego pode estar sendo bloqueado
Workers não conseguem alcançar o driver (Connecting to /<ip>:2222 timed out)	A NetworkPolicy do pod single-user está bloqueando o ingress dos pods Worker do Spark. Adicione a regra de ingress da seção Ingress (Workers Spark → driver) e atualize o release