Utilisation de JupyterHub dans le service de mégadonnées 3.0.26 ou version antérieure

Utilisez JupyterHub pour gérer les carnets ODH 1.x du service de mégadonnées 3.0.26 ou antérieurs pour des groupes d'utilisateurs.

Préalables

Avant d'accéder à JupyterHub à partir d'un navigateur, un administrateur doit :

JupyterHub Données d'identification par défaut

Les données d'identification de connexion de l'administrateur par défaut pour JupyterHub dans le service de mégadonnées 3.0.21 et les versions antérieures sont les suivantes :

  • Nom d'utilisateur : jupyterhub
  • Mot de passe : Mot de passe de l'administrateur Apache Ambari. Il s'agit du mot de passe d'administrateur de la grappe qui a été spécifié lors de la création de celle-ci.
  • Nom de principal pour la grappe hautement disponible : jupyterhub
  • Fichier keytab de la grappe hautement disponible : /etc/security/keytabs/jupyterhub.keytab

Les données d'identification de connexion de l'administrateur par défaut pour JupyterHub dans le service de mégadonnées 3.0.22 à 3.0.26 sont les suivantes :

  • Nom d'utilisateur : jupyterhub
  • Mot de passe : Mot de passe de l'administrateur Apache Ambari. Il s'agit du mot de passe d'administrateur de la grappe qui a été spécifié lors de la création de celle-ci.
  • Nom principal de la grappe hautement disponible : jupyterhub/<FQDN-OF-UN1-Hostname>
  • Fichier keytab de la grappe hautement disponible : /etc/security/keytabs/jupyterhub.keytab
    Exemple :
    Principal name for HA cluster: jupyterhub/pkbdsv2un1.rgroverprdpub1.rgroverprd.oraclevcn.com
              Keytab for HA cluster: /etc/security/keytabs/jupyterhub.keytab 

L'administrateur crée des utilisateurs supplémentaires et leurs données d'identification de connexion, et fournit les données d'identification de connexion à ces utilisateurs. Pour plus d'informations, voir Gérer les utilisateurs et les autorisations.

Note

Sauf mention explicite d'un autre type d'administrateur, le terme administrator ou admin dans l'ensemble de cette section fait référence à l'administrateur de JupyterHub, jupyterhub.

Accès à JupyterHub

Accédez à JupyterHub au moyen du navigateur pour les grappes du service de mégadonnées 3.0.26 ou antérieures. JupyterHub est accessible dans un navigateur une fois que les préalables sont satisfaits.
  1. Ouvrez une fenêtre de navigateur.
  2. Entrez une URL dans le format suivant :
    https://<node_ip_address>:8000

    Exemple :

    https://192.0.2.0:8000
  3. Connectez-vous à l'aide de vos données d'identification.
    Si vous êtes un utilisateur administrateur : Utilisez l'option Créer un utilisateur administrateur.
    Si vous n'êtes pas administrateur : Inscrivez-vous à partir de la page d'inscription. Un administrateur doit autoriser le nouvel utilisateur inscrit. Après autorisation, l'utilisateur peut se connecter.

Vous pouvez également accéder au lien JupyterHub à partir de la page des détails de la grappe sous URL de la grappe.

Vous pouvez également créer un équilibreur de charge pour fournir un élément frontal sécurisé pour accéder aux services, notamment JupyterHub. Voir Connexion aux services d'une grappe à l'aide d'un équilibreur de charge.

Génération de carnets

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

Les préalables doivent être satisfaits pour l'utilisateur qui tente de générer des carnets.

  1. Accédez à JupyterHub.
  2. Connectez-vous avec les données d'identification de l'administrateur. 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.
  3. Vous êtes dirigé vers une page d'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 dans une grappe qui n'est pas hautement disponible

Les préalables doivent être satisfaits pour l'utilisateur qui tente de générer des carnets.

  1. Accédez à JupyterHub.
  2. Connectez-vous avec les données d'identification de l'administrateur. 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.

