Usando JupyterHub no Big Data Service 3.0.27 ou Mais Recente

Use JupyterHub para gerenciar notebooks ODH 2.x do Big Data Service 3.0.27 ou posterior para grupos de usuários.

Pré-requisitos

Acessando o JupyterHub

Acesse JupyterHub por meio do browser para clusters ODH 2.x do Big Data Service 3.0.27 ou posterior.

Acesse o Apache Ambari.
Na barra de ferramentas lateral, em Serviços, selecione JupyterHub.

Gerenciar JupyterHub

Um usuário JupyterHub admin pode executar as seguintes tarefas para gerenciar notebooks em JupyterHub nos nós ODH 2.x do Big Data Service 3.0.27 ou posterior.

Para gerenciar os serviços do Oracle Linux 7 com o comando systemctl, consulte Como Trabalhar com Serviços do Sistema.

Para acessar uma instância do Oracle Cloud Infrastructure, consulte Conectando-se à sua Instância.

Interrompendo, Iniciando ou Reiniciando o JupyterHub por Meio do Ambari

Como administrador, você pode interromper ou desativar JupyterHub para que ele não consuma recursos, como memória. A reinicialização também pode ajudar com problemas ou comportamentos inesperados.

Observação

Interrompa ou inicie JupyterHub por meio do Ambari para clusters do Big Data Service 3.0.27 ou mais recentes.

Acesse o Apache Ambari.
Na barra de ferramentas lateral, em Serviços, selecione JupyterHub.
Selecione Ações:
- Para iniciar o JupyterHub, selecione Iniciar.
- Para interromper o JupyterHub, selecione Interromper.
- Para reiniciar o JupyterHub, selecione Reiniciar.

Adicionando o Servidor JupyterHub

Como administrador, você pode adicionar o Servidor JupyterHub a um nó do Big Data Service.

Observação

Está disponível para clusters do Big Data Service 3.0.27 ou mais recentes.

Acesse o Apache Ambari.
Na barra de ferramentas lateral, selecione Hosts.
Para adicionar o Servidor JupyterHub, selecione um host em que JupyterHub não esteja instalado.
Selecione Adicionar.
Selecione JupyterHub Server.

Movendo o Servidor JupyterHub

Como administrador, você pode mover o Servidor JupyterHub para outro nó do Big Data Service.

Observação

Está disponível para clusters do Big Data Service 3.0.27 ou mais recentes.

Acesse o Apache Ambari.
Na barra de ferramentas lateral, em Serviços, selecione JupyterHub.
Selecione Ações e, em seguida, Mover Servidor JupyterHub.
Selecione Próximo.
Selecione o host para o qual mover o Servidor JupyterHub.
Conclua o assistente de movimentação.

Executando Verificações de Serviço/Saúde do JupyterHub

Como administrador, você pode executar verificações de serviço/integridade JupyterHub por meio do Ambari.

Observação

Está disponível para clusters do Big Data Service 3.0.27 ou mais recentes.

Acesse o Apache Ambari.
Na barra de ferramentas lateral, em Serviços, selecione JupyterHub.
Selecione Ações e, em seguida, Executar Verificação de Serviço.

Gerenciar Usuários e Permissões

Use um dos dois métodos de autenticação para autenticar usuários em JupyterHub para que eles possam criar notebooks e, opcionalmente, administrar JupyterHub em clusters ODH 2.x do Big Data Service 3.0.27 ou posterior.

OS usuários JupyterHub devem ser adicionados como usuários do sistema operacional em todos OS nós de cluster do Big Data Service para clusters do Big Data Service não Active Directory (AD), nos quais OS usuários não são sincronizados automaticamente em todos OS nós de cluster. Os administradores podem usar o script de Gerenciamento de Usuários JupyterHub para adicionar usuários e grupos antes de acessar JupyterHub.

Pré-requisitos

Execute o seguinte antes de acessar JupyterHub:

O acesso SSH ao nó em que JupyterHub está instalado.
Navegue até /usr/odh/current/jupyterhub/install.

Para fornecer os detalhes de todos os usuários e grupos no arquivo sample_user_groups.json, execute:

sudo python3 UserGroupManager.py sample_user_groups.json
          
          Verify user creation by executing the following command:
          id <any-user-name>

Tipos de Autenticação Suportados

NativeAuthenticator: Este autenticador é usado para aplicativos JupyterHub de pequeno ou médio porte. Cadastre-se e a autenticação são implementadas como nativas de JupyterHub sem depender de serviços externos.
SSOAuthenticator: Esse autenticador fornece uma subclasse de jupyterhub.auth.Authenticator que atua como um Provedor de Serviços SAML2. Direcione-o para um Provedor de Identidades SAML2 configurado adequadamente e ele ativará o sign-on único para JupyterHub.

Autenticação Nativa

A autenticação nativa depende do banco de dados do usuário JupyterHub para autenticar usuários.

A autenticação nativa se aplica a clusters HA e não HA. Consulte autenticador nativo para obter detalhes sobre o autenticador nativo.

Pré-requisitos para Autorizar um Usuário em um Cluster de Alta Disponibilidade

Esses pré-requisitos devem ser atendidos para autorizar um usuário em um cluster HA do Big Data Service usando a autenticação nativa.

