Uso de JupyterHub en Big Data Service 3.0.27 o posterior

Utilice JupyterHub para gestionar blocs de notas de Big Data Service 3.0.27 o posterior de ODH 2.x para grupos de usuarios.

Requisitos

Acceso a JupyterHub

Acceda a JupyterHub a través del explorador para los clusters de Big Data Service 3.0.27 o posterior ODH 2.x.

Acceda a Apache Ambari.
En la barra de herramientas lateral, en Servicios, seleccione JupyterHub.

Gestionar JupyterHub

Un usuario JupyterHub admin puede realizar las siguientes tareas para gestionar blocs de notas en JupyterHub en nodos de ODH 2.x de Big Data Service 3.0.27 o posterior.

Para gestionar los servicios de Oracle Linux 7 con el comando systemctl, consulte la sección sobre cómo trabajar con servicios del sistema.

Para conectarse a una instancia de Oracle Cloud Infrastructure, consulte Conexión a una instancia.

Parada, Inicio o Reinicio de JupyterHub mediante Ambari

Como administrador, puede parar o desactivar JupyterHub para que no consuma recursos como, por ejemplo, la memoria. Reiniciar también puede ayudar con problemas o comportamientos inesperados.

Nota

Pare o inicie JupyterHub mediante Ambari para clusters de Big Data Service 3.0.27 o posteriores.

Acceda a Apache Ambari.
En la barra de herramientas lateral, en Servicios, seleccione JupyterHub.
Seleccione Acciones:
- Para iniciar JupyterHub, seleccione Iniciar.
- Para parar JupyterHub, seleccione Parar.
- Para reiniciar JupyterHub, seleccione Reiniciar.

Agregando servidor JupyterHub

Como administrador, puede agregar el servidor JupyterHub a un nodo de Big Data Service.

Nota

Está disponible para clusters de Big Data Service 3.0.27 o posteriores.

Acceda a Apache Ambari.
En la barra de herramientas lateral, seleccione Hosts (Hosts).
Para agregar el servidor JupyterHub, seleccione un host en el que JupyterHub no esté instalado.
Seleccione Agregar.
Seleccione Servidor JupyterHub.

Movimiento del servidor JupyterHub

Como administrador, puede mover el servidor JupyterHub a un nodo de Big Data Service diferente.

Nota

Está disponible para clusters de Big Data Service 3.0.27 o posteriores.

Acceda a Apache Ambari.
En la barra de herramientas lateral, en Servicios, seleccione JupyterHub.
Seleccione Acciones y, a continuación, seleccione Mover servidor JupyterHub.
Seleccione Next (Siguiente).
Seleccione el host al que desea mover el servidor JupyterHub.
Complete el asistente de movimiento.

Ejecución de comprobaciones del sistema/servicio JupyterHub

Como administrador, puede ejecutar comprobaciones de servicio/estado de JupyterHub mediante Ambari.

Nota

Está disponible para clusters de Big Data Service 3.0.27 o posteriores.

Acceda a Apache Ambari.
En la barra de herramientas lateral, en Servicios, seleccione JupyterHub.
Seleccione Acciones y, a continuación, Ejecutar comprobación de servicio.

Gestión de usuarios y permisos

Utilice uno de los dos métodos de autenticación para autenticar usuarios en JupyterHub de modo que puedan crear blocs de notas y, si lo desea, administrar JupyterHub en clusters de ODH 2.x de Big Data Service 3.0.27 o posterior.

Los usuarios de JupyterHub se deben agregar como usuarios del sistema operativo en todos los nodos de cluster de Big Data Service para clusters de Big Data Service que no sean de Active Directory (AD), donde los usuarios no se sincronizan automáticamente entre todos los nodos de cluster. Los administradores pueden utilizar el script de gestión de usuarios JupyterHub para agregar usuarios y grupos antes de conectarse a JupyterHub.

Requisitos

Complete lo siguiente antes de acceder a JupyterHub:

Inicie sesión SSH en el nodo donde está instalado JupyterHub.
Vaya a /usr/odh/current/jupyterhub/install.

Para proporcionar los detalles de todos los usuarios y grupos en el archivo sample_user_groups.json, ejecute:

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

Tipos de Autenticación Soportados

NativeAuthenticator: este autenticador se utiliza para aplicaciones JupyterHub pequeñas o medianas. El registro y la autenticación se implantan como nativos de JupyterHub sin depender de servicios externos.
SSOAuthenticator: este autenticador proporciona una subclase de jupyterhub.auth.Authenticator que actúa como proveedor de servicios SAML2. Diríjala a un proveedor de identidad SAML2 configurado correctamente y activa la conexión única para JupyterHub.

Autenticación Nativa

La autenticación nativa depende de la base de datos de usuarios JupyterHub para autenticar usuarios.

La autenticación nativa se aplica tanto a los clusters de HA como a los clusters sin HA. Consulte la sección sobre el autenticador nativo para obtener más información sobre el autenticador nativo.

Requisitos para autorizar un usuario en un cluster de HA

Estos requisitos se deben cumplir para autorizar a un usuario en un cluster de HA de Big Data Service mediante autenticación nativa.