Gérer JupyterHub

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

Configuration de JupyterHub au moyen du navigateur

En tant qu'utilisateur admin, vous pouvez configurer JupyterHub.

Note

Configurez JupyterHub au moyen du navigateur pour les grappes du service de mégadonnées 3.0.26 ou antérieures.
  1. Connectez-vous en tant qu'utilisateur opc au noeud d'utilitaire où JupyterHub est installé (le deuxième noeud d'utilitaire d'une grappe hautement disponible, ou le premier et unique noeud d'une grappe qui n'est pas hautement disponible).
  2. Utilisez sudo pour gérer les configurations JupyterHub stockées dans /opt/jupyterhub/jupyterhub_config.py.
    Par exemple, pour modifier le numéro de port de JupyterHub, exécutez les commandes suivantes :
    vi /opt/jupyterhub/jupyterhub_config.py
    # search for c.JupyterHub.bind_url and edit the port number and save
    sudo systemctl restart jupyterhub.service
    sudo systemctl status jupyterhub.service
Arrêt et démarrage de JupyterHub au moyen du navigateur
Note

Arrêtez ou démarrez JupyterHub au moyen du navigateur pour les grappes du service de mégadonnées 3.0.26 ou antérieures.

En tant qu'utilisateur admin, vous pouvez arrêter ou désactiver l'application afin qu'elle ne consomme pas de ressources, telles que la mémoire. Le redémarrage peut également aider à rectifier des problèmes inattendus ou un comportement.

  1. Connectez-vous en tant qu'utilisateur opc au noeud d'utilitaire où JupyterHub est installé (le deuxième noeud d'utilitaire d'une grappe hautement disponible, ou le premier et unique noeud d'une grappe qui n'est pas hautement disponible).
  2. Utilisez sudo pour démarrer, arrêter ou redémarrer JupyterHub.
    sudo systemctl start jupyterhub.service
    sudo systemctl stop jupyterhub.service
    sudo systemctl restart jupyterhub.service
    sudo systemctl status jupyterhub.service
Gestion des limites des carnets

En tant qu'administrateur, vous pouvez limiter le nombre de serveurs de carnets actifs dans la grappe du service de mégadonnées.

Par défaut, le nombre de serveurs de carnets actifs est réglé à deux fois le nombre d'OCPU du noeud. La limite d'OCPU par défaut est trois et la limite de mémoire par défaut est 2 G. Le nombre minimal de carnets actifs par défaut est 10 et le nombre maximal de carnets actifs est 80.
  1. Connectez-vous en tant qu'utilisateur opc au noeud d'utilitaire où JupyterHub est installé (le deuxième noeud d'utilitaire d'une grappe hautement disponible, ou le premier et unique noeud d'une grappe qui n'est pas hautement disponible).
  2. Utilisez sudo pour modifier les configurations JupyterHub stockées dans /opt/jupyterhub/jupyterhub_config.py.
    Exemple :
    c.JupyterHub.active_server_limit = 10
    c.Spawner.cpu_limit = 3
    c.Spawner.mem_limit = '2G'
Mise à jour du gestionnaire de contenu des carnets
Mise à jour du gestionnaire de contenu HDFS

Par défaut, les carnets sont stockés dans le répertoire HDFS d'une grappe.

Vous devez avoir accès au répertoire HDFS hdfs:///user/<username>/. Les carnets sont enregistrés dans hdfs:///user/<username>/notebooks/.

  1. Connectez-vous en tant qu'utilisateur opc au noeud d'utilitaire où JupyterHub est installé (le deuxième noeud d'utilitaire d'une grappe hautement disponible, ou le premier et unique noeud d'une grappe qui n'est pas hautement disponible).
  2. Utilisez sudo pour gérer les configurations JupyterHub stockées dans /opt/jupyterhub/jupyterhub_config.py.
    c.Spawner.args = ['--ServerApp.contents_manager_class="hdfscm.HDFSContentsManager"']
  3. Utilisez sudo pour redémarrer JupyterHub.
    sudo systemctl restart jupyterhub.service
