Documentazione di Oracle Cloud Infrastructure

Utilizzo di JupyterHub in Big Data Service 3.0.27 o versioni successive

Utilizzare JupyterHub per gestire i notebook ODH 2.x Big Data Service 3.0.27 o versioni successive per gruppi di utenti.

Prerequisiti

Accesso a JupyterHub

Accedere a JupyterHub tramite il browser per i cluster Big Data Service 3.0.27 o versioni successive ODH 2.x.
  1. Accedi ad Apache Ambari.
  2. Nella barra degli strumenti laterale, in Servizi selezionare JupyterHub.

Gestisci JupyterHub

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

Per gestire i servizi Oracle Linux 7 con il comando systemctl, vedere Working With System Services.

Per collegarsi a un'istanza di Oracle Cloud Infrastructure, vedere Connessione all'istanza.

Arresto, avvio o riavvio di JupyterHub tramite Ambari

L'amministratore può arrestare o disabilitare JupyterHub in modo che non utilizzi risorse, ad esempio la memoria. Il riavvio potrebbe essere utile anche per problemi o comportamenti imprevisti.

Nota

Arrestare o avviare JupyterHub tramite Ambari per i cluster Big Data Service 3.0.27 o versioni successive.
  1. Accedi ad Apache Ambari.
  2. Nella barra degli strumenti laterale, in Servizi selezionare JupyterHub.
  3. Selezionare Azioni:
    • Per avviare JupyterHub, selezionare Start.
    • Per arrestare JupyterHub, selezionare Stop.
    • Per riavviare JupyterHub, selezionare Riavvia.
Aggiunta del server JupyterHub

L'amministratore può aggiungere il server JupyterHub a un nodo del servizio Big Data.

Nota

Questa opzione è disponibile per i cluster Big Data Service 3.0.27 o versioni successive.
  1. Accedi ad Apache Ambari.
  2. Nella barra degli strumenti laterale selezionare Host.
  3. Per aggiungere il server JupyterHub, selezionare un host in cui JupyterHub non è installato.
  4. Selezionare Aggiungi.
  5. Selezionare Server JupyterHub.
Spostamento del server JupyterHub

L'amministratore può spostare il server JupyterHub in un altro nodo del servizio Big Data.

Nota

Questa opzione è disponibile per i cluster Big Data Service 3.0.27 o versioni successive.
  1. Accedi ad Apache Ambari.
  2. Nella barra degli strumenti laterale, in Servizi selezionare JupyterHub.
  3. Selezionare Azioni, quindi Sposta server JupyterHub.
  4. Selezionare Next.
  5. Selezionare l'host in cui spostare il server JupyterHub.
  6. Completare lo spostamento guidato.
Esecuzione dei controlli di servizio/integrità di JupyterHub

L'amministratore può eseguire i controlli di servizio/integrità JupyterHub tramite Ambari.

Nota

Questa opzione è disponibile per i cluster Big Data Service 3.0.27 o versioni successive.
  1. Accedi ad Apache Ambari.
  2. Nella barra degli strumenti laterale, in Servizi selezionare JupyterHub.
  3. Selezionare Azioni, quindi Esegui controllo servizio.

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 nei cluster ODH 2.x di Big Data Service 3.0.27 o versioni successive.

Gli utenti JupyterHub devono essere aggiunti come utenti del sistema operativo su tutti i nodi del cluster Big Data Service per i cluster Big Data Service non Active Directory (AD), in cui gli utenti non vengono sincronizzati automaticamente su tutti i nodi del cluster. Gli amministratori possono utilizzare lo script JupyterHub User Management per aggiungere utenti e gruppi prima di eseguire l'accesso a JupyterHub.

Requisito

Prima di accedere a JupyterHub, completare le operazioni riportate di seguito.

  1. Collegamento SSH al nodo in cui è installato JupyterHub.
  2. Passare a /usr/odh/current/jupyterhub/install.
  3. Per fornire i dettagli di tutti gli utenti e i gruppi nel file sample_user_groups.json, eseguire:
    sudo python3 UserGroupManager.py sample_user_groups.json
          
          Verify user creation by executing the following command:
          id <any-user-name>

Tipi di autenticazione supportati

  • NativeAuthenticator: questo authenticator viene utilizzato per le applicazioni JupyterHub di piccole o medie dimensioni. L'iscrizione e l'autenticazione vengono implementate come native per JupyterHub senza fare affidamento su servizi esterni.
  • SSOAuthenticator: questo autenticatore fornisce una sottoclasse di jupyterhub.auth.Authenticator che funge da provider di servizi SAML2. Indirizzarlo a un provider di identità SAML2 configurato in modo appropriato e abilita Single Sign-On per JupyterHub.
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 Ambari per i cluster Big Data Service 3.0.27 o versioni successive ODH 2.x.

Uso dell'autenticazione LDAP mediante Ambari

