Utilizzo di JupyterHub in Big Data Service 3.0.26 o precedente

Utilizzare JupyterHub per gestire i notebook ODH 1.x Big Data Service 3.0.26 o versioni precedenti per gruppi di utenti.

Prerequisiti

Prima di poter accedere a JupyterHub da un browser, un amministratore deve:

  • Rendere il nodo disponibile per le connessioni in entrata dagli utenti. L'indirizzo IP privato del nodo deve essere mappato a un indirizzo IP pubblico. In alternativa, il cluster può essere impostato per utilizzare un bastion host o FastConnect Oracle. Vedere Connessione a nodi cluster con indirizzi IP privati.
  • Aprire la porta 8000 sul nodo configurando le regole di entrata nella lista di sicurezza di rete. Vedere Definizione delle regole di sicurezza.

JupyterHub Credenziali predefinite

Le credenziali di accesso amministratore predefinite per JupyterHub in Big Data Service 3.0.21 e versioni precedenti sono le seguenti:

  • Nome utente: jupyterhub
  • Password: Apache Ambari admin password. Si tratta della password amministratore del cluster specificata al momento della creazione del cluster.
  • Nome principal per il cluster HA: jupyterhub
  • Tabella chiavi per il cluster HA: /etc/security/keytabs/jupyterhub.keytab

Le credenziali di accesso amministratore predefinite per JupyterHub in Big Data Service da 3.0.22 a 3.0.26 sono le seguenti:

  • Nome utente: jupyterhub
  • Password: Apache Ambari admin password. Si tratta della password amministratore del cluster specificata al momento della creazione del cluster.
  • Nome principal per il cluster HA: jupyterhub/<FQDN-OF-UN1-Hostname>
  • Tabella chiavi per il cluster HA: /etc/security/keytabs/jupyterhub.keytab
    esempio:
    Principal name for HA cluster: jupyterhub/pkbdsv2un1.rgroverprdpub1.rgroverprd.oraclevcn.com
              Keytab for HA cluster: /etc/security/keytabs/jupyterhub.keytab 

L'amministratore crea utenti aggiuntivi e le relative credenziali di accesso e fornisce le credenziali di accesso a tali utenti. Per ulteriori informazioni, vedere Gestire utenti e autorizzazioni.

Nota

A meno che non si faccia esplicitamente riferimento a un altro tipo di amministratore, l'uso di administrator o admin in questa sezione fa riferimento all'amministratore JupyterHub, jupyterhub.

Accesso a JupyterHub

Accedere a JupyterHub tramite il browser per i cluster Big Data Service 3.0.26 o versioni precedenti. L'accesso a JupyterHub viene eseguito in un browser dopo aver soddisfatto i prerequisiti.
  1. Aprire una finestra del browser.
  2. Immettere un URL nel seguente formato:
    https://<node_ip_address>:8000

    esempio:

    https://192.0.2.0:8000
  3. Accedi con le tue credenziali.
    Se si è un utente amministratore, utilizzare Crea un nuovo utente amministratore.
    Se sei un utente non amministratore: registrati dalla pagina Iscriviti. Un utente amministratore deve autorizzare il nuovo utente registrato. Dopo l'autorizzazione, l'utente può accedere.

In alternativa, è possibile accedere al collegamento JupyterHub dalla pagina Dettagli cluster in URL cluster.

Puoi anche creare un load balancer per fornire un front end sicuro per l'accesso ai servizi, tra cui JupyterHub. Vedere Connessione ai servizi in un cluster mediante Load Balancer.

Creazione di blocchi appunti

Generazione di notebook in un cluster HA

I prerequisiti devono essere soddisfatti per l'utente che tenta di generare dinamicamente i notebook.

  1. Accedere a JupyterHub.
  2. Accedi con le credenziali di amministrazione. L'autorizzazione funziona solo se l'utente è presente sull'host Linux. JupyterHub cerca l'utente sull'host Linux durante il tentativo di generare dinamicamente il server notebook.
  3. Si viene reindirizzati a una pagina Opzioni server in cui è necessario richiedere un ticket Kerberos. Questo ticket può essere richiesto utilizzando il principal Kerberos e il file keytab o la password Kerberos. L'amministratore del cluster può fornire il nome principale Kerberos e il file keytab o la password Kerberos.

    Il ticket Kerberos è necessario per accedere alle directory HDFS e ad altri servizi Big Data che si desidera utilizzare.