Mise à jour du gestionnaire de contenu du stockage d'objets

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. Connectez-vous en tant qu'utilisateur opc au noeud d'utilitaire où JupyterHub est installé (le deuxième noeud d'utilitaire d'une grappe hautement disponible, ou le premier et unique noeud d'une grappe qui n'est pas hautement disponible).
  2. Utilisez sudo pour gérer les configurations JupyterHub stockées dans /opt/jupyterhub/jupyterhub_config.py. Voir Générer la clé d'accès et la clé secrète pour savoir comment générer les clés requises.
    c.Spawner.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="<region>"','--ServerApp.root_dir=""']
  3. Utilisez sudo pour redémarrer JupyterHub.
    sudo systemctl restart jupyterhub.service

Intégration avec le stockage d'objets

Intégrer Spark au service de stockage d'objets à utiliser avec les grappes du service de mégadonnées.

Dans JupyterHub, pour que Spark fonctionne avec le stockage d'objets, vous devez définir certaines propriétés de système et les alimenter dans les propriétés spark.driver.extraJavaOption et spark.executor.extraJavaOptions des configurations de Spark.

Préalables

Avant de pouvoir intégrer JupyterHub avec le stockage d'objets, vous devez :

  • Créer un seau dans le magasin d'objets pour stocker des données.
  • Créer une clé d'API de stockage d'objets.
Extraire les valeurs des propriétés de système

Les propriétés que vous devez définir dans les configurations de Spark sont les suivantes :

  • TenantID
  • Userid
  • Fingerprint
  • PemFilePath
  • PassPhrase
  • Region

Extrayez les valeurs de ces propriétés :

  1. Ouvrez le menu de navigation et sélectionnez Analyse et intelligence artificielle. Sous Lac de données, sélectionnez Service de mégadonnées.
  2. Dans la page de liste Grappes, sélectionnez la grappe avec laquelle vous voulez travailler. Si vous avez besoin d'aide pour trouver la page de liste ou la grappe, voir Liste des grappes d'un compartiment.
  3. Pour voir les grappes d'un autre compartiment, utilisez le filtre Compartiment pour changer de compartiment.

    Vous devez être autorisé à travailler dans un compartiment pour voir les ressources qu'il contient. Si vous n'êtes pas certain du compartiment à utiliser, communiquez avec un administrateur. Pour plus d'informations, voir Présentation des compartiments.

  4. Dans la page des détails de la grappe, sous Ressources, sélectionnez Clés d'API du service de stockage d'objets.
  5. Dans le menu Actions (trois points) de la clé d'API à afficher, sélectionnez Voir le fichier de configuration.

Le fichier de configuration contient tous les détails des propriétés de système, à l'exception de la phrase secrète. La phrase secrète est spécifiée lors de la création de la clé d'API de stockage d'objets et vous devez récupérer et utiliser la même phrase secrète.

