Utilisation de JupyterHub dans Big Data Service 3.0.27 ou version ultérieure

Utilisez JupyterHub pour gérer les blocs-notes ODH 2.x de Big Data Service 3.0.27 ou version ultérieure pour des groupes d'utilisateurs.

Prérequis

Accès à JupyterHub

Accédez à JupyterHub via le navigateur pour les clusters ODH 2.x Big Data Service 3.0.27 ou versions 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 blocs-notes dans JupyterHub sur les noeuds ODH 2.x Big Data Service 3.0.27 ou versions ultérieures.

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

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

Arrêt, démarrage ou redémarrage de JupyterHub via Ambari

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

Remarque

Arrêtez ou démarrez JupyterHub via Ambari pour les clusters Big Data Service 3.0.27 ou versions ultérieures.
  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 Big Data Service.

Remarque

Cette option est disponible pour les clusters Big Data Service 3.0.27 ou versions ultérieures.
  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 sur lequel 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 Big Data Service.

Remarque

Cette option est disponible pour les clusters Big Data Service 3.0.27 ou versions ultérieures.
  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 de l'état/du service JupyterHub

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

Remarque

Cette option est disponible pour les clusters Big Data Service 3.0.27 ou versions ultérieures.
  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 de service.

Gestion des utilisateurs et des droits d'accès

Utilisez l'une des deux méthodes d'authentification pour authentifier les utilisateurs auprès de JupyterHub afin qu'ils puissent créer des blocs-notes et, éventuellement, administrer JupyterHub sur des clusters ODH 2.x Big Data Service 3.0.27 ou versions ultérieures.

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

Prérequis

Avant d'accéder à JupyterHub, procédez comme suit :

  1. Connectez-vous via SSH au noeud sur lequel 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 la commande suivante :
    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 implémentées comme natives dans JupyterHub sans dépendre de services externes.
  • SSOAuthenticator : cet authentificateur fournit une sous-classe de jupyterhub.auth.Authenticator qui agit en tant que fournisseur de services SAML2. Orientez-le vers un fournisseur d'identités SAML2 configuré de façon appropriée et activez l'accès avec connexion unique pour JupyterHub.
Authentification au format natif

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

L'authentification native s'applique aux clusters qu'ils soient hautement disponibles ou non. Pour plus d'informations sur l'authentificateur natif, reportez-vous à Authentificateur natif.

Conditions préalables à l'autorisation d'un utilisateur dans un cluster HA