O usuário deve existir no host do Linux. Execute o comando a seguir para adicionar um novo usuário do Linux em todos os nós de um cluster.
```
# Add linux user
dcli -C "useradd -d /home/<username> -m -s /bin/bash <username>"
```
Para iniciar um servidor de notebook, um usuário deve fornecer o principal e o arquivo keytab path/password e solicitar um ticket do Kerberos na interface do JupyterHub. Para criar um keytab, o administrador do cluster deve adicionar o principal do Kerberos com uma senha e com um arquivo keytab. Execute os comandos a seguir no primeiro nó principal (mn0) do cluster.
```
# Create a kdc principal with password or give access to existing keytabs.
kadmin.local -q "addprinc <principalname>"
Password Prompt: Enter passwrod
 
# Create a kdc principal with keytab file or give access to existing keytabs.
kadmin.local -q 'ktadd -k /etc/security/keytabs/<principal>.keytab principal'
```
O novo usuário deve possuir permissões corretas do Ranger para armazenar arquivos no diretório HDFS hdfs:///users/<username>, pois os notebooks individuais são armazenados em /users/<username>/notebooks. O administrador do cluster pode adicionar a permissão necessária na interface do Ranger abrindo o seguinte URL em um browser.
```
https://<un0-host-ip>:6182
```
O novo usuário deve ter permissões corretas no Yarn, Hive e Object Storage para ler e gravar dados e executar jobs do Spark. O usuário pode usar a personificação do Livy (executar jobs do Big Data Service como usuário do Livy) sem obter permissões explícitas no Spark, Yarn e em outros serviços.

Execute o comando a seguir para conceder ao novo usuário acesso ao diretório HDFS.

# Give access to hdfs directory
# kdc realm is by default BDSCLOUDSERVICE.ORACLE.COM
kinit -kt /etc/security/keytabs/hdfs.headless.keytab hdfs-<clustername>@<kdc_realm> 
sudo su hdfs -c "hdfs dfs -mkdir /user/<username>"
sudo su hdfs -c "hdfs dfs -chown -R jupy5 /user/<username>"

Pré-requisitos para Autorizar um Usuário em um Cluster que não seja de HA

Esses pré-requisitos devem ser atendidos para autorizar um usuário em um cluster não HA do Big Data Service usando a autenticação nativa.

O usuário deve existir no host do Linux. Execute o comando a seguir para adicionar um novo usuário do Linux em todos os nós de um cluster.
```
# Add linux user
dcli -C "useradd -d /home/<username> -m -s /bin/bash <username>"
```
O novo usuário deverá ter permissões corretas para armazenar arquivos no diretório hdfs:///users/<username> do HDFS. Execute o comando a seguir para conceder ao novo usuário acesso ao diretório HDFS.
```
# Give access to hdfs directory
sudo su hdfs -c "hdfs dfs -mkdir /user/<username>"
sudo su hdfs -c "hdfs dfs -chown -R jupy5 /user/<username>"
```

Adicionando um Usuário Admin

Os usuários administradores são responsáveis por configurar e gerenciar JupyterHub. Os usuários administradores também são responsáveis por autorizar usuários recém-inscritos em JupyterHub.

Antes de adicionar um usuário administrador, os pré-requisitos devem ser atendidos para um cluster HA ou cluster não HA.

Acesse o Apache Ambari.
Na barra de ferramentas lateral, em Serviços, selecione JupyterHub.
Selecione Configurações e, em seguida, Configurações Avançadas.
Selecione Advanced jupyterhub-config.
Adicione o usuário administrador a c.Authenticator.admin_users.
Selecione Salvar.

Um usuário administrador no arquivo de configuração JupyterHub não precisa ter autorização explícita durante o acesso. Após a inscrição, você pode entrar diretamente.

Adicionando Outros Usuários

Antes de adicionar outros usuários, os pré-requisitos devem ser atendidos para um cluster do Big Data Service.

Acesse JupyterHub.
Inscreva-se para o novo usuário. Usuários não administradores precisam de autorização explícita dos usuários administradores.
O usuário administrador deve acessar JupyterHub e na nova opção de menu para autorizar usuários conectados e o novo usuário.
O novo usuário agora pode acessar.

Excluindo Usuários

Um usuário administrador pode excluir usuários JupyterHub.

Acesse JupyterHub.
Abra Arquivo > HubControlPanel.
Navegue até a página Autorizar Usuários.
Exclua os usuários que você deseja remover.

Autenticação LDAP

Você pode usar a autenticação LDAP por meio do Ambari para clusters ODH 2.x do Big Data Service 3.0.27 ou posterior.

Usando Autenticação LDAP Usando Ambari

Para usar o autenticador LDAP, atualize o arquivo de configuração JupyterHub com os detalhes da conexão LDAP.

Observação

Use o Ambari para autenticação LDAP em clusters do Big Data Service 3.0.27 ou mais recentes.

Consulte Autenticador LDAP para obter detalhes sobre o autenticador LDAP.

Acesse o Apache Ambari.
Na barra de ferramentas lateral, em Serviços, selecione JupyterHub.

Selecione Configuração e, em seguida, em Configuração avançada do jupyterhub > Definições Base, informe o seguinte:

c.JupyterHub.authenticator_class = 'ldapauthenticator.LDAPAuthenticator'
          c.LDAPAuthenticator.server_port = <port>
          c.LDAPAuthenticator.server_address = 'ldaps://<host>'
          c.LDAPAuthenticator.lookup_dn = False
          c.LDAPAuthenticator.use_ssl = True
          c.LDAPAuthenticator.lookup_dn_search_filter = '({login_attr}={login})'
          c.LDAPAuthenticator.lookup_dn_search_user = '<user>'
          c.LDAPAuthenticator.lookup_dn_search_password = '<example-password>'
          #c.LDAPAuthenticator.user_search_base = 'ou=KerberosPrincipals,ou=Hadoop,dc=cesa,dc=corp'
          c.LDAPAuthenticator.user_attribute = 'sAMAccountName'
          c.LDAPAuthenticator.lookup_dn_user_dn_attribute = 'cn'
          c.LDAPAuthenticator.escape_userdn = False
          c.LDAPAuthenticator.bind_dn_template = ["cn={username},ou=KerberosPrincipals,ou=Hadoop,dc=cesa,dc=corp"]

Reinicie JupyterHub.

Configurar Autenticação de SSO no Serviço Big Data Service JupyterHub