El usuario debe existir en el host de Linux. Ejecute el siguiente comando para agregar un nuevo usuario de Linux en todos los nodos de un cluster.
```
# Add linux user
dcli -C "useradd -d /home/<username> -m -s /bin/bash <username>"
```
Para iniciar un servidor de portátiles, un usuario debe proporcionar el principal y el archivo keytab path/password, así como solicitar un ticket de Kerberos desde la interfaz de JupyterHub. Para crear una tabla de claves, el administrador del cluster debe agregar el principal de Kerberos con una contraseña y un archivo keytab. Ejecute los siguientes comandos en el primer nodo maestro (mn0) del 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'
```
El nuevo usuario debe contar con los permisos de Ranger correctos para almacenar archivos en el directorio de HDFS hdfs:///users/<username> ya que los blocs de nota individuales se almacenan en /users/<username>/notebooks. El administrador del cluster puede agregar el permiso necesario desde la interfaz de Ranger abriendo la siguiente URL en un explorador web.
```
https://<un0-host-ip>:6182
```
El nuevo usuario debe tener los permisos correctos en Yarn, Hive y Object Storage para leer y escribir datos, y ejecutar trabajos de Spark. También puede utilizar la suplantación de Livy (ejecutar trabajos de Big Data Service como usuario Livy) sin obtener permisos explícitos en Spark, Yarn y otros servicios.

Ejecute el siguiente comando para otorgar al nuevo usuario acceso al directorio de 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>"

Requisitos para autorizar un usuario en un cluster que no tiene HA

Estos requisitos se deben cumplir para autorizar a un usuario en un cluster sin HA de Big Data Service mediante autenticación nativa.

El usuario debe existir en el host de Linux. Ejecute el siguiente comando para agregar un nuevo usuario de Linux en todos los nodos de un cluster.
```
# Add linux user
dcli -C "useradd -d /home/<username> -m -s /bin/bash <username>"
```
El nuevo usuario debe tener los permisos correctos para almacenar los archivos en el directorio de HDFS hdfs:///users/<username>. Ejecute el siguiente comando para otorgar al nuevo usuario acceso al directorio de 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>"
```

Adición de un Usuario Administrador

Los usuarios administradores son los responsables de configurar y gestionar JupyterHub. Los usuarios administradores también son responsables de autorizar a los usuarios recién registrados en JupyterHub.

Antes de agregar un usuario administrador, se deben cumplir los requisitos de un cluster de HA o un cluster sin HA.

Acceda a Apache Ambari.
En la barra de herramientas lateral, en Servicios, seleccione JupyterHub.
Seleccione Configuración y, a continuación, seleccione Configuraciones avanzadas.
Seleccione Advanced jupyterhub-config.
Agregue el usuario administrador a c.Authenticator.admin_users.
Seleccione Guardar.

No es necesario que un usuario administrador del archivo de configuración JupyterHub tenga autorización explícita durante el inicio de sesión. Después de registrarse, puede conectarse directamente.

Adición de Otros Usuarios

Antes de agregar otros usuarios, se deben cumplir los requisitos para un cluster de Big Data Service.

Acceda a JupyterHub.
Regístrese para el nuevo usuario. Los usuarios no administradores necesitan una autorización explícita de los usuarios administradores.
El usuario administrador debe conectarse a JupyterHub y desde la nueva opción de menú para autorizar a los usuarios conectados, debe autorizar al nuevo usuario.
El nuevo usuario ahora puede conectarse.

Supresión de usuarios

Un usuario administrador puede suprimir usuarios JupyterHub.

Acceda a JupyterHub.
Abra Archivo > HubControlPanel.
Vaya a la página Authorize Users.
Suprima los usuarios que desea eliminar.

Autenticación de LDAP

Puede utilizar la autenticación LDAP mediante Ambari para clusters de ODH 2.x de Big Data Service 3.0.27 o posterior.

Uso de la autenticación de LDAP mediante Ambari

Para utilizar el autenticador de LDAP, debe actualizar el archivo de configuración de JupyterHub con los detalles de conexión de LDAP.

Nota

Utilice Ambari para la autenticación LDAP en clusters de Big Data Service 3.0.27 o posteriores.

Consulte la sección sobre el autenticador de LDAP para obtener detalles sobre el autenticador de LDAP.

Acceda a Apache Ambari.
En la barra de herramientas lateral, en Servicios, seleccione JupyterHub.

Seleccione Configuración y, a continuación, en Configuración avanzada de jupyterhub > Configuración base, introduzca lo siguiente:

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 autenticación de SSO en Big Data Service JupyterHub Service

pConfigure Autenticación de SSO en el servicio Big Data Service 3.0.27 o posterior ODH 2.x JupyterHub.

Uso del Dominio de Identidad de Oracle

Puede utilizar el dominio de identidad de Oracle para configurar la autenticación de SSO en clusters JupyterHub de ODH 2.x de Big Data Service 3.0.27 o posterior.

Creación de un dominio de identidad. Para obtener más información, consulte .
En el dominio, en Aplicaciones integradas, agregue una aplicación SAML.
Proporcione los siguientes detalles necesarios al crear la aplicación:
- ID de entidad: es un ID único. Puede utilizar la URL base de JupyterHub, por ejemplo, https://myjupyterhub/saml2_auth/ent.
- URL de Consumidor de Afirmaciones:
  - URL de JupyterHub: https://<Jupyterhub-Host>:<Port>/hub/saml2_auth/acs
  - URL de Load Balancer: https://<Load-Balancer>:<Port>/hub/saml2_auth/acs
