Utilizza il plug-in JupyterLab di Dataproc per sessioni batch serverless e di blocco note interattive

Limitazioni e considerazioni di Dataproc Serverless

  • I job Spark vengono eseguiti con l'identità dell'account di servizio, non con l'identità dell'utente che invia l'email.

Prima di iniziare

  1. Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  3. Attiva l'API Dataproc.

    Abilita l'API

  4. Installa Google Cloud CLI.

  5. Per initialize gcloud CLI, esegui questo comando: 

    gcloud init
    6.

  6. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  7. Attiva l'API Dataproc.

    Abilita l'API

  8. Installa Google Cloud CLI.

  9. Per initialize gcloud CLI, esegui questo comando: 

    gcloud init
    10.

Installa il plug-in JupyterLab di Dataproc

Puoi installare e utilizzare il plug-in JupyterLab di Dataproc su una macchina o una VM che ha accesso a servizi Google, come la tua macchina locale o un'istanza VM di Compute Engine.

Per installare il plug-in, procedi nel seguente modo:

  1. Assicurati che Python 3.8+ sia installato sulla macchina. Puoi scaricare e installare Python da python.org/downloads.

    1. Verifica l'installazione di Python 3.8 e versioni successive.

      python3 --version

  2. Installa JupyterLab 3.6.3+ sulla macchina.

    pip3 install --upgrade jupyterlab

    1. Verificare l'installazione di JupyterLab 3.6.3 o versioni successive.

      pip3 show jupyterlab

  3. Installa il plug-in JupyterLab di Dataproc.

    pip3 install dataproc-jupyter-plugin

    1. Se la tua versione di JupyterLab è precedente a 4.0.0, abilita l'estensione del plug-in.

      jupyter server extension enable dataproc_jupyter_plugin

  4. Avvia JupyterLab.

    jupyter lab

    1. Nel tuo browser si apre la pagina Avvio app JupyterLab. Contiene una sezione Job e sessioni Dataproc. Può anche contenere le sezioni Blocchi note serverless di Dataproc e Blocchi note del cluster Dataproc se hai accesso ai blocchi note serverless o ai cluster Dataproc di Dataproc con il componente facoltativo Jupyter in esecuzione nel tuo progetto.

    2. Per impostazione predefinita, la sessione Dataproc serverless per Spark Interactive viene eseguita nel progetto e nella regione impostati durante l'esecuzione di gcloud init in Prima di iniziare. Puoi modificare le impostazioni del progetto e della regione per le tue sessioni dalla pagina Impostazioni > Impostazioni Dataproc di JupyterLab.

Creazione di un modello di runtime serverless Dataproc

I modelli di runtime serverless Dataproc (chiamati anche modelli session) contengono impostazioni di configurazione per l'esecuzione di codice Spark in una sessione. Puoi creare e gestire modelli di runtime utilizzando Jupyterlab o gcloud CLI.

JupyterLab

  1. Fai clic sulla scheda New runtime template nella sezione Blocchi note serverless di Dataproc della pagina Avvio app JupyterLab.

  2. Compila il modulo Modello di runtime.

  3. Specifica un Nome visualizzato e una Descrizione, quindi inserisci o conferma le altre impostazioni.

    Note

    • Configurazione di rete: la subnet deve avere l'accesso privato Google abilitato e deve consentire la comunicazione con la subnet su tutte le porte (consulta Dataproc Serverless per la configurazione di rete Spark).

      Se la subnet della rete default per la regione che hai configurato quando hai eseguito gcloud init in Prima di iniziare non è abilitata per l'accesso privato Google:

      • Abilitala per l'accesso privato Google oppure
      • Seleziona un'altra rete con una subnet a livello di regione in cui è abilitato l'accesso privato Google. Puoi modificare la regione utilizzata da Dataproc Serverless dalla pagina Impostazioni > Impostazioni di Dataproc di JupyterLab.

    • Metastore: per utilizzare un servizio Dataproc Metastore nelle tue sessioni, seleziona l'ID, la regione e il servizio del progetto metastore.

    • Tempo di inattività massimo: il tempo massimo di inattività del notebook prima della fine della sessione. Intervallo consentito: da 10 minuti a 336 ore (14 giorni).

    • Tempo massimo della sessione:la durata massima di una sessione prima che venga terminata. Intervallo consentito: da 10 minuti a 336 ore (14 giorni).

    • PHS: puoi selezionare un server di cronologia Spark permanente disponibile per accedere ai log di sessione durante e dopo le sessioni.

    • Proprietà Spark: fai clic su Aggiungi proprietà per ogni proprietà da impostare per le sessioni Spark serverless. Consulta le proprietà di Spark per un elenco delle proprietà Spark supportate e non supportate, tra cui le proprietà di runtime, risorse e scalabilità automatica di Spark.

    • Etichette: fai clic su Aggiungi etichetta per ciascuna etichetta da impostare sulle sessioni Spark serverless.

  4. Puoi visualizzare i modelli di runtime nella pagina Impostazioni > Impostazioni di Dataproc.

    • Puoi eliminare un modello dal menu Azione.

  5. Fai clic su Salva.

  6. Apri e ricarica la pagina Avvio app JupyterLab per visualizzare la scheda dei modelli di blocco note salvato nella pagina Avvio app JupyterLab.

