Documentation sur Oracle Cloud Infrastructure

Utilisation de JupyterHub dans le service de mégadonnées 3.0.27 ou version ultérieure

Utilisez JupyterHub pour gérer les blocs-notes ODH 2.x du service de mégadonnées version 3.0.27 ou ultérieure pour les groupes d'utilisateurs.

Préalables

Accès à JupyterHub

Accédez à JupyterHub au moyen du navigateur pour les grappes ODH 2.x du service de mégadonnées 3.0.27 ou ultérieures.
  1. Accédez à Apache Ambari.
  2. Dans la barre d'outils latérale, sous Services, sélectionnez JupyterHub.

Gérer JupyterHub

Un utilisateur JupyterHub admin peut effectuer les tâches suivantes pour gérer les carnets dans JupyterHub sur les noeuds ODH 2.x du service de mégadonnées 3.0.27 ou ultérieurs.

Pour gérer les services Oracle Linux 7 à l'aide de la commande systemctl, voir Utilisation de services de système.

Pour vous connecter à une instance Oracle Cloud Infrastructure, voir Connexion à votre instance.

Arrêt, démarrage ou redémarrage de JupyterHub au moyen d'Ambari

En tant qu'administrateur, vous pouvez arrêter ou désactiver JupyterHub pour ne pas consommer de ressources, telles que la mémoire. Le redémarrage peut également aider à rectifier des problèmes inattendus ou un comportement.

Note

Arrêtez ou démarrez JupyterHub au moyen d'Ambari pour les grappes du service de mégadonnées version 3.0.27 ou ultérieure.
  1. Accédez à Apache Ambari.
  2. Dans la barre d'outils latérale, sous Services, sélectionnez JupyterHub.
  3. Sélectionnez Actions :
    • Pour démarrer JupyterHub, sélectionnez Démarrer.
    • Pour arrêter JupyterHub, sélectionnez Arrêter.
    • Pour redémarrer JupyterHub, sélectionnez Redémarrer.
Ajout du serveur JupyterHub

En tant qu'administrateur, vous pouvez ajouter le serveur JupyterHub à un noeud du service de mégadonnées.

Note

Cette option est disponible pour les grappes du service de mégadonnées version 3.0.27 ou ultérieure.
  1. Accédez à Apache Ambari.
  2. Dans la barre d'outils latérale, sélectionnez Hôtes.
  3. Pour ajouter le serveur JupyterHub, sélectionnez un hôte où JupyterHub n'est pas installé.
  4. Sélectionnez Ajouter.
  5. Sélectionnez JupyterHub Server.
Déplacement du serveur JupyterHub

En tant qu'administrateur, vous pouvez déplacer le serveur JupyterHub vers un autre noeud du service de mégadonnées.

Note

Cette option est disponible pour les grappes du service de mégadonnées version 3.0.27 ou ultérieure.
  1. Accédez à Apache Ambari.
  2. Dans la barre d'outils latérale, sous Services, sélectionnez JupyterHub.
  3. Sélectionnez Actions, puis Déplacer le serveur JupyterHub.
  4. Sélectionnez Suivant.
  5. Sélectionnez l'hôte vers lequel déplacer le serveur JupyterHub.
  6. Terminez l'assistant de déplacement.
Exécution des vérifications d'état/de service JupyterHub

En tant qu'administrateur, vous pouvez exécuter des vérifications d'état/de service JupyterHub au moyen d'Ambari.

Note

Cette option est disponible pour les grappes du service de mégadonnées version 3.0.27 ou ultérieure.
  1. Accédez à Apache Ambari.
  2. Dans la barre d'outils latérale, sous Services, sélectionnez JupyterHub.
  3. Sélectionnez Actions, puis Exécuter la vérification du service.

Gérer les utilisateurs et les autorisations

Utilisez l'une des deux méthodes d'authentification pour authentifier les utilisateurs dans JupyterHub afin qu'ils puissent créer des carnets et, éventuellement, administrer JupyterHub sur les grappes ODH 2.x du service de mégadonnées 3.0.27 ou ultérieures.

Les utilisateurs JupyterHub doivent être ajoutés en tant qu'utilisateurs du système d'exploitation sur tous les noeuds de la grappe du service de mégadonnées pour les grappes du service de mégadonnées non Active Directory (AD), où les utilisateurs ne sont pas synchronisés automatiquement sur tous les noeuds de la grappe. Les administrateurs peuvent utiliser le script de gestion des utilisateurs JupyterHub pour ajouter des utilisateurs et des groupes avant de se connecter à JupyterHub.

Conditions requises :

Effectuez les opérations suivantes avant d'accéder à JupyterHub :

  1. Connectez-vous SSH au noeud où JupyterHub est installé.
  2. Accédez à /usr/odh/current/jupyterhub/install.
  3. Pour fournir les détails de tous les utilisateurs et groupes dans le fichier sample_user_groups.json, exécutez :
    sudo python3 UserGroupManager.py sample_user_groups.json
          
          Verify user creation by executing the following command:
          id <any-user-name>

Types d'authentification pris en charge

  • NativeAuthenticator : Cet authentificateur est utilisé pour les applications JupyterHub de petite ou moyenne taille. L'inscription et l'authentification sont mises en oeuvre en tant que version native de JupyterHub sans avoir recours à des services externes.
  • SSOAuthenticator : Cet authentificateur fournit une sous-classe de jupyterhub.auth.Authenticator qui agit en tant que fournisseur de services SAML2. Dirigez-le vers un fournisseur d'identités SAML2 configuré correctement et active l'authentification unique pour JupyterHub.
Authentification native

L'authentification native dépend de la base de données d'utilisateurs JupyterHub pour l'authentification des utilisateurs.

L'authentification native s'applique aux grappes qui sont hautement disponibles et à celles qui ne le sont pas. Reportez-vous à NativeAuthenticator pour plus de détails sur l'authentificateur natif.

Préalables à l'autorisation d'un utilisateur dans une grappe hautement disponible

