Utilisation de JupyterHub dans Big Data Service 3.0.26 ou version antérieure

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

Prérequis

Pour permettre l'accès à JupyterHub à partir d'un navigateur, un administrateur doit :

  • Rendre le noeud disponible pour les connexions entrantes des utilisateurs. L'adresse IP privée du noeud doit être mise en correspondance avec une adresse IP publique. Le cluster peut également être configuré de façon à utiliser un bastion ou Oracle FastConnect. Reportez-vous à la section Connecting to Cluster Nodes with Private IP Addresses.
  • Ouvrir le port 8000 sur le noeud en configurant les règles entrantes dans la liste de sécurité réseau. Reportez-vous à Définition de règles de sécurité.

JupyterHub Informations d'identification par défaut

Les informations d'identification de connexion administrateur par défaut pour JupyterHub dans Big Data Service 3.0.21 et versions antérieures sont les suivantes :

  • Nom utilisateur : jupyterhub
  • Mot de passe : mot de passe de l'administrateur Apache Ambari. Il s'agit du mot de passe d'administration de cluster indiqué lors de la création du cluster.
  • Nom de principal pour un cluster hautement disponible : jupyterhub
  • Fichier keytab pour un cluster hautement disponible : /etc/security/keytabs/jupyterhub.keytab

Les informations d'identification de connexion administrateur par défaut pour JupyterHub dans Big Data Service 3.0.22 à 3.0.26 sont les suivantes :

  • Nom utilisateur : jupyterhub
  • Mot de passe : mot de passe de l'administrateur Apache Ambari. Il s'agit du mot de passe d'administration de cluster indiqué lors de la création du cluster.
  • Nom de principal pour le cluster HA : jupyterhub/<FQDN-OF-UN1-Hostname>
  • Fichier keytab pour un cluster 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 informations d'identification de connexion, et fournit ces informations à ces utilisateurs. Pour plus d'informations, voir Gérer les utilisateurs et les autorisations.

Remarque

Sauf s'il est explicitement fait référence à un autre type d'administrateur, la notion administrator ou admin dans cette section fait référence à l'administrateur JupyterHub (jupyterhub).

Accès à JupyterHub

Accédez à JupyterHub via le navigateur pour les clusters Big Data Service 3.0.26 ou versions antérieures. JupyterHub est accessible dans un navigateur une fois les conditions préalables respectées.
  1. Ouvrez une fenêtre de navigateur.
  2. Entrez une URL au format suivant :
    https://<node_ip_address>:8000

    Exemple :

    https://192.0.2.0:8000
  3. Connectez-vous avec vos informations d'identification.
    Si vous n'êtes pas administrateur, inscrivez-vous à partir de la page 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 de détails du cluster sous URL de cluster.

Vous pouvez également créer un équilibreur de charge afin de fournir un front-end sécurisé permettant d'accéder aux services, y compris JupyterHub. Reportez-vous à Connecting to Services on a Cluster Using Load Balancer.

Génération dynamique de blocs-notes

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

Les prérequis doivent être respectés par l'utilisateur qui tente de générer dynamiquement des blocs-notes.

  1. Accédez à JupyterHub.
  2. Connectez-vous avec les informations d'identification d'administration. 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.
  3. Vous êtes redirigé vers une page d'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 dans un cluster non hautement disponible

Les prérequis doivent être respectés par l'utilisateur qui tente de générer dynamiquement des blocs-notes.

  1. Accédez à JupyterHub.
  2. Connectez-vous avec les informations d'identification d'administration. 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.

Gérer JupyterHub

Un utilisateur JupyterHub admin peut effectuer les tâches suivantes pour gérer les blocs-notes dans JupyterHub sur les noeuds Big Data Service 3.0.26 ou versions antérieures d'ODH 1.x.

Configuration de JupyterHub via le navigateur

En tant que admin, vous pouvez configurer JupyterHub.

Remarque