- URL de desconexión única, URL de respuesta de desconexión: https://<Jupyterhub-Host>:<Port>/hub/logout
Active la aplicación.
Asigne usuarios a la aplicación.
Vaya a la aplicación creada y seleccione Descargar metadatos de proveedor de identidad y, a continuación, copie este archivo de metadatos en el host JupyterHub y asegúrese de que tiene acceso de lectura para todos los usuarios.
Actualice los parámetros de sesión del usuario. Para obtener más información, consulte Setting Session Limits.

Uso de OKTA mediante Ambari

Puede utilizar OKTA para configurar la autenticación de SSO en los clusters JupyterHub de ODH 2.x de Big Data Service 3.0.27 o posterior.

Conectar a OKTA.
En la barra de herramientas lateral, seleccione Aplicaciones > Aplicaciones > Crear integración de aplicación.
Seleccione SAML 2.0.
Proporcione los siguientes detalles y cree la aplicación.
- Nombre de aplicación: nombre de la aplicación. Por ejemplo, JupyterHub-SSO.
- URL de conexión única: URL de conexión única. Por ejemplo: https://<Jupyterhub-Host>:<Port>/hub/saml2_auth/acs.
- Audience URI (SP Entity ID) (URI de destinatario (ID de entidad SP)): ID único. Puede utilizar la URL base de JupyterHub. Por ejemplo: https://myjupyterhub/saml2_auth/ent.
Asigne usuarios a la aplicación.
Seleccione la ficha de inicio de sesión y obtenga los siguientes detalles:
- URL de metadatos: descargue el archivo de metadatos y, a continuación, cópielo en el host JupyterHub.
- Identificar URL: copie la URL del inicio de sesión y, a continuación, actualice la misma en las configuraciones de JupyterHub (saml2_login_url).

Activación de SSO

Acceda a Apache Ambari.
En la barra de herramientas lateral, en Servicios, seleccione JupyterHub.
Seleccione Configuración > Configuración > Autenticador de Servidor de Bloc de Notas.
Seleccione SamlSSOAuthenticator.
Seleccione Guardar.
Seleccione Avanzado.
Actualice los parámetros en la sección Advanced Jupiter-config SamlSSOAuthenticator-Configs:
- c.Saml2Authenticator.saml2_metadata_file name: ruta al archivo de metadatos del proveedor de identidad (IDP) en el nodo instalado JupyterHub. Por ejemplo: '/tmp/IDCSMetadata.xml'.
- c.Saml2Authenticator.saml2_entity_id: identificador único para mantener la asignación del proveedor de identidad (IDP) al proveedor de servicios (JupyterHub). Este identificador debe ser el mismo tanto en las configuraciones de la aplicación IDP como en el proveedor de servicios (JupyterHub). Por ejemplo: https://myjupyterhub/saml2_auth/ent
- c.Saml2Authenticator.saml2_login_URL: URL de conexión única (SSO). Para los usuarios de Oracle IDCS, puede obtenerlo del IDP metadata.xml file. En el archivo metadata.xml file, busque la etiqueta AssertionConsumerService y obtenga el valor del atributo de ubicación. Para OKTA, copie el valor de la URL de inicio de sesión presente en la ficha Inicio de sesión. Por ejemplo: https://idcs-1234.identity.oraclecloud.com/fed/v1/sp/sso
- #c.Saml2Authenticator.saml2_metadata_URL: opcional. URL del archivo de metadatos del proveedor de identidad (IDP). Asegúrese de que se puede acceder a la URL proporcionada desde el nodo instalado JupyterHub. Se necesita saml2_metadata_filename o saml2_metadata_url. Por ejemplo: https://idcs-1234.identity.oraclecloud.com/sso/saml/metadata
- #c.Saml2Authenticator.saml2_attribute_username: opcional. Especifique un atributo para que se considere como usuario a partir de la afirmación de SAML. Si no se especifica ningún atributo, el nombre de usuario de conexión se trata como usuario. Introduzca 'Email'.
- #c.Saml2Authenticator.saml2_private_file_path y #c.Saml2Authenticator.saml2_public_file_path: opcional. Si el proveedor de identidad (IDP) cifra los datos de afirmación, el proveedor de servicios (SP) JupyterHub debe proporcionar las claves privadas y públicas necesarias para descifrar los datos de afirmación. Por ejemplo:
  
  #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. De esta forma, se configura el botón de conexión para que se muestre como 'Sign in with {login_service}'. Introduzca 'Oracle IDCS'.
Reinicie JupyterHub.

Configuración de JupyterHub mediante Ambari

Como administrador, puede gestionar las configuraciones de JupyterHub mediante Ambari para clusters de ODH 2.x de Big Data Service 3.0.27 o posterior.

Acceda a Apache Ambari.
En la barra de herramientas lateral, en Servicios, seleccione JupyterHub.
Seleccione Configs. Se admiten las siguientes configuraciones:
- Configuración del propietario:
  - ODHSystemdSpawner: un generador de informes personalizado utilizado para generar servidores de bloc de notas de un solo usuario mediante systemd en el nodo local donde está instalado el servidor JupyterHub.
  - ODHYarnSpawner: Spawner personalizado para JupyterHub que inicia servidores de bloc de notas en clusters YARN. Este es el generador por defecto que utiliza Big Data Service.