Per utilizzare l'autenticatore LDAP, è necessario aggiornare il file di configurazione JupyterHub con i dettagli di connessione LDAP.

Nota

Utilizzare Ambari per l'autenticazione LDAP nei cluster Big Data Service 3.0.27 o versioni successive.

Fare riferimento all'autenticatore LDAP per i dettagli sull'autenticazione LDAP.

  1. Accedi ad Apache Ambari.
  2. Nella barra degli strumenti laterale, in Servizi selezionare JupyterHub.
  3. Selezionare Configurazione, quindi in Configurazione jupyterhub avanzata > Impostazioni base immettere quanto riportato di seguito. 
    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. Riavviare JupyterHub.
Configurare l'autenticazione SSO nel servizio Big Data JupyterHub

pConfigure Autenticazione SSO nel servizio Big Data 3.0.27 o versione successiva del servizio ODH 2.x JupyterHub.

Uso del dominio di Oracle Identity

È possibile utilizzare il dominio Oracle Identity per impostare l'autenticazione SSO nei cluster Big Data Service 3.0.27 o versioni successive di ODH 2.x JupyterHub.

  1. Creare un dominio di Identity. Per ulteriori informazioni, vedere .
  2. Nel dominio, in Applicazioni integrate, aggiungere un'applicazione SAML.
  3. Fornire i dettagli richiesti riportati di seguito durante la creazione dell'applicazione.
    • ID entità: ID univoco. È possibile utilizzare l'URL di base di JupyterHub, ad esempio https://myjupyterhub/saml2_auth/ent.
    • URL consumer asserzioni:
      • JupyterHub URL: https://<Jupyterhub-Host>:<Port>/hub/saml2_auth/acs
      • URL load balancer: https://<Load-Balancer>:<Port>/hub/saml2_auth/acs
    • URL di logout singolo, URL di risposta di logout: https://<Jupyterhub-Host>:<Port>/hub/logout
  4. Attiva l'applicazione.
  5. Assegna gli utenti all'applicazione.
  6. Passare all'applicazione creata e selezionare Scarica metadati provider di identità, quindi copiare questo file di metadati nell'host JupyterHub e assicurarsi che disponga dell'accesso in lettura per tutti gli utenti.
  7. Aggiornare i parametri della sessione dell'utente. Per ulteriori informazioni, vedere Impostazione dei limiti di sessione.
Utilizzo di OKTA tramite Ambari

È possibile utilizzare OKTA per impostare l'autenticazione SSO nei cluster JupyterHub di Big Data Service 3.0.27 o versioni successive di ODH 2.x.

  1. Connettersi a OKTA.
  2. Nella barra degli strumenti laterale selezionare Applicazioni > Applicazioni > Crea integrazione applicazioni.
  3. Selezionare SAML 2.0.
  4. Fornire i dettagli riportati di seguito e creare l'applicazione.
    • Nome applicazione: il nome dell'applicazione. ad esempio JupyterHub-SSO.
    • URL Single Sign-On: l'URL Single Sign-On. Ad esempio: https://<Jupyterhub-Host>:<Port>/hub/saml2_auth/acs.
    • Audience URI (SP Entity ID): ID univoco. È possibile utilizzare l'URL di base di JupyterHub. Ad esempio: https://myjupyterhub/saml2_auth/ent.
  5. Assegna gli utenti all'applicazione.
  6. Selezionare la scheda di accesso e ottenere i seguenti dettagli:
    • URL metadati: scaricare il file di metadati, quindi copiarlo nell'host JupyterHub.
    • Collega URL: copiare l'URL di collegamento, quindi aggiornarlo nelle configurazioni JupyterHub (saml2_login_url).