Ces préalables doivent être satisfaits pour autoriser un utilisateur dans une grappe hautement disponible pour le service de mégadonnées à l'aide de l'authentification native.

  1. L'utilisateur doit exister sur l'hôte Linux. Exécutez la commande suivante pour ajouter un nouvel utilisateur Linux sur tous les noeuds d'une grappe. 
    # Add linux user
dcli -C "useradd -d /home/<username> -m -s /bin/bash <username>"
  2. Pour démarrer un serveur de carnets, un utilisateur doit fournir le principal et le fichier keytab path/password et demander un ticket Kerberos à partir de l'interface JupyterHub. Pour créer un fichier keytab, l'administrateur de la grappe doit ajouter un principal Kerberos avec un mot de passe et un fichier keytab. Exécutez les commandes suivantes sur le premier noeud principal (mn0) de la grappe. 
    # 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'
  3. Le nouvel utilisateur doit disposer des autorisations Ranger appropriées pour stocker des fichiers dans le répertoire HDFS hdfs:///users/<username> , car les carnets individuels sont stockés dans /users/<username>/notebooks. L'administrateur de la grappe peut ajouter l'autorisation requise à partir de l'interface Ranger en ouvrant l'URL suivante dans un navigateur Web. 
    https://<un0-host-ip>:6182
  4. Le nouvel utilisateur doit avoir les autorisations appropriées sur Yarn, Hive et sur le stockage d'objets pour pouvoir lire et écrire des données, et exécuter des tâches Spark. L'utilisateur peut également utiliser l'emprunt d'identité Livy (exécuter des tâches du service de mégadonnées en tant qu'utilisateur Livy) s'il ne dispose pas des autorisations explicites pour Spark, Yarn et les autres services.
  5. Exécutez la commande suivante pour accorder au nouvel utilisateur l'accès au répertoire 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éalables à l'autorisation d'un utilisateur dans une grappe qui n'est pas hautement disponible

Ces préalables doivent être satisfaits pour autoriser un utilisateur dans une grappe non hautement disponible du service de mégadonnées à l'aide de l'authentification native.

  1. L'utilisateur doit exister sur l'hôte Linux. Exécutez la commande suivante pour ajouter un nouvel utilisateur Linux sur tous les noeuds d'une grappe. 
    # Add linux user
dcli -C "useradd -d /home/<username> -m -s /bin/bash <username>"
  2. Le nouvel utilisateur doit disposer des autorisations appropriées pour stocker des fichiers dans le répertoire HDFS hdfs:///users/<username> . Exécutez la commande suivante pour accorder au nouvel utilisateur l'accès au répertoire 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>"
Ajout d'un administrateur

Les administrateurs sont responsables de la configuration et de la gestion de JupyterHub. Les administrateurs sont également responsables de l'autorisation des utilisateurs qui viennent de s'inscrire à JupyterHub.

Avant l'ajout d'un utilisateur administrateur, les conditions requises doivent être remplies pour une grappe non hautement disponible.

  1. Accédez à Apache Ambari.
  2. Dans la barre d'outils latérale, sous Services, sélectionnez JupyterHub.
  3. Sélectionnez Configs, puis Advanced Configs.
  4. Sélectionnez Advanced jupyterhub-config.
  5. Ajoutez l'utilisateur administrateur à c.Authenticator.admin_users.
  6. Sélectionnez enregistrer.
Un administrateur du fichier de configuration JupyterHub n'a pas besoin d'une autorisation explicite lors de la connexion. Après vous être inscrit, vous pouvez vous connecter directement.
Ajout d'autres utilisateurs

Avant d'ajouter d'autres utilisateurs, les conditions requises doivent être remplies pour une grappe du service de mégadonnées.

  1. Accédez JupyterHub.
  2. Inscrivez-vous en tant que nouvel utilisateur. Les utilisateurs non administrateurs ont besoin d'une autorisation explicite de la part des utilisateurs administrateurs.
  3. L'administrateur doit se connecter à JupyterHub et, à partir de la nouvelle option de menu permettant d'autoriser les utilisateurs connectés, il doit autoriser le nouvel utilisateur.
    Capture d'écran de la page d'autorisation d'utilisateurs dans Jupyterhub
  4. Le nouvel utilisateur peut désormais se connecter.
Suppression d'utilisateurs

Un administrateur peut supprimer des utilisateurs JupyterHub.

  1. Accédez JupyterHub.
  2. Ouvrez File (Fichier) > HubControlPanel.
  3. Naviguez jusqu'à la page Authorize Users (Autoriser des utilisateurs).
  4. Supprimez les utilisateurs voulus.
Authentification LDAP

Vous pouvez utiliser l'authentification LDAP au moyen d'Ambari pour les clusters Big Data Service 3.0.27 ou ultérieurs ODH 2.x.

Utilisation de l'authentification LDAP à l'aide d'Ambari

Pour utiliser l'authentification LDAP, vous devez mettre à jour le fichier de configuration JupyterHub avec les informations de connexion à LDAP.

Note

Utilisez Ambari pour l'authentification LDAP sur les grappes du service de mégadonnées version 3.0.27 ou ultérieure.

Reportez-vous à Authentificateur LDAP pour plus de détails sur l'authentificateur LDAP.

  1. Accédez à Apache Ambari.
  2. Dans la barre d'outils latérale, sous Services, sélectionnez JupyterHub.
  3. Sélectionnez Config (Configuration), puis sous Advanced jupyterhub config (Configuration avancée de jupyterhub) > Base Settings (Paramètres de base), entrez les informations suivantes : 
    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"]
  4. Redémarrez JupyterHub.
Configurer l'authentification unique dans le service de mégadonnées JupyterHub

pConfigure Authentification unique dans le service de mégadonnées 3.0.27 ou version ultérieure du service ODH 2.x JupyterHub.

Utilisation du domaine d'identité Oracle

Vous pouvez utiliser le domaine d'identité Oracle pour configurer l'authentification unique dans les grappes ODH 2.x JupyterHub du service de mégadonnées 3.0.27 ou ultérieures.

  1. Créer un domaine d'identité. Pour plus d'informations, voir .
  2. Dans le domaine, sous Applications intégrées, ajoutez une application SAML.
  3. Fournissez les détails requis suivants lors de la création de l'application :
    • ID entité : Il s'agit d'un ID unique. Vous pouvez utiliser l'URL de base de JupyterHub, par exemple https://myjupyterhub/saml2_auth/ent.
    • URL de consommateur d'assertion :
      • URL JupyterHub : https://<Jupyterhub-Host>:<Port>/hub/saml2_auth/acs
      • URL de l'équilibreur de charge : https://<Load-Balancer>:<Port>/hub/saml2_auth/acs
    • URL de déconnexion unique, URL de réponse de déconnexion : https://<Jupyterhub-Host>:<Port>/hub/logout
  4. Activez l'application.
  5. Affecter des utilisateurs à l'application.
  6. Naviguez jusqu'à l'application créée et sélectionnez Télécharger les métadonnées du fournisseur d'identités, puis copiez ce fichier de métadonnées sur l'hôte JupyterHub et assurez-vous qu'il dispose d'un accès en lecture pour tous les utilisateurs.
  7. Mettez à jour les paramètres de session de l'utilisateur. Pour plus d'informations, voir Définition des limites de session.
Utilisation d'OKTA via Ambari

Vous pouvez utiliser OKTA pour configurer l'authentification unique dans les grappes ODH 2.x JupyterHub du service de mégadonnées 3.0.27 ou ultérieures.

  1. Connectez-vous à OKTA.
  2. Dans la barre d'outils latérale, sélectionnez Applications > Applications > Créer une intégration d'application.
  3. Sélectionnez SAML 2.0.
  4. Fournissez les détails suivants et créez l'application.
    • Nom de l'application : Nom de l'application. Par exemple, JupyterHub-SSO.
    • URL d'authentification unique : URL d'authentification unique. Par exemple : https://<Jupyterhub-Host>:<Port>/hub/saml2_auth/acs.
    • URI de public (ID entité SP) : ID unique. Vous pouvez utiliser l'URL de base de JupyterHub. Par exemple : https://myjupyterhub/saml2_auth/ent.
  5. Affecter des utilisateurs à l'application.
  6. Sélectionnez l'onglet de connexion et obtenez les détails suivants :
    • URL des métadonnées : Téléchargez le fichier de métadonnées, puis copiez-le sur l'hôte JupyterHub.
    • URL de connexion : Copiez l'URL de connexion, puis mettez-la à jour dans les configurations JupyterHub (saml2_login_url).
Activation de l'authentification unique
  1. Accédez à Apache Ambari.
  2. Dans la barre d'outils latérale, sous Services, sélectionnez JupyterHub.
  3. Sélectionnez Config (Configuration) > Settings (Paramètres) > Notebook Server Authenticator (Authentificateur de serveur de carnet).
  4. Sélectionnez SamlSSOAuthenticator.
  5. Sélectionnez enregistrer.
  6. Sélectionnez Avancé.
  7. Mettez à jour les paramètres dans la section Jupiter-config avancé SamlSSOAuthenticator-Configs :

    • c.Saml2Authenticator.saml2_metadata_file name : Chemin d'accès au fichier de métadonnées du fournisseur d'identités dans le noeud installé JupyterHub. Par exemple : '/tmp/IDCSMetadata.xml'.

    • c.Saml2Authenticator.saml2_entity_id : Identificateur unique permettant de gérer le mappage entre le fournisseur d'identités et le fournisseur de services (JupyterHub). Cet identificateur doit être identique dans les configurations d'application du fournisseur d'identités et du fournisseur de services (JupyterHub). Par exemple : https://myjupyterhub/saml2_auth/ent

    • c.Saml2Authenticator.saml2_login_URL : URL de connexion unique. Pour les utilisateurs d'Oracle IDCS, vous pouvez obtenir cette information auprès du fournisseur d'identités metadata.xml file. Dans le fichier metadata.xml file, recherchez le marqueur AssertionConsumerService et obtenez la valeur de l'attribut location. Pour OKTA, copiez la valeur de l'URL de connexion présente dans l'onglet de connexion. Par exemple : https://idcs-1234.identity.oraclecloud.com/fed/v1/sp/sso

    • #c.Saml2Authenticator.saml2_metadata_URL : Facultatif. URL du fichier de métadonnées du fournisseur d'identités. Assurez-vous que l'URL fournie est accessible à partir du noeud installé JupyterHub. saml2_metadata_filename ou saml2_metadata_url est requis. Par exemple : https://idcs-1234.identity.oraclecloud.com/sso/saml/metadata

    • #c.Saml2Authenticator.saml2_attribute_username : Facultatif. Spécifiez un attribut à considérer comme utilisateur à partir de l'assertion SAML. Si aucun attribut n'est spécifié, le nom utilisateur de connexion est traité en tant qu'utilisateur. Entrez 'Courriel'.

    • #c.Saml2Authenticator.saml2_private_file_path et #c.Saml2Authenticator.saml2_public_file_path : Facultatif. Si le fournisseur d'identités chiffre les données d'assertion, le fournisseur de services JupyterHub doit fournir les clés privées et publiques nécessaires pour déchiffrer les données d'assertion. Par exemple :

      #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 : Facultatif. Cela configure le bouton de connexion à afficher en tant que 'Sign in with {login_service}'. Entrez 'Oracle IDCS'.

  8. Redémarrez JupyterHub.
Configurer JupyterHub au moyen d'Ambari

En tant qu'administrateur, vous pouvez gérer les configurations JupyterHub au moyen des grappes Ambari pour le service de mégadonnées 3.0.27 ou ultérieures ODH 2.x.

  1. Accédez à Apache Ambari.
  2. Dans la barre d'outils latérale, sous Services, sélectionnez JupyterHub.
  3. Sélectionner Configs. Les configurations suivantes sont prises en charge :
    • Configuration de Spawner :
      • ODHSystemdSpawner : Générateur de vulnérabilités personnalisé utilisé pour générer dynamiquement des serveurs de carnet à utilisateur unique à l'aide de Systemd sur le noeud local où le serveur JupyterHub est installé.
      • ODHYarnSpawner : Spawner personnalisé pour JupyterHub qui lance les serveurs de carnet sur les grappes YARN. Il s'agit du générateur par défaut utilisé par le service de mégadonnées.
    • Configuration commune : Il s'agit de configurations telles que l'adresse IP de liaison et le port où JupyterHub serait exécuté.
    • Configuration de l'authentificateur : Deux authentificateurs peuvent être utilisés pour authentifier les utilisateurs qui se connectent à JupyterHub. Pour plus d'informations sur les types d'authentification, voir Gérer les utilisateurs et les autorisations.
    • Mode de persistance :
      • HDFS : Permet de conserver les carnets sur HDFS
      • Git : Permet d'utiliser une extension JupyterLab pour le contrôle des versions à l'aide de Git, ce qui permet la persistance des carnets sur les serveurs distants au moyen de Git.

Génération de carnets

Les configurations Spawner suivantes sont prises en charge sur les grappes du service de mégadonnées 3.0.27 et ultérieures ODH 2.x.

Entrez les informations suivantes :

  1. Authentification native :
    1. Se connecter à l'aide des données d'identification de l'utilisateur connecté
    2. Entrer l'utilisateur.
    3. Entrer le mot de passe.
  2. À l'aide de SamlSSOAuthenticator :
    1. Connectez-vous avec l'authentification unique.
    2. Connectez-vous avec l'application d'authentification unique configurée.

Générer des carnets sur une grappe hautement disponible

Pour la grappe intégrée AD :

  1. Connectez-vous à l'aide de l'une des méthodes précédentes. L'autorisation ne fonctionne que si l'utilisateur est présent sur l'hôte Linux. JupyterHub recherche l'utilisateur sur l'hôte Linux lors de la tentative de génération du serveur de carnets.
  2. Vous êtes dirigé vers une page Options de serveur où vous devez demander un ticket Kerberos. Ce ticket peut être demandé à l'aide du principal Kerberos et du fichier keytab, ou du mot de passe Kerberos. L'administrateur de la grappe peut fournir le principal Kerberos et le fichier keytab, ou le mot de passe Kerberos. Le ticket Kerberos est nécessaire pour accéder aux répertoires HDFS et aux autres services de mégadonnées que vous voulez utiliser.

Génération de carnets sur une grappe qui n'est pas hautement disponible

Pour la grappe intégrée AD :

Connectez-vous à l'aide de l'une des méthodes précédentes. L'autorisation ne fonctionne que si l'utilisateur est présent sur l'hôte Linux. JupyterHub recherche l'utilisateur sur l'hôte Linux lors de la tentative de génération du serveur de carnets.

Configuration de l'environnement Git
  1. Configurez des clés SSH/des jetons d'accès pour le noeud de grappe du service de mégadonnées.
  2. Sélectionnez le mode de persistance du carnet Git.
Configurer la connexion Git

Pour configurer la connexion Git pour JupyterHub, procédez comme suit :

  1. Jetons d'accès pour le noeud de grappe du service de mégadonnées.
  2. Sélectionner le mode de persistance du carnet en tant que Git

Génération d'une paire de clés SSH

  1. Ouvrez un terminal ou une invite de commande.
  2. Pour générer une nouvelle paire de clés SSH, exécutez : 
    ssh-keygen -t rsa -b 4096 -C "your_email@example.com"
  3. (Facultatif) Suivez les invites pour spécifier l'emplacement du fichier et la phrase secrète (facultatif).
  4. Enregistrer la clé publique :
    1. Connectez-vous à votre compte de serveur Git.
    2. Accédez à la section des paramètres ou des clés SSH de votre compte.
    3. Ajoutez le contenu de la clé publique (~/.ssh/id_rsa.pub) au compte de serveur Git.
  5. Configurez l'agent SSH :

    Si vous disposez de nombreuses clés SSH gérées par l'agent SSH, vous pouvez créer un fichier de configuration pour spécifier la clé à utiliser pour chaque serveur Git.

    1. Ouvrez ou créez le fichier de configuration SSH (~/.ssh/config) dans un éditeur de texte.
    2. Ajoutez des entrées pour chaque serveur Git en spécifiant le fichier d'identité associé à chaque clé SSH.
  6. Connectez le référentiel Git local à distant à l'aide de SSH :
    1. Ouvrez un terminal ou une invite de commande.
    2. Accédez au référentiel Git local.
    3. Pour faire passer l'URL distante de HTTPS à SSH, exécutez : 
      
git remote set-url origin git@github.com:username/repository.git

      Remplacez username/repository.git par l'URL du référentiel Git appropriée.

  7. Vérifiez la connexion SSH :
    1. Testez la connexion SSH au serveur Git : 
      ssh -T git@github.com
  8. (Facultatif) Si vous êtes invité à confirmer l'authenticité de l'hôte, entrez Oui pour continuer.

Utilisation de jetons d'accès

Vous pouvez utiliser des jetons d'accès comme suit :

  • GitHub:
    1. Connectez-vous à votre compte GitHub.
    2. Naviguez jusqu'à Paramètres > Paramètres du développeur > Jetons d'accès personnel.
    3. Générez un nouveau jeton d'accès avec les autorisations appropriées.
    4. Utilisez le jeton d'accès comme mot de passe lorsque vous êtes invité à vous authentifier.
  • GitLab:
    1. Connectez-vous à votre compte GitHub.
    2. Naviguez jusqu'à Paramètres > Jetons d'accès.
    3. Générez un nouveau jeton d'accès avec les autorisations appropriées.
    4. Utilisez le jeton d'accès comme mot de passe lorsque vous êtes invité à vous authentifier.
  • BitBucket:
    1. Connectez-vous à votre compte BitBucket.
    2. Naviguez jusqu'à Paramètres > Mots de passe d'application.
    3. Générez un nouveau jeton de mot de passe d'application avec les autorisations appropriées.
    4. Utilisez le nouveau mot de passe de l'application comme mot de passe lorsque vous êtes invité à vous authentifier.

Sélectionner le mode de persistance comme Git

  1. Accédez à Apache Ambari.
  2. Dans la barre d'outils latérale, sous Services, sélectionnez JupyterHub.
  3. Sélectionnez Configs, puis Settings (Paramètres).
  4. Recherchez le mode de persistance du carnet, puis sélectionnez Git dans la liste déroulante.
  5. Sélectionnez Actions, puis Tout redémarrer.
Configuration de HDFS dans JupyterHub pour le stockage des carnets
Pour configurer HDFS en tant que stockage par défaut pour les carnets JupyterHub, sélectionnez le mode de persistance HDFS.
  1. Accédez à Apache Ambari.
  2. Dans la barre d'outils latérale, sous Services, sélectionnez JupyterHub.
  3. Sélectionnez Configs, puis Settings (Paramètres).
  4. Recherchez le mode de persistance du carnet, puis sélectionnez HDFS dans la liste déroulante.
  5. Sélectionnez Actions, puis Tout redémarrer.
Configuration du stockage d'objets dans JupyterHub pour le stockage de carnets

En tant qu'utilisateur administrateur, vous pouvez stocker les carnets d'utilisateurs individuels dans le stockage d'objets au lieu de HDFS. Lorsque vous faites passer le gestionnaire de contenu de HDFS au stockage d'objets, les blocs-notes existants ne sont pas copiés vers le stockage d'objets. Les nouveaux carnets sont enregistrés dans le stockage d'objets.

  1. Accédez à Apache Ambari.
  2. Dans la barre d'outils latérale, sous Services, sélectionnez JupyterHub.
  3. Sélectionnez Configs, puis Advanced (Avancé).
  4. Naviguez jusqu'à la section c.YarnSpawner.args = yarn_spawner_default_rags, puis remplacez le contenu par : 
    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=""']
  5. Redémarrez tous les serveurs JupyterHub à partir du menu Actions.

Montage du seau de stockage d'objets Oracle à l'aide de rclone avec l'authentification de principal d'utilisateur

Vous pouvez monter le service Oracle Object Storage à l'aide de rclone avec l'authentification de principal d'utilisateur (clés d'API) sur un noeud de grappe du service de mégadonnées à l'aide de rclone et de fuse3, personnalisés pour les utilisateurs JupyterHub.

