Utilizzo dei notebook

Oracle Big Data Service utilizza l'applicazione notebook Big Data Studio come interfaccia notebook e ambiente di codifica.

Creazione di un notebook

Per creare un notebook:
  1. Accedere all'applicazione notebook. Vedere Accesso a Big Data Studio.
  2. Fare clic sull'icona Notebook a sinistra.
  3. Fare clic su Crea o Crea notebook e specificare quanto segue:
    • Nome: nome del notebook.

    • Descrizione: descrizione del blocco note.

    • Tag: parole chiave per il notebook. Queste parole chiave fungono da tag di ricerca quando si cerca il blocco note. È inoltre possibile aggiungere tag in un secondo momento modificando il blocco appunti.

    • Tipo: selezionare il tipo di notebook. Le scelte sono:

      • Predefinito: applica l'aspetto di Zeppelin, in cui è possibile ridimensionare e posizionare i paragrafi uno accanto all'altro.
      • Jupyter: applica l'aspetto di Jupyter, in cui i paragrafi vengono visualizzati in una singola colonna.
  4. Fare clic su Crea.

È possibile eseguire molte azioni in un blocco appunti. Per informazioni su alcuni di essi, vedere Panoramica dell'interfaccia utente dei notebook.

Dopo aver creato un blocco appunti, è possibile creare paragrafi nel blocco appunti. Vedere Creazione di paragrafi.

Panoramica dell'interfaccia utente dei notebook

Di seguito sono riportati alcuni degli elementi dello schermo più comuni che verranno visualizzati quando si lavora all'interno di un notebook. Spostare il mouse sulle icone nell'interfaccia utente per visualizzarne le funzioni.

Icona descrizione;

Modifica notebook

Modifica i dettagli di un blocco appunti, ad esempio nome, descrizione e tag.

Esegui paragrafi

Esegue tutti i paragrafi in un blocco appunti in ordine sequenziale.

Invalida sessione

Reimposta qualsiasi connessione o codice eseguito in un notebook.

Eliminare il notebook

Elimina un blocco note.

Nascondi/Mostra codice

Nasconde o mostra la sezione codice in tutti i paragrafi di un blocco appunti.

Nascondi/Mostra risultato

Nasconde o mostra la sezione dei risultati in tutti i paragrafi di un blocco appunti.

Sola lettura/scrittura

Imposta la modalità di sola lettura o scrittura del notebook.

Nascondi/Mostra pannello

Mostra o nasconde i comandi della barra delle impostazioni dei paragrafi, la barra degli strumenti dei risultati e la finestra di dialogo delle impostazioni per un paragrafo selezionato in un pannello a destra del blocco appunti.

Controllo versioni

Crea una versione di un notebook o visualizza le versioni.

Cancella risultato

Cancella i risultati per tutti i paragrafi di un notebook.

Cancella dipendenze paragrafo

Rimuove tutte le dipendenze di paragrafo definite.

Apri come Iframe

Apre un notebook in un Iframe. Ciò consente di incorporare un blocco appunti all'interno di un'altra pagina Web.

Condividi notebook

Condivide un notebook.

Duplica notebook

Crea una copia di un blocco appunti.

Esporta notebook

Esporta un notebook nel computer come file .dnsb.

Zeppelin/Jupyter

Imposta il layout preferito di un notebook (formato di layout Zeppelin o Jupyter).

Modello/altro modello predefinito

Applica l'aspetto generale del blocco appunti utilizzando il modello predefinito o un altro modello.

Importazione di un notebook

È possibile importare notebook dal computer locale nell'applicazione notebook Big Data Studio. Questo include i notebook Jupyter.

Per importare un notebook:
  1. Accedere all'applicazione notebook. Vedere Accesso a Big Data Studio.
  2. Nella pagina Blocchi note, fare clic sull'icona Importa blocchi note in alto a destra.
  3. Trascinare o cercare il blocco note da importare. Le estensioni di file valide sono .json, .dsnb e .ipynb.
  4. Fare clic su Importa.

Duplicazione di un notebook

Quando si clona un blocco appunti, ne viene creata una copia.

Per duplicare un notebook:
  1. Accedere all'applicazione notebook. Vedere Accesso a Big Data Studio.
  2. Nella pagina Blocchi appunti aprire il blocco appunti che si desidera duplicare.
  3. Fare clic sull'icona Duplica blocco note e creare la copia.

    A meno che il nome non venga modificato, il notebook duplicato viene denominato Copia del nome del notebook corrente.

  4. Se la copia è di sola lettura e si desidera eseguirla o modificarla, fare clic sull'icona a forma di lucchetto in alto a destra del notebook aperto per sbloccarla.