Generazione di notebook in un cluster non HA

I prerequisiti devono essere soddisfatti per l'utente che tenta di generare dinamicamente i notebook.

  1. Accedere a JupyterHub.
  2. Accedi con le credenziali di amministrazione. L'autorizzazione funziona solo se l'utente è presente sull'host Linux. JupyterHub cerca l'utente sull'host Linux durante il tentativo di generare dinamicamente il server notebook.

Gestisci JupyterHub

Un utente JupyterHub admin può eseguire i task riportati di seguito per gestire i notebook in JupyterHub sui nodi ODH 1.x di Big Data Service 3.0.26 o versioni precedenti.

Configurazione di JupyterHub tramite il browser

Come admin, è possibile configurare JupyterHub.

Nota

Configurare JupyterHub tramite il browser per i cluster Big Data Service 3.0.26 o versioni precedenti.
  1. Connettersi come utente opc al nodo di utility in cui è installato JupyterHub (il secondo nodo di utility di un cluster HA (altamente disponibile) o il primo e unico nodo di utility di un cluster non HA).
  2. Utilizzare sudo per gestire le configurazioni JupyterHub memorizzate in /opt/jupyterhub/jupyterhub_config.py.
    Ad esempio, per modificare il numero di porta di JupyterHub, eseguire i comandi seguenti
    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
Arresto e avvio di JupyterHub tramite il browser
Nota

Arrestare o avviare JupyterHub tramite il browser per i cluster Big Data Service 3.0.26 o versioni precedenti.

In qualità di utente admin, è possibile arrestare o disabilitare l'applicazione in modo che non utilizzi risorse, ad esempio la memoria. Il riavvio potrebbe essere utile anche per problemi o comportamenti imprevisti.

  1. Connettersi come utente opc al nodo di utility in cui è installato JupyterHub (il secondo nodo di utility di un cluster HA (altamente disponibile) o il primo e unico nodo di utility di un cluster non HA).
  2. Utilizzare sudo per avviare, arrestare o riavviare JupyterHub.
    sudo systemctl start jupyterhub.service
    sudo systemctl stop jupyterhub.service
    sudo systemctl restart jupyterhub.service
    sudo systemctl status jupyterhub.service
Gestione dei limiti del notebook

L'amministratore può limitare il numero di server notebook attivi nel cluster Big Data Service.

Per impostazione predefinita, il numero di notebook server attivi viene impostato sul doppio del numero di OCPU nel nodo. Il limite predefinito di OCPU è di tre unità e il limite predefinito di memoria è di 2 G. Le impostazioni predefinite per il numero minimo di notebook attivi sono 10 e il numero massimo di notebook attivi è 80.
  1. Connettersi come utente opc al nodo di utility in cui è installato JupyterHub (il secondo nodo di utility di un cluster HA (altamente disponibile) o il primo e unico nodo di utility di un cluster non HA).
  2. Utilizzare sudo per modificare le configurazioni JupyterHub memorizzate in /opt/jupyterhub/jupyterhub_config.py.
    Ad esempio:
    c.JupyterHub.active_server_limit = 10
    c.Spawner.cpu_limit = 3
    c.Spawner.mem_limit = '2G'
Aggiornamento di Gestione contenuti notebook
Aggiornamento di HDFS Content Manager

Per impostazione predefinita, i notebook vengono memorizzati nella directory HDFS di un cluster.

È necessario avere accesso alla directory HDFS hdfs:///user/<username>/. I notebook vengono salvati in hdfs:///user/<username>/notebooks/.

  1. Connettersi come utente opc al nodo di utility in cui è installato JupyterHub (il secondo nodo di utility di un cluster HA (altamente disponibile) o il primo e unico nodo di utility di un cluster non HA).
  2. Utilizzare sudo per gestire le configurazioni JupyterHub memorizzate in /opt/jupyterhub/jupyterhub_config.py.
    c.Spawner.args = ['--ServerApp.contents_manager_class="hdfscm.HDFSContentsManager"']
  3. Utilizzare sudo per riavviare JupyterHub.
    sudo systemctl restart jupyterhub.service