Effectuez cette procédure pour les grappes ODH 2.x du service de mégadonnées version 3.0.28 ou ultérieure afin de permettre un accès transparent et une gestion du stockage d'objets directement à partir de votre environnement JupyterHub, améliorant ainsi vos capacités de traitement des données.
  1. Accédez à Apache Ambari.
  2. Dans la barre d'outils latérale, sous Services, sélectionnez JupyterHub.
  3. Sélectionnez Sommaire, puis JUPYTERHUB_SERVER.
  4. Obtenez les informations sur l'hôte à partir des informations affichées.
  5. Connectez-vous à l'hôte du service de mégadonnées à l'aide des données d'identification SSH utilisées lors de la création de la grappe. Pour plus d'informations, voir Connexion à un noeud de grappe au moyen de SSH.
  6. Pour vérifier l'installation de rclone et de fuse3 sur le noeud, exécutez : 
    rclone version 
# Ensure version is v1.66

fusermount3 --version 
# Ensure FUSE version 3 is installed
  7. Créez une clé d'API et configurez rclone. Pour plus d'informations, voir Configurer l'authentification avec un utilisateur OCI et une clé d'API, Obtenir l'espace de noms de la location OCI et le compartiment du seau.
  8. Configurez la configuration rclone. Pour plus d'informations, voir Configurer le clone pour le service de stockage d'objets pour OCI.
  9. Pour monter le seau de stockage d'objets, exécutez la commande suivante en tant qu'utilisateur connecté.

    Ce qui suit exécute l'opération de montage avec l'utilisateur connecté `Jupyterhub`. Le processus démon s'exécute en tant que processus Linux sur le noeud où cette opération est déclenchée.

    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
    Note

    Pour utiliser les carnets Jupyter, assurez-vous que l'emplacement de montage se trouve dans le répertoire de base de l'utilisateur connecté et que le répertoire de montage est vide.
                                    sudo -u jupyterhub ls -ltr /home/jupyterhub/mount_dir
  10. (Facultatif) rcloneTo vérifiez que le montage a réussi. Exécutez les opérations suivantes. Cet exemple répertorie le contenu du seau mount_dir.
    sudo -u jupyterhub ls -ltr /home/jupyterhub/mount_dir
  11. Exécutez les procédures de nettoyage.

    Lors de l'exécution en mode arrière-plan, vous devez arrêter le montage manuellement. Utilisez les opérations de nettoyage suivantes lorsque JupyterHub et les serveurs de carnet ne sont pas utilisés.

    Sous Linux :
    sudo -u jupyterhub fusermount3 -u /home/jupyterhub/mount_dir
    L'opération umount peut échouer, par exemple lorsque le point de montage est occupé. Lorsque cela se produit, il est de la responsabilité de l'utilisateur que vous devez arrêter le montage manuellement.
    sudo -u jupyterhub umount -l /home/jupyterhub/mount_dir : lazy unmount