Interpreti supportati

L'applicazione notebook Big Data Studio fornisce interpreti che eseguono codice in diverse lingue. Sono supportati gli interpreti elencati di seguito.

Ogni interprete dispone di un set di proprietà che possono essere personalizzate da un amministratore e applicate a tutti i notebook. Vedere Configurazione degli interpreti.

Iniziare un paragrafo con %interpreter come mostrato di seguito e quindi codificare il paragrafo con la sintassi corrispondente.

Nota

Gli interpreti Spark e PySpark supportano la modalità client YARN. L'esecuzione degli interpreti in modalità client YARN implica l'avvio di un driver Spark da parte di Big Data Studio e l'invio dei comandi dell'applicazione Spark ai Node Manager YARN da eseguire. In questo modo YARN gestisce la memoria anziché il nodo cluster.
Digita Traduzione Utilizzo

graalvm

oracle.datastudio.interpreter.graalvm.GraalVMInterpreter

Specificare il tipo di lingua come mostrato di seguito, quindi utilizzare la sintassi per tale lingua.

%python-graalvm
%js-graalvm
%java-graalvm
%ruby-graalvm

jdbc

(default)

org.apache.zeppelin.jdbc.JDBCInterpreter

%jdbc

Le impostazioni del database devono essere configurate correttamente. Gli amministratori devono andare a Interpreti > jdbc > jdbc(default) nell'interfaccia utente Web di Big Data Studio e verificare o configurare le impostazioni riportate di seguito.

  • Stringa di connessione al database default.url:

  • Utente default user: con autorizzazione per la connessione al database

  • Password default password: per il database

jdbc

(Cloud SQL)

org.apache.zeppelin.jdbc.JDBCInterpreter

%jdbc.cloudsql

Per utilizzare questo interprete, è necessario aggiungere Cloud SQL al cluster. Vedere Aggiunta di Cloud SQL. Cloud SQL consente di utilizzare SQL per eseguire query sulle origini Big Data. Vedere Utilizzo di Cloud SQL con Big Data.

Gli amministratori devono inoltre modificare la password predefinita utilizzata con l'interprete:

  1. Connettersi al nodo del server di query come utente root ed eseguire le operazioni riportate di seguito.
    # su - oracle
    sqlplus / as sysdba
    sql> alter session set container=bdsqlusr;
    sql> alter user datastudio_user identified by "new_password";
    In questo modo viene impostata la nuova password. Per creare un superutente (facoltativo), utilizzare:
    # su - oracle
    sqlplus / as sysdba
    sql> alter session set container=bdsqlusr;
    sql> create user new_user_name identified by "new_password";
    sql> GRANT ALL PRIVILEGES TO new_user_name;
  2. Andare a Interpreti > jdbc > jdbc.cloudsql nell'interfaccia utente Web di Big Data Studio, immettere la nuova password nel campo default.password e fare clic su Aggiorna. Se è stato creato un superutente, è necessario aggiornare il campo default.user. Se Cloud SQL non è stato aggiunto al cluster, non verrà visualizzata la scheda jdbc.cloudsql.

jdbc

(Hive)

org.apache.zeppelin.jdbc.JDBCInterpreter

%jdbc.hive

Nei cluster non protetti non è necessaria alcuna configurazione aggiuntiva.

Nei cluster protetti, l'utente datastudio deve essere aggiunto al gruppo che dispone delle autorizzazioni per la scrittura nel database. Per ulteriori informazioni, vedere Concessione dell'accesso alle tabelle Hive.

md (rimozione)

oracle.datastudio.markdown.MarkdownInterpreter

%md

pyspark

org.apache.zeppelin.spark.PySparkInterpreter

%pyspark

python

oracle.datastudio.python.DsPythonInterpreter

%python

Gli amministratori del cluster possono installare altri pacchetti Python nell'host del cluster. Utilizzare SSH per connettersi al cluster, quindi utilizzare pip per installare i pacchetti Python.

Quando i pacchetti vengono installati e le nuove librerie si trovano in una delle posizioni riportate di seguito, le librerie diventano disponibili per il percorso di ricerca del modulo dell'interprete Python nel notebook.