- Configuración común: son configuraciones como IP de enlace y puerto en los que se ejecutaría JupyterHub.
- Configuración de autenticador: Admitimos dos autenticadores que se pueden utilizar para autenticar usuarios que se conectan a JupyterHub. Para obtener más información sobre los tipos de autenticación, consulte Gestión de usuarios y permisos.
- Modo de permanencia:
  - HDFS: permite mantener blocs de notas en HDFS
  - Git: permite utilizar una extensión JupyterLab para el control de versiones mediante Git, lo que permite la persistencia de blocs de notas en servidores remotos a través de Git.

Generación de blocs de notas

Las siguientes configuraciones de Spawner están soportadas en los clusters de Big Data Service 3.0.27 y posteriores de ODH 2.x.

Complete lo siguiente:

Autenticación Nativa:
1. Iniciar sesión con credenciales de usuario conectado
2. Introducir usuario.
3. Introduzca la contraseña.
Uso de SamlSSOAuthenticator:
1. Conéctese con SSO.
2. Complete el inicio de sesión con la aplicación SSO configurada.

Generación de blocs de notas en un cluster de HA

Para el cluster integrado de AD:

Inicie sesión con cualquiera de los métodos anteriores. La autorización solo funciona si el usuario está presente en el host de Linux. JupyterHub busca el usuario en el host de Linux al intentar generar el servidor del bloc de notas.
Se le redirigirá a una página de opciones de servidor en la que debe solicitar un ticket de Kerberos. Este ticket se puede solicitar mediante el principal de Kerberos y el archivo keytab, o la contraseña de Kerberos. El administrador del cluster puede proporcionar el principal de Kerberos y el archivo keytab, o la contraseña de Kerberos. El ticket de Kerberos es necesario para obtener acceso a los directorios de HDFS y otros servicios de big data que desea utilizar.

Generación de Notebooks en un cluster sin HA

Para el cluster integrado de AD:

Inicie sesión con cualquiera de los métodos anteriores. La autorización solo funciona si el usuario está presente en el host de Linux. JupyterHub busca el usuario en el host de Linux al intentar generar el servidor del bloc de notas.

Configuración del Entorno Git

Configure claves SSH/tokens de acceso para el nodo de cluster de Big Data Service.
Seleccione el modo de persistencia de bloc de notas como Git.

Configuración de la conexión Git

Para configurar la conexión de Git para JupyterHub, complete lo siguiente:

Configure las claves SSH/ Tokens de acceso para el nodo de cluster de Big Data Service.
Seleccionar modo de persistencia de bloc de notas como Git

Generación de Par de Claves SSH

Abra un terminal o un símbolo del sistema.

Para generar un nuevo par de claves SSH, ejecute:

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

(Opcional) Siga las indicaciones para especificar la ubicación del archivo y la frase de contraseña (opcional).
Registrar la clave pública:
1. Inicie sesión en su cuenta de servidor de Git.
2. Vaya a la sección de configuración o claves SSH de su cuenta.
3. Agregue el contenido de la clave pública (~/.ssh/id_rsa.pub) a la cuenta del servidor de Git.
Configure el agente SSH:

Si tiene muchas claves SSH gestionadas por el agente SSH, puede crear un archivo de configuración para especificar qué clave utilizar para cada servidor Git.
1. Abra o cree el archivo de configuración SSH (~/.ssh/config) en un editor de texto.
2. Agregue entradas para cada servidor de Git especificando el archivo de identidad asociado a cada clave SSH.
Conecte el repositorio de Git local a remoto mediante SSH:
1. Abra un terminal o un símbolo del sistema.
2. Navegue al repositorio de Git local.
3. Para cambiar la URL remota de HTTPS a SSH, ejecute:
```
git remote set-url origin git@github.com:username/repository.git
```
  Sustituya username/repository.git por la URL del repositorio de Git adecuada.
Verifique la conexión SSH:
1. Pruebe la conexión SSH al servidor de Git:
```
ssh -T git@github.com
```
(Opcional) Si se le solicita que confirme la autenticidad del host, introduzca yes para continuar.

Uso de tokens de acceso

Puede utilizar tokens de acceso de las siguientes formas:

GitHub:
1. Conéctese a su cuenta de GitHub.
2. Vaya a Configuración > Configuración de desarrollador > Tokens de acceso personal.
3. Genere un nuevo token de acceso con los permisos adecuados.
4. Utilice el token de acceso como contraseña cuando se le solicite autenticación.
GitLab:
1. Conéctese a su cuenta de GitHub.
2. Vaya a Configuración > Tokens de acceso.
3. Genere un nuevo token de acceso con los permisos adecuados.
4. Utilice el token de acceso como contraseña cuando se le solicite autenticación.
BitBucket:
1. Conéctese a su cuenta de BitBucket.
2. Vaya a Configuración > Contraseñas de aplicación.
3. Genere un nuevo token de contraseña de aplicación con los permisos adecuados.
4. Utilice la nueva contraseña de aplicación como contraseña cuando se le solicite autenticación.

Selección del Modo de Persistencia como Git

Acceda a Apache Ambari.
En la barra de herramientas lateral, en Servicios, seleccione JupyterHub.
Seleccione Configuración y, a continuación, seleccione Configuración.
Busque Modo de persistencia de bloc de notas y, a continuación, seleccione Git en la lista desplegable.
Seleccione Acciones y, a continuación, seleccione Reiniciar todo.

Configuración de HDFS en JupyterHub para almacenar blocs de notas

Para configurar HDFS como almacenamiento por defecto para los blocs de notas JupyterHub, seleccione el modo de persistencia como HDFS.