pConfigure Autenticação SSO no serviço ODH 2.x JupyterHub do Big Data Service 3.0.27 ou posterior.

Usando o Domínio de Identidades da Oracle

Você pode usar o Oracle Identity Domain para configurar a Autenticação SSO nos clusters ODH 2.x JupyterHub do Big Data Service 3.0.27 ou posterior.

Criar um domínio de identidades. Para obter mais informações, consulte .
No domínio, em Aplicativos Integrados, adicione um Aplicativo SAML.
Forneça os seguintes detalhes necessários ao criar o aplicativo:
- ID da Entidade: Este é um ID exclusivo. Você pode usar o URL base de JupyterHub, por exemplo, https://myjupyterhub/saml2_auth/ent.
- URL do consumidor de asserção:
  - JupyterHub URL: https://<Jupyterhub-Host>:<Port>/hub/saml2_auth/acs
  - URL do Balanceador de Carga: https://<Load-Balancer>:<Port>/hub/saml2_auth/acs
- URL de log-out único, URL de resposta de log-out: https://<Jupyterhub-Host>:<Port>/hub/logout
Ative o aplicativo.
Designe usuários ao aplicativo.
Navegue até o aplicativo criado e selecione Fazer Download de Metadados do Provedor de Identidades. Em seguida, copie esse arquivo de metadados para o host JupyterHub e certifique-se de que ele tenha acesso de Leitura para todos os usuários.
Atualize os parâmetros de sessão do usuário. Para obter mais informações, consulte Setting Session Limits.

Usando o OKTA com o Ambari

Você pode usar o OKTA para configurar a Autenticação SSO nos clusters ODH 2.x JupyterHub do Big Data Service 3.0.27 ou posterior.

Acesse o OKTA.
Na barra de ferramentas lateral, selecione Aplicativos > Aplicativos > Criar Integração de Aplicativo.
Selecione SAML 2.0.
Forneça os seguintes detalhes e crie o Aplicativo.
- Nome do Aplicativo: O nome do aplicativo. Por exemplo, JupyterHub-SSO.
- URL de sign-on único: O URL de sign-on único. Por exemplo: https://<Jupyterhub-Host>:<Port>/hub/saml2_auth/acs.
- URI do Público (ID da Entidade SP): O ID exclusivo. Você pode usar o URL base de JupyterHub. Por exemplo: https://myjupyterhub/saml2_auth/ent.
Designe usuários ao aplicativo.
Selecione a guia de conexão e obtenha os seguintes detalhes:
- URL de Metadados: Faça download do arquivo de metadados e copie-o para o host JupyterHub.
- URL de Acesso: Copie o URL e atualize-o nas configurações do JupyterHub (saml2_login_url).

Ativando SSO

Acesse o Apache Ambari.
Na barra de ferramentas lateral, em Serviços, selecione JupyterHub.
Selecione Configuração > Configurações > Autenticador do Servidor de Notebook.
Selecione SamlSSOAuthenticator.
Selecione Salvar.
Selecione Avançado.
Atualize os parâmetros na seção Advanced Jupiter-config SamlSSOAuthenticator-Configs:
- c.Saml2Authenticator.saml2_metadata_file name: O caminho para o arquivo de metadados do Provedor de Identidades (IDP) no nó instalado JupyterHub. Por exemplo: '/tmp/IDCSMetadata.xml'.
- c.Saml2Authenticator.saml2_entity_id: Um identificador exclusivo para manter o mapeamento do Provedor de Identidades (IDP) para o Provedor de Serviços (JupyterHub). Esse identificador deve ser o mesmo nas configurações do aplicativo IDP e no Provedor de Serviços (JupyterHub). Por exemplo: https://myjupyterhub/saml2_auth/ent
- c.Saml2Authenticator.saml2_login_URL: O URL de sign-on único (SSO). Para o Oracle IDCS, os Usuários podem obter isso no IDP metadata.xml file. No arquivo metadata.xml file, procure a tag AssertionConsumerService e obtenha o valor do atributo de localização. Para OKTA, copie o valor do URL de acesso presente na guia de acesso. Por exemplo: https://idcs-1234.identity.oraclecloud.com/fed/v1/sp/sso
- #c.Saml2Authenticator.saml2_metadata_URL: Opcional. O URL do arquivo de metadados do Provedor de Identidades (IDP). Certifique-se de que o URL fornecido esteja acessível no nó instalado JupyterHub. saml2_metadata_filename ou saml2_metadata_url é obrigatório. Por exemplo: https://idcs-1234.identity.oraclecloud.com/sso/saml/metadata
- #c.Saml2Authenticator.saml2_attribute_username: Opcional. Especifique um atributo a ser considerado como o usuário da asserção SAML. Se nenhum atributo for especificado, o nome de usuário de acesso será tratado como o usuário. Insira 'E-mail'.
- #c.Saml2Authenticator.saml2_private_file_path e #c.Saml2Authenticator.saml2_public_file_path: Opcional. Se o Provedor de Identidades (IDP) criptografar dados de asserção, o Provedor de Serviços (SP) JupyterHub deverá fornecer as chaves privadas e públicas necessárias para decriptografar os dados de asserção. Por exemplo:
  
  #c.Saml2Authenticator.saml2_public_file_path: '/etc/security/serverKeys/jupyterhubsso.key'
  
  #c.Saml2Authenticator.saml2_public_file_path: '/etc/security/serverKeys/jupyterhubsso.crt'
- #c.Saml2Authenticator.login_service: Opcional. Isso configura o botão de acesso para ser exibido como 'Sign in with {login_service}'. Digite 'Oracle IDCS'.
Reinicie JupyterHub.

Configurar JupyterHub por meio do Ambari

Como administrador, você pode gerenciar configurações JupyterHub por meio do Ambari para clusters ODH 2.x do Big Data Service 3.0.27 ou posterior.