/usr/bin
/usr/lib
/usr/lib64

rserveinterprete

com.oracle.oml.interpreter.plainrinterpreter.PlainRInterpreter

Sintassi %r e quindi R

Gli amministratori del cluster possono installare altri pacchetti R sull'host del cluster. Utilizzare SSH per connettersi al cluster, quindi utilizzare R CMD o R install.packages per installare i pacchetti R:

R CMD [options] package_name.tar.gz
R install.packages(url_for_packages, NULL)

Quando vengono installati i pacchetti, le nuove librerie si trovano in /usr/lib64/R/. Le librerie in questa directory vengono aggiunte all'interprete R. Le librerie in altre directory non sono disponibili per l'applicazione notebook.

scintilla

org.apache.zeppelin.spark.SparkInterpreter

%spark

Creazione dei paragrafi

I paragrafi vengono utilizzati nei notebook per esplorare i dati in modo interattivo. I paragrafi contengono codice eseguibile che restituisce risultati in molti formati diversi.

È possibile utilizzare interpreti diversi nello stesso blocco appunti. Le impostazioni dell'interpreter possono essere configurate da un amministratore. Vedere Configurazione degli interpreti.

Per creare un paragrafo:

  1. Accedere all'applicazione notebook. Vedere Accesso a Big Data Studio.
  2. Dalla pagina Blocchi appunti, aprire il blocco appunti per il quale si desidera aggiungere paragrafi (o creare un nuovo blocco appunti).
  3. Passare il mouse sopra o sotto un paragrafo per visualizzare la barra degli strumenti dell'interprete:

    La barra degli strumenti Interprete viene visualizzata come barra di navigazione con 12 cerchi. Ogni cerchio ha un'icona su di esso. Ad esempio, un segno più. Il resto delle immagini non è chiaro.

  4. Fare clic su un'icona nella barra degli strumenti per selezionare un interprete e aggiungere un nuovo paragrafo che utilizza tale interprete. Quando si fa clic su alcune icone, il paragrafo creato include il codice di esempio che è possibile eseguire.

    Le icone non sono disponibili per tutti gli interpreti. Per gli interpreti per i quali non sono presenti icone, fare clic sul segno più (+) e iniziare il paragrafo con %interpreter. Ad esempio, per Spark, fare clic sul segno + nella barra degli strumenti e iniziare il paragrafo con %spark. Per un elenco degli interpreti supportati, vedere Interpreti supportati.

  5. Codificare il paragrafo come desiderato. Le modifiche vengono salvate automaticamente.

Per informazioni su alcune delle azioni che è possibile eseguire nei paragrafi, vedere Panoramica dell'interfaccia utente Paragrafi.

Panoramica dell'interfaccia utente dei paragrafi

Di seguito sono riportati alcuni degli elementi dello schermo più comuni che verranno visualizzati quando si lavora con i paragrafi. Spostare il mouse sulle icone nell'interfaccia utente per visualizzarne le funzioni.

Icona descrizione;

Esegui paragrafo

Esegue il codice o la query in un paragrafo.

Immettere la modalità di dipendenza

Aggiunge o rimuove i paragrafi dipendenti.

commenti

Aggiunge commenti a un paragrafo.

Espandi/comprimi

Espande un paragrafo e lo mostra in modalità a schermo intero oppure comprime tale vista.

Mostra/ Nascondi numeri di riga

Mostra o nasconde i numeri di riga nel codice di un paragrafo (si applica solo alla sezione del codice).

Visibilità

Gestisce le impostazioni di visibilità in un paragrafo. Questo controlla il modo in cui un paragrafo può essere visualizzato dall'autore e da altri utenti che hanno accesso al blocco appunti.

Impostazioni

Fornisce una serie di azioni. Utilizzare questa opzione per:
  • Spostare un paragrafo verso l'alto o verso il basso

  • Cancella il risultato del paragrafo

  • Aprire un paragrafo come Iframe

  • Duplica un paragrafo

  • Elimina un paragrafo

Accesso a HDFS da Spark e PySpark

Per accedere a HDFS in un notebook e leggere e scrivere in HDFS, è necessario concedere l'accesso alle cartelle e ai file all'utente a cui l'applicazione notebook Big Data Studio accederà come HDFS.