Acceda a Apache Ambari.
En la barra de herramientas lateral, en Servicios, seleccione JupyterHub.
Seleccione Configuración y, a continuación, seleccione Configuración.
Busque Modo de persistencia de bloc de notas y, a continuación, seleccione HDFS en la lista desplegable.
Seleccione Acciones y, a continuación, seleccione Reiniciar todo.

Configuración de Object Storage en JupyterHub para almacenar blocs de notas

Como usuario administrador, puede almacenar los blocs de notas de usuario individual en Object Storage en lugar de HDFS. Al cambiar el gestor de contenido de HDFS a Object Storage, los blocs de notas existentes no se copian en Object Storage. Los nuevos blocs de notas se guardan en Object Storage.

Acceda a Apache Ambari.
En la barra de herramientas lateral, en Servicios, seleccione JupyterHub.
Seleccione Configuración y, a continuación, seleccione Avanzado.

Vaya a la sección c.YarnSpawner.args = yarn_spawner_default_rags y, a continuación, sustituya el contenido 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 los servidores JupyterHub desde el menú Acciones.

Montaje del cubo de Oracle Object Storage mediante `rclone` con autenticación de principal de usuario

Puede montar Oracle Object Storage mediante rclone con autenticación de principal de usuario (claves de API) en un nodo de cluster de Big Data Service mediante rclone y fuse3, adaptados para los usuarios de JupyterHub.

Realice este procedimiento para los clusters de ODH 2.x de Big Data Service 3.0.28 o posterior con el fin de permitir un acceso y gestión uniformes de Object Storage directamente desde el entorno JupyterHub, mejorando las capacidades de manejo de datos.

Acceda a Apache Ambari.
En la barra de herramientas lateral, en Servicios, seleccione JupyterHub.
Seleccione Resumen y, a continuación, seleccione JUPYTERHUB_SERVER.
Obtenga la información de host de la información de host que se muestra.
Conéctese al host de Big Data Service con las credenciales SSH utilizadas al crear el cluster. Para obtener más información, consulte Connecting to a Cluster Node Using SSH.

Para verificar la instalación de rclone y fuse3 en el nodo, ejecute:

rclone version 
# Ensure version is v1.66

fusermount3 --version 
# Ensure FUSE version 3 is installed

Cree la clave de API y configure rclone. Para obtener más información, consulte Configuración de la autenticación con un usuario de OCI y una clave de API, obtención del espacio de nombres de arrendamiento de OCI y el compartimento de cubo.
Configure la configuración de rclone. Para obtener más información, consulte Configuración de clonación para OCI Object Storage.
Para montar el cubo de Object Storage, ejecute el siguiente comando como usuario de conexión.
A continuación, se ejecuta la operación de montaje con el usuario conectado `Jupyterhub`. El proceso del daemon se ejecuta como un proceso de Linux en el nodo donde se dispara esta operación.
```
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
```
Nota

Para trabajar con blocs de notas de Jupyter, asegúrese de que la ubicación de montaje está dentro del directorio raíz del usuario de conexión y de que el directorio de montaje está vacío.
```
sudo -u jupyterhub ls -ltr /home/jupyterhub/mount_dir
```
(Opcional) Para verificar que el montaje se haya realizado correctamente, ejecute lo siguiente. En este ejemplo se muestra el contenido del cubo mount_dir.
```
sudo -u jupyterhub ls -ltr /home/jupyterhub/mount_dir
```
Ejecute procedimientos de limpieza.
Cuando se ejecuta en modo de fondo, debe detener el montaje manualmente. Utilice las siguientes operaciones de limpieza cuando los servidores JupyterHub y Notebook no estén en uso.
En Linux:
```
sudo -u jupyterhub fusermount3 -u /home/jupyterhub/mount_dir
```
La operación umount puede fallar, por ejemplo, cuando el punto de montaje está ocupado. Cuando eso sucede, es responsabilidad del usuario que detenga el montaje manualmente.
```
sudo -u jupyterhub umount -l /home/jupyterhub/mount_dir : lazy unmount
sudo -u jupyterhub umount -f /home/jupyterhub/mount_dir : force unmount
```

Gestionar entornos conda en JupyterHub

Nota

Puede gestionar entornos conda en clusters de ODH 2.x de Big Data Service 3.0.28 o posterior.

Cree un entorno conda con dependencias específicas y cuatro núcleos (Python/PySpark/Spark/SparkR) que apunten al entorno conda creado.
Los entornos conda y los núcleos creados mediante esta operación están disponibles para todos los usuarios del servidor de bloc de notas.
La operación de creación de entorno conda independiente consiste en disociar la operación con el reinicio del servicio.

Requisitos previos

JupyterHub se instala mediante la interfaz de usuario de Ambari.
Verifique el acceso de Internet al cluster para descargar dependencias durante la creación del conda.
Los entornos conda y los núcleos creados con esta operación están disponibles para todos los usuarios del servidor de bloc de notas".
Proporcione:
- Configuraciones adicionales de Conda para evitar fallos de creación de conda. Para obtener más información, consulte conda create.
- Dependencias en el formato .txt de requisitos estándar.
- Nombre de entorno conda que no existe.
Suprima manualmente los núcleos o entornos conda.

Personalización de configuraciones globales