gcloud

  1. Creare un file YAML con la configurazione del tuo modello di runtime.

    YAML semplice

    environmentConfig:
  executionConfig:
    networkUri: default
jupyterSession:
  kernel: PYTHON
  displayName: Team A
labels:
  purpose: testing
description: Team A Development Environment

    YAML complesso

    environmentConfig:
  executionConfig:
    serviceAccount: sa1
    # Choose either networkUri or subnetworkUri
    networkUri: default
    subnetworkUri: subnet
    networkTags:
     - tag1
    kmsKey: key1
    idleTtl: 3600s
    ttl: 14400s
    stagingBucket: staging-bucket
  peripheralsConfig:
    metastoreService: projects/my-project-id/locations/us-central1/services/my-metastore-id
    sparkHistoryServerConfig:
      dataprocCluster: projects/my-project-id/regions/us-central1/clusters/my-cluster-id
jupyterSession:
  kernel: PYTHON
  displayName: Team A
labels:
  purpose: testing
runtimeConfig:
  version: "1.1"
  containerImage: gcr.io/my-project-id/my-image:1.0.1
  properties:
    "p1": "v1"
description: Team A Development Environment

    Se la subnet della rete default per la regione che hai configurato quando hai eseguito gcloud init in Prima di iniziare non è abilitata per l'accesso privato Google:

    • Abilitala per l'accesso privato Google oppure
    • Seleziona un'altra rete con una subnet a livello di regione in cui è abilitato l'accesso privato Google. Puoi modificare la regione utilizzata da Dataproc Serverless dalla pagina Impostazioni > Impostazioni di Dataproc di JupyterLab.

  2. Crea un modello di sessione (runtime) dal tuo file YAML eseguendo il seguente comando gcloud beta dataproc session-templates import localmente o in Cloud Shell:

    gcloud beta dataproc session-templates import TEMPLATE_ID \
    --source=YAML_FILE \
    --project=PROJECT_ID \
    --location=REGION

Avvia e gestisci blocchi note

Dopo aver installato il plug-in JupyterLab di Dataproc, puoi fare clic sulle schede dei modelli nella pagina Avvio app di JupyterLab per:

avvia un blocco note Jupyter su Dataproc serverless

La sezione Blocchi note serverless di Dataproc nella pagina Avvio app JupyterLab mostra le schede dei modelli di blocco note che corrispondono ai modelli di runtime serverless di Dataproc (vedi Creare un modello di runtime serverless di Dataproc).

  1. Fai clic su una scheda per creare una sessione Dataproc serverless e avviare un blocco note. Quando la creazione della sessione è completa e il kernel del blocco note è pronto per l'uso, lo stato del kernel cambia da Unknown a Idle.

  2. Scrivere e testare il codice del blocco note.

    1. Copia e incolla il seguente codice Pi estimation PySpark nella cella del blocco note PySpark, quindi premi Maiusc+Invio per eseguire il codice. 

      import random
    
def inside(p):
    x, y = random.random(), random.random()
    return x*x + y*y < 1
    