Quando Big Data Studio accede a HDFS (e ad altri servizi cluster Hadoop), vengono utilizzati gli utenti riportati di seguito.

  • interpreteruser è l'utente e il gruppo utilizzati con i cluster non protetti.

  • datastudio è l'utente e il gruppo utilizzati con i cluster protetti (abilitati per Kerberos).

Si noti che questi utenti non sono gli utenti utilizzati per accedere all'interfaccia utente Web di Big Data Studio.

In un cluster protetto è necessario ottenere un ticket Kerberos per l'utente prima di eseguire i comandi hdfs. Ad esempio, per eseguire il comando kinit oracle per l'utente oracle.

Concessione dell'accesso alle cartelle HDFS

È possibile concedere l'accesso in lettura e scrittura alle cartelle HDFS. È inoltre possibile rimuovere tale accesso.

Per concedere l'accesso alle cartelle HDFS, procedere come segue.
  1. Creare una directory HDFS a cui si desidera fornire l'accesso se non è già disponibile. In questo esempio la directory è /user/oracle/test.
    hdfs dfs -mkdir /user/oracle/test
  2. Fornire l'accesso tramite le ACL HDFS.
    1. Verificare l'accesso all'ACL corrente. Esempio:
      hdfs dfs -getfacl /user/oracle/test

      Vedrai qualcosa del genere:

      # file: /user/oracle/test
      # owner: oracle
      # group: oracle
      user:rwx
      group:r-x
      other:r-x
    2. Rendere i file e le sottodirectory nella directory leggibili dal gruppo:
      • Per i cluster non protetti, impostare le autorizzazioni sul gruppo interpreteruser. Ad esempio:

        hdfs dfs -setfacl -m group:interpreteruser:rwx /user/oracle/test
      • Per i cluster protetti, impostare le autorizzazioni sul gruppo datastudio. Ad esempio:

        hdfs dfs -setfacl -m group:datastudio:rwx /user/oracle/test
    3. Impostare l'impostazione ACL predefinita per la directory padre:
      • Per i cluster non protetti, impostare le autorizzazioni predefinite sul gruppo interpreteruser. Ad esempio:

        hdfs dfs -setfacl -m default:group:interpreteruser:rwx /user/oracle/test
      • Per i cluster protetti, impostare le autorizzazioni predefinite sul gruppo datastudio. Ad esempio:

        hdfs dfs -setfacl -m default:group:datastudio:rwx /user/oracle/test
    4. Aggiungere le autorizzazioni corrette per l'utente. È inoltre possibile rimuovere l'accesso già concesso. Esempio:
      • Impostare l'autorizzazione read

        • Cluster non protetti:

          hdfs dfs -setfacl -m user:interpreteruser:r-x /user/oracle/test
        • Cluster protetti:

          hdfs dfs -setfacl -m user:datastudio:r-x /user/oracle/test
      • Impostare l'autorizzazione write

        • Cluster non protetti:

          hdfs dfs -setfacl -m user:interpreteruser:rwx /user/oracle/test
        • Cluster protetti:

          hdfs dfs -setfacl -m user:datastudio:rwx /user/oracle/test
      • Rimuovi accesso

        • Cluster non protetti:

          hdfs dfs -setfacl -m user:interpreteruser:--- /user/oracle/test
        • Cluster protetti:

          hdfs dfs -setfacl -m user:datastudio:--- /user/oracle/test
  3. Verificare l'accesso diretto all'ACL. Esempio:
    hdfs dfs -getfacl /user/oracle/test
    # file: /user/oracle/test
    # owner: oracle
    # group: oracle

    Vedrai qualcosa come il seguente. In questo esempio vengono visualizzate le autorizzazioni per interpreteruser.

    user:rwx
    user:interpreteruser:r-x  
    group:r-x
    group:interpreteruser:rwx
    mask:rwx
    other:r-x
    default:user:rwx
    default:group:r-x
    default:group:interpreteruser:rwx
    default:mask:rwx
    default:other:r-x
  4. Eseguire il test della configurazione eseguendo lo script seguente in un notebook. In questo esempio viene utilizzato Spark. Ora dovrebbe essere possibile leggere e scrivere in HDFS.
    %spark
        import scala.sys.process.Process
        import org.apache.spark.SparkConf
        import org.apache.hadoop.fs.{FileSystem, Path}
    
        //Get the Name Node Service
        val df_name_xml = Process(Seq("bash", "-c", "grep -A1  -- dfs.nameservices  /etc/hadoop/conf/hdfs-site.xml  | grep -v dfs ") ).lineStream.mkString
        var df_name = df_name_xml.trim.replaceAll("<value>|</value>", "")
        println (df_name)
    
        val fs = FileSystem.get(spark.sparkContext.hadoopConfiguration)
    
        var namenode=df_name //NameNode Nameservice
        var testfile="test.csv"
        var dir = "/user/oracle/test"
    
        val rdd = sc.parallelize(List(
            (0, 60),
            (0, 56),
            (0, 54),
            (0, 62),
            (0, 61),
            (0, 53),
            (0, 55),
            (0, 62),
            (0, 64),
            (1, 73),
            (1, 78),
            (1, 67),
            (1, 68),
            (1, 78)
        ))
    
        rdd.saveAsTextFile(s"hdfs://$namenode:8020$dir/$testfile")
        var input = sc.textFile(s"hdfs://$namenode:8020$dir/$testfile")
        input.count()
        fs.delete(new Path(s"$dir/$testfile"))