sudo -u jupyterhub umount -f /home/jupyterhub/mount_dir : force unmount

Gérer les environnements Conda dans JupyterHub

Note

Vous pouvez gérer les environnements Conda sur les grappes ODH 2.x du service de mégadonnées version 3.0.28 ou ultérieure.
  • Créez un environnement Conda avec des dépendances spécifiques et créez quatre noyaux (Python/PySpark/Spark/SparkR) qui pointent vers l'environnement Conda créé.
  • Les environnements Conda et les noyaux créés à l'aide de cette opération sont disponibles pour tous les utilisateurs du serveur de carnet.
  • Une opération d'environnement Conda de création distincte consiste à découpler l'opération avec le redémarrage du service.
Conditions requises
  • JupyterHub est installé au moyen de l'interface utilisateur d'Ambari.
  • Vérifiez l'accès Internet à la grappe pour télécharger les dépendances lors de la création de l'environnement Conda.
  • Les environnements Conda et les noyaux créés à l'aide de cette opération sont disponibles pour tous les utilisateurs du serveur de carnet."
  • Fournir :
    • Configurations supplémentaires Conda pour éviter l'échec de la création Conda. Pour plus d'informations, voir conda create.
    • Dépendances dans le format standard Requirements.txt.
    • Nom d'environnement Conda inexistant.
  • Supprimez manuellement les environnements Conda ou les noyaux.