Exemple : Stockage et lecture de données à partir du stockage d'objets dans le noyau Python à l'aide de pyspark
  1. Accédez à JupyterHub.
  2. Ouvrez un nouveau carnet.
  3. Copiez et collez les commandes suivantes pour vous connecter à Spark.
    import findspark
    findspark.init()
    import pyspark
  4. Copiez et collez les commandes suivantes pour créer une session Spark avec les configurations spécifiées. Remplacez les variables par les valeurs de propriétés de système que vous avez extraites précédemment.
    from pyspark.sql import SparkSession
    
    spark = SparkSession \
        .builder \
        .enableHiveSupport() \
        .config("spark.driver.extraJavaOptions", "-DBDS_OSS_CLIENT_REGION=<Region> -DBDS_OSS_CLIENT_AUTH_TENANTID=<TenantId> -DBDS_OSS_CLIENT_AUTH_USERID=<UserId> -DBDS_OSS_CLIENT_AUTH_FINGERPRINT=<FingerPrint> -DBDS_OSS_CLIENT_AUTH_PEMFILEPATH=<PemFile> -DBDS_OSS_CLIENT_AUTH_PASSPHRASE=<PassPhrase>")\
        .config("spark.executor.extraJavaOptions" , "-DBDS_OSS_CLIENT_REGION=<Region> -DBDS_OSS_CLIENT_AUTH_TENANTID=<TenantId> -DBDS_OSS_CLIENT_AUTH_USERID=<UserId> -DBDS_OSS_CLIENT_AUTH_FINGERPRINT=<FingerPrint> -DBDS_OSS_CLIENT_AUTH_PEMFILEPATH=<PemFile> -DBDS_OSS_CLIENT_AUTH_PASSPHRASE=<PassPhrase>")\
        .appName("<appname>") \
        .getOrCreate()
  5. Copiez et collez les commandes suivantes pour créer les répertoires et le fichier de stockage d'objets et pour stocker les données au format Parquet.
    demoUri = "oci://<BucketName>@<Tenancy>/<DirectoriesAndSubDirectories>/"
    parquetTableUri = demoUri + "<fileName>"
    spark.range(10).repartition(1).write.mode("overwrite").format("parquet").save(parquetTableUri)
  6. Copiez et collez la commande suivante pour lire des données à partir du stockage d'objets.
    spark.read.format("parquet").load(parquetTableUri).show()
  7. Exécutez le carnet avec toutes ces commandes.

    Accéder au stockage d'objets dans Jupyter

La sortie du code est affichée. Vous pouvez naviguer jusqu'au seau de stockage d'objets à partir de la console et rechercher le fichier créé dans le seau.

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.

Par défaut, les grappes ODH 1.x prennent en charge l'authentification native. Toutefois, l'authentification pour JupyterHub et les autres services de mégadonnées doit être gérée différemment. Pour générer des carnets d'utilisateur unique, l'utilisateur qui se connecte à JupyterHub doit être présent sur l'hôte Linux et avoir les autorisations nécessaires pour écrire dans le répertoire racine dans HDFS. Sinon, le générateur échoue car le processus de carnet est déclenché en tant qu'utilisateur Linux.

Pour plus d'informations sur l'authentification native, voir Authentification native.

Pour plus d'informations sur l'authentification LDAP pour le service de mégadonnées 3.0.26 ou une version antérieure, voir Authentification LDAP.

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.

Conditions requises pour autoriser un utilisateur dans une grappe HA

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>"
Conditions requises pour autoriser 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'un navigateur pour les clusters ODH 1.x du service de mégadonnées 3.0.26 ou antérieurs.

Intégrer à Trino