Abilitazione di SSO
  1. Accedi ad Apache Ambari.
  2. Nella barra degli strumenti laterale, in Servizi selezionare JupyterHub.
  3. Selezionare Configurazione > Impostazioni > Autenticatore server notebook.
  4. Selezionare SamlSSOAuthenticator.
  5. Selezionare Salva.
  6. Selezionare Avanzate.
  7. Aggiornare i parametri nella sezione Advanced Jupiter-config SamlSSOAuthenticator-Configs:

    • c.Saml2Authenticator.saml2_metadata_file name: il percorso del file di metadati del provider di identità (IDP) nel nodo installato JupyterHub. Ad esempio: '/tmp/IDCSMetadata.xml'.

    • c.Saml2Authenticator.saml2_entity_id: identificativo univoco per la gestione del mapping dal provider di identità (IDP) al provider di servizi (JupyterHub). Questo identificativo deve essere lo stesso sia nelle configurazioni dell'applicazione IDP che nel provider di servizi (JupyterHub). Ad esempio: https://myjupyterhub/saml2_auth/ent

    • c.Saml2Authenticator.saml2_login_URL: URL di accesso Single Sign-On (SSO). Gli utenti Oracle IDCS possono ottenerlo dal provider di identità metadata.xml file. Nel file metadata.xml file cercare il tag AssertionConsumerService e ottenere il valore dell'attributo di posizione. Per OKTA, copiare il valore dell'URL di accesso presente nella scheda Collega. Ad esempio: https://idcs-1234.identity.oraclecloud.com/fed/v1/sp/sso

    • #c.Saml2Authenticator.saml2_metadata_URL: facoltativo. URL del file di metadati del provider di identità (IDP). Assicurarsi che l'URL fornito sia raggiungibile dal nodo installato JupyterHub. È necessario specificare saml2_metadata_filename o saml2_metadata_url. Ad esempio: https://idcs-1234.identity.oraclecloud.com/sso/saml/metadata

    • #c.Saml2Authenticator.saml2_attribute_username: facoltativo. Specificare un attributo da considerare come utente dall'asserzione SAML. Se non viene specificato alcun attributo, il nome utente di accesso viene considerato come utente. Immettere 'E-mail'.

    • #c.Saml2Authenticator.saml2_private_file_path e #c.Saml2Authenticator.saml2_public_file_path: facoltativi. Se il provider di identità (IDP) cifra i dati di asserzione, il provider di servizi (SP) JupyterHub deve fornire le chiavi private e pubbliche necessarie per decifrare i dati di asserzione. Ad esempio:

      #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: facoltativo. In questo modo viene configurato il pulsante di accesso da visualizzare come 'Sign in with {login_service}'. Immettere 'Oracle IDCS'.

  8. Riavviare JupyterHub.
Configura JupyterHub tramite Ambari

L'amministratore può gestire le configurazioni JupyterHub tramite Ambari per i cluster Big Data Service 3.0.27 o versioni successive ODH 2.x.

  1. Accedi ad Apache Ambari.
  2. Nella barra degli strumenti laterale, in Servizi selezionare JupyterHub.
  3. Selezionare Configurazioni. Sono supportate le seguenti configurazioni:
    • Configurazione del proprietario:
      • ODHSystemdSpawner: un generatore generato dinamicamente personalizzato utilizzato per generare dinamicamente i server notebook a utente singolo utilizzando systemd sul nodo locale in cui è installato il server JupyterHub.
      • ODHYarnSpawner: un Spawner personalizzato per JupyterHub che avvia i server notebook sui cluster YARN. Si tratta del generatore di dati predefinito utilizzato da Big Data Service.
    • Configurazione comune: si tratta di configurazioni quali l'IP di associazione e la porta in cui eseguire JupyterHub.
    • Configurazione dell'autenticatore: sono supportati due autenticatori che possono essere utilizzati per autenticare gli utenti che si collegano a JupyterHub. Per ulteriori informazioni sui tipi di autenticazione, vedere Gestisci utenti e autorizzazioni.
    • Modalità persistenza:
      • HDFS: consente di rendere persistenti i notebook su HDFS
      • Git: consente di utilizzare un'estensione JupyterLab per il controllo delle versioni utilizzando Git. Ciò consente la persistenza dei notebook sui server remoti tramite Git.

Creazione di blocchi appunti

Le seguenti configurazioni di Spawner sono supportate nei cluster Big Data Service 3.0.27 e versioni successive di ODH 2.x.

Specificare quanto segue:

  1. Autenticazione nativa:
    1. Connettersi utilizzando le credenziali utente collegate
    2. Immettere nome utente.
    3. Immettere password.
  2. Utilizzando SamlSSOAuthenticator:
    1. Accedi con accesso SSO.
    2. Completare l'accesso con l'applicazione SSO configurata.

Generazione di notebook su un cluster HA

Per il cluster integrato AD:

  1. Eseguire l'accesso utilizzando uno dei metodi precedenti. 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.
  2. 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 blocchi appunti in un cluster non HA

Per il cluster integrato AD:

Eseguire l'accesso utilizzando uno dei metodi precedenti. 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.

Impostazione dell'ambiente Git
  1. Configurare le chiavi SSH/token di accesso per il nodo cluster Big Data Service.
  2. Selezionare la modalità di persistenza del notebook come Git.
Impostare la connessione Git

Per impostare la connessione Git per JupyterHub, completare quanto segue:

  1. Token di accesso per il nodo cluster del servizio Big Data.
  2. Selezionare la modalità di persistenza del notebook come Git