Personnaliser les configurations globales
  1. Accédez à Apache Ambari.
  2. Dans la barre d'outils latérale, sous Services, sélectionnez JupyterHub.
  3. Sélectionnez Configs, puis Advanced (Avancé).
  4. Faites défiler l'affichage jusqu'à la section jupyterhub-conda-env-configs.
  5. Mettez à jour les champs suivants :
    • Configurations supplémentaires Conda : Ce champ permet de fournir des paramètres supplémentaires à ajouter à la commande de création Conda par défaut. La commande de création Conda par défaut est 'conda create -y -p conda_env_full_path -c conda-forge pip python=3.8.

      Si les configurations supplémentaires sont fournies en tant que '--override-channels --no-default-packages --no-pin -c pytorch', l'exécution finale de la commande de création Conda est 'conda create -y -p conda_env_full_path -c conda-forge pip python=3.8 --override-channels --no-default-packages --no-pin -c pytorch'.

    • Nom de l'environnement Conda : Ce champ fournit un nom unique pour l'environnement Conda. Fournissez un environnement Conda unique chaque fois qu'un nouvel environnement est créé.
    • Dépendances Python : Ce champ liste toutes les dépendances python/R/Ruby/Lua/Scala/Java/JavaScript/C/C++/FORTRAN, etc. accessibles à vos canaux Conda au format de fichier Requirements.txt.

      Pour plus d'informations sur les exigences relatives au fichier .txt, voir Format de fichier des exigences.

  6. Sélectionnez enregistrer.
  7. Sélectionnez Actions, puis Activer l'environnement Conda.
    Une fois l'activation terminée, les éléments suivants sont affichés dans l'interface utilisateur JupyterHub :
    • Noyau Python : conda_python3_kernel_{conda_env_name}
    • noyau PySpark : conda_pyspark_kernel_{conda_env_name}
    • Noyau Spark : conda_spark_kernel_{conda_env_name}
    • noyau SparkR : conda_sparkr_kernel_{conda_env_name}
    Note

    Ces noyaux pointent vers l'environnement Conda créé.