Configurez JupyterHub via le navigateur pour les clusters Big Data Service 3.0.26 ou versions antérieures.
  1. Connectez-vous en tant qu'utilisateur opc au noeud utilitaire sur lequel JupyterHub est installé (le deuxième noeud utilitaire d'un cluster hautement disponible ou le premier et unique noeud utilitaire d'un cluster non 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 via le navigateur
Remarque

Arrêtez ou démarrez JupyterHub via le navigateur pour les clusters Big Data Service 3.0.26 ou versions antérieures.

En tant que admin, vous pouvez arrêter ou désactiver l'application pour éviter qu'elle ne consomme des ressources, comme la mémoire. Le redémarrage peut également aider à résoudre des problèmes ou des comportements inattendus.

  1. Connectez-vous en tant qu'utilisateur opc au noeud utilitaire sur lequel JupyterHub est installé (le deuxième noeud utilitaire d'un cluster hautement disponible ou le premier et unique noeud utilitaire d'un cluster non 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 de bloc-notes

En tant qu'administrateur, vous pouvez limiter le nombre de serveurs de bloc-notes actifs dans le cluster Big Data Service.

Par défaut, le nombre de serveurs de bloc-notes actifs est défini comme le double du nombre d'OCPU dans le noeud. La limite d'OCPU par défaut est de trois et la limite de mémoire par défaut est de 2 G. Par défaut, le nombre minimal de blocs-notes actifs est de 10 et le nombre maximal de blocs-notes actifs est de 80.
  1. Connectez-vous en tant qu'utilisateur opc au noeud utilitaire sur lequel JupyterHub est installé (le deuxième noeud utilitaire d'un cluster hautement disponible ou le premier et unique noeud utilitaire d'un cluster non 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 de bloc-notes
Mise à jour du gestionnaire de contenu HDFS

Par défaut, les blocs-notes sont stockés dans le répertoire HDFS d'un cluster.

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

  1. Connectez-vous en tant qu'utilisateur opc au noeud utilitaire sur lequel JupyterHub est installé (le deuxième noeud utilitaire d'un cluster hautement disponible ou le premier et unique noeud utilitaire d'un cluster non 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 Object Storage

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. Connectez-vous en tant qu'utilisateur opc au noeud utilitaire sur lequel JupyterHub est installé (le deuxième noeud utilitaire d'un cluster hautement disponible ou le premier et unique noeud utilitaire d'un cluster non hautement disponible).
  2. Utilisez sudo pour gérer les configurations JupyterHub stockées dans /opt/jupyterhub/jupyterhub_config.py. Reportez-vous à Génération de clés d'accès et secrètes pour découvrir 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 à Object Storage

Intégrer Spark à Object Storage pour une utilisation avec des clusters Big Data Service.

Dans JupyterHub, pour que Spark fonctionne avec Object Storage, vous devez définir certaines propriétés système et les renseigner dans les propriétés spark.driver.extraJavaOption et spark.executor.extraJavaOptions des configurations Spark.

Prérequis

Pour pouvoir intégrer JupyterHub à Object Storage, vous devez :

  • Créez un bucket dans la banque d'objets pour stocker les données.
  • Créer une clé d'API Object Storage
Extraction des valeurs des propriétés système

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

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

Extrayez ensuite les valeurs de ces propriétés :

  1. Ouvrez le menu de navigation et sélectionnez Analytics et IA. Sous Data Lake, sélectionnez Big Data Service.
  2. Dans la page de liste Clusters, sélectionnez le cluster avec lequel vous voulez travailler. Si vous avez besoin d'aide pour trouver la page de liste ou le cluster, reportez-vous à Liste des clusters dans un compartiment.
  3. Pour visualiser les clusters dans un autre compartiment, utilisez le filtre Compartiment pour changer de compartiment.

    Vous devez être autorisé à travailler dans un compartiment pour y voir les ressources. En cas de doute sur le compartiment à utiliser, contactez un administrateur. Pour plus d'informations, reportez-vous à Présentation des compartiments.

  4. Sur la page de détails du cluster, sous Ressources, sélectionnez Clés d'API Object Storage.
  5. Dans le menu Actions (trois points) de la clé d'API à afficher, sélectionnez Afficher le fichier de configuration.