count = sc.parallelize(range(0, 10000)) .filter(inside).count()
print("Pi is roughly %f" % (4.0 * count / 10000))

      Risultato blocco note:

  3. Dopo aver creato e utilizzato un blocco note, puoi terminare la sessione del blocco note facendo clic su Chiudi kernel dalla scheda Kernel.

    • Se non termini la sessione, Dataproc la termina alla scadenza del timer di inattività della sessione. Puoi configurare il tempo di inattività della sessione nella configurazione del modello di runtime. Il tempo di inattività predefinito della sessione è di un'ora.

avvia un blocco note su un cluster Dataproc su Compute Engine

Se hai creato un cluster Dataproc su Compute Engine Jupyter, la pagina Avvio app JupyterLab contiene una sezione Blocco note del cluster Dataproc con schede kernel preinstallate.

Per avviare un blocco note Jupyter sul tuo cluster Dataproc su Compute Engine:

  1. Fai clic su una scheda nella sezione Blocco note del cluster Dataproc.

  2. Quando lo stato del kernel passa da Unknown a Idle, puoi iniziare a scrivere ed eseguire il codice del blocco note.

  3. Dopo aver creato e utilizzato un blocco note, puoi terminare la sessione del blocco note facendo clic su Chiudi kernel dalla scheda Kernel.

Gestisci i file di input e di output in Cloud Storage

L'analisi dei dati esplorativi e la creazione di modelli ML spesso implica input e output basati su file. Dataproc Serverless accede a questi file su Cloud Storage.

  • Per accedere al browser Cloud Storage, fai clic sull'icona del browser Cloud Storage nella barra laterale della pagina Avvio app JupyterLab, quindi fai doppio clic su una cartella per visualizzarne i contenuti.

  • Puoi fare clic sui tipi di file supportati da Jupyter per aprirli e modificarli. Le modifiche ai file che salvi vengono scritte in Cloud Storage.

  • Per creare una nuova cartella di Cloud Storage, fai clic sull'icona della nuova cartella, quindi inserisci il nome della cartella.

  • Per caricare file in un bucket Cloud Storage o in una cartella, fai clic sull'icona di caricamento, quindi seleziona i file da caricare.

Sviluppa il codice del blocco note Spark

Dopo aver installato il plug-in JupyterLab di Dataproc, puoi avviare i blocchi note Jupyter dalla pagina Avvio app di JupyterLab per sviluppare il codice dell'applicazione.

Sviluppo di codice PySpark e Python

I cluster Dataproc Serverless e Dataproc su Compute Engine supportano i kernel PySpark. Dataproc su Compute Engine supporta anche i kernel Python.

Sviluppo di codice SQL

Fai clic sulla scheda kernel PySpark nella sezione Blocchi note serverless di Dataproc o Blocco note cluster Dataproc della pagina Avvio app di JupyterLab, per aprire un blocco note PySpark per scrivere ed eseguire codice SQL.

Magic SQL di Spark: poiché il kernel PySpark che avvia Dataproc Serverless Notebooks è precaricato con Spark SQL, invece di utilizzare spark.sql('SQL STATEMENT').show() per racchiudere l'istruzione SQL, puoi digitare %%sparksql magic nella parte superiore di una cella, quindi digitare l'istruzione SQL nella cella.

BigQuery SQL: il connettore Spark di BigQuery consente al codice del blocco note di caricare i dati dalle tabelle BigQuery, di eseguire analisi in Spark e quindi di scrivere i risultati in una tabella BigQuery.

Il runtime di Dataproc Serverless 2.1 include il connettore Spark BigQuery. Se utilizzi Dataproc Serverless 2.0 o un runtime precedente per avviare i blocchi note serverless di Dataproc, puoi installare il connettore BigQuery di Spark aggiungendo la seguente proprietà Spark al tuo modello di runtime Dataproc Serverless:

spark.jars: gs://spark-lib/bigquery/spark-bigquery-with-dependencies_2.12-0.25.2.jar

Sviluppo di codice Scala