Concessione dell'accesso ai file HDFS

È possibile concedere l'accesso in lettura a file HDFS specifici. È inoltre possibile rimuovere tale accesso.

Per concedere l'accesso ai file HDFS, procedere come segue.
  1. Se non si dispone già di un file HDFS a cui si desidera fornire l'accesso, è possibile crearne uno. In questo esempio viene utilizzato /user/oracle/test.txt.
    $ ls -l / > /tmp/test.txt
    $ hdfs dfs -put /tmp/test.txt  /user/oracle
    $ hdfs dfs -chmod o-r   /user/oracle/test.txt
  2. Impostare le autorizzazioni corrette o rimuovere l'accesso. Esempio:
    • Impostare l'autorizzazione read

      • Cluster non protetti:

        hdfs dfs -setfacl -m user:interpreteruser:r--  /user/oracle/test.txt
      • Cluster protetti:

        hdfs dfs -setfacl -m user:datastudio:r--  /user/oracle/test.txt
    • Rimuovi accesso

      • Cluster non protetti:

        hdfs dfs -setfacl -m user:interpreteruser:--- /user/oracle/test.txt
      • Cluster protetti:

        hdfs dfs -setfacl -m user:datastudio:--- /user/oracle/test.txt
  3. Eseguire il test della configurazione eseguendo lo script seguente in un notebook. In questo esempio viene utilizzato Spark.
    %spark
    import scala.sys.process.Process
    import org.apache.spark.SparkConf
    
    //Get the Name Node Service
    val df_name_xml = Process(Seq("bash", "-c", "grep -EA1 -- 'dfs.namenode.servicerpc-address<|dfs.nameservices' /etc/hadoop/conf/hdfs-site.xml | grep -v dfs ") ).lineStream.mkString
    var df_name = df_name_xml.trim.replaceAll("<value>|</value>|:8022", "")
    println (df_name)
    
    var namenode=df_name //NameNode Nameservice
    var testfile="test.txt"
    var dir = "/user/oracle"
    
    var x = sc.textFile(s"hdfs://$namenode:8020$dir/$testfile")
    x.take(10).foreach(println)
PySpark Esempi per HDFS

Gli esempi riportati di seguito mostrano come utilizzare PySpark con HDFS. È necessario accedere a HDFS come descritto negli argomenti precedenti. Assicurarsi di utilizzare l'interprete %pyspark.

Ottieni una sessione Spark

Per utilizzare HDFS, è necessaria una sessione Spark.

%pyspark
from pyspark.sql import SparkSession
sparkSession = SparkSession.builder.appName("SparkSessionName").getOrCreate()

Lettura in HDFS

Per leggere utilizzando SparkSession:

%pyspark
df_load = sparkSession.read.csv('/hdfs/full/path/to/folder') 
df_load.show()

Scrivi a HDFS

Utilizzare DataFrame per scrivere in HDFS. Per scrivere utilizzando SparkSession:

%pyspark
data = [('One', 1), ('Two', 2), ('Three', 3)]
# Create DataFrame
df = sparkSession.createDataFrame(data)
# Write into HDFS 
df.write.mode("overwrite").csv("/hdfs/full/path/to/folder")
# /hdfs/full/path/to/folder is created when dfs.write is executed
Le opzioni df.write.mode specificano il funzionamento dell'operazione di salvataggio quando i dati esistono già:
  • append: Aggiunge il contenuto di questo DataFrame ai dati esistenti.

  • overwrite: sovrascrive i dati esistenti.

  • ignore: Ignora questa operazione se i dati esistono già.

  • error o errorifexists: restituisce un'eccezione se i dati esistono già.