Configurer un environnement Conda propre à l'utilisateur

Cette opération crée un environnement Conda avec des dépendances spécifiées et crée le noyau spécifié (Python/PySpark/Spark/SparkR) pointant vers l'environnement Conda créé.

  • Si l'environnement Conda spécifié existe déjà, l'opération passe directement à l'étape de création du noyau
  • Les environnements Conda ou les noyaux créés à l'aide de cette opération sont disponibles uniquement pour un utilisateur spécifique
  • Exécutez manuellement le script python kernel_install_script.py en mode sudo :
     '/var/lib/ambari-server/resources/mpacks/odh-ambari-mpack-2.0.8/stacks/ODH/1.1.12/services/JUPYTER/package/scripts/'

    Exemple : 

    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éalables

  • Vérifiez l'accès Internet à la grappe pour télécharger les dépendances lors de la création de l'environnement Conda. Sinon, la création échoue.
  • Si un noyau portant le nom --kernel_name existe, une exception est générée.
  • Entrez les éléments suivants :
  • Supprimez manuellement les environnements Conda ou les noyaux pour tout utilisateur.

Configurations disponibles pour la personnalisation

  • --user (obligatoire) : OS et utilisateur JupyterHub pour lesquels le noyau et l'environnement Conda sont créés.
  • --conda_env_name (obligatoire) : Fournissez un nom unique pour l'environnement Conda chaque fois qu'une nouvelle application est créée pour --user.
  • --kernel_name : (Obligatoire) Indiquez un nom de noyau unique.
  • --kernel_type : (obligatoire) Doit être l'un des suivants (python / PysPark / Spark / SparkR)
  • --custom_requirements_txt_file_path : (facultatif) Si des dépendances Python/R/Ruby/Lua/Scala/Java/JavaScript/C/C++/FORTRAN sont installées à l'aide de canaux Conda, vous devez spécifier ces bibliothèques dans un fichier .txt d'exigences et fournir le chemin complet.

    Pour plus d'informations sur un format standard permettant de définir le fichier .txt des exigences, voir https://pip.pypa.io/en/stable/reference/requirements-file-format/.

  • --conda_additional_configs : (Facultatif)
    • Ce champ fournit des paramètres supplémentaires à ajouter à la commande de création Conda par défaut.
    • La commande de création Conda par défaut est : 'conda create -y -p conda_env_full_path -c conda-forge pip python=3.8'.
    • Si --conda_additional_configs est indiqué en tant que '--override-channels --no-default-packages --no-pin -c pytorch', l'exécution de la commande de création Conda finale est 'conda create -y -p conda_env_full_path -c conda-forge pip python=3.8 --override-channels --no-default-packages --no-pin -c pytorch'.