I cluster Dataproc su Compute Engine creati con immagini versione 2.0 o successive, 2.1 e successive includono Apache Toree, un kernel Scala per la piattaforma di blocchi note Jupyter che fornisce accesso interattivo a Spark.

  • Fai clic sulla scheda Apache Toree nella sezione Blocco note del cluster Dataproc della pagina Avvio app JupyterLab per aprire un blocco note per lo sviluppo del codice Scala.

Esplora metadati

Se un'istanza Dataproc Metastore (DPMS) è collegata a un modello di runtime Dataproc serverless o a un cluster Dataproc su Compute Engine, lo schema dell'istanza DPMS viene visualizzato in Esplora metadati JupyterLab all'apertura di un blocco note. DPMS è un servizio Hive Metastore (HMS) completamente gestito e scalabile orizzontalmente su Google Cloud.

Per visualizzare i metadati HMS in Esplora metadati:

Per aprire Esplora metadati JupyterLab, fai clic sulla relativa icona nella barra laterale.

Puoi cercare un database, una tabella o una colonna in Esplora metadati. Fai clic sul nome di un database, una tabella o una colonna per visualizzare i metadati associati.

Esegui il deployment del codice

Dopo aver installato il plug-in JupyterLab di Dataproc, puoi utilizzare JupyterLab per:

  • Esegui il codice del tuo blocco note sull'infrastruttura serverless Dataproc

  • Invia job batch all'infrastruttura serverless Dataproc o al cluster Dataproc su Compute Engine.

Esegui codice blocco note su Dataproc serverless

  • Fai clic sull'icona Esegui o premi i tasti Maiusc-Invio per eseguire il codice in una cella del blocco note.

  • Utilizza il menu Esegui per eseguire il codice in una o più celle del blocco note.

Inviare un job batch a Dataproc serverless

  • Fai clic sulla scheda Serverless nella sezione Job e sessioni Dataproc nella pagina Avvio app JupyterLab.

  • Fai clic sulla scheda Batch (Crea batch), quindi su Create Batch (Crea batch) e compila i campi Batch Info (Informazioni batch).

  • Fai clic su Invia per inviare il job.

Invia un job batch a un cluster Dataproc su Compute Engine

  • Fai clic sulla scheda Cluster nella sezione Job e sessioni Dataproc nella pagina Avvio app JupyterLab.

  • Fai clic sulla scheda Job, quindi su Invia job.

  • Seleziona un cluster, quindi compila i campi Job.

  • Fai clic su Invia per inviare il job.

Visualizzare e gestire le risorse

Dopo aver installato il plug-in JupyterLab di Dataproc, puoi visualizzare e gestire Dataproc Serverless e Dataproc su Compute Engine dalla sezione Job e sessioni Dataproc nella pagina Avvio app di JupyterLab.

Fai clic sulla sezione Job e sessioni Dataproc per visualizzare le schede Cluster e Serverless.

Per visualizzare e gestire le sessioni Dataproc Serverless:

  1. Fai clic sulla scheda Serverless.
  2. Fai clic sulla scheda Sessioni e poi su un ID sessione per aprire la pagina Dettagli sessione in modo da visualizzare le proprietà della sessione, visualizzare il log di Google Cloud in Esplora log e terminare una sessione. Nota: viene creata una sessione serverless di Dataproc unica per avviare ogni blocco note serverless di Dataproc.

Per visualizzare e gestire i batch serverless Dataproc:

  1. Fai clic sulla scheda Batch per visualizzare l'elenco dei batch Dataproc serverless nel progetto e nella regione attuali. Fai clic su un ID batch per visualizzare i dettagli del batch.

Per visualizzare e gestire i cluster Dataproc su Compute Engine:

  1. Fai clic sulla scheda Cluster. La scheda Cluster è selezionata per elencare i cluster Dataproc su Compute Engine attivi nel progetto e nella regione attuali. Puoi fare clic sulle icone nella colonna Azioni per avviare, arrestare o riavviare un cluster. Fai clic sul nome di un cluster per visualizzarne i dettagli. Puoi fare clic sulle icone nella colonna Azioni per clonare, arrestare o eliminare un job.

Per visualizzare e gestire i job Dataproc su Compute Engine:

  1. Fai clic sulla scheda Job per visualizzare l'elenco dei job nel progetto corrente. Fai clic su un ID job per visualizzare i dettagli del job.