Acesse o Apache Ambari.
Na barra de ferramentas lateral, em Serviços, selecione JupyterHub.
Selecione Configurações. As seguintes configurações são suportadas:
- Configuração do Proprietário:
  - ODHSystemdSpawner: Um criador personalizado usado para gerar servidores de notebook de usuário único usando systemd no nó local em que o Servidor JupyterHub está instalado.
  - ODHYarnSpawner: Um Spawner personalizado para JupyterHub que inicia servidores de notebook em clusters do YARN. Este é o criador padrão usado pelo Big Data Service.
- Configuração Comum: São configurações como IP de Binding e porta em que JupyterHub seria executado.
- Configuração do Autenticador: Suportamos dois Autenticadores que podem ser usados para autenticar usuários que acessam JupyterHub. Para obter mais informações sobre os tipos de autenticação, consulte Gerenciar Usuários e Permissões.
- modo de persistência:
  - HDFS: Permite persistir notebooks no HDFS
  - Git: Permite que você use uma extensão JupyterLab para controle de versão usando o Git. Isso permite a persistência de notebooks em servidores remotos por meio do Git.

Criando Notebooks

As configurações do Spawner a seguir são suportadas nos clusters ODH 2.x do Big Data Service 3.0.27 e posterior.

Preencha as seguintes informações:

Autenticação Nativa:
1. Acessar usando credenciais de usuário conectado
2. Inserir nome do usuário.
3. Informe a senha.
Usando SamlSSOAuthenticator:
1. Faça login com SSO.
2. Conclua o sign-in com o aplicativo SSO configurado.

Criando Notebooks em um Cluster HA

Para cluster integrado do AD:

Efetue sign-in usando um dos métodos anteriores. A autorização só funcionará se o usuário estiver presente no host do Linux. O JupyterHub procura o usuário no host do Linux enquanto tenta gerar o servidor de notebook.
Você será redirecionado para uma página Opções do Servidor, na qual deverá solicitar um ticket do Kerberos. Esse ticket pode ser solicitado usando o principal do Kerberos e o arquivo keytab ou a senha do Kerberos. O administrador do cluster pode fornecer o principal do Kerberos e o arquivo keytab ou a senha do Kerberos. O ticket do Kerberos é necessário para ter acesso nos diretórios HDFS e em outros serviços do big data que você deseja usar.

Criando Notebooks em um Cluster não HA

Para cluster integrado do AD:

Efetue sign-in usando um dos métodos anteriores. A autorização só funcionará se o usuário estiver presente no host do Linux. O JupyterHub procura o usuário no host do Linux enquanto tenta gerar o servidor de notebook.

Configurando o Ambiente Git

Configure chaves SSH/Tokens de acesso para o nó do cluster do Big Data Service.
Selecione o modo de persistência do notebook como Git.

Configurar a Conexão Git

Para configurar a conexão Git para JupyterHub, faça o seguinte:

Configurar chaves SSH/ Tokens de acesso para o nó do cluster do Big Data Service.
Selecionar modo de persistência de notebook como Git

Gerando Par de Chaves SSH

Abra um terminal ou prompt de comando.

Para gerar um novo par de chaves SSH, execute:

ssh-keygen -t rsa -b 4096 -C "your_email@example.com"

(Opcional) Siga os prompts para especificar o local do arquivo e a frase-senha (opcional).
Registrar a chave pública:
1. Acesse sua conta do servidor Git.
2. Navegue até a seção de configurações ou chaves SSH da sua conta.
3. Adicione o conteúdo da chave pública (~/.ssh/id_rsa.pub) à conta do servidor Git.
Configure o agente SSH:

Se você tiver muitas chaves SSH gerenciadas pelo agente SSH, poderá criar um arquivo de configuração para especificar qual chave usar para cada servidor Git.
1. Abra ou crie o arquivo de configuração SSH (~/.ssh/config) em um editor de texto.
2. Adicione entradas para cada servidor Git especificando o arquivo de identidade associado a cada chave SSH.
Conecte o repositório Git local ao remoto usando SSH:
1. Abra um terminal ou prompt de comando.
2. Navegue até o repositório Git local.
3. Para alternar o URL remoto de HTTPS para SSH, execute:
```
git remote set-url origin git@github.com:username/repository.git
```
  Substitua username/repository.git pelo URL do repositório Git apropriado.
Verifique a conexão SSH:
1. Teste a conexão SSH com o servidor Git:
```
ssh -T git@github.com
```
(Opcional) Se for solicitado que você confirme a autenticidade do host, digite yes para continuar.

Usando Tokens de Acesso

Você pode usar tokens de acesso das seguintes formas:

GitHub:
1. Acesse sua conta do GitHub.
2. Navegue até Definições > Configurações do desenvolvedor > Tokens de acesso pessoal.
3. Gere um novo token de acesso com as permissões apropriadas.
4. Use o token de acesso como sua senha quando for solicitada a autenticação.
GitLab:
1. Acesse sua conta do GitHub.
2. Navegue até Definições > Tokens de Acesso.
3. Gere um novo token de acesso com as permissões apropriadas.
4. Use o token de acesso como sua senha quando for solicitada a autenticação.
BitBucket:
1. Acesse sua conta do BitBucket.
2. Navegue até Configurações > Senhas do aplicativo.
3. Gere um novo token de senha de aplicativo com as permissões apropriadas.
4. Use a nova senha do aplicativo como senha quando for solicitada a autenticação.

Selecionando o Modo de Persistência como Git

Acesse o Apache Ambari.
Na barra de ferramentas lateral, em Serviços, selecione JupyterHub.
Selecione Configurações e, em seguida, Configurações.
Procure o modo de persistência de notebook e selecione Git na lista drop-down.
Selecione Ações e, em seguida, Reiniciar Tudo.

Configurando o HDFS no JupyterHub para Armazenar Notebooks