Generazione della coppia di chiavi SSH

  1. Aprire un terminale o un prompt dei comandi.
  2. Per generare una nuova coppia di chiavi SSH, eseguire le operazioni riportate di seguito. 
    ssh-keygen -t rsa -b 4096 -C "your_email@example.com"
  3. (Opzionale) Seguire i prompt per specificare la posizione e la passphrase del file (opzionale).
  4. Registrare la chiave pubblica:
    1. Accedere all'account del server Git.
    2. Passare alla sezione Impostazioni o Chiavi SSH del proprio account.
    3. Aggiungere il contenuto della chiave pubblica (~/.ssh/id_rsa.pub) all'account del server Git.
  5. Configurare l'agente SSH:

    Se l'agente SSH gestisce molte chiavi SSH, è possibile creare un file di configurazione per specificare la chiave da utilizzare per ciascun server Git.

    1. Aprire o creare il file di configurazione SSH (~/.ssh/config) in un editor di testo.
    2. Aggiungere voci per ogni server Git specificando il file di identità associato a ciascuna chiave SSH.
  6. Connettere il repository Git locale a remoto utilizzando SSH:
    1. Aprire un terminale o un prompt dei comandi.
    2. Passare al repository Git locale.
    3. Per passare da HTTPS a SSH all'URL remoto, eseguire le operazioni riportate di seguito. 
      
git remote set-url origin git@github.com:username/repository.git

      Sostituire username/repository.git con l'URL del repository Git appropriato.

  7. Verificare la connessione SSH:
    1. Eseguire il test della connessione SSH al server Git: 
      ssh -T git@github.com
  8. (Facoltativo) Se viene richiesto di confermare l'autenticità dell'host, immettere yes per continuare.

Uso dei token di accesso

È possibile utilizzare i token di accesso come riportato di seguito.

  • GitHub:
    1. Collegarsi all'account GitHub.
    2. Passare a Impostazioni > Impostazioni sviluppatore > Token di accesso personale.
    3. Generare un nuovo token di accesso con le autorizzazioni appropriate.
    4. Utilizzare il token di accesso come password quando viene richiesta l'autenticazione.
  • GitLab:
    1. Collegarsi all'account GitHub.
    2. Passare a Impostazioni > Token di accesso.
    3. Generare un nuovo token di accesso con le autorizzazioni appropriate.
    4. Utilizzare il token di accesso come password quando viene richiesta l'autenticazione.
  • BitBucket:
    1. Collegarsi all'account BitBucket.
    2. Passare a Impostazioni > Password applicazione.
    3. Generare un nuovo token password applicazione con le autorizzazioni appropriate.
    4. Utilizzare la nuova password dell'applicazione come password quando viene richiesta l'autenticazione.

Selezione della modalità di persistenza come Git

  1. Accedi ad Apache Ambari.
  2. Nella barra degli strumenti laterale, in Servizi selezionare JupyterHub.
  3. Selezionare Config, quindi Impostazioni.
  4. Cercare la modalità di persistenza blocco note, quindi selezionare Git dall'elenco a discesa.
  5. Selezionare Azioni, quindi Riavvia tutto.
Impostazione di HDFS in JupyterHub per la memorizzazione dei notebook
Per impostare HDFS come storage predefinito per i notebook JupyterHub, selezionare la modalità di persistenza come HDFS.
  1. Accedi ad Apache Ambari.
  2. Nella barra degli strumenti laterale, in Servizi selezionare JupyterHub.
  3. Selezionare Config, quindi Impostazioni.
  4. Cercare la modalità di persistenza Notebook, quindi selezionare HDFS dall'elenco a discesa.
  5. Selezionare Azioni, quindi Riavvia tutto.
Impostazione dello storage degli oggetti in JupyterHub per la memorizzazione dei notebook

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. Accedi ad Apache Ambari.
  2. Nella barra degli strumenti laterale, in Servizi selezionare JupyterHub.
  3. Selezionare Config, quindi Avanzate.
  4. Passare alla sezione c.YarnSpawner.args = yarn_spawner_default_rags, quindi sostituire il contenuto con: 
    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. Riavviare tutti i server JupyterHub dal menu Azioni.

Esecuzione del MOUNT del bucket di storage degli oggetti Oracle mediante rclone con l'autenticazione del principal utente

È possibile eseguire il MOUNT dello storage degli oggetti Oracle utilizzando rclone con le chiavi API (User Principal Authentication) su un nodo cluster Big Data Service utilizzando rclone e fuse3, personalizzate per gli utenti JupyterHub.

Completare questa procedura per i cluster ODH 2.x di Big Data Service 3.0.28 o versioni successive per consentire l'accesso e la gestione trasparenti dello storage degli oggetti direttamente dall'ambiente JupyterHub, migliorando le funzionalità di gestione dei dati.
  1. Accedi ad Apache Ambari.
  2. Nella barra degli strumenti laterale, in Servizi selezionare JupyterHub.
  3. Selezionare Riepilogo, quindi selezionare JUPYTERHUB_SERVER.
  4. Ottenere le informazioni sull'host dalle informazioni sull'host visualizzate.
  5. Connettersi all'host del servizio Big Data utilizzando le credenziali SSH utilizzate durante la creazione del cluster. Per ulteriori informazioni, vedere Connessione a un nodo cluster tramite SSH.
  6. Per verificare l'installazione di rclone e fuse3 sul nodo, eseguire le operazioni riportate di seguito. 
    rclone version 