Configuration de l'environnement Conda propre à l'utilisateur

  1. Vérifiez que JupyterHub est installé au moyen de l'interface utilisateur d'Ambari.
  2. Accédez par SSH à la grappe, puis accédez à /var/lib/ambari-server/resources/mpacks/odh-ambari-mpack-2.0.8/stacks/ODH/1.1.12/services/JUPYTER/package/scripts/.
  3. Exécuter avec des éléments spécifiques à votre environnement : 
    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

    Cet exemple d'exécution de script avec les paramètres indiqués crée un environnement Conda conda_jupy_env_1 pour les bds d'utilisateur, installe des dépendances personnalisées pour conda_jupy_env_1 et crée un noyau spark avec le nom spark_bds_1. Une fois cette opération terminée, le noyau spark_bds_1 s'affiche dans l'interface utilisateur JupyterHub de l'utilisateur bds uniquement.

Créer un équilibreur de charge et un jeu dorsal

Pour plus d'informations sur la création de jeux dorsaux, voir Création d'un jeu dorsal d'équilibreur de charge.

Création de l'équilibreur de charge

Pour plus d'informations sur la création d'un équilibreur de charge public, voir Création d'un équilibreur de charge et entrez les détails suivants.

  1. ouvrez le menu de navigation, sélectionnez Service de réseau, puis Équilibreur de charge. Équilibreur de charge. La page équilibreurs de charge s'affiche.
  2. Sous Portée de la liste, sélectionnez le compartiment où se trouve la grappe.
  3. Dans le champ Nom de l'équilibreur de charge, entrez un nom pour identifier l'équilibreur de charge. Par exemple, JupyterHub-LoadBalancer.
  4. Dans la section Sélectionner un type d'affichage, sélectionnez Public.
  5. Dans la section Affecter une adresse IP publique, sélectionnez adresse IP réservée.
  6. Sélectionnez Créer une adresse IP réservée.
  7. Dans le champ Nom de l'adresse IP publique, entrez un nom. Par exemple, jupyterhub-ip
  8. Dans Créer dans le compartiment, sélectionnez le compartiment dans lequel se trouve la grappe.
  9. Dans la section Sélectionner un réseau, effectuez les opérations suivantes :
    1. Dans la section Réseau en nuage virtuel <Compartment> , sélectionnez le VCN utilisé par la grappe.
    2. Dans le champ Sous-réseau dans <Compartment> , sélectionnez le sous-réseau utilisé par la grappe.
  10. Sélectionnez Suivant. La page Sélectionner des serveurs dorsaux s'affiche.
  11. Dans Spécifier une politique d'équilibrage de charge, sélectionnez Hachage d'adresse IP.
    Note

    N'ajoutez pas de serveurs dorsaux à ce stade.
  12. Dans la section Spécifier la politique de vérification de l'état, effectuez les opérations suivantes :
    1. Dans le champ Port, entrez 8000.
    2. Dans le champ Chemin de l'URL, entrez //hub/api.
  13. Sélectionnez Utiliser SSL.
  14. Dans la section Ressource de certificat, effectuez les opérations suivantes :
    1. Sélectionnez Certificat géré par l'équilibreur de charge dans la liste déroulante.
    2. Sélectionnez Coller le certificat SSL.
    3. Dans le champ Certificat SSL, copiez et collez un certificat directement dans ce champ.
    4. Sélectionnez Coller le certificat de l'AC.
    5. Dans le champ Certificat de l'autorité de certification, entrez le certificat Oracle à l'aide de /etc/security/serverKeys/bdsOracleCA.crt qui est présent dans la grappe. Pour les autorités de certification publiques, ce certificat peut être obtenu directement à partir de leur site.
    6. (Facultatif) Sélectionnez Sélectionner la clé privée.
      1. Sélectionnez Coller la clé privée.
      2. Dans le champ Clé privée, collez une clé privée directement dans ce champ.
  15. Sélectionnez Afficher les options avancées pour accéder à d'autres options.
  16. Sélectionnez l'onglet Jeu dorsal, puis entrez le nom du jeu dorsal. Par exemple, JupyterHub-Serveurs dorsaux.
  17. Sélectionnez Persistance de session, puis Activer la persistance des témoins de l'équilibreur de charge. Les témoins sont générés automatiquement.
  18. Sélectionnez Suivant. La page Configurer le module d'écoute apparaît. Entrez les informations suivantes :
    1. Dans le champ Nom du module d'écoute, entrez le nom de ce dernier. Par exemple : JupyterHub-Listener.
    2. Sélectionnez HTTPS pour spécifier le type de trafic que gère le module d'écoute.
    3. Dans le champ Préciser le port que le module d'écoute surveille pour le trafic entrant, entrez 8000.
    4. Sélectionnez Coller le certificat SSL.
    5. Dans le champ Certificat SSL, copiez et collez un certificat directement dans ce champ.
    6. Sélectionnez Certificat géré par l'équilibreur de charge dans la liste déroulante.
    7. Sélectionnez Coller le certificat de l'AC.
    8. Dans le champ Certificat de l'autorité de certification, entrez le certificat de l'autorité de certification de la grappe.
    9. Sélectionnez spécifier la clé privée.
      1. Sélectionnez Coller la clé privée.
      2. Dans le champ Clé privée, collez une clé privée directement dans ce champ.
  19. Sélectionnez Suivant, puis Soumettre.
Configurer le jeu dorsal

Pour plus d'informations sur la création d'un équilibreur de charge public, voir Création d'un équilibreur de charge et entrez les détails suivants.

  1. ouvrez le menu de navigation, sélectionnez Service de réseau, puis Équilibreur de charge. Sélectionner un équilibreur de charge. La page Équilibreurs de charge s'affiche.
  2. Sélectionnez le compartiment dans la liste. Tous les équilibreurs de charge de ce compartiment sont présentés sous forme de tableau.
  3. Sélectionnez l'équilibreur de charge auquel vous voulez ajouter un serveur dorsal. La page des détails de l'équilibreur de charge s'affiche.
  4. Sélectionnez Jeux dorsaux, puis sélectionnez le jeu dorsal que vous avez créé lors de la création de l'équilibreur de charge.
  5. Sélectionnez des adresses IP, puis entrez l'adresse IP privée requise de la grappe.
  6. Entrez 8000 pour le port.
  7. Sélectionnez Ajouter.
Configurer le jeu dorsal