Para configurar o HDFS como o armazenamento padrão para notebooks JupyterHub, selecione o modo de persistência como HDFS.

Acesse o Apache Ambari.
Na barra de ferramentas lateral, em Serviços, selecione JupyterHub.
Selecione Configurações e, em seguida, Configurações.
Procure o modo de persistência de notebook e selecione HDFS na lista drop-down.
Selecione Ações e, em seguida, Reiniciar Tudo.

Configurando o Serviço Object Storage em JupyterHub para Armazenar Notebooks

Como usuário administrador, você pode armazenar os notebooks de usuários individuais no Object Storage, em vez de no HDFS. Quando você altera o gerenciador de conteúdo do HDFS para o Object Storage, os notebooks existentes não são copiados para o Object Storage. Os novos notebooks são salvos no Object Storage.

Acesse o Apache Ambari.
Na barra de ferramentas lateral, em Serviços, selecione JupyterHub.
Selecione Configurações e, em seguida, Avançado.

Navegue até a seção c.YarnSpawner.args = yarn_spawner_default_rags e, em seguida, substitua o conteúdo por:

c.YarnSpawner.args = ['--ServerApp.contents_manager_class="s3contents.S3ContentsManager"', '--S3ContentsManager.bucket="<bucket-name>"', '--S3ContentsManager.access_key_id="<accesskey>"', '--S3ContentsManager.secret_access_key="<secret-key>"', '--S3ContentsManager.endpoint_url="https://<object-storage-endpoint>"', '–S3ContentsManager.region_name=""','–ServerApp.root_dir=""']

Reinicie todos os servidores JupyterHub no menu Ações.

Montando o Bucket do Oracle Object Storage Usando `rclone` com Autenticação do Controlador de Usuários

Você pode montar o Oracle Object Storage usando rclone com Autenticação Principal do Usuário (Chaves de API) em um nó de cluster do Big Data Service usando rclone e fuse3, personalizados para usuários do JupyterHub.

Conclua este procedimento para clusters ODH 2.x do Big Data Service 3.0.28 ou posterior para permitir acesso e gerenciamento contínuos do Object Storage diretamente do seu ambiente JupyterHub, aprimorando seus recursos de tratamento de dados.

Acesse o Apache Ambari.
Na barra de ferramentas lateral, em Serviços, selecione JupyterHub.
Selecione Resumo e, em seguida, JUPYTERHUB_SERVER.
Obtenha as informações do host a partir das informações do host exibidas.
Acesse o host do Big Data Service usando as credenciais SSH usadas ao criar o cluster. Para obter mais informações, consulte Conectando-se a um Nó de Cluster com o SSH.

Para verificar a instalação de rclone e fuse3 no nó, execute:

rclone version 
# Ensure version is v1.66

fusermount3 --version 
# Ensure FUSE version 3 is installed

Crie uma chave de API e configure a configuração de rclone. Para obter mais informações, consulte Configurar Autenticação com um Usuário do OCI e uma Chave de API, Obter o Namespace da Tenancy do OCI e o Compartimento do Bucket.
Configure a configuração rclone. Para obter mais informações, consulte Configurar Rclone para o OCI Object Storage.
Para montar o bucket do Object Storage, execute o comando a seguir como usuário de acesso.
A seguir, é executada a operação de montagem com o usuário conectado `Jupyterhub`. O processo daemon é executado como um processo do Linux no nó em que essa operação é acionada.
```
sudo -u jupyterhub rclone mount remote_name:bucket1 /home/jupyterhub/mount_dir --allow-non-empty --file-perms 0666 --dir-perms 0777 --vfs-cache-mode=full --dir-cache-time=30s --vfs-write-back=2m --cache-info-age=60m --daemon
```
Observação

Para trabalhar com Jupyter Notebooks, certifique-se de que o local de montagem esteja dentro do diretório home do usuário de acesso e certifique-se de que o diretório de montagem esteja vazio.
```
sudo -u jupyterhub ls -ltr /home/jupyterhub/mount_dir
```
(Opcional) Para verificar se a montagem foi bem-sucedida, execute o seguinte. Este exemplo lista o conteúdo do bucket mount_dir.
```
sudo -u jupyterhub ls -ltr /home/jupyterhub/mount_dir
```
Executar procedimentos de limpeza.
Ao executar no modo de plano de fundo, você deve interromper a montagem manualmente. Use as seguintes operações de limpeza quando os servidores JupyterHub e Notebook não estiverem em uso.
No Linux:
```
sudo -u jupyterhub fusermount3 -u /home/jupyterhub/mount_dir
```
A operação umount pode falhar, por exemplo, quando o ponto de montagem está ocupado. Quando isso acontece, é responsabilidade do usuário interromper a montagem manualmente.
```
sudo -u jupyterhub umount -l /home/jupyterhub/mount_dir : lazy unmount
sudo -u jupyterhub umount -f /home/jupyterhub/mount_dir : force unmount
```

Gerenciar Ambientes Conda em JupyterHub

Observação

Você pode gerenciar ambientes Conda em clusters ODH 2.x do Big Data Service 3.0.28 ou posterior.

Crie um ambiente conda com dependências específicas e crie quatro kernels (Python/PySpark/Spark/SparkR) que apontam para o ambiente conda criado.
Os ambientes conda e os kernels criados usando esta operação estão disponíveis para todos os usuários do servidor de notebook.
A operação de criação separada do ambiente conda é desacoplar a operação com a reinicialização do serviço.

Pré-requisitos

O JupyterHub é instalado por meio da IU do Ambari.
Verifique o acesso à Internet ao cluster para fazer download de dependências durante a criação do conda.
Os ambientes conda e os kernels criados usando esta operação estão disponíveis para todos os usuários do servidor de notebook."
Forneça:
- Configurações adicionais do conda para evitar falha na criação do conda. Para obter mais informações, consulte conda create
- Dependências no formato de requisitos padrão.txt.
- Um nome de ambiente conda que não existe.
Exclua manualmente ambientes conda ou kernels.