# Ensure version is v1.66

fusermount3 --version 
# Ensure FUSE version 3 is installed
  7. Creare la chiave API e impostare la configurazione rclone. Per ulteriori informazioni, vedere Impostazione dell'autenticazione con un utente e una chiave API OCI, Ottenere lo spazio di nomi e il compartimento bucket della tenancy OCI.
  8. Impostare la configurazione rclone. Per ulteriori informazioni, vedere Configura Rclone per OCI Object Storage.
  9. Per eseguire il MOUNT del bucket di storage degli oggetti, eseguire il comando riportato di seguito come utente di collegamento.

    Di seguito viene eseguita l'operazione di attivazione con l'utente connesso `Jupyterhub`. Il processo daemon viene eseguito come processo Linux sul nodo in cui viene attivata questa operazione.

    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
    Nota

    Per utilizzare i notebook Jupyter, assicurarsi che la posizione di accesso sia all'interno della directory home dell'utente di accesso e che la directory di accesso sia vuota.
                                    sudo -u jupyterhub ls -ltr /home/jupyterhub/mount_dir
  10. (Facoltativo) Per verificare che l'attivazione sia riuscita, eseguire le operazioni riportate di seguito. In questo esempio vengono elencati i contenuti del bucket mount_dir. 
    sudo -u jupyterhub ls -ltr /home/jupyterhub/mount_dir
  11. Eseguire le procedure di cleanup.

    Quando si esegue in modalità in background è necessario arrestare manualmente l'installazione. Utilizzare le seguenti operazioni di cleanup quando i server JupyterHub e Notebook non sono in uso.

    In Linux:
    sudo -u jupyterhub fusermount3 -u /home/jupyterhub/mount_dir
    L'operazione umount può non riuscire, ad esempio quando il punto di attivazione è occupato. Quando ciò accade, è responsabilità dell'utente interrompere manualmente il montaggio.
    sudo -u jupyterhub umount -l /home/jupyterhub/mount_dir : lazy unmount
sudo -u jupyterhub umount -f /home/jupyterhub/mount_dir : force unmount

Gestire gli ambienti Conda in JupyterHub

Nota

È possibile gestire gli ambienti Conda nei cluster ODH 2.x di Big Data Service 3.0.28 o versioni successive.
  • Crea un ambiente Conda con dipendenze specifiche e crea quattro kernel (Python/PySpark/Spark/SparkR) che puntano all'ambiente Conda creato.
  • Gli ambienti e i kernel Conda creati utilizzando questa operazione sono disponibili per tutti gli utenti del server notebook.
  • L'operazione di creazione ambiente Conda separata consente di scollegare l'operazione con il riavvio del servizio.
Requisiti indispensabili
  • JupyterHub viene installato tramite l'interfaccia utente di Ambari.
  • Verificare l'accesso Internet al cluster per scaricare le dipendenze durante la creazione del Conda.
  • Gli ambienti e i kernel Conda creati con questa operazione sono disponibili per tutti gli utenti dei server notebook".
  • Fornire:
    • Conda configurazioni aggiuntive per evitare errori di creazione Conda. Per ulteriori informazioni, vedere conda create.
    • Dipendenze nel formato dei requisiti standard.txt.
    • Nome di ambiente Conda inesistente.
  • Eliminare manualmente envs o kernel conda.
Personalizzazione delle configurazioni globali
  1. Accedi ad Apache Ambari.
  2. Nella barra degli strumenti laterale, in Servizi selezionare JupyterHub.
  3. Selezionare Config, quindi Avanzate.
  4. Scorrere fino alla sezione jupyterhub-conda-env-configs.
  5. Aggiornare i seguenti campi:
    • Conda Altre configurazioni: questo campo viene utilizzato per fornire parametri aggiuntivi da aggiungere al comando di creazione Conda predefinito. Il comando di creazione Conda predefinito è 'conda create -y -p conda_env_full_path -c conda-forge pip python=3.8.

      Se le configurazioni aggiuntive sono indicate come '--override-channels --no-default-packages --no-pin -c pytorch', l'esecuzione finale del comando di creazione del Conda è 'conda create -y -p conda_env_full_path -c conda-forge pip python=3.8 --override-channels --no-default-packages --no-pin -c pytorch'.

    • Nome ambiente Honda: questo campo consente di fornire un nome univoco per l'ambiente Conda. Fornire un ambiente Conda univoco ogni volta che viene creato un nuovo ambiente.
    • Dipendenze Python: questo campo elenca tutte le dipendenze python/R/Ruby/Lua/Scala/Java/JavaScript/C/C++/FORTRAN e così via accessibili ai canali Conda nel formato del file requirements.txt.

      Per ulteriori informazioni sui requisiti del file .txt, vedere Requirements File Format.

  6. Selezionare Salva.
  7. Selezionare Azioni, quindi Attiva ambiente Conda.
    Al termine dell'attivazione, nell'interfaccia utente JupyterHub vengono visualizzati i seguenti elementi:
    • Kernel Python: conda_python3_kernel_{conda_env_name}
    • Kernel PySpark: conda_pyspark_kernel_{conda_env_name}
    • Kernel Spark: conda_spark_kernel_{conda_env_name}
    • Kernel SparkR: conda_sparkr_kernel_{conda_env_name}
    Nota

    Questi kernel puntano all'ambiente Conda creato.