Préalables
  • Trino doit être installé et configuré dans la grappe du service de mégadonnées.
  • Installez le module Python suivant dans le noeud JupyterHub (un1 pour la haute disponibilité / un0 pour la grappe non hautement disponible)
    Note

    Ignorez cette étape si le module Trino-Python est déjà présent dans le noeud.
    python3.6 -m pip install trino[sqlalchemy]
     
    Offline Installation:
    Download the required python module in any machine where we have internet access
    Example:
    python3 -m pip download trino[sqlalchemy] -d /tmp/package
    Copy the above folder content to the offline node & install the package
    python3 -m pip install ./package/*
     
    Note : trino.sqlalchemy is compatible with the latest 1.3.x and 1.4.x SQLAlchemy versions. 
    BDS cluster node comes with python3.6 and SQLAlchemy-1.4.46 by default.
Intégration à la grappe hautement disponible du service de mégadonnées

Si Trino-Ranger-Plugin est activé, assurez-vous d'ajouter l'utilisateur keytab fourni dans les politiques Trino Ranger respectives. Voir Intégration de Trino à Ranger.

Par défaut, Trino utilise le nom principal complet de Kerberos en tant qu'utilisateur. Par conséquent, lors de l'ajout ou de la mise à jour de politiques trino-ranger, vous devez utiliser le nom principal complet de Kerberos comme nom d'utilisateur.

Pour l'exemple de code suivant, utilisez jupyterhub@BDSCLOUDSERVICE.ORACLE.COM comme utilisateur dans les politiques trino-ranger.

Note

Si le plugiciel Trino-Ranger est activé, veillez à ajouter l'utilisateur keytab fourni dans les politiques Trino Ranger respectives. Pour plus de détails, voir Activation de Ranger pour Trino.

Fournissez les autorisations Ranger pour JupyterHub aux politiques suivantes :

  • all - catalog, schema, table, column
  • all - function
  1. Ouvrez une fenêtre de navigateur.
  2. Entrez une URL dans le format suivant :
    https://<node_ip_address>:8000

    Par exemple :

    https://192.0.2.0:8000
  3. Connectez-vous à l'aide de vos données d'identification. Voir JupyterHub Données d'identification par défaut.
  4. Entrez le principe et le onglet de clé.
  5. Ouvrez le carnet Phython 3.
  6. Créer un moteur avec Trino :
    from sqlalchemy import create_engine
    from sqlalchemy.schema import Table, MetaData
    from sqlalchemy.sql.expression import select, text
    from trino.auth import KerberosAuthentication
    from subprocess import Popen, PIPE
    import pandas as pd
     
    # Provide user specific keytab_path and principal. If user wants to run queries 
    with different keytab then user can update below keytab_path & user_principal 
    else #user can use same keytab_path, principal that is used while starting the 
    notebook session.
    #Refer below sample code
     
    keytab_path='/etc/security/keytabs/jupyterhub.keytab'
    user_principal='jupyterhub@BDSCLOUDSERVICE.ORACLE.COM'
    # Cert path is required for SSL.
    cert_path= '/etc/security/serverKeys/oraclerootCA.crt'
    # trino url = 'trino://<trino-coordinator>:<port>'
    trino_url='trino://trinohamn0.sub03011425120.hubvcn.oraclevcn.com:7778'
     
     
    # This is optional step, required only if user wants to run queries with different keytab.
     
    kinit_args = [ '/usr/bin/kinit', '-kt', keytab_path, user_principal]
    subp = Popen(kinit_args, stdin=PIPE, stdout=PIPE, stderr=PIPE)
    subp.wait()
       
    engine = create_engine(
        trino_url,
        connect_args={
            "auth": KerberosAuthentication(service_name="trino", principal=user_principal, ca_bundle=cert_path),
            "http_scheme": "https",
            "verify": True
        }
    )
  7. Exécutez l'interrogation :
    query = "select custkey, name, phone, acctbal from tpch.sf1.customer limit 10"
    df = pd.read_sql(query, engine)
    print(df)
Intégration à une grappe non hautement disponible du service de mégadonnées
  1. Ouvrez une fenêtre de navigateur.
  2. Entrez une URL dans le format suivant :
    https://<node_ip_address>:8000

    Par exemple :

    https://192.0.2.0:8000
  3. Connectez-vous à l'aide de vos données d'identification. Voir JupyterHub Données d'identification par défaut.
  4. Ouvrez le carnet Phython 3.
  5. Créer un moteur avec Trino :
    from sqlalchemy import create_engine
    from sqlalchemy.schema import Table, MetaData
    from sqlalchemy.sql.expression import select, text
    import pandas as pd
     
    # trino url = 'trino://trino@<trino-coordinator>:<port>'
    trino_url='trino://trino@trinohamn0.sub03011425120.hubvcn.oraclevcn.com:8285'
     
    engine = create_engine(trino_url)
  6. Exécutez l'interrogation :
    query = "select custkey, name, phone, acctbal from tpch.sf1.customer limit 10"
    df = pd.read_sql(query, engine)
    print(df)