Aggiornamento di Object Storage Content Manager

Un utente amministratore può memorizzare i singoli notebook utente nello storage degli oggetti anziché in HDFS. Quando si modifica il content manager da HDFS a Object Storage, i notebook esistenti non vengono copiati nello storage degli oggetti. I nuovi notebook vengono salvati nello storage degli oggetti.

  1. Connettersi come utente opc al nodo di utility in cui è installato JupyterHub (il secondo nodo di utility di un cluster HA (altamente disponibile) o il primo e unico nodo di utility di un cluster non HA).
  2. Utilizzare sudo per gestire le configurazioni JupyterHub memorizzate in /opt/jupyterhub/jupyterhub_config.py. Per informazioni su come generare le chiavi necessarie, vedere Genera accesso e chiave segreta.
    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. Utilizzare sudo per riavviare JupyterHub.
    sudo systemctl restart jupyterhub.service

Integrazione con lo storage degli oggetti

Integra Spark con lo storage degli oggetti per l'uso con i cluster Big Data Service.

In JupyterHub, affinché Spark possa utilizzare lo storage degli oggetti, è necessario definire alcune proprietà di sistema e inserirle nelle proprietà spark.driver.extraJavaOption e spark.executor.extraJavaOptions nelle configurazioni Spark.

Prerequisiti

Prima di poter integrare correttamente JupyterHub con lo storage degli oggetti, devi:

  • Creare un bucket nell'area di memorizzazione degli oggetti per memorizzare i dati.
  • Creare una chiave API di storage degli oggetti.
Recupero dei valori delle proprietà di sistema

Le proprietà da definire nelle configurazioni Spark sono le seguenti:

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

È possibile recuperare i valori per le seguenti proprietà:

  1. Aprire il menu di navigazione e selezionare Analytics e AI. In Data lake, selezionare Big Data Service.
  2. Nella pagina della lista Cluster selezionare il cluster che si desidera utilizzare. Se è necessaria assistenza per trovare la pagina della lista o il cluster, vedere Elenca cluster in un compartimento.
  3. Per visualizzare i cluster in un compartimento diverso, utilizzare il filtro Compartimento per cambiare compartimento.

    È necessario disporre dell'autorizzazione per lavorare in un compartimento e visualizzare le risorse al suo interno. In caso di dubbi su quale compartimento utilizzare, contattare un amministratore. Per ulteriori informazioni, vedere Introduzione ai compartimenti.

  4. Nella pagina Dettagli cluster, in Risorse, selezionare Tasti API di storage degli oggetti.
  5. Dal menu Azioni (tre punti) della chiave API che si desidera visualizzare, selezionare Visualizza file di configurazione.

Il file di configurazione include tutti i dettagli delle proprietà di sistema, ad eccezione della passphrase. La passphrase viene specificata durante la creazione della chiave API di storage degli oggetti ed è necessario ricordare e utilizzare la stessa passphrase.

Esempio: memorizzazione e lettura dei dati dallo storage degli oggetti nel kernel Python mediante pyspark
  1. Accedere a JupyterHub.
  2. Aprire un nuovo notebook.
  3. Copiare e incollare i seguenti comandi per connettersi a Spark.
    import findspark
    findspark.init()
    import pyspark
  4. Copiare e incollare i comandi seguenti per creare una sessione Spark con le configurazioni specificate. Sostituire le variabili con i valori delle proprietà di sistema recuperati in precedenza.
    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. Copiare e incollare i comandi seguenti per creare le directory e il file dello storage degli oggetti e memorizzare i dati in formato Parquet.
    demoUri = "oci://<BucketName>@<Tenancy>/<DirectoriesAndSubDirectories>/"
    parquetTableUri = demoUri + "<fileName>"
    spark.range(10).repartition(1).write.mode("overwrite").format("parquet").save(parquetTableUri)
  6. Copiare e incollare il comando seguente per leggere i dati dallo storage degli oggetti.
    spark.read.format("parquet").load(parquetTableUri).show()
  7. Eseguire il notebook con tutti questi comandi.

    Accedi allo storage degli oggetti su Jupyter