Imposta ambiente Conda specifico dell'utente

Questa operazione crea un ambiente Conda con dipendenze specificate e crea il kernel specificato (Python/PySpark/Spark/SparkR) che punta all'ambiente Conda creato.

  • Se l'ambiente Conda specificato esiste già, l'operazione passa direttamente al passo di creazione del kernel
  • Gli ambienti o i kernel Conda creati utilizzando questa operazione sono disponibili solo per un utente specifico
  • Eseguire manualmente lo script python kernel_install_script.py in modalità sudo:
     '/var/lib/ambari-server/resources/mpacks/odh-ambari-mpack-2.0.8/stacks/ODH/1.1.12/services/JUPYTER/package/scripts/'

    Ad esempio: 

    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

Prerequisiti

  • Verificare l'accesso Internet al cluster per scaricare le dipendenze durante la creazione del Conda. In caso contrario, la creazione non riesce.
  • Se esiste un kernel denominato --kernel_name, viene restituita un'eccezione.
  • Fornire i seguenti dati:
  • Eliminare manualmente envs o kernel conda per qualsiasi utente.

Configurazioni disponibili per la personalizzazione

  • --user (obbligatorio): utente OS e JupyterHub per il quale vengono creati kernel e ambiente conda.
  • --conda_env_name (obbligatorio): fornire un nome univoco per l'ambiente Conda ogni volta che viene creato un nuovo en per --user.
  • --kernel_name: (obbligatorio) Fornire un nome kernel univoco.
  • --kernel_type: (obbligatorio) deve essere uno dei seguenti (python / PysPark / Spark / SparkR)
  • --custom_requirements_txt_file_path: (facoltativo) Se qualsiasi Python/R/Ruby/Lua/Scala/Java/JavaScript/C/C++/FORTRAN e così via, le dipendenze vengono installate utilizzando canali Conda, è necessario specificare tali librerie in un file .txt dei requisiti e fornire il percorso completo.

    Per ulteriori informazioni su un formato standard per la definizione del file .txt dei requisiti, vedere https://pip.pypa.io/en/stable/reference/requirements-file-format/.

  • --conda_additional_configs: (facoltativo)
    • Questo campo fornisce parametri aggiuntivi da aggiungere al comando di creazione Conda predefinito.
    • Il comando di creazione Conda predefinito è: 'conda create -y -p conda_env_full_path -c conda-forge pip python=3.8'.
    • Se --conda_additional_configs viene fornito come '--override-channels --no-default-packages --no-pin -c pytorch', l'esecuzione finale del comando di creazione del Conda è 'conda create -y -p conda_env_full_path -c conda-forge pip python=3.8 --override-channels --no-default-packages --no-pin -c pytorch'.

Impostazione di un ambiente Conda specifico dell'utente

  1. Verificare che JupyterHub sia installato tramite l'interfaccia utente di Ambari.
  2. SSH nel cluster, quindi passare a /var/lib/ambari-server/resources/mpacks/odh-ambari-mpack-2.0.8/stacks/ODH/1.1.12/services/JUPYTER/package/scripts/.
  3. Esegui con specifiche per il tuo ambiente: 
    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

    Questa esecuzione di script di esempio con i parametri specificati crea un ambiente Conda conda_jupy_env_1 per l'utente BDS, installa dipendenze personalizzate per conda_jupy_env_1 e crea un kernel spark con il nome spark_bds_1. Dopo il completamento di questa operazione, il kernel spark_bds_1 viene visualizzato solo nell'interfaccia utente JupyterHub dell'utente bds.

Creare un load balancer e un set backend

Per ulteriori informazioni sulla creazione dei set backend, vedere Creazione di un set backend del load balancer.

Creazione del load balancer