Acceda a Apache Ambari.
En la barra de herramientas lateral, en Servicios, seleccione JupyterHub.
Seleccione Configuración y, a continuación, seleccione Avanzado.
Desplácese a la sección jupyterhub-conda-env-configs.
Actualice los siguientes campos:
- Configuraciones Adicionales de Conda: este campo se utiliza para proporcionar parámetros adicionales que se agregarán al comando de creación de conda por defecto. El comando de creación conda por defecto es 'conda create -y -p conda_env_full_path -c conda-forge pip python=3.8.
  Si las configuraciones adicionales se proporcionan como '--override-channels --no-default-packages --no-pin -c pytorch', la ejecución final del comando de creación de conda es 'conda create -y -p conda_env_full_path -c conda-forge pip python=3.8 --override-channels --no-default-packages --no-pin -c pytorch'.
- Nombre de Entorno Conda: este campo proporciona un nombre único para el entorno conda. Proporcione un entorno conda único cada vez que se cree un nuevo entorno.
- Dependencias de Python: este campo muestra todas las dependencias de python/R/Ruby/Lua/Scala/Java/JavaScript/C/C++/FORTRAN, etc., y las dependencias a las que pueden acceder los canales conda en el formato del archivo .txt de requisitos.
  Para obtener más información sobre los requisitos del archivo .txt, consulte Requirements File Format.
Seleccione Guardar.
Seleccione Acciones y, a continuación, seleccione Activar entorno conda.
Una vez finalizada la activación, se muestra lo siguiente en la interfaz de usuario JupyterHub:
- Núcleo de Python: conda_python3_kernel_{conda_env_name}
- Núcleo PySpark: conda_pyspark_kernel_{conda_env_name}
- Núcleo de Spark: conda_spark_kernel_{conda_env_name}
- Núcleo SparkR: conda_sparkr_kernel_{conda_env_name}
Nota

Estos núcleos apuntan al entorno conda creado.

Configuración del Entorno Conda Específico del Usuario

Esta operación crea un entorno conda con dependencias especificadas y crea el núcleo especificado (Python/PySpark/Spark/SparkR) que apunta al entorno conda creado.

Si el entorno conda especificado ya existe, la operación continúa directamente con el paso de creación del núcleo
Los entornos conda o los núcleos creados mediante esta operación solo están disponibles para un usuario específico

Ejecute manualmente el script de python kernel_install_script.py en modo sudo:

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

Ejemplo:

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

Requisitos

Verifique el acceso de Internet al cluster para descargar dependencias durante la creación del conda. De lo contrario, falla la creación.
Si existe un núcleo con el nombre --kernel_name, se devuelve una excepción.
Proporcione lo siguiente:
- Configuraciones conda para evitar fallos de creación. Para obtener más información, consulte https://conda.io/projects/conda/en/latest/commands/create.html.
- Dependencias proporcionadas en el formato .txt de requisitos estándar.
Suprima manualmente los entornos conda o los núcleos de cualquier usuario.

Configuraciones disponibles para personalización

--user (obligatorio): sistema operativo y usuario JupyterHub para el que se crea el núcleo y el entorno conda.
--conda_env_name (obligatorio): proporcione un nombre único para el entorno conda cada vez que se cree un nuevo en para --user.
--kernel_name: (obligatorio) proporcione un nombre de núcleo único.
--kernel_type: (obligatorio) debe ser uno de los siguientes (python / PysPark / Spark / SparkR)
--custom_requirements_txt_file_path: (opcional) si algún Python/R/Ruby/Lua/Scala/Java/JavaScript/C/C++/FORTRAN, etc., las dependencias se instalan mediante canales conda, debe especificar esas bibliotecas en un archivo .txt de requisitos y proporcionar la ruta completa.
Para obtener más información sobre un formato estándar para definir el archivo .txt de requisitos, consulte https://pip.pypa.io/en/stable/reference/requirements-file-format/.
--conda_additional_configs: (opcional)
- Este campo proporciona parámetros adicionales que se agregarán al comando predeterminado de creación de conda.
- El comando de creación conda por defecto es: 'conda create -y -p conda_env_full_path -c conda-forge pip python=3.8'.
- Si --conda_additional_configs se proporciona como '--override-channels --no-default-packages --no-pin -c pytorch', la ejecución final del comando de creación de conda es 'conda create -y -p conda_env_full_path -c conda-forge pip python=3.8 --override-channels --no-default-packages --no-pin -c pytorch'.

Configuración de un entorno conda específico del usuario

Verifique que JupyterHub esté instalado mediante la interfaz de usuario de Ambari.
SSH en el cluster y, a continuación, navegue hasta /var/lib/ambari-server/resources/mpacks/odh-ambari-mpack-2.0.8/stacks/ODH/1.1.12/services/JUPYTER/package/scripts/.
Ejecute con elementos específicos para su entorno:
```
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
```
Esta ejecución de script de ejemplo con los parámetros proporcionados crea un entorno conda conda_jupy_env_1 para el bds de usuario, instala dependencias personalizadas para conda_jupy_env_1 y crea un núcleo spark con el nombre spark_bds_1. Una vez finalizada correctamente esta operación, el núcleo spark_bds_1 se muestra solo en la interfaz de usuario JupyterHub del usuario bds.

Creación de un equilibrador de carga y un juego de backend

Para obtener más información sobre la creación de juegos de backends, consulte Creación de un juego de backends del equilibrador de carga.

Creación del equilibrador de carga

Para obtener más información sobre la creación de un equilibrador de carga público, consulte Creación de un equilibrador de carga y complete los siguientes detalles.