Pour plus d'informations sur la création d'un équilibreur de charge public, voir Création d'un équilibreur de charge et entrez les détails suivants.

  1. Ouvrez un navigateur et entrez https://<loadbalancer ip>:8000.
  2. Sélectionnez le compartiment dans la liste. Tous les équilibreurs de charge de ce compartiment sont présentés sous forme de tableau.
  3. Assurez-vous qu'il redirige vers l'un des serveurs JupyterHub. Pour vérifier, ouvrez une session de terminal sur JupyterHub pour trouver le noeud qui a été atteint.
Limitations
  • Après l'opération d'ajout de noeud, l'administrateur de la grappe doit mettre à jour manuellement l'entrée d'hôte de l'équilibreur de charge dans les noeuds nouvellement ajoutés. Applicable à tous les ajouts de noeuds à la grappe. Par exemple, un noeud de travail, un noeud de calcul uniquement et un noeud.
  • Le certificat doit être mis à jour manuellement vers l'équilibreur de charge en cas d'expiration. Cette étape garantit que l'équilibreur de charge n'utilise pas de certificats périmés et évite les échecs de vérification de l'état ou de communication des jeux dorsaux. Pour plus d'informations, voir Mise à jour d'un certificat d'équilibreur de charge arrivant à expiration pour mettre à jour un certificat expiré.

Lancer les noyaux Trino-SQL

Le noyau JupyterHub PyTrino fournit une interface SQL qui vous permet d'exécuter des interrogations Trino à l'aide de JupyterHub SQL. Disponible pour les grappes ODH 2.x du service de mégadonnées version 3.0.28 ou ultérieure.

Lancement du noyau PyTrino et exécution d'interrogations Trino
  1. Installez Trino.
  2. Configurez le coordinateur et le port Trino :
    1. Accédez à Apache Ambari.
    2. Dans la barre d'outils latérale, sous Services, sélectionnez JupyterHub.
    3. Sélectionnez Configs, puis Advanced (Avancé).
    4. Dans la section Jupyterhub-trino-kernel-configs avancée, configurez le nom d'hôte du coordonnateur trino et le port trino.
  3. Sélectionnez Enregistrer, puis redémarrez JupyterHub.
  4. Accédez à JupyterHub.
  5. Ouvrez un serveur de carnet. Vous êtes réacheminé vers la page de lancement.
  6. Sélectionnez le noyau PyTrino.
  7. Vous pouvez exécuter des interrogations Trino dans le noyau PyTrino de l'une des façons suivantes :
    • Exécutez des exemples d'interrogations Trino à l'aide de %sql <Trino-query> , puis sélectionnez Exécuter.

      Exemple : 

      %sql select custkey, name, phone, acctbal from tpch.sf1.customer limit 10
    • Vous pouvez écrire la logique Python en haut du résultat de l'interrogation. Par exemple :
      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)
    • Pour les interrogations sur plusieurs lignes, exécutez %%sql. Par exemple :
      # 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}}
Définition des paramètres de session Trino
Les paramètres de session Trino peuvent être configurés à partir de l'interface utilisateur Ambari JupyterHub. Ces paramètres de session sont appliqués à toutes les sessions utilisateur. Pour plus d'informations sur les paramètres de session, voir Numéro de référence des propriétés.
  1. Accédez à Apache Ambari.
  2. Dans la barre d'outils latérale, sous Services, sélectionnez JupyterHub.
  3. Sélectionnez Configs, puis Advanced (Avancé).
  4. Dans la section Jupyterhub-trino-kernel-configs personnalisée, ajoutez les paramètres de session suivants : 
    trino_session_params_<SESSION_PARAM> = <VALUE>

    Par exemple, trino_session_params_query_max_planning_time = 1200m.

  5. (Facultatif) Pour lister les paramètres de session, exécutez : 
    %sql SHOW session
  6. Pour définir les paramètres de la session de carnet courante, exécutez : %sql SET SESSION Par exemple : 
    %sql SET SESSION query_max_run_time='2h'
Définition des paramètres de données d'identification supplémentaires Trino
Les paramètres de données d'identification supplémentaires Trino requis pour accéder aux données du magasin d'objets peuvent être configurés à partir de l'interface utilisateur d'Ambari JupyterHub.
  1. Accédez à Apache Ambari.
  2. Dans la barre d'outils latérale, sous Services, sélectionnez JupyterHub.
  3. Configs, puis sélectionnez Advanced (Avancé).
  4. Dans la section Jupyterhub-trino-kernel-configs personnalisés, ajoutez les paramètres de données d'identification supplémentaires suivants : 
    trino_extra_credentials_<BDS_OSS_CLIENT_PARAM> = <VALUE>

    Par exemple, trino_extra_credentials_BDS_OSS_CLIENT_REGION = us-region-1.

Définition des paramètres SqlMagic
Les configurations SqlMagic vous offrent un contrôle flexible sur le comportement et l'apparence des opérations SQL exécutées dans les carnets Jupyter. Ces paramètres peuvent être configurés à partir de l'interface utilisateur d'Ambari JupyterHub et appliqués à toutes les sessions d'utilisateur.

Pour plus d'informations sur les paramètres SqlMagic, voir https://jupysql.ploomber.io/en/latest/api/configuration.html#changing-configuration.

  1. Accédez à Apache Ambari.
  2. Dans la barre d'outils latérale, sous Services, sélectionnez JupyterHub.
  3. Sélectionnez Configs, puis Advanced (Avancé).
  4. Dans la section Jupyterhub-sql-magic-configs personnalisée, ajoutez les paramètres magiques suivants :
    SqlMagic.<PARAM> = <VALUE>
    Exemple : 
    SqlMagic.displaycon = False
  5. Pour obtenir la liste des paramètres SqlMagic, exécutez : 
    %config SqlMagic
  6. (Facultatif) Vous pouvez définir les paramètres SqlMagic pour la session de carnet courante uniquement.

    Exemple : 

    %config SqlMagic.displaycon=False