Personalizando Configurações Globais

Acesse o Apache Ambari.
Na barra de ferramentas lateral, em Serviços, selecione JupyterHub.
Selecione Configurações e, em seguida, Avançado.
Role até a seção jupyterhub-conda-env-configs.
Atualize os seguintes campos:
- Configurações Adicionais do Conda: Este campo é usado para fornecer parâmetros adicionais a serem anexados ao comando de criação do conda padrão. O comando de criação conda padrão é 'conda create -y -p conda_env_full_path -c conda-forge pip python=3.8.
  Se as configurações adicionais forem fornecidas como '--override-channels --no-default-packages --no-pin -c pytorch', a execução do comando final de criação de conda será 'conda create -y -p conda_env_full_path -c conda-forge pip python=3.8 --override-channels --no-default-packages --no-pin -c pytorch'.
- Nome do Ambiente Conda: este campo deve fornecer um nome exclusivo para o ambiente conda. Forneça um ambiente conda exclusivo sempre que um novo ambiente for criado.
- Dependências do Python: Este campo lista todas as dependências python/R/Ruby/Lua/Scala/Java/JavaScript/C/C++/FORTRAN e assim por diante as dependências acessíveis aos canais conda no formato do arquivo requirements.txt.
  Para obter mais informações sobre os requisitos de arquivo .txt, consulte Formato de Arquivo de Requisitos.
Selecione Salvar.
Selecione Ações e, em seguida, Ativar Env Conda.
Após a conclusão da ativação, o seguinte é exibido na IU JupyterHub:
- Kernel do Python: conda_python3_kernel_{conda_env_name}
- Kernel PySpark: conda_pyspark_kernel_{conda_env_name}
- Kernel do Spark: conda_spark_kernel_{conda_env_name}
- Kernel SparkR: conda_sparkr_kernel_{conda_env_name}
Observação

Esses kernels apontam para o ambiente conda criado.

Configurar Ambiente Conda Específico do Usuário

Esta operação cria um ambiente conda com dependências especificadas e cria o kernel especificado (Python/PySpark/Spark/SparkR) apontando para o ambiente conda criado.

Se o ambiente conda especificado já existir, a operação passará diretamente para a etapa de criação do kernel
Os ambientes ou kernels conda criados usando esta operação estão disponíveis apenas para um usuário específico

Execute manualmente o script python kernel_install_script.py no modo sudo:

 '/var/lib/ambari-server/resources/mpacks/odh-ambari-mpack-2.0.8/stacks/ODH/1.1.12/services/JUPYTER/package/scripts/'

Por exemplo:

sudo python kernel_install_script.py --conda_env_name conda_jupy_env_1 --conda_additional_configs '--override-channels --no-default-packages --no-pin -c pytorch' --custom_requirements_txt_file_path ./req.txt --kernel_type spark --kernel_name spark_jupyterhub_1 --user jupyterhub

Pré-requisitos

Verifique o acesso à Internet ao cluster para fazer download de dependências durante a criação do conda. Caso contrário, a criação falhará.
Se existir um kernel com o nome --kernel_name, uma exceção será gerada.
Forneça as seguintes informações:
- Configurações Conda para evitar falha na criação. Para obter mais informações, consulte https://conda.io/projects/conda/en/latest/commands/create.html.
- Dependências fornecidas no formato .txt dos requisitos padrão.
Exclua manualmente ambientes conda ou kernels para qualquer usuário.

Configurações Disponíveis para Personalização

--user (obrigatório): SO e usuário JupyterHub para quem o ambiente conda e kernel é criado.
--conda_env_name (obrigatório): Forneça um nome exclusivo para o ambiente conda toda vez que uma nova en for criada para --user.
--kernel_name: (obrigatório) Forneça um nome de kernel exclusivo.
--kernel_type: (obrigatório) Deve ser um dos seguintes (python / PysPark / Spark / SparkR)
--custom_requirements_txt_file_path: (opcional) Se qualquer Python/R/Ruby/Lua/Scala/Java/JavaScript/C/C++/FORTRAN e assim por diante, as dependências forem instaladas usando canais conda, você deverá especificar essas bibliotecas em um arquivo .txt de requisitos e fornecer o caminho completo.
Para obter mais informações sobre um formato padrão para definir o arquivo .txt de requisitos, consulte https://pip.pypa.io/en/stable/reference/requirements-file-format/.
--conda_additional_configs: (opcional)
- Este campo fornece parâmetros adicionais a serem anexados ao comando de criação de conda padrão.
- O comando de criação conda padrão é: 'conda create -y -p conda_env_full_path -c conda-forge pip python=3.8'.
- Se --conda_additional_configs for fornecido como '--override-channels --no-default-packages --no-pin -c pytorch', a execução do comando final de criação de conda será 'conda create -y -p conda_env_full_path -c conda-forge pip python=3.8 --override-channels --no-default-packages --no-pin -c pytorch'.

Configurando o Ambiente Conda Específico do Usuário

Verifique se o JupyterHub está instalado por meio da IU do Ambari.
Estabeleça SSH no cluster e navegue até /var/lib/ambari-server/resources/mpacks/odh-ambari-mpack-2.0.8/stacks/ODH/1.1.12/services/JUPYTER/package/scripts/.
Execute com detalhes do seu ambiente:
```
sudo python/python3 kernel_install_script.py --conda_env_name conda_jupy_env_1 --conda_additional_configs '--override-channels --no-default-packages --no-pin -c pytorch' --custom_requirements_txt_file_path ./req.txt --kernel_type spark --kernel_name spark_bds_1 --user bds
```
Essa execução de script de amostra com os parâmetros fornecidos cria um ambiente conda conda_jupy_env_1 para os bds do usuário, instala dependências personalizadas para conda_jupy_env_1 e cria um kernel spark com o nome spark_bds_1. Após a conclusão bem-sucedida dessa operação, o kernel spark_bds_1 é exibido somente na IU JupyterHub do usuário bds.