Per ulteriori informazioni sulla creazione di un load balancer pubblico, vedere Creazione di un load balancer e completare i dettagli riportati di seguito.

  1. Aprire il menu di navigazione, selezionare Networking e quindi Load balancer. Load balancer. Viene visualizzata la pagina Load balancer.
  2. In Ambito elenco, selezionare il Compartimento in cui si trova il cluster.
  3. Nel campo Nome load balancer immettere un nome per identificare il load balancer. ad esempio JupyterHub-LoadBalancer.
  4. Nella sezione Scegli tipo di visibilità, selezionare Pubblico.
  5. Nella sezione Assign a public IP address selezionare Reserved IP address.
  6. Selezionare Crea nuovo indirizzo IP riservato.
  7. Nel campo Nome IP pubblico, immettere un nome. Ad esempio, ip-jupyterhub
  8. In Crea nel compartimento, selezionare il compartimento in cui si trova il cluster.
  9. Nella sezione Scegli rete, completare quanto segue:
    1. Nella sezione Rete cloud virtuale <Compartment> selezionare la VCN utilizzata dal cluster.
    2. Nel campo Subnet in <Compartment> selezionare la subnet utilizzata dal cluster.
  10. Selezionare Successivo. Viene visualizzata la pagina Scegli backend.
  11. Nel campo Specificare un criterio di bilanciamento del carico, selezionare Hash IP.
    Nota

    Non aggiungere i backend in questo momento.
  12. Nella sezione Specificare il criterio di controllo dello stato, completare quanto riportato di seguito.
    1. Nel campo Porta, immettere 8000.
    2. Nel campo Percorso URL (URI) immettere //hub/api.
  13. Selezionare Usa SSL.
  14. Nella sezione Risorsa certificato, completare le operazioni riportate di seguito.
    1. Selezionare Certificato gestito dal load balancer dall'elenco a discesa.
    2. Selezionare Incolla certificato SSL.
    3. Nel campo Certificato SSL copiare e incollare un certificato direttamente in questo campo.
    4. Selezionare Incolla certificato CA.
    5. Nel campo Certificato CA, immettere il certificato Oracle utilizzando /etc/security/serverKeys/bdsOracleCA.crt presente nel cluster. Per le autorità di certificazione pubbliche (CA), questo certificato può essere ottenuto direttamente dal proprio sito.
    6. (Facoltativo) Selezionare Specifica chiave privata.
      1. Selezionare Incolla chiave privata.
      2. Nel campo Chiave privata incollare una chiave privata direttamente in questo campo.
  15. Selezionare Mostra opzioni avanzate per accedere a più opzioni.
  16. Selezionare la scheda Set backend, quindi immettere il nome del set backend. Ad esempio, JupyterHubbackend.
  17. Selezionare Resistenza sessione, quindi selezionare Abilita persistenza cookie load balancer. I cookie vengono generati automaticamente.
  18. Selezionare Successivo. Viene visualizzata la pagina Configura listener. Completare le operazioni riportate di seguito.
    1. Nel campo Nome listener, immettere un nome per il listener. Ad esempio, JupyterHub-Listener.
    2. Selezionare HTTPS per Specificare il tipo di traffico gestito dal listener.
    3. Nel campo Specificare la porta monitorata dal listener per il traffico in entrata, immettere 8000.
    4. Selezionare Incolla certificato SSL.
    5. Nel campo Certificato SSL copiare e incollare un certificato direttamente in questo campo.
    6. Selezionare Certificato gestito dal load balancer dall'elenco a discesa.
    7. Selezionare Incolla certificato CA.
    8. Nel campo Certificato CA immettere il certificato CA del cluster.
    9. Selezionare Specifica chiave privata.
      1. Selezionare Incolla chiave privata.
      2. Nel campo Chiave privata incollare una chiave privata direttamente in questo campo.
  19. Selezionare Successivo, quindi Sottometti.
Configurare il set backend

Per ulteriori informazioni sulla creazione di un load balancer pubblico, vedere Creazione di un load balancer e completare i dettagli riportati di seguito.

  1. Aprire il menu di navigazione, selezionare Networking e quindi Load balancer. Selezionare Load balancer. Viene visualizzata la pagina Load balancer.
  2. Selezionare il compartimento dalla lista. Tutti i load balancer in tale compartimento sono elencati in formato di tabella.
  3. Selezionare il load balancer a cui si desidera aggiungere un backend. Viene visualizzata la pagina dei dettagli del load balancer.
  4. Selezionare Set backend, quindi selezionare il set backend creato in Creazione del load balancer.
  5. Selezionare gli indirizzi IP, quindi immettere l'indirizzo IP privato richiesto del cluster.
  6. Immettere 8000 per la porta.
  7. Selezionare Aggiungi.
Configurare il set backend

Per ulteriori informazioni sulla creazione di un load balancer pubblico, vedere Creazione di un load balancer e completare i dettagli riportati di seguito.

  1. Aprire un browser e immettere https://<loadbalancer ip>:8000.
  2. Selezionare il compartimento dalla lista. Tutti i load balancer in tale compartimento sono elencati in formato di tabella.
  3. Assicurarsi che venga eseguito il reindirizzamento a uno dei server JupyterHub. Per verificare, aprire una sessione terminale sul JupyterHub per trovare il nodo raggiunto.