Viene visualizzato l'output del codice. Puoi passare al bucket di storage degli oggetti dalla console e trovare il file creato nel bucket.

Gestire utenti e autorizzazioni

Utilizzare uno dei due metodi di autenticazione per autenticare gli utenti in JupyterHub in modo che possano creare notebook e, facoltativamente, amministrare JupyterHub.

Per impostazione predefinita, i cluster ODH 1.x supportano l'autenticazione nativa. Tuttavia, l'autenticazione per JupyterHub e altri servizi Big Data deve essere gestita in modo diverso. Per generare dinamicamente i notebook utente singolo, l'utente che accede a JupyterHub deve essere presente nell'host Linux e deve disporre delle autorizzazioni per scrivere nella directory radice in HDFS. In caso contrario, il generatore di dati non riesce poiché il processo del notebook viene attivato come utente Linux.

Per informazioni sull'autenticazione nativa, vedere Autenticazione nativa.

Per informazioni sull'autenticazione LDAP per Big Data Service 3.0.26 o versioni precedenti, vedere Autenticazione LDAP.

Autenticazione nativa

L'autenticazione nativa dipende dal database degli utenti JupyterHub per l'autenticazione degli utenti.

L'autenticazione nativa si applica sia ai cluster HA che a quelli non HA. Per informazioni dettagliate sull'autenticatore nativo, vedere autenticatore nativo.

Prerequisiti per l'autorizzazione di un utente in un cluster HA

Questi prerequisiti devono essere soddisfatti per autorizzare un utente in un cluster HA di Big Data Service utilizzando l'autenticazione nativa.

  1. L'utente deve trovarsi nell'host Linux. Eseguire il comando seguente per aggiungere un nuovo utente Linux su tutti i nodi di un cluster.
    # Add linux user
    dcli -C "useradd -d /home/<username> -m -s /bin/bash <username>"
  2. Per avviare un server notebook, è necessario fornire il nome principale e il file della tabella chiavi path/password e richiedere un ticket Kerberos dall'interfaccia JupyterHub. Per creare una tabella chiavi, l'amministratore del cluster deve aggiungere un principal Kerberos con una password e un file keytab. Eseguire i comandi riportati di seguito sul primo nodo principale (mn0) nel 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. Il nuovo utente deve disporre delle autorizzazioni Ranger corrette per memorizzare i file nella directory HDFS hdfs:///users/<username> poiché i singoli notebook sono memorizzati in /users/<username>/notebooks. L'amministratore del cluster può aggiungere l'autorizzazione richiesta dall'interfaccia Ranger aprendo l'URL seguente in un browser Web.
    https://<un0-host-ip>:6182
  4. Il nuovo utente deve disporre delle autorizzazioni corrette su Yarn, Hive e Storage degli oggetti per leggere e scrivere i dati ed eseguire i job Spark. In alternativa, l'utente può utilizzare la rappresentazione Livy (eseguire i job del servizio Big Data come utente Livy) senza ottenere autorizzazioni esplicite su Spark, Yarn e altri servizi.
  5. Eseguire il comando riportato di seguito per concedere al nuovo utente l'accesso alla directory 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>"
Prerequisiti per l'autorizzazione di un utente in un cluster non HA

Questi prerequisiti devono essere soddisfatti per autorizzare un utente in un cluster non HA del servizio Big Data utilizzando l'autenticazione nativa.

  1. L'utente deve trovarsi nell'host Linux. Eseguire il comando seguente per aggiungere un nuovo utente Linux su tutti i nodi di un cluster.
    # Add linux user
    dcli -C "useradd -d /home/<username> -m -s /bin/bash <username>"
  2. Per memorizzare i file nella directory HDFS hdfs:///users/<username> , il nuovo utente deve disporre delle autorizzazioni corrette. Eseguire il comando seguente per concedere al nuovo utente l'accesso alla directory 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>"
Aggiunta di un utente amministratore

Gli utenti amministratori sono responsabili della configurazione e della gestione JupyterHub. Gli utenti amministratori sono inoltre responsabili dell'autorizzazione dei nuovi utenti registrati su JupyterHub.