Abra el menú de navegación, seleccione Networking y, a continuación, seleccione Load balancers. Equilibrador de carga. Aparecerá la página Equilibradores de Carga.
En Ámbito de lista, seleccione el compartimento en el que se encuentra el cluster.
En el campo Nombre de equilibrador de carga, introduzca un nombre para identificar el equilibrador de carga. Por ejemplo, JupyterHub-LoadBalancer.
En la sección Seleccionar Tipo de Visibilidad, seleccione Público.
En la sección Assign a public IP address, seleccione Reserved IP address.
Seleccione Create new reserved IP address.
En el campo Nombre de IP pública, introduzca un nombre. Por ejemplo, jupyterhub-ip
En Crear en compartimento, seleccione el compartimento en el que se encuentra el cluster.
En la sección Seleccionar red, complete lo siguiente:
1. En la sección Red virtual en la nube <Compartment>, seleccione la VCN que utiliza el cluster.
2. En el campo Subred en <Compartment>, seleccione la subred que utiliza el cluster.
Seleccione Next. Aparece la página Seleccionar backend.
En Especificar una política de equilibrio de carga, seleccione Hash de IP.

Nota

No agregue backends en este punto.
En la sección Especificar política de comprobación del sistema, complete lo siguiente:
1. En el campo Puerto, introduzca 8000.
2. En la ruta de acceso de URL (URI), introduzca //hub/api.
Seleccione Usar SSL.
En la sección Recurso de certificado, complete lo siguiente:
1. Seleccione Load balancer Managed Certificate en la lista desplegable.
2. Seleccione Pegar certificado SSL.
3. En el campo Certificado SSL, copie y pegue un certificado directamente en este campo.
4. Seleccione Pegar certificado de CA.
5. En el campo Certificado de CA, introduzca el certificado de Oracle mediante /etc/security/serverKeys/bdsOracleCA.crt, que está presente en el cluster. Para las autoridades de certificación públicas (CA), este certificado se puede obtener directamente desde su sitio.
6. (Opcional) Seleccione Especificar clave privada.
  1. Seleccione Paste private key.
  2. En el campo Clave privada, pegue una clave privada directamente en este campo.
Seleccione Mostrar opciones avanzadas para acceder a más opciones.
Seleccione el separador Juego de backends y, a continuación, introduzca el nombre del juego de backends. Por ejemplo, JupyterHub-Backends.
Seleccione Persistencia de sesión y, a continuación, seleccione Activar persistencia de cookies de equilibrador de carga. Las cookies se generan automáticamente.
Seleccione Next. Aparece la página Configurar Listener. Complete lo siguiente:
1. En el campo Nombre del listener, introduzca un nombre para el listener. Por ejemplo: JupyterHub-Listener.
2. Seleccione HTTPS para Especificar el tipo de tráfico que maneja el listener.
3. En el campo Especificar el puerto que el listener supervisa para el tráfico de entrada, introduzca 8000.
4. Seleccione Pegar certificado SSL.
5. En el campo Certificado SSL, copie y pegue un certificado directamente en este campo.
6. Seleccione Load balancer Managed Certificate en la lista desplegable.
7. Seleccione Pegar certificado de CA.
8. En el campo Certificado de CA, introduzca el certificado de CA del cluster.
9. Seleccione Specify private key.
  1. Seleccione Paste private key.
  2. En el campo Clave privada, pegue una clave privada directamente en este campo.
Seleccione Siguiente y, a continuación, seleccione Enviar.

Configuración del juego de backends

Para obtener más información sobre la creación de un equilibrador de carga público, consulte Creación de un equilibrador de carga y complete los siguientes detalles.

Abra el menú de navegación, seleccione Networking y, a continuación, seleccione Load balancers. Seleccione Equilibrador de carga. Aparecerá la página Equilibradores de carga.
Seleccione el compartimento en la lista. Todos los equilibradores de carga de ese compartimento se muestran en formato tabular.
Seleccione el equilibrador de carga al que desea agregar un backend. Aparece la página de detalles del equilibrador de carga.
Seleccione Juegos de backends y, a continuación, seleccione el juego de backends que ha creado en Creación del equilibrador de carga.
Seleccione las direcciones IP y, a continuación, introduzca la dirección IP privada necesaria del cluster.
Introduzca 8000 para el Puerto.
Seleccione Agregar.

Configuración del juego de backends

Para obtener más información sobre la creación de un equilibrador de carga público, consulte Creación de un equilibrador de carga y complete los siguientes detalles.

Abra un explorador e introduzca https://<loadbalancer ip>:8000.
Seleccione el compartimento en la lista. Todos los equilibradores de carga de ese compartimento se muestran en formato tabular.
Asegúrese de que redirige a uno de los servidores JupyterHub. Para verificarlo, abra una sesión de terminal en JupyterHub para buscar el nodo al que se ha llegado.

Limitaciones

Después de agregar la operación de nodo, el administrador del cluster debe actualizar manualmente la entrada de host del equilibrador de carga en los nodos recién agregados. Aplicable a todas las adiciones de nodos al cluster. Por ejemplo, nodo de trabajador, solo cálculo y nodos.
El certificado se debe actualizar manualmente al equilibrador de carga en caso de caducidad. Este paso garantiza que el equilibrador de carga no utilice certificados anticuados y evita fallos de comprobación del sistema/comunicación en los juegos de backends. Para obtener más información, consulte Actualización de un certificado de equilibrador de carga que caduca para actualizar el certificado caducado.