Limiti
  • Dopo l'operazione di aggiunta del nodo, l'amministratore del cluster deve aggiornare manualmente la voce host del load balancer nei nodi appena aggiunti. Applicabile a tutte le aggiunte nodo al cluster. Ad esempio, nodo di lavoro, solo calcolo e nodi.
  • In caso di scadenza, il certificato deve essere aggiornato manualmente al load balancer. Questo passo garantisce che il load balancer non utilizzi certificati obsoleti ed evita errori di controllo dello stato/comunicazione nei set backend. Per ulteriori informazioni, vedere Aggiornamento di un certificato load balancer in scadenza per aggiornare il certificato scaduto.

Avvia Trino-SQL Kernels

Il kernel JupyterHub PyTrino fornisce un'interfaccia SQL che consente di eseguire query Trino utilizzando JupyterHub SQL. È disponibile per i cluster ODH 2.x Big Data Service 3.0.28 o versioni successive.

Avvio del kernel PyTrino ed esecuzione delle query Trino
  1. Installare Trino.
  2. Configura Trino Coordinatore e porto:
    1. Accedi ad Apache Ambari.
    2. Nella barra degli strumenti laterale, in Servizi selezionare JupyterHub.
    3. Selezionare Config, quindi Avanzate.
    4. Nella sezione Advanced Jupyterhub-trino-kernel-configs configurare il nome host del coordinatore Trino e la porta Trino.
  3. Selezionare Salva, quindi riavviare JupyterHub.
  4. Accedi a JupyterHub.
  5. Aprire un notebook server. Si viene reindirizzati alla pagina Launcher.
  6. Selezionare il kernel PyTrino.
  7. È possibile eseguire query Trino nel kernel PyTrino nei modi seguenti:
    • Eseguire query di esempio Trino utilizzando %sql <Trino-query> , quindi selezionare Esegui.

      Ad esempio: 

      %sql select custkey, name, phone, acctbal from tpch.sf1.customer limit 10
    • È possibile scrivere la logica Python al di sopra del risultato della query. Ad esempio:
      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)
    • Per le query su più righe, eseguire %%sql. Ad esempio:
      # 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}}
Impostazione dei parametri di sessione Trino
I parametri della sessione Trino possono essere configurati dall'interfaccia utente Ambari JupyterHub. Questi parametri di sessione vengono applicati a tutte le sessioni utente. Per ulteriori informazioni sui parametri di sessione, vedere N. riferimento proprietà.
  1. Accedi ad Apache Ambari.
  2. Nella barra degli strumenti laterale, in Servizi selezionare JupyterHub.
  3. Selezionare Config, quindi Avanzate.
  4. Nella sezione Custom Jupyterhub-trino-kernel-configs aggiungere i seguenti parametri di sessione: 
    trino_session_params_<SESSION_PARAM> = <VALUE>

    Ad esempio, trino_session_params_query_max_planning_time = 1200m.

  5. (Facoltativo) Per visualizzare l'elenco dei parametri della sessione, eseguire le operazioni riportate di seguito. 
    %sql SHOW session
  6. Per impostare i parametri per la sessione notebook corrente, eseguire: %sql SET SESSION Ad esempio: 
    %sql SET SESSION query_max_run_time='2h'
Impostazione dei parametri delle credenziali supplementari Trino
I parametri delle credenziali aggiuntive Trino necessari per accedere ai dati dell'area di memorizzazione degli oggetti possono essere configurati dall'interfaccia utente di JupyterHub Ambari.
  1. Accedi ad Apache Ambari.
  2. Nella barra degli strumenti laterale, in Servizi selezionare JupyterHub.
  3. Config, quindi selezionare Avanzate.
  4. Nella sezione Custom Jupyterhub-trino-kernel-configs aggiungere i seguenti parametri delle credenziali supplementari: 
    trino_extra_credentials_<BDS_OSS_CLIENT_PARAM> = <VALUE>

    Ad esempio, trino_extra_credentials_BDS_OSS_CLIENT_REGION = us-region-1.

Impostazione dei parametri SqlMagic
Le configurazioni SqlMagic offrono un controllo flessibile sul comportamento e sull'aspetto delle operazioni SQL eseguite nei notebook Jupyter. Questi parametri possono essere configurati dall'interfaccia utente di JupyterHub Ambari e applicati a tutte le sessioni utente.

Per ulteriori informazioni sui parametri SqlMagic, vedere https://jupysql.ploomber.io/en/latest/api/configuration.html#changing-configuration.

  1. Accedi ad Apache Ambari.
  2. Nella barra degli strumenti laterale, in Servizi selezionare JupyterHub.
  3. Selezionare Config, quindi Avanzate.
  4. Nella sezione Custom Jupyterhub-sql-magic-configs aggiungere i seguenti parametri Magical:
    SqlMagic.<PARAM> = <VALUE>
    Ad esempio: 
    SqlMagic.displaycon = False
  5. Per ottenere l'elenco dei parametri SqlMagic, eseguire: 
    %config SqlMagic
  6. (Facoltativo) È possibile impostare i parametri SqlMagic solo per la sessione notebook corrente.

    Ad esempio: 

    %config SqlMagic.displaycon=False