Prima di aggiungere un utente amministratore, è necessario soddisfare i prerequisiti per un cluster non HA.

  1. Accedi ad Apache Ambari.
  2. Nella barra degli strumenti laterale, in Servizi selezionare JupyterHub.
  3. Selezionare Config, quindi Configurazioni avanzate.
  4. Selezionare Advanced jupyterhub-config.
  5. Aggiungere un utente di amministrazione a c.Authenticator.admin_users.
  6. Selezionare Salva.
Un utente amministratore nel file di configurazione JupyterHub non deve disporre di un'autorizzazione esplicita durante l'accesso. Dopo esserti registrato, puoi accedere direttamente.
Aggiunta di altri utenti

Prima di aggiungere altri utenti, è necessario soddisfare i prerequisiti per un cluster Big Data Service.

  1. Accedi JupyterHub.
  2. Iscriviti al nuovo utente. Gli utenti non amministratori devono disporre di un'autorizzazione esplicita da parte degli utenti amministratori.
  3. L'utente Admin deve accedere a JupyterHub e, dalla nuova opzione di menu, autorizzare gli utenti collegati, autorizzare il nuovo utente.
    Screenshot della pagina Autorizza utenti in Jupyterhub
  4. Il nuovo utente può collegarsi.
Eliminazione degli utenti

Un utente amministratore può eliminare gli utenti JupyterHub.

  1. Accedi JupyterHub.
  2. Aprire File > HubControlPanel.
  3. Passare alla pagina Autorizza utenti.
  4. Eliminare gli utenti che si desidera rimuovere.
Autenticazione LDAP

È possibile utilizzare l'autenticazione LDAP tramite un browser per i cluster Big Data Service 3.0.26 o versioni precedenti di ODH 1.x.

Integra con Trino

Prerequisiti
  • Trino deve essere installato e configurato nel cluster Big Data Service.
  • Installare il seguente modulo Python nel nodo JupyterHub (un1 per HA / un0 per cluster non HA)
    Nota

    Ignorare questo passo se il modulo Trino-Python è già presente nel nodo.
    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.
Integrazione con il cluster HA di Big Data Service

Se Trino-Ranger-Plugin è abilitato, assicurarsi di aggiungere l'utente keytab fornito nei rispettivi criteri Trino Ranger. Vedere Integrazione di Trino con Ranger.

Per impostazione predefinita, Trino utilizza come utente il nome principale Kerberos completo. Pertanto, quando si aggiungono/aggiornano i criteri trino-ranger, è necessario utilizzare il nome principale Kerberos completo come nome utente.

Per il seguente esempio di codice, utilizzare jupyterhub@BDSCLOUDSERVICE.ORACLE.COM come utente nei criteri trino-ranger.

Nota

Se Trino-Ranger-Plugin è abilitato, assicurarsi di aggiungere l'utente keytab fornito nei rispettivi criteri Trino Ranger. Per ulteriori dettagli, vedere Abilitazione di Ranger per Trino.

Fornire le autorizzazioni Ranger per JupyterHub ai criteri seguenti:

  • all - catalog, schema, table, column
  • all - function
  1. Aprire una finestra del browser.
  2. Immettere un URL nel seguente formato:
    https://<node_ip_address>:8000

    Ad esempio:

    https://192.0.2.0:8000
  3. Collegarsi con le credenziali. Vedere JupyterHub Credenziali predefinite.
  4. Inserire il principio e la scheda chiave.
  5. Aprire il notebook Phython 3.
  6. Crea motore con 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. Eseguire la query:
    query = "select custkey, name, phone, acctbal from tpch.sf1.customer limit 10"
    df = pd.read_sql(query, engine)
    print(df)
Integrazione con il cluster non HA di Big Data Service
  1. Aprire una finestra del browser.
  2. Immettere un URL nel seguente formato:
    https://<node_ip_address>:8000

    Ad esempio:

    https://192.0.2.0:8000
  3. Connettersi utilizzando le credenziali. Vedere JupyterHub Credenziali predefinite.
  4. Aprire il notebook Phython 3.
  5. Crea motore con 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. Eseguire la query:
    query = "select custkey, name, phone, acctbal from tpch.sf1.customer limit 10"
    df = pd.read_sql(query, engine)
    print(df)