Le fichier de configuration contient tous les détails des propriétés système, à l'exception de la phrase de passe. La phrase de passe est indiquée lors de la création de la clé d'API Object Storage. Vous devez vous en souvenir et utiliser la même phrase de passe.

Exemple : stockage et lecture de données à partir d'Object Storage dans le noyau Python à l'aide de pyspark
  1. Accédez à JupyterHub.
  2. Ouvrez un nouveau bloc-notes.
  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 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 fichiers Object Storage, et 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 les données à partir d'Object Storage.
    spark.read.format("parquet").load(parquetTableUri).show()
  7. Exécutez le bloc-notes avec toutes ces commandes.

    Accès à Object Storage sur Jupyter

La sortie du code est affichée. Vous pouvez accéder au bucket Object Storage à partir de la console et trouver le fichier créé dans le bucket.

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.

Par défaut, les clusters ODH 1.x prennent en charge l'authentification native. Toutefois, l'authentification pour JupyterHub et d'autres services Big Data doit être gérée différemment. Pour générer dynamiquement des blocs-notes pour utilisateur unique, l'utilisateur qui se connecte à JupyterHub doit être présent sur l'hôte Linux et disposer des droits d'accès en écriture sur le répertoire racine dans HDFS. Sinon, le générateur échoue lorsque le processus de bloc-notes sera déclenché sous l'utilisateur Linux.

Pour plus d'informations sur l'authentification native, reportez-vous à Authentification native.

Pour plus d'informations sur l'authentification LDAP pour Big Data Service 3.0.26 ou une version antérieure, reportez-vous à Authentification LDAP.

Authentification native

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.

Prérequis pour l'autorisation d'un utilisateur dans un cluster hautement disponible

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>"
Conditions requises pour l'autorisation d'un utilisateur dans un cluster non hautement disponible

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 un navigateur pour les clusters ODH 1.x Big Data Service 3.0.26 ou versions antérieures.

Intégrer avec Trino

Prérequis
  • Trino doit être installé et configuré dans le cluster Big Data Service.
  • Installez le module Python suivant dans le noeud JupyterHub (un1 pour HA / un0 pour un cluster non hautement disponible)
    Remarque

    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 au cluster de haute disponibilité Big Data Service

Si Trino-Ranger-Plugin est activé, veillez à ajouter l'utilisateur keytab fourni dans les stratégies Trino Ranger respectives. Reportez-vous à Intégration de Trino à Ranger.

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

Pour l'exemple de code suivant, utilisez jupyterhub@BDSCLOUDSERVICE.ORACLE.COM en tant qu'utilisateur dans les stratégies trino-ranger.

Remarque

Si le module d'extension Trino-Ranger est activé, veillez à ajouter l'utilisateur keytab fourni dans les stratégies Trino Ranger respectives. Pour plus de détails, reportez-vous à Activation de Ranger pour Trino.

Fournissez les droits d'accès Ranger pour JupyterHub aux stratégies suivantes :

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

    Par exemple :

    https://192.0.2.0:8000
  3. Connectez-vous avec vos informations d'identification. Reportez-vous à JupyterHub Informations d'identification par défaut.
  4. Entrez le principe et le onglet Clé.
  5. Ouvrez le bloc-notes 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 la requête :
    query = "select custkey, name, phone, acctbal from tpch.sf1.customer limit 10"
    df = pd.read_sql(query, engine)
    print(df)
Intégration à un cluster non hautement disponible Big Data Service
  1. Ouvrez une fenêtre de navigateur.
  2. Entrez une URL au format suivant :
    https://<node_ip_address>:8000

    Par exemple :

    https://192.0.2.0:8000
  3. Connectez-vous avec vos informations d'identification. Reportez-vous à Informations d'identification par défaut JupyterHub.
  4. Ouvrez le bloc-notes 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 la requête :
    query = "select custkey, name, phone, acctbal from tpch.sf1.customer limit 10"
    df = pd.read_sql(query, engine)
    print(df)