Ces prérequis doivent être respectés pour autoriser un utilisateur dans un cluster hautement disponible Big Data Service à l'aide de l'authentification native.

  1. L'utilisateur doit exister dans l'hôte Linux. Exécutez la commande suivante pour ajouter un nouvel utilisateur Linux sur tous les noeuds d'un cluster.
    # Add linux user
    dcli -C "useradd -d /home/<username> -m -s /bin/bash <username>"
  2. Pour démarrer un serveur de bloc-notes, 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 cluster doit ajouter un principal Kerberos avec un mot de passe et un fichier keytab. Exécutez les commandes suivantes sur le premier noeud maître (mn0) du 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'
  3. Le nouvel utilisateur doit disposer des droits d'accès Ranger corrects pour stocker les fichiers dans le répertoire HDFS hdfs:///users/<username> car les blocs-notes individuels sont stockés dans /users/<username>/notebooks. L'administrateur de cluster peut ajouter le droit d'accès requis à partir de l'interface Ranger en ouvrant l'URL suivante dans un navigateur Web.
    https://<un0-host-ip>:6182
  4. Le nouvel utilisateur doit disposer des droits d'accès corrects sur Yarn, Hive et Object Storage pour lire et écrire des données, et exécuter des travaux Spark. L'utilisateur peut également recourir à l'emprunt d'identité Livy (exécuter des travaux Big Data Service en tant qu'utilisateur Livy) sans obtenir de droits d'accès explicites sur Spark, Yarn et d'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érequis pour l'autorisation d'unutilisateur dans un clusters non hautement disponibles

Ces prérequis doivent être respectés pour autoriser un utilisateur dans un cluster Big Data Service non hautement disponible à l'aide de l'authentification native.

  1. L'utilisateur doit exister dans l'hôte Linux. Exécutez la commande suivante pour ajouter un nouvel utilisateur Linux sur tous les noeuds d'un cluster.
    # Add linux user
    dcli -C "useradd -d /home/<username> -m -s /bin/bash <username>"
  2. Le nouvel utilisateur doit disposer des droits d'accès appropriés 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 la gestion de JupyterHub. Les administrateurs sont également chargés de l'autorisation des utilisateurs nouvellement inscrits sur JupyterHub.

Avant l'ajout d'un administrateur, les prérequis doivent être respectés pour un cluster hautement disponible ou un cluster non hautement disponible.

  1. Accédez à Apache Ambari.
  2. Dans la barre d'outils latérale, sous Services, sélectionnez JupyterHub.
  3. Sélectionnez Configurations, puis Configurations avancées.
  4. Sélectionnez Advanced jupyterhub-config.
  5. Ajoutez un administrateur à c.Authenticator.admin_users.
  6. Sélectionnez Save (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 prérequis doivent être respectés pour un cluster Big Data Service.

  1. Accédez à JupyterHub.
  2. Inscrivez le nouvel utilisateur. Les utilisateurs non administrateurs ont besoin d'une autorisation explicite de la part des administrateurs.
  3. L'administrateur doit se connecter à JupyterHub et, à partir de la nouvelle option de menu permettant d'autoriser les utilisateurs connectés, autoriser le nouvel utilisateur.
    Capture d'écran de la page Autoriser des 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 Fichier > HubControlPanel.
  3. Accédez à la page Autoriser des utilisateurs.
  4. Supprimez les utilisateurs voulus.
Authentification LDAP

Vous pouvez utiliser l'authentification LDAP via Ambari pour les clusters ODH 2.x Big Data Service 3.0.27 ou versions ultérieures.

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 détails de connexion LDAP.

Remarque

Utilisez Ambari pour l'authentification LDAP sur les clusters Big Data Service 3.0.27 ou versions ultérieures.

Pour plus d'informations sur l'authentificateur LDAP, reportez-vous à Authentificateur LDAP.

  1. Accédez à Apache Ambari.
  2. Dans la barre d'outils latérale, sous Services, sélectionnez JupyterHub.
  3. Sélectionnez Config, puis sous Configuration jupyterhub avancée > 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 SSO dans le service Big Data JupyterHub

pConfigure Authentification SSO dans Big Data Service 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 SSO dans les clusters ODH 2.x JupyterHub Big Data Service 3.0.27 ou versions ultérieures.

  1. Création d'un domaine d'identité. Pour plus d'informations, reportez-vous à la section .
  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 du 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. Affectez des utilisateurs à l'application.
  6. Accédez à 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, reportez-vous à Définition des limites de session.
Utilisation d'OKTA via Ambari

Vous pouvez utiliser OKTA pour configurer l'authentification SSO dans des clusters ODH 2.x JupyterHub Big Data Service 3.0.27 ou versions ultérieures.

  1. Connexion à 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. Indiquez les informations suivantes et créez l'application.
    • Nom de l'application : nom de l'application. Par exemple, JupyterHub-SSO.
    • URL d'accès avec connexion unique : URL d'accès avec connexion unique. Par exemple : https://<Jupyterhub-Host>:<Port>/hub/saml2_auth/acs.
    • Audience URI (SP Entity ID) : ID unique. Vous pouvez utiliser l'URL de base de JupyterHub. Par exemple : https://myjupyterhub/saml2_auth/ent.
  5. Affectez des utilisateurs à l'application.
  6. Sélectionnez l'onglet de connexion et obtenez les détails suivants :
    • URL de 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 SSO
  1. Accédez à Apache Ambari.
  2. Dans la barre d'outils latérale, sous Services, sélectionnez JupyterHub.
  3. Sélectionnez Config > Paramètres > Authentificateur de serveur de bloc-notes.
  4. Sélectionnez SamlSSOAuthenticator.
  5. Sélectionnez Save (Enregistrer).
  6. Sélectionnez Avancé.
  7. Mettez à jour les paramètres de la section Advanced Jupiter-config SamlSSOAuthenticator-Configs :
    • c.Saml2Authenticator.saml2_metadata_file name : chemin du fichier de métadonnées de fournisseur d'identités dans le noeud installé JupyterHub. Par exemple : '/tmp/IDCSMetadata.xml'.

    • c.Saml2Authenticator.saml2_entity_id : identificateur unique permettant de tenir à jour la correspondance entre le fournisseur d'identités et le fournisseur de services (JupyterHub). Cet identificateur doit être identique dans les configurations d'application de fournisseur d'identités et dans le fournisseur de services (JupyterHub). Par exemple : https://myjupyterhub/saml2_auth/ent

    • c.Saml2Authenticator.saml2_login_URL : URL de connexion unique (SSO). Pour Oracle IDCS, les utilisateurs peuvent l'obtenir auprès du fournisseur d'identités metadata.xml file. Dans le fichier metadata.xml file, recherchez la balise AssertionConsumerService et obtenez la valeur de l'attribut d'emplacement. 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. Indiquez 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 'Adresse électronique'.

    • #c.Saml2Authenticator.saml2_private_file_path et #c.Saml2Authenticator.saml2_public_file_path : facultatif. Si le fournisseur d'identités crypte les données d'assertion, le fournisseur de services JupyterHub doit fournir les clés privées et publiques nécessaires pour décrypter 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 pour qu'il s'affiche sous la forme 'Sign in with {login_service}'. Entrez 'Oracle IDCS'.

  8. Redémarrez JupyterHub.
Configurer JupyterHub via Ambari

En tant qu'administrateur, vous pouvez gérer les configurations JupyterHub via Ambari pour les clusters ODH 2.x 3.0.27 ou versions ultérieures de Big Data Service.

  1. Accédez à Apache Ambari.
  2. Dans la barre d'outils latérale, sous Services, sélectionnez JupyterHub.
  3. Sélectionnez Configurations. Les configurations suivantes sont prises en charge :
    • Configuration Spawner :
      • ODHSystemdSpawner : outil de spawner personnalisé utilisé pour générer dynamiquement des serveurs de bloc-notes à utilisateur unique à l'aide de systemd sur le noeud local sur lequel le serveur JupyterHub est installé.
      • ODHYarnSpawner : outil Spawner personnalisé pour JupyterHub qui lance des serveurs de bloc-notes sur des clusters YARN. Il s'agit de l'outil de génération par défaut utilisé par Big Data Service.
    • Configuration commune : il s'agit de configurations telles que l'adresse IP de liaison et le port sur lesquels JupyterHub serait exécuté.
    • Configuration de l'authentificateur : nous prenons en charge deux authentificateurs qui peuvent être utilisés pour authentifier les utilisateurs se connectant à JupyterHub. Pour plus d'informations sur les types d'authentification, reportez-vous à Gestion des utilisateurs et des droits d'accès.
    • Mode de persistance :
      • HDFS : permet de rendre persistants les blocs-notes sur HDFS
      • Git : vous permet d'utiliser une extension JupyterLab pour le contrôle de version à l'aide de Git, ce qui permet la persistance des blocs-notes sur les serveurs distants via Git.

Génération dynamique de blocs-notes

Les configurations Spawner suivantes sont prises en charge sur les clusters Big Data Service 3.0.27 et versions ultérieures ODH 2.x.

Renseignez les champs suivants :

  1. Authentification native :
    1. Se connecter à l'aide des informations d'identification utilisateur connectées
    2. Entrer le nom utilisateur.
    3. Entrer le mot de passe.
  2. Utilisation de SamlSSOAuthenticator :
    1. Connectez-vous avec la connexion SSO.
    2. Terminez la connexion avec l'application SSO configurée.

Génération dynamique de blocs-notes sur un cluster hautement disponible

Pour le cluster intégré AD :

  1. Connectez-vous à l'aide de l'une des méthodes précédentes. L'autorisation fonctionne uniquement si l'utilisateur est présent sur l'hôte Linux. JupyterHub recherche l'utilisateur sur l'hôte Linux pendant la tentative de génération dynamique du serveur de bloc-notes.
  2. Vous êtes redirigé vers une page Options de serveur sur laquelle 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 cluster 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 Big Data que vous voulez utiliser.

Génération dynamique de blocs-notes sur un cluster non HA

Pour le cluster intégré AD :

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

Configurer l'environnement Git
  1. Configurez des clés SSH/jetons d'accès pour le noeud de cluster Big Data Service.
  2. Sélectionnez le mode de persistance de bloc-notes Git.
Configuration de la connexion Git

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

  1. Configurez les clés SSH/les jetons d'accès pour le noeud de cluster Big Data Service.
  2. Sélectionner le mode de persistance de bloc-notes 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 la commande suivante :
    ssh-keygen -t rsa -b 4096 -C "your_email@example.com"
  3. (Facultatif) Suivez les invites pour indiquer l'emplacement du fichier et la phrase de passe (facultatif).
  4. Inscrire 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 indiquer 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 à distance à l'aide de SSH :
    1. Ouvrez un terminal ou une invite de commande.
    2. Accédez au référentiel Git local.
    3. Pour basculer l'URL distante de HTTPS vers SSH, exécutez la commande suivante :
      
      git remote set-url origin git@github.com:username/repository.git

      Remplacez username/repository.git par l'URL de 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 yes 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. Accédez à Paramètres > Paramètres du développeur > Jetons d'accès personnel.
    3. Générez un nouveau jeton d'accès avec les droits d'accès appropriés.
    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. Accédez à Paramètres > Jetons d'accès.
    3. Générez un nouveau jeton d'accès avec les droits d'accès appropriés.
    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. Accédez à 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 en tant que Git

  1. Accédez à Apache Ambari.
  2. Dans la barre d'outils latérale, sous Services, sélectionnez JupyterHub.
  3. Sélectionnez Configurations, puis Paramètres.
  4. Recherchez le mode de persistance de bloc-notes, 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 blocs-notes
Pour configurer HDFS en tant que stockage par défaut pour les blocs-notes 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 Configurations, puis Paramètres.
  4. Recherchez le mode de persistance de bloc-notes, puis sélectionnez HDFS dans la liste déroulante.
  5. Sélectionnez Actions, puis Tout redémarrer.
Configuration d'Object Storage dans JupyterHub pour le stockage des blocs-notes

En tant qu'administrateur, vous pouvez stocker les blocs-notes des utilisateurs individuels dans Object Storage au lieu de HDFS. Lorsque vous passez le gestionnaire de contenu de HDFS vers Object Storage, les blocs-notes existants ne sont pas copiés vers Object Storage. Les nouveaux blocs-notes sont enregistrés dans Object Storage.

  1. Accédez à Apache Ambari.
  2. Dans la barre d'outils latérale, sous Services, sélectionnez JupyterHub.
  3. Sélectionnez Configurations, puis Avancé.
  4. Accédez à 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 bucket Oracle Object Storage à l'aide de rclone avec l'authentification du principal utilisateur

Vous pouvez monter Oracle Object Storage à l'aide de rclone avec l'authentification de principal utilisateur (clés d'API) sur un noeud de cluster Big Data Service à l'aide de rclone et de fuse3, adaptés aux utilisateurs JupyterHub.

Suivez cette procédure pour les clusters ODH 2.x Big Data Service 3.0.28 ou versions ultérieures afin de bénéficier d'un accès et d'une gestion transparents d'Object Storage directement à partir de votre environnement JupyterHub, ce qui améliore vos fonctionnalités de gestion des données.
  1. Accédez à Apache Ambari.
  2. Dans la barre d'outils latérale, sous Services, sélectionnez JupyterHub.
  3. Sélectionnez Récapitulatif, puis choisissez JUPYTERHUB_SERVER.
  4. Obtenez les informations d'hôte à partir des informations d'hôte affichées.
  5. Connectez-vous à l'hôte Big Data Service à l'aide des informations d'identification SSH utilisées lors de la création du cluster. Pour plus d'informations, reportez-vous à Connecting to a Cluster Node Using SSH.
  6. Pour vérifier l'installation de rclone et fuse3 sur le noeud, exécutez la commande suivante :
    rclone version 
    # Ensure version is v1.66
    
    fusermount3 --version 
    # Ensure FUSE version 3 is installed
  7. Créez une clé d'API et configurez la configuration rclone. Pour plus d'informations, reportez-vous à Configuration de l'authentification avec un utilisateur et une clé d'API OCI, Obtention de l'espace de noms de location OCI et du compartiment de bucket.
  8. Configurez la configuration rclone. Pour plus d'informations, reportez-vous à Configuration de Rclone pour OCI Object Storage.
  9. Pour monter le bucket Object Storage, exécutez la commande suivante en tant qu'utilisateur connecté.

    La commande suivante 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 sur lequel 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
    
    Remarque

    Pour utiliser Jupyter Notebooks, 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) Pour vérifier que le montage a réussi, exécutez la commande suivante. Cet exemple répertorie le contenu du bucket mount_dir.
    sudo -u jupyterhub ls -ltr /home/jupyterhub/mount_dir
    
  11. Exécutez les procédures de nettoyage.

    Lorsque vous exécutez en mode arrière-plan, vous devez arrêter le montage manuellement. Utilisez les opérations de nettoyage suivantes lorsque les serveurs JupyterHub et de bloc-notes 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
    

Gestion des environnements conda dans JupyterHub

Remarque

Vous pouvez gérer les environnements conda sur les clusters ODH 2.x Big Data Service 3.0.28 ou versions ultérieures.
  • 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 de serveur de bloc-notes.
  • Une opération de création d'environnement conda distincte consiste à découpler l'opération avec le redémarrage du service.
Prérequis
  • JupyterHub est installé via l'interface utilisateur Ambari.
  • Vérifiez l'accès Internet au cluster pour télécharger les dépendances lors de la création de conda.
  • Les environnements conda et les noyaux créés à l'aide de cette opération sont disponibles pour tous les utilisateurs de serveur de bloc-notes.
  • Fournir :
    • Configurations supplémentaires conda pour éviter l'échec de la création conda. Pour plus d'informations, reportez-vous à conda create.
    • Dépendances au format standard requirements.txt.
    • Nom d'environnement conda inexistant.
  • Supprimez manuellement les environnements conda ou les noyaux.
Personnalisation des configurations globales
  1. Accédez à Apache Ambari.
  2. Dans la barre d'outils latérale, sous Services, sélectionnez JupyterHub.
  3. Sélectionnez Configurations, puis Avancé.
  4. Faites défiler la page jusqu'à la section jupyterhub-conda-env-configs.
  5. Mettez à jour les champs suivants :
    • Configurations supplémentaires conda : ce champ est utilisé pour 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 indiquées 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 environnement est créé.
    • Dépendances Python : ce champ répertorie 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 la configuration requise pour le fichier .txt, reportez-vous à la section Requirements File Format.

  6. Sélectionnez Save (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}
    Remarque

    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 indiqué (Python/PySpark/Spark/SparkR) pointant vers l'environnement conda créé.

  • Si l'environnement conda indiqué 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 ne sont disponibles que 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érequis

  • Vérifiez l'accès Internet au cluster pour télécharger les dépendances lors de la création de conda. Sinon, la création échoue.
  • S'il existe un noyau nommé --kernel_name, une exception est générée.
  • Entrez les informations suivantes :
  • Supprimez manuellement les environnements conda ou les noyaux pour n'importe quel utilisateur.

Configurations disponibles pour la personnalisation

  • --user (obligatoire) : système d'exploitation et utilisateur JupyterHub pour lesquels le noyau et l'environnement conda sont créés.
  • --conda_env_name (obligatoire) : indiquez un nom unique pour l'environnement conda chaque fois qu'un environnement est créé pour --user.
  • --kernel_name : (obligatoire) indiquez un nom de noyau unique.
  • --kernel_type : (obligatoire) doit être l'un des éléments 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, etc., 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 d'exigences, reportez-vous à https://pip.pypa.io/en/stable/reference/requirements-file-format/.

  • --conda_additional_configs : (facultatif)
    • Ce champ fournit des paramètres supplémentaires à ajouter à la fin de 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 défini sur '--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'.

Configuration d'un environnement conda propre à l'utilisateur

  1. Vérifiez que JupyterHub est installé via l'interface utilisateur Ambari.
  2. Connectez-vous via SSH au cluster, 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écutez l'opération avec les spécificités de 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 l'utilisateur bds, installe des dépendances personnalisées pour conda_jupy_env_1 et crée un noyau sparkline nommé spark_bds_1. Une fois cette opération terminée, le noyau spark_bds_1 est affiché dans l'interface utilisateur JupyterHub de l'utilisateur bds uniquement.

Création d'un équilibreur de charge et d'un ensemble de back-ends

Pour plus d'informations sur la création d'ensembles de back-ends, reportez-vous à Création d'un ensemble de back-ends d'équilibreur de charge.

Création de l'équilibreur de charges

Pour plus d'informations sur la création d'un équilibreur de charge public, reportez-vous à Création d'un équilibreur de charge et renseignez les détails suivants.

  1. Ouvrez le menu de navigation. Sélectionnez Fonctions de réseau, puis Équilibreurs de charge. Equilibreur de charge. La page Equilibreurs de charges apparaît.
  2. Sous Portée de la liste, sélectionnez le compartiment dans lequel se trouve le cluster.
  3. Dans le champ Nom de l'équilibreur de charge, saisissez un nom pour identifier l'équilibreur de charge. Par exemple : JupyterHub-LoadBalancer.
  4. Dans la section Sélectionner le type de visibilité, sélectionnez Publique.
  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 le compartiment Créer dans, sélectionnez le compartiment dans lequel se trouve le cluster.
  9. Dans la section Choisir des fonctions de réseau, effectuez les opérations suivantes :
    1. Dans la section Réseau cloud virtuel <Compartment>, sélectionnez le VCN utilisé par le cluster.
    2. Dans le champ Sous-réseau dans <Compartment>, sélectionnez le sous-réseau utilisé par le cluster.
  10. Sélectionnez Next (Suivant). La page Choisir des back-end est affichée.
  11. Dans Spécifier une stratégie d'équilibrage de charge, sélectionnez Hachage IP.
    Remarque

    A ce stade, n'ajoutez pas de back-ends.
  12. Dans la section Spécifier une stratégie de vérification de l'état, effectuez les opérations suivantes :
    1. Dans le champ Port, entrez 8000.
    2. Dans le champ URL Path (URI), 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 d'autorité de certification.
    5. Dans le champ Certificat d'autorité de certification, entrez le certificat Oracle à l'aide de /etc/security/serverKeys/bdsOracleCA.crt présent dans le cluster. Pour les autorités de certification publiques, ce certificat peut être obtenu directement à partir de leur site.
    6. (Facultatif) Sélectionnez Spécifier une 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 Ensemble de back-ends, puis entrez le nom de l'ensemble de back-ends. Par exemple, JupyterHub-Backends.
  17. Sélectionnez Persistance de session, puis Activer la persistance de cookie d'équilibreur de charge. Les cookies sont générés automatiquement.
  18. Sélectionnez Next (Suivant). La page Configurer un processus d'écoute s'affiche. Renseignez les champs suivants :
    1. Dans le champ Nom du processus d'écoute, entrez le nom du processus d'écoute. Par exemple : JupyterHub-Listener.
    2. Sélectionnez HTTPS pour indiquer le type de trafic géré par le processus d'écoute.
    3. Dans le champ Indiquer le port surveillé par le processus d'écoute pour le trafic entrant, saisissez 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 d'autorité de certification.
    8. Dans le champ Certificat CA, entrez le certificat CA du cluster.
    9. Sélectionnez Spécifier une 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 l'ensemble de back-ends

Pour plus d'informations sur la création d'un équilibreur de charge public, reportez-vous à Création d'un équilibreur de charge et renseignez les détails suivants.

  1. Ouvrez le menu de navigation. Sélectionnez Fonctions de réseau, puis Équilibreurs de charge. Sélectionnez Equilibreur de charge. La page Equilibreurs de charge apparaît.
  2. Sélectionnez le compartiment dans la liste. Tous les équilibreurs de charge de ce compartiment sont répertoriés dans un tableau.
  3. Sélectionnez l'équilibreur de charge auquel ajouter un back-end. La page de détails de l'équilibreur de charge apparaît.
  4. Sélectionnez Ensembles de back-ends, puis l'ensemble de back-ends que vous avez créé dans Création de l'équilibreur de charge.
  5. Sélectionnez des adresses IP, puis entrez l'adresse IP privée requise du cluster.
  6. Entrez 8000 pour le Port.
  7. Sélectionnez Ajouter.
Configuration de l'ensemble de back-ends

Pour plus d'informations sur la création d'un équilibreur de charge public, reportez-vous à Création d'un équilibreur de charge et renseignez 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 répertoriés dans un tableau.
  3. Assurez-vous qu'il redirige vers l'un des serveurs JupyterHub. Pour vérifier, ouvrez une session de terminal sur JupyterHub afin de trouver le noeud atteint.
Limites
  • Après l'opération d'ajout de noeud, l'administrateur de cluster 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 noeud au cluster. Par exemple, le noeud de processus actif, le calcul uniquement et les noeuds.
  • Le certificat doit être mis à jour manuellement vers l'équilibreur de charge en cas d'expiration. Cette étape permet de s'assurer que l'équilibreur de charge n'utilise pas de certificats obsolètes et d'éviter les échecs de vérification de l'état/communication des ensembles de back-ends. Pour plus d'informations, reportez-vous à Mise à jour d'un certificat d'équilibreur de charge arrivant à expiration afin de mettre à jour le certificat expiré.

Lancer les noyaux Trino-SQL

Le noyau JupyterHub PyTrino fournit une interface SQL qui vous permet d'exécuter des requêtes Trino à l'aide de JupyterHub SQL. Cette fonctionnalité est disponible pour les clusters ODH 2.x Big Data Service 3.0.28 ou versions ultérieures.

Lancement du noyau PyTrino et exécution des requêtes 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 Configurations, puis Avancé.
    4. Dans la section Advanced Jupyterhub-trino-kernel-configs, configurez le nom d'hôte du coordinateur Trino et le port Trino.
  3. Sélectionnez Enregistrer, puis redémarrez JupyterHub.
  4. Accédez à JupyterHub.
  5. Ouvrez un serveur de bloc-notes. Vous êtes redirigé vers la page du lanceur.
  6. Sélectionnez le noyau PyTrino.
  7. Vous pouvez exécuter des requêtes Trino dans le noyau PyTrino de l'une des manières suivantes :
    • Exécutez des exemples de requêtes 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 une logique Python en plus du résultat de la requête. 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 requêtes multilignes, 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, reportez-vous à 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 Configurations, puis Avancé.
  4. Dans la section Custom Jupyterhub-trino-kernel-configs, 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 afficher la liste des paramètres de session, exécutez la commande suivante :
    %sql SHOW session
  6. Pour définir les paramètres de la session de bloc-notes en cours, exécutez : %sql SET SESSION Par exemple :
    %sql SET SESSION query_max_run_time='2h'
Définir les paramètres des informations d'identification supplémentaires Trino
Les paramètres d'informations d'identification supplémentaires Trino requis pour accéder aux données de la banque d'objets peuvent être configurés à partir de l'interface utilisateur Ambari JupyterHub.
  1. Accédez à Apache Ambari.
  2. Dans la barre d'outils latérale, sous Services, sélectionnez JupyterHub.
  3. Configurations, puis sélectionnez Avancé.
  4. Dans la section Personnalisé Jupyterhub-trino-kernel-configs, ajoutez les paramètres d'informations 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éfinir les paramètres SqlMagic
Les configurations SqlMagic vous permettent de contrôler avec souplesse le comportement et l'apparence des opérations SQL exécutées dans des blocs-notes Jupyter. Ces paramètres peuvent être configurés à partir de l'interface utilisateur Ambari JupyterHub et appliqués à toutes les sessions utilisateur.

Pour plus d'informations sur les paramètres SqlMagic, reportez-vous à 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 Configurations, puis Avancé.
  4. Dans la section Personnalisé Jupyterhub-sql-magic-configs, ajoutez les paramètres magiques suivants :
    SqlMagic.<PARAM> = <VALUE>
    Exemple :
    SqlMagic.displaycon = False
  5. Pour obtenir la liste des paramètres SqlMagic, exécutez la commande suivante :
    %config SqlMagic
  6. (Facultatif) Vous pouvez définir des paramètres SqlMagic pour la session de bloc-notes en cours uniquement.

    Exemple :

    %config SqlMagic.displaycon=False