Criar um Balanceador de Carga e um Conjunto de Backend

Para obter mais informações sobre a criação de conjuntos de backend, consulte Criando um Conjunto de Backend do Balanceador de Carga.

Criando o Serviço Load Balancer

Para obter mais informações sobre como criar um Balanceador de Carga público, consulte Criando um Balanceador de Carga e conclua os detalhes a seguir.

Abra o menu de navegação, selecione Rede e Balanceadores de carga. Balanceador de carga. A página Balanceadores de carga é exibida.
Em Escopo da lista, selecione o Compartimento no qual o cluster está localizado.
No campo Nome do balanceador de carga, digite um nome para identificar o Balanceador de Carga. Por exemplo, JupyterHub-LoadBalancer.
Na seção Choose Visibility type, selecione Public.
Na seção Designar um endereço IP público, selecione Endereço IP Reservado.
Selecione Criar novo endereço IP reservado.
No campo Nome do IP Público, informe um nome. Por exemplo, jupyterhub-ip
Em Criar no compartimento, selecione o compartimento em que o cluster está localizado.
Na seção Escolher rede, faça o seguinte:
1. Na seção Rede virtual na nuvem <Compartment>, selecione a VCN usada pelo cluster.
2. No campo Subnet in <Compartment>, selecione a sub-rede usada pelo cluster.
Selecione Próximo. A página Escolher backends é exibida.
Em Especificar uma política de balanceamento de carga, selecione Hash de IP.

Observação

Não adicione Backends neste ponto.
Na seção Especificar política de verificação de integridade, faça o seguinte:
1. No campo Porta, digite 8000.
2. No Caminho do URL (URI), digite //hub/api.
Selecione Usar SSL.
Na seção Recurso de certificado, faça o seguinte:
1. Selecione Load balancer managed certificate na lista drop-down.
2. Selecione Paste SSL certificate.
3. No campo certificado SSL, copie e cole um certificado diretamente neste campo.
4. Selecione Colar certificado da CA.
5. No campo Certificado CA, digite o certificado Oracle usando /etc/security/serverKeys/bdsOracleCA.crt, que está presente no cluster. Para autoridades de certificação públicas (CAs), esse certificado pode ser obtido diretamente em seu site.
6. (Opcional) Selecione Especificar chave privada.
  1. Selecione Colar chave privada.
  2. No campo Chave privada, cole uma chave privada diretamente nesse campo.
Selecione Mostrar opções avançadas para acessar mais opções.
Selecione a guia Conjunto de backend e informe o Nome do conjunto de backend. Por exemplo, JupyterHub-Backends.
Selecione Persistência de sessão e Ativar persistência de cookie do balanceador de carga. Os cookies são gerados automaticamente.
Selecione Próximo. A página Configurar listener é exibida. Preencha as seguintes informações:
1. No campo Nome do ouvinte, digite um nome para o ouvinte. Por exemplo: JupyterHub-Listener.
2. Selecione HTTPS para Specifique o tipo de tráfego que seu listener trata.
3. No campo Especificar a porta que o listener monitora para tráfego de entrada, digite 8000.
4. Selecione Paste SSL certificate.
5. No campo certificado SSL, copie e cole um certificado diretamente neste campo.
6. Selecione Load balancer managed certificate na lista drop-down.
7. Selecione Colar certificado da CA.
8. No campo Certificado da CA, informe o certificado da CA do cluster.
9. Selecione Specify private key.
  1. Selecione Colar chave privada.
  2. No campo Chave privada, cole uma chave privada diretamente nesse campo.
Selecione Próximo e, em seguida, Enviar.

Configurar o Conjunto de Backend

Para obter mais informações sobre como criar um Balanceador de Carga público, consulte Criando um Balanceador de Carga e conclua os detalhes a seguir.

Abra o menu de navegação, selecione Rede e Balanceadores de carga. Selecione Balanceador de carga. A página Balanceadores de carga é exibida.
Selecione o Compartimento na lista. Todos os balanceadores de carga desse compartimento são listados em formato tabular.
Selecione o balanceador de carga ao qual deseja adicionar um back-end. A página de detalhes do balanceador de carga é exibida.
Selecione Conjuntos de backend e, em seguida, selecione o conjunto de backend criado em Criando o Balanceador de Carga.
Selecione endereços IP e, em seguida, informe o endereço IP privado necessário do cluster.
Informe 8000 para a Porta.
Selecione Adicionar.

Configurar o Conjunto de Backend

Para obter mais informações sobre como criar um Balanceador de Carga público, consulte Criando um Balanceador de Carga e conclua os detalhes a seguir.

Abra um navegador e digite https://<loadbalancer ip>:8000.
Selecione o Compartimento na lista. Todos os balanceadores de carga desse compartimento são listados em formato tabular.
Certifique-se de que ele redirecione para um dos servidores JupyterHub. Para verificar, abra uma sessão de terminal em JupyterHub para localizar qual nó foi atingido.

Limitações

Após a operação de adição de nó, o administrador do cluster deve atualizar manualmente a entrada do host do Balanceador de Carga nos nós recém-adicionados. Aplicável a todas as adições de nó ao cluster. Por exemplo, nó de trabalho, somente computação e nós.
O certificado deve ser atualizado manualmente para o Balanceador de Carga em caso de expiração. Esta etapa garante que o Balanceador de Carga não esteja usando certificados desatualizados e evita falhas de verificação/comunicação de integridade em conjuntos de backend. Para obter mais informações, consulte Atualizando um Certificado do Balanceador de Carga a Expirar para atualizar o certificado expirado.