Esempio 1: Scrittura in una directory

Questo esempio scrive in una directory /tmp a cui tutti gli utenti HDFS hanno accesso.

%pyspark
from pyspark.sql import SparkSession
sparkSession = SparkSession.builder.appName("pyspark-write").getOrCreate()
# Create data
data = [('One', 1), ('Two', 2), ('Three', 3), ('Four', 4), ('Five', 5)]
df = sparkSession.createDataFrame(data)
# Write into HDFS 
df.write.mode("overwrite").csv("/tmp/testpysparkcsv")

Esempio 2: leggere le informazioni

Questo esempio legge le informazioni nella directory /tmp/testpysparkcsv creata nell'esempio precedente.

%pyspark
from pyspark.sql import SparkSession
sparkSession = SparkSession.builder.appName("pyspark-read").getOrCreate()
# Read from HDFS
df_load = sparkSession.read.csv('/tmp/testpysparkcsv')

df_load.show()

Accesso a Hive da Spark e PySpark

Per accedere a Hive in un notebook e leggere e scrivere in Hive, è necessario concedere l'accesso alle cartelle e ai file all'utente a cui l'applicazione notebook Big Data Studio accederà con il nome Hive.

Quando Big Data Studio accede a Hive, vengono utilizzati gli utenti riportati di seguito.

  • interpreteruser è l'utente e il gruppo utilizzati con i cluster non protetti.

  • datastudio è l'utente e il gruppo utilizzati con i cluster protetti (abilitati per Kerberos).

Si noti che questi utenti non sono gli utenti utilizzati per accedere all'interfaccia utente Web di Big Data Studio.

Concessione dell'accesso alle tabelle Hive

È possibile abilitare Big Data Studio per accedere a tutte le tabelle Hive aggiungendo l'utente datastudio al gruppo di amministratori hive. L'utente che esegue questi passi deve eseguire il login a un nodo del cluster come utente root.

Nota

Nei cluster CDH protetti, all'utente e al gruppo datastudio è possibile concedere un accesso con filtro più esteso a tabelle specifiche creando e utilizzando i ruoli Sentry. Per ulteriori informazioni, vedere Hive SQL Syntax for Use with Sentry nella documentazione di Cloudera.

Per concedere l'accesso alle tabelle Hive, effettuare le operazioni riportate di seguito.

  1. Aggiungere l'utente datastudio a un gruppo con accesso a Hive. Negli esempi seguenti il gruppo è hive.

    Cluster non protetti:

    dcli -C usermod -a -G hive interpreteruser

    Cluster protetti:

    dcli -C usermod -a -G hive datastudio
  2. Verificare che l'utente faccia parte di un gruppo con accesso a Hive.

    Cluster non protetto:

    dcli -C id interpreteruser

    Cluster protetto:

    dcli -C id datastudio
  3. Eseguire il test della configurazione eseguendo lo script seguente in un notebook. In questo esempio viene utilizzato Spark. Ora dovresti essere in grado di leggere e scrivere nei database Hive.
    %spark
    import org.apache.spark.sql.SparkSession
    val conf = sc.getConf
    sc.stop()
    
    val customSql = SparkSession.builder().config(conf).enableHiveSupport().getOrCreate()
    
    customSql.sql(s"use default").show()
    customSql.sql(s"show tables").show()
    customSql.sql("CREATE TABLE IF NOT EXISTS testds ( eid int, name String,  salary String, destination String)").show()
    customSql.sql(s"describe  testds").show()
Rimozione dell'accesso a Hive

Per rimuovere l'accesso a Hive, rimuovere l'utente dal gruppo a cui è consentito l'accesso. In questo esempio, il gruppo è hive.

Cluster non protetti:

dcli -C gpasswd -d interpreteruser hive

Cluster protetti:

dcli -C gpasswd -d datastudio hive
PySpark Esempi per Hive

Gli esempi riportati di seguito mostrano come utilizzare PySpark con Hive. È necessario accedere a Hive come descritto negli argomenti precedenti. Assicurarsi di utilizzare l'interprete %pyspark.

Utilizzare spark.sql per utilizzare Hive

Utilizzare spark.sql per utilizzare Hive. Chiamata alla funzione spark.sql:

%pyspark
# Run the SQL instruction in quiet mode
spark.sql("SQL instruction")
# Show some output
spark.sql("SQL instruction").show()

Esempio di istruzioni SQL che non mostrano informazioni:

%pyspark
spark.sql ("DROP TABLE IF EXISTS hive_table")
spark.sql("CREATE TABLE IF NOT EXISTS hive_table (number int, Ordinal_Number string, Cardinal_Number string) ROW FORMAT DELIMITED FIELDS TERMINATED BY ',' LINES TERMINATED BY '\n' ")
spark.sql("load data inpath '/tmp/pysparktestfile.csv' into table pyspark_numbers_from_file")
spark.sql("insert into table pyspark_numbers_from_file2 select * from pyspark_numbers_from_file")
spark.sql("CREATE TABLE IF NOT EXISTS pyspark_numbers (number int, Ordinal_Number string, Cardinal_Number string) USING com.databricks.spark.csv OPTIONS \
(path \"/full/path/hdfs/dataframe/folder\", header \"false\")")

Esempio di istruzioni SQL che mostrano informazioni:

%pyspark
spark.sql("show databases").show()
spark.sql("show tables").show()
spark.sql("describe hive_table ").show()
spark.sql("select * hive_Table limit 5").show()

Esempio 1: creazione di una tabella

%pyspark
spark.sql("CREATE TABLE IF NOT EXISTS pyspark_test_table ( eid int, name String,  salary String, destination String)")
spark.sql("describe pyspark_test_table ").show()

Esempio 2: rimozione di una tabella

%pyspark
spark.sql ("DROP TABLE IF EXISTS pyspark_test_table")

Esempio 3: creare un file con 9000 righe

%pyspark
from pyspark.sql import SparkSession
import re

single_digit = ["","one", "two", "three" , "four" , "five" , "six" , "seven" , "eight" , "nine"] 
ten_to_nineteen  =["ten","eleven","twelve","thirteen" ,"fourteen","fifteen","sixteen","seventeen","eighteen","nineteen"]
two_digits  =["","","twenty","thirty","fourty","fithy","sixty","seventy","eighty","ninety"]
ten_power = ["hundred","thousand"]
data = []

def cardinalNum(number):
    if len (str(number)) == 1 :
        return single_digit[number]
    elif len (str(number)) == 2 :
        if str(number)[0] == "1" :
            return ten_to_nineteen[int(str(number)[1])]
        else:
            return two_digits[int(str(number)[0])] + " " + single_digit[int(str(number)[1])]
    elif len (str(number)) == 3 :
        return   single_digit[int(str(number)[0])] + " " + ten_power[0] + " " +  cardinalNum(int(str(number)[1:3]))
    elif len (str(number)) == 4 :
        return cardinalNum(int(str(number)[0:1])) + " " + ten_power[1] + " " + cardinalNum(int(str(number)[1:4]))
    else:
        return str(number)

def ordinalNum(number):
    if re.match(".*1[0-9]$", str(number)):
        return(str(number) + 'th')
    elif re.match(".*[04-9]$", str(number)):
        return(str(number) + 'th')
    elif re.match(".*1$", str(number)):
        return(str(number) + 'st')
    elif re.match(".*2$", str(number)):
        return(str(number) + 'nd')
    elif re.match(".*3$", str(number)):
        return(str(number) + 'rd')
    else:
        return(str(number))

sparkSession = SparkSession.builder.appName("pyspark-write").getOrCreate()

# Create data
for number in range(1, 9001):
    tmpdata=[ (number) ,( ordinalNum(number)) ,(cardinalNum(number))]
    data.append(tmpdata) 
    #print ( str(number) + ',' + ordinalNum(number) + ',' + cardinalNum(number))

df = sparkSession.createDataFrame(data)

# Write into HDFS
df.write.mode("overwrite").csv("/tmp/testpyspark")

Esempio 4: caricamento dalla cartella DataFrame

%pyspark
spark.sql("CREATE TABLE IF NOT EXISTS pyspark_numbers (number int, Ordinal_Number string, Cardinal_Number string) USING com.databricks.spark.csv OPTIONS \
(path \"/tmp/testpyspark\", header \"false\")")
spark.sql ("describe pyspark_numbers").show()
spark.sql ("select * from pyspark_numbers").show()
spark.sql("select count(*) from pyspark_numbers").show()

Esempio 5: caricamento da un file .csv