Iniciar núcleos Trino-SQL

El núcleo JupyterHub PyTrino proporciona una interfaz SQL que permite ejecutar consultas Trino mediante JupyterHub SQL. Está disponible para clusters ODH 2.x de Big Data Service 3.0.28 o posterior.

Inicio del núcleo PyTrino y ejecución de consultas Trino

Instale Trino.
Configure el coordinador y el puerto de Trino:
1. Acceda a Apache Ambari.
2. En la barra de herramientas lateral, en Servicios, seleccione JupyterHub.
3. Seleccione Configuración y, a continuación, seleccione Avanzado.
4. En la sección Advanced Jupyterhub-trino-kernel-configs, configure el Trino Coordinator Hostname y el Trino Port.
Seleccione Guardar y, a continuación, reinicie JupyterHub.
Acceda a JupyterHub.
Abra un servidor de bloc de notas. Se le redirigirá a la página del iniciador.
Seleccione el núcleo PyTrino.

Puede ejecutar consultas de Trino en el núcleo PyTrino de las siguientes formas:

Ejecute consultas de ejemplo de Trino mediante %sql <Trino-query> y, a continuación, seleccione Ejecutar.
Ejemplo:
```
%sql select custkey, name, phone, acctbal from tpch.sf1.customer limit 10
```

Puede escribir la lógica de Python sobre el resultado de la consulta. Por ejemplo:

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 las consultas de varias líneas, ejecute %%sql. Por ejemplo:

# 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}}

Definición de Parámetros de Sesión Trino

Los parámetros de sesión de Trino se pueden configurar desde la interfaz de usuario de Ambari JupyterHub. Estos parámetros de sesión se aplican a todas las sesiones de usuario.

Para obtener más información sobre los parámetros de sesión, consulte Properties reference#.

Acceda a Apache Ambari.
En la barra de herramientas lateral, en Servicios, seleccione JupyterHub.
Seleccione Configuración y, a continuación, seleccione Avanzado.
En la sección Custom Jupyterhub-trino-kernel-configs, agregue los siguientes parámetros de sesión:
```
trino_session_params_<SESSION_PARAM> = <VALUE>
```
Por ejemplo, trino_session_params_query_max_planning_time = 1200m.
(Opcional) Para ver la lista de parámetros de sesión, ejecute:
```
%sql SHOW session
```
Para definir parámetros para la sesión de bloc de notas actual, ejecute: %sql SET SESSION. Por ejemplo:
```
%sql SET SESSION query_max_run_time='2h'
```

Definición de parámetros de credenciales adicionales de Trino

Los parámetros de credenciales adicionales de Trino necesarios para acceder a los datos del almacén de objetos se pueden configurar desde la interfaz de usuario de Ambari JupyterHub.

Acceda a Apache Ambari.
En la barra de herramientas lateral, en Servicios, seleccione JupyterHub.
Configuración y, a continuación, seleccione Avanzada.
En la sección Custom Jupyterhub-trino-kernel-configs, agregue los siguientes parámetros adicionales de credenciales:
```
trino_extra_credentials_<BDS_OSS_CLIENT_PARAM> = <VALUE>
```
Por ejemplo, trino_extra_credentials_BDS_OSS_CLIENT_REGION = us-region-1.

Definición de parámetros SqlMagic

Las configuraciones de SqlMagic proporcionan un control flexible sobre el comportamiento y el aspecto de las operaciones SQL ejecutadas en los blocs de notas de Jupyter. Estos parámetros se pueden configurar desde la interfaz de usuario de Ambari JupyterHub y se pueden aplicar a todas las sesiones de usuario.

Para obtener más información sobre los parámetros SqlMagic, consulte https://jupysql.ploomber.io/en/latest/api/configuration.html#changing-configuration.

Acceda a Apache Ambari.
En la barra de herramientas lateral, en Servicios, seleccione JupyterHub.
Seleccione Configs y, a continuación, seleccione Advanced.
En la sección Custom Jupyterhub-sql-magic-configs, agregue los siguientes parámetros mágicos:
SqlMagic.<PARAM> = <VALUE>
Ejemplo:
```
SqlMagic.displaycon = False
```
Para obtener la lista de parámetros SqlMagic, ejecute:
```
%config SqlMagic
```
(Opcional) Puede definir parámetros SqlMagic solo para la sesión de bloc de notas actual.
Ejemplo:
```
%config SqlMagic.displaycon=False
```

Documentación de Oracle Cloud Infrastructure

Uso de JupyterHub en Big Data Service 3.0.27 o posterior

Requisitos

Acceso a JupyterHub

Gestionar JupyterHub

Gestión de usuarios y permisos

Requisitos

Tipos de Autenticación Soportados

Uso de la autenticación de LDAP mediante Ambari

Generación de blocs de notas

Generación de blocs de notas en un cluster de HA

Generación de Notebooks en un cluster sin HA

Generación de Par de Claves SSH

Uso de tokens de acceso

Selección del Modo de Persistencia como Git

Montaje del cubo de Oracle Object Storage mediante rclone con autenticación de principal de usuario

Gestionar entornos conda en JupyterHub

Requisitos

Configuraciones disponibles para personalización

Configuración de un entorno conda específico del usuario

Creación de un equilibrador de carga y un juego de backend

Iniciar núcleos Trino-SQL

Montaje del cubo de Oracle Object Storage mediante `rclone` con autenticación de principal de usuario