Iniciar Kernels Trino-SQL

O kernel JupyterHub PyTrino fornece uma interface SQL que permite executar consultas Trino usando o SQL JupyterHub. Isso está disponível para clusters ODH 2.x do Big Data Service 3.0.28 ou posterior.

Iniciando o Kernel PyTrino e Executando Consultas de Trino

Instale o Trino.
Configurar Coordenador Trino e porta:
1. Acesse o Apache Ambari.
2. Na barra de ferramentas lateral, em Serviços, selecione JupyterHub.
3. Selecione Configurações e, em seguida, Avançado.
4. Na seção Advanced Jupyterhub-trino-kernel-configs, configure o Nome do Host do Coordenador do Trino e a Porta do Trino.
Selecione Salvar e reinicie JupyterHub.
Acesse JupyterHub.
Abra um servidor de notebook. Você é redirecionado para a página do Inicializador.
Selecione o kernel PyTrino.

Você pode executar consultas Trino no kernel PyTrino das seguintes maneiras:

Execute as consultas de amostra do Trino usando %sql <Trino-query> e selecione Executar.
Exemplo:
```
%sql select custkey, name, phone, acctbal from tpch.sf1.customer limit 10
```

Você pode escrever a lógica Python sobre o resultado da consulta. Por exemplo:

result = %sql select custkey, name, phone, acctbal from tpch.sf1.customer limit 10

 
def classify_balance(acctbal):
    if acctbal < 1000:
        return 'Low'
    elif 1000 <= acctbal < 5000:
        return 'Medium'
    else:
        return 'High'
df = result.DataFrame()
df['balance_class'] = df['acctbal'].apply(classify_balance)
print(df)

Para consultas de várias linhas, execute %%sql. Por exemplo:

# Using the %%sql magic command to execute a multi-line SQL query with the limit variable



top_threshold = 3
 
%%sql
SELECT custkey, name, acctbal
FROM tpch.sf1.customer
WHERE acctbal > 1000
ORDER BY acctbal DESC limit {{top_threshold}}

Definindo Parâmetros da Sessão Trino

Os parâmetros da sessão Trino podem ser configurados na IU do Ambari JupyterHub. Esses parâmetros de sessão são aplicados a todas as sessões do usuário.

Para obter mais informações sobre parâmetros de sessão, consulte No de referência de propriedades.

Acesse o Apache Ambari.
Na barra de ferramentas lateral, em Serviços, selecione JupyterHub.
Selecione Configurações e, em seguida, Avançado.
Na seção Custom Jupyterhub-trino-kernel-configs, adicione os seguintes parâmetros de sessão:
```
trino_session_params_<SESSION_PARAM> = <VALUE>
```
Por exemplo, trino_session_params_query_max_planning_time = 1200m.
(Opcional) Para listar parâmetros de sessão, execute:
```
%sql SHOW session
```
Para definir parâmetros para a sessão de notebook atual, execute: %sql SET SESSION Por exemplo:
```
%sql SET SESSION query_max_run_time='2h'
```

Definindo Parâmetros de Credencial Extra do Trino

Os parâmetros de credencial extra do Trino necessários para acessar dados do Armazenamento de Objetos podem ser configurados na IU do Ambari JupyterHub.

Acesse o Apache Ambari.
Na barra de ferramentas lateral, em Serviços, selecione JupyterHub.
Configurações e selecione Avançado.
Na seção Custom Jupyterhub-trino-kernel-configs, adicione os seguintes parâmetros de credencial extras:
```
trino_extra_credentials_<BDS_OSS_CLIENT_PARAM> = <VALUE>
```
Por exemplo, trino_extra_credentials_BDS_OSS_CLIENT_REGION = us-region-1.

Definindo Parâmetros SqlMagic

As configurações SqlMagic fornecem controle flexível sobre o comportamento e a aparência das operações SQL executadas em notebooks Jupyter. Esses parâmetros podem ser configurados na IU do Ambari JupyterHub e aplicados a todas as sessões do usuário.

Para obter mais informações sobre parâmetros SqlMagic, consulte https://jupysql.ploomber.io/en/latest/api/configuration.html#changing-configuration.

Acesse o Apache Ambari.
Na barra de ferramentas lateral, em Serviços, selecione JupyterHub.
Selecione Configurações e, em seguida, Avançado.
Na seção Custom Jupyterhub-sql-magic-configs, adicione os seguintes parâmetros Mágicos:
SqlMagic.<PARAM> = <VALUE>
Exemplo:
```
SqlMagic.displaycon = False
```
Para obter a lista de parâmetros SqlMagic, execute:
```
%config SqlMagic
```
(Opcional) Você só pode definir parâmetros SqlMagic para a sessão de notebook atual.
Exemplo:
```
%config SqlMagic.displaycon=False
```

Documentação do Oracle Cloud Infrastructure

Usando JupyterHub no Big Data Service 3.0.27 ou Mais Recente

Pré-requisitos

Acessando o JupyterHub

Gerenciar JupyterHub

Gerenciar Usuários e Permissões

Pré-requisitos

Tipos de Autenticação Suportados

Usando Autenticação LDAP Usando Ambari

Criando Notebooks

Criando Notebooks em um Cluster HA

Criando Notebooks em um Cluster não HA

Gerando Par de Chaves SSH

Usando Tokens de Acesso

Selecionando o Modo de Persistência como Git

Montando o Bucket do Oracle Object Storage Usando rclone com Autenticação do Controlador de Usuários

Gerenciar Ambientes Conda em JupyterHub

Pré-requisitos

Configurações Disponíveis para Personalização

Configurando o Ambiente Conda Específico do Usuário

Criar um Balanceador de Carga e um Conjunto de Backend

Iniciar Kernels Trino-SQL

Montando o Bucket do Oracle Object Storage Usando `rclone` com Autenticação do Controlador de Usuários