%pyspark
spark.sql("CREATE TABLE IF NOT EXISTS pyspark_numbers_from_file (number int, Ordinal_Number string, Cardinal_Number string) ROW FORMAT DELIMITED FIELDS TERMINATED BY ',' LINES TERMINATED BY '\n' ")
spark.sql("load data inpath '/tmp/pysparktestfile.csv' into table pyspark_numbers_from_file")

Per creare il file pysparktestfile.csv, copiare il file generato nell'esempio 3 riportato sopra, ad esempio:

# Command listing files
hdfs dfs  -ls /tmp/testpyspark/

# Output listing files
Found 2 items
-rw-r--r--   3 datastudio supergroup          0 2020-08-21 16:50 /tmp/testpyspark/_SUCCESS
-rw-r--r--  
 3 datastudio supergroup     416250 2020-08-21 16:50 
/tmp/testpyspark/part-00000-5bf7c92a-e2ad-4f79-802e-c84c0c3b4cc0-c000.csv

# Command copying file
hdfs dfs -cp -p /tmp/testpyspark/part-00000-5bf7c92a-e2ad-4f79-802e-c84c0c3b4cc0-c000.csv /tmp/pysparktestfile.csv

Esempio 6: inserimento da una tabella a un'altra

%pyspark
spark.sql("CREATE TABLE IF NOT EXISTS pyspark_numbers_new (number int, Ordinal_Number string, Cardinal_Number string) ")
spark.sql("insert into table pyspark_numbers_new  select * from pyspark_numbers_from_file")
spark.sql("select * from  pyspark_numbers_new").show()
spark.sql("select count(*) from pyspark_numbers_new").show()
spark.sql("select count(*) from pyspark_numbers_from_file").show()

Creazione di versioni di un notebook

È possibile creare una versione di un notebook, che funge da snapshot del notebook al momento della creazione della versione.

Per creare una versione di un notebook:
  1. Accedere all'applicazione notebook. Vedere Accesso a Big Data Studio.
  2. Nella pagina Blocchi appunti aprire il blocco appunti di cui si desidera creare la versione.
  3. Fare clic su Controllo delle versioni in alto a sinistra.
  4. Selezionare Crea versione per creare una nuova versione del blocco note oppure Visualizza cronologia versioni per visualizzare e accedere alle versioni già create.

Esportazione di un notebook

È possibile esportare i notebook dall'applicazione notebook Big Data Studio nel computer locale. Questo include i notebook Jupyter.

Per esportare un notebook:
  1. Accedere all'applicazione notebook. Vedere Accesso a Big Data Studio.
  2. Nella pagina Blocchi note, fare clic sull'icona Seleziona blocchi note.
  3. Selezionare il notebook da esportare.
  4. Fare clic sull'icona Esporta blocchi note in alto a destra.
  5. Modificare le impostazioni, se si desidera, quindi fare clic su Esporta. Il file verrà esportato come file .dsnb.
  6. Scegliere tra le opzioni di esportazione visualizzate, quindi fare clic su OK per procedere con l'esportazione.

Eliminazione di un notebook

È possibile eliminare i notebook per i quali si dispone delle autorizzazioni di eliminazione.

Per eliminare un notebook:
  1. Accedere all'applicazione notebook. Vedere Accesso a Big Data Studio.
  2. Nella pagina Blocchi note, fare clic sull'icona Seleziona blocchi note.
  3. Selezionare il blocco note che si desidera eliminare.
  4. Fare clic sull'icona Elimina blocchi note in alto a destra, quindi fare clic su Elimina per confermare l'azione.

È inoltre possibile eliminare un blocco appunti aprendo il blocco appunti e facendo clic sull'icona Elimina blocco appunti nella parte superiore.

Collegamenti da tastiera per i notebook

È possibile utilizzare i tasti di scelta rapida per eseguire determinate azioni, ad esempio selezionare i paragrafi e duplicare ed esportare i notebook.

Per visualizzare un elenco di collegamenti disponibili, aprire un blocco appunti, fare clic sul proprio nome utente in alto a destra e selezionare Tasti di scelta rapida dal menu. È possibile aprire una panoramica di tutti i collegamenti o cercare i collegamenti. Se ci si trova in una pagina che non dispone di collegamenti, non verrà visualizzata l'opzione Tasti di scelta rapida.

È inoltre possibile cercare i collegamenti premendo ctrl+shift+f.