Esegui il codice PySpark nei notebook di BigQuery Studio

Puoi creare una sessione Spark in un blocco note di BigQuery Studio per utilizzare il codice PySpark per analizzare e trasformare i dati su scala più ampia. L'utilizzo di questa integrazione gestita ti consente di aggiungere dinamicamente pacchetti Python ed elaborare set di dati di grandi dimensioni senza uscire dall'ambiente del notebook.

Prima di iniziare

Se non l'hai ancora fatto, crea un progetto Google Cloud e un bucket Cloud Storage.

1. Configurare il progetto

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

      Roles required to select or create a project

      • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
      • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.
      Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

      Go to project selector

   2. Enable the Managed Service for Apache Spark, BigQuery, and Cloud Storage APIs, if any are not already enabled.

      Roles required to enable APIs

      To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). Learn how to grant roles.

      Enable the APIs

2. Crea un bucket Cloud Storage nel tuo progetto se non ne hai uno che puoi utilizzare.

3. Configura il notebook

   • Credenziali del notebook: per impostazione predefinita, la sessione del notebook utilizza le tue credenziali utente. In alternativa, può utilizzare le credenziali del service account di sessione.
     • Credenziali utente: il tuo account utente deve disporre dei seguenti ruoli Identity and Access Management:
       • Dataproc Editor (ruolo roles/dataproc.editor)
       • BigQuery Studio User (ruolo roles/bigquery.studioUser)
       • Ruolo Service Account User (roles/iam.serviceAccountUser) sul service account di sessione. Questo ruolo contiene l'autorizzazione iam.serviceAccounts.actAs richiesta per simulare l'identità del account di servizio.
     • Credenziali del service account: se vuoi specificare le credenziali del account di servizio anziché quelle dell'utente per la sessione del blocco note, il service account della sessione deve avere il seguente ruolo:
       • Dataproc Worker (ruolo roles/dataproc.worker)
   • Runtime del notebook: il notebook utilizza un runtime predefinito di Gemini Enterprise Agent Platform, a meno che non selezioni un runtime diverso. Se vuoi definire il tuo runtime, crealo dalla pagina Runtime nella console Google Cloud . Nota: quando utilizzi la libreria NumPy, utilizza la versione 1.26 di NumPy, supportata da Spark 3.5, nel runtime del notebook.

Prezzi

Per informazioni sui prezzi, consulta Prezzi del runtime dei blocchi note di BigQuery.

Apri un notebook Python di BigQuery Studio

1. Nella console Google Cloud , vai alla pagina BigQuery.

   Vai a BigQuery

2. Nella barra delle schede del riquadro dei dettagli, fai clic sulla freccia accanto al segno +, quindi fai clic su Notebook.

Crea una sessione Spark in un notebook BigQuery Studio

Puoi utilizzare un notebook Python di BigQuery Studio per creare una sessione interattiva di Spark Connect. A ogni notebook di BigQuery Studio può essere associata una sola sessione Spark attiva.

Puoi creare una sessione Spark in un notebook Python di BigQuery Studio nei seguenti modi:

• Configura e crea una singola sessione nel notebook.
• Configura una sessione Spark in un template di sessione interattiva, quindi utilizza il template per configurare e creare una sessione nel notebook. BigQuery fornisce una funzionalità Query using Spark che ti aiuta a iniziare a programmare la sessione basata su modelli, come spiegato nella scheda Sessione Spark basata su modelli.

Sessione singola

Per creare una sessione Spark in un nuovo notebook, segui questi passaggi:

1. Nella barra delle schede del riquadro dell'editor, fai clic sulla freccia menu a discesa accanto al segno +, quindi fai clic su Notebook.

   

2. Copia ed esegui il seguente codice in una cella del notebook per configurare e creare una sessione Spark di base.

from google.cloud.dataproc_spark_connect import DataprocSparkSession
from google.cloud.dataproc_v1 import Session

import pyspark.sql.functions as f

session = Session()

# Create the Spark session.
spark = (
   DataprocSparkSession.builder
     .appName("APP_NAME")
     .dataprocSessionConfig(session)
     .getOrCreate()
)

Sostituisci quanto segue:

• APP_NAME: un nome facoltativo per la sessione.
• Impostazioni facoltative della sessione: puoi aggiungere le impostazioni dell'API Managed Service for Apache Spark Session per personalizzare la sessione. Ecco alcuni esempi:
  • RuntimeConfig:

    

    • session.runtime_config.properties={spark.property.key1:VALUE_1,...,spark.property.keyN:VALUE_N}
    • session.runtime_config.container_image = path/to/container/image
  • EnvironmentConfig:

    

    • session.environment_config.execution_config.subnetwork_uri = "SUBNET_NAME"
    • session.environment_config.execution_config.ttl = {"seconds": VALUE}
    • session.environment_config.execution_config.service_account = SERVICE_ACCOUNT

Sessione Spark basata su template

Puoi inserire ed eseguire il codice in una cella del notebook per creare una sessione Spark basata su un modello di sessione esistente. Le impostazioni di configurazione di session fornite nel codice del notebook sostituiranno le stesse impostazioni configurate nel template di sessione.

Per iniziare rapidamente, utilizza il modello Query using Spark per precompilare il notebook con il codice del modello di sessione Spark:

1. Nella barra delle schede del riquadro dell'editor, fai clic sulla freccia menu a discesa accanto al segno +, quindi fai clic su Notebook.

   

2. In Inizia con un modello, fai clic su Esegui query utilizzando Spark, quindi su Utilizza modello per inserire il codice nel notebook.

   

3. Specifica le variabili come spiegato nelle Note.
4. Puoi eliminare eventuali celle di codice campione aggiuntive inserite nel notebook.

from google.cloud.dataproc_spark_connect import DataprocSparkSession
from google.cloud.dataproc_v1 import Session
session = Session()
project_id = "PROJECT_ID"
location = "LOCATION"
# Configure the session with an existing session template.
session_template = "SESSION_TEMPLATE"
session.session_template = f"projects/{project_id}/locations/{location}/sessionTemplates/{session_template}"
# Create the Spark session.
spark = (
   DataprocSparkSession.builder
     .appName("APP_NAME")
     .dataprocSessionConfig(session)
     .getOrCreate()
)

Sostituisci quanto segue:

• PROJECT_ID: l'ID progetto, elencato nella sezione Informazioni sul progetto della dashboard della consoleGoogle Cloud .
• LOCATION: la regione di Compute Engine in cui verrà eseguita la sessione del notebook. Se non viene fornita, verrà utilizzata la regione della VM che crea il notebook.

• SESSION_TEMPLATE: il nome di un template di sessione interattiva esistente. Le impostazioni di configurazione della sessione vengono ottenute dal template. Il template deve inoltre specificare le seguenti impostazioni:

  • Versione runtime 2.3+

  • Tipo di notebook: Spark Connect

    Esempio:

    

• APP_NAME: un nome facoltativo per la sessione.

Scrivi ed esegui il codice PySpark nel tuo notebook di BigQuery Studio

Dopo aver creato una sessione Spark nel notebook, utilizzala per eseguire il codice del notebook Spark nel notebook.

Supporto dell'API PySpark di Spark Connect: la sessione del notebook di Spark Connect supporta la maggior parte delle API PySpark, tra cui DataFrame, Functions e Column, ma non supporta SparkContext, RDD e altre API PySpark. Per saperne di più, consulta Che cosa è supportato in Spark 3.5.

Suggerimento: puoi consultare il Riferimento API Spark SQL per scoprire se Spark Connect supporta un'API. La documentazione di un'API supportata contiene il messaggio "Supporta Spark Connect":

Scritture dirette del notebook Spark Connect: le sessioni Spark in un notebook BigQuery Studio preconfigurano il connettore Spark BigQuery per eseguire scritture di dati DIRETTE. Il metodo di scrittura DIRECT utilizza l'API BigQuery Storage Write, che scrive i dati direttamente in BigQuery; il metodo di scrittura INDIRECT, che è l'impostazione predefinita per i batch di Managed Service for Apache Spark, scrive i dati in un bucket Cloud Storage intermedio, quindi scrive i dati in BigQuery (per ulteriori informazioni sulle scritture INDIRECT, consulta Leggi e scrivi dati da e in BigQuery).

API specifiche di Managed Service for Apache Spark: Managed Service for Apache Spark semplifica l'aggiunta dinamica di pacchetti PyPI alla tua sessione Spark estendendo il metodo addArtifacts. Puoi specificare l'elenco nel formato version-scheme (simile a pip install). In questo modo, il server Spark Connect installa i pacchetti e le relative dipendenze su tutti i nodi del cluster, rendendoli disponibili ai worker per le tue UDF.

Esempio che installa la versione textdistance specificata e le librerie random2 compatibili più recenti sul cluster per consentire l'esecuzione delle UDF che utilizzano textdistance e random2 sui nodi worker.

spark.addArtifacts("textdistance==4.6.1", "random2", pypi=True)

Guida al codice del notebook: il notebook di BigQuery Studio fornisce assistenza per il codice quando tieni il puntatore sul nome di una classe o di un metodo e fornisce assistenza per il completamento del codice durante l'inserimento.

Nell'esempio seguente, l'inserimento di DataprocSparkSession e il posizionamento del puntatore sul nome di questa classe mostrano il completamento del codice e la guida alla documentazione.

Suggerimento: consulta Dataproc Spark Connect Client su GitHub per informazioni sull'utilizzo dei metodi DataprocSparkSession.builder per configurare le sessioni di Spark Connect.

Esempi di PySpark per i notebook BigQuery Studio

Questa sezione fornisce esempi di notebook Python di BigQuery Studio con codice PySpark per eseguire le seguenti attività:

• Eseguire un conteggio delle parole su un set di dati pubblico di Shakespeare.
• Crea una tabella Iceberg con i metadati salvati nel catalogo di runtime Lakehouse.

Wordcount

L'esempio di PySpark seguente crea una sessione Spark, quindi conta le occorrenze delle parole in un set di dati bigquery-public-data.samples.shakespeare pubblico.

# Basic wordcount example
from google.cloud.dataproc_spark_connect import DataprocSparkSession
from google.cloud.dataproc_v1 import Session
import pyspark.sql.functions as f
session = Session()

# Create the Spark session.
spark = (
   DataprocSparkSession.builder
     .appName("APP_NAME")
     .dataprocSessionConfig(session)
     .getOrCreate()
)
# Run a wordcount on the public Shakespeare dataset.
df = spark.read.format("bigquery").option("table", "bigquery-public-data.samples.shakespeare").load()
words_df = df.select(f.explode(f.split(f.col("word"), " ")).alias("word"))
word_counts_df = words_df.filter(f.col("word") != "").groupBy("word").agg(f.count("*").alias("count")).orderBy("word")
word_counts_df.show()

Sostituisci quanto segue:

• APP_NAME: un nome facoltativo per la sessione.

Output:

L'output della cella elenca un esempio dell'output del conteggio parole. Per visualizzare i dettagli della sessione nella console Google Cloud , fai clic sul link Visualizzazione dettagliata della sessione interattiva. Si apre un riquadro dei dettagli di Spark che fornisce schede per Log, Esecutori, SQL e Job (inclusa una cronologia degli eventi). Per monitorare la sessione Spark, fai clic su Visualizza UI di Spark nella pagina dei dettagli della sessione.

Interactive Session Detail View: LINK
+------------+-----+
|        word|count|
+------------+-----+
|           '|   42|
|       ''All|    1|
|     ''Among|    1|
|       ''And|    1|
|       ''But|    1|
|    ''Gamut'|    1|
|       ''How|    1|
|        ''Lo|    1|
|      ''Look|    1|
|        ''My|    1|
|       ''Now|    1|
|         ''O|    1|
|      ''Od's|    1|
|       ''The|    1|
|       ''Tis|    4|
|      ''When|    1|
|       ''tis|    1|
|      ''twas|    1|
|          'A|   10|
|'ARTEMIDORUS|    1|
+------------+-----+
only showing top 20 rows

Tabella Iceberg

Esegui il codice PySpark per creare una tabella Iceberg con i metadati del catalogo di runtime Lakehouse

Il seguente codice di esempio crea un sample_iceberg_table con i metadati della tabella archiviati nel catalogo di runtime Lakehouse, quindi esegue una query sulla tabella.

from google.cloud.dataproc_spark_connect import DataprocSparkSession
from google.cloud.dataproc_v1 import Session
# Create the Dataproc Serverless session.
session = Session()
# Set the session configuration for BigLake Metastore with the Iceberg environment.
project_id = "PROJECT_ID"
region = "REGION"
subnet_name = "SUBNET_NAME"
location = "LOCATION"
session.environment_config.execution_config.subnetwork_uri = f"{subnet_name}"
warehouse_dir = "gs://BUCKET/WAREHOUSE_DIRECTORY"
catalog = "CATALOG"
namespace = "NAMESPACE"
session.runtime_config.properties[f"spark.sql.catalog.{catalog}"] = "org.apache.iceberg.spark.SparkCatalog"
session.runtime_config.properties[f"spark.sql.catalog.{catalog}.catalog-impl"] = "org.apache.iceberg.gcp.bigquery.BigQueryMetastoreCatalog"
session.runtime_config.properties[f"spark.sql.catalog.{catalog}.gcp_project"] = f"{project_id}"
session.runtime_config.properties[f"spark.sql.catalog.{catalog}.gcp_location"] = f"{location}"
session.runtime_config.properties[f"spark.sql.catalog.{catalog}.warehouse"] = f"{warehouse_dir}"
# Create the Spark Connect session.
spark = (
   DataprocSparkSession.builder
     .appName("APP_NAME")
     .dataprocSessionConfig(session)
     .getOrCreate()
)
# Create the namespace in BigQuery.
spark.sql(f"USE `{catalog}`;")
spark.sql(f"CREATE NAMESPACE IF NOT EXISTS `{namespace}`;")
spark.sql(f"USE `{namespace}`;")
# Create the Iceberg table.
spark.sql("DROP TABLE IF EXISTS `sample_iceberg_table`");
spark.sql("CREATE TABLE sample_iceberg_table (id int, data string) USING ICEBERG;")
spark.sql("DESCRIBE sample_iceberg_table;")
# Insert table data and query the table.
spark.sql("INSERT INTO sample_iceberg_table VALUES (1, \"first row\");")
# Alter table, then query and display table data and schema.
spark.sql("ALTER TABLE sample_iceberg_table ADD COLUMNS (newDoubleCol double);")
spark.sql("DESCRIBE sample_iceberg_table;")
df = spark.sql("SELECT * FROM sample_iceberg_table")
df.show()
df.printSchema()

Note:

• PROJECT_ID: l'ID progetto, elencato nella sezione Informazioni sul progetto della dashboard della consoleGoogle Cloud .
• REGION e SUBNET_NAME: specifica la regione di Compute Engine e il nome di una subnet nella regione della sessione. Managed Service for Apache Spark attiva l'accesso privato Google (PGA) sulla subnet specificata.
• LOCATION: la BigQuery_metastore_config.location e la spark.sql.catalog.{catalog}.gcp_location predefinite sono US, ma puoi scegliere qualsiasi località BigQuery supportata.
• BUCKET e WAREHOUSE_DIRECTORY: il bucket Cloud Storage e la cartella utilizzati per la directory del warehouse Iceberg.
• CATALOG e NAMESPACE: il nome e lo spazio dei nomi del catalogo Iceberg si combinano per identificare la tabella Iceberg (catalog.namespace.table_name).
• APP_NAME: un nome facoltativo per la sessione.

L'output della cella elenca sample_iceberg_table con la colonna aggiunta e visualizza un link alla pagina Dettagli sessione interattiva nella console Google Cloud . Si apre un riquadro dei dettagli di Spark che fornisce schede per Log, Esecutori, SQL e Job (inclusa una cronologia degli eventi). Puoi fare clic su Visualizza UI di Spark nella pagina dei dettagli della sessione per monitorare la sessione Spark.

Interactive Session Detail View: LINK
+---+---------+------------+
| id|     data|newDoubleCol|
+---+---------+------------+
|  1|first row|        NULL|
+---+---------+------------+

root
 |-- id: integer (nullable = true)
 |-- data: string (nullable = true)
 |-- newDoubleCol: double (nullable = true)

Visualizza i dettagli della tabella in BigQuery

Per controllare i dettagli della tabella Iceberg in BigQuery, segui questi passaggi:

1. Nella console Google Cloud , vai alla pagina BigQuery.

   Vai a BigQuery

2. Nel riquadro delle risorse del progetto, fai clic sul progetto, quindi sul tuo spazio dei nomi per elencare la tabella sample_iceberg_table. Fai clic sulla tabella Dettagli per visualizzare le informazioni di Apri la configurazione della tabella del catalogo.

   I formati di input e output sono i formati di classe Hadoop InputFormat e OutputFormat standard utilizzati da Iceberg.

   

Altri esempi

Crea un DataFrame Spark (sdf) da un DataFrame Pandas (df).

sdf = spark.createDataFrame(df)
sdf.show()

Esegui aggregazioni su Spark DataFrames.

from pyspark.sql import functions as f

sdf.groupby("segment").agg(
   f.mean("total_spend_per_user").alias("avg_order_value"),
   f.approx_count_distinct("user_id").alias("unique_customers")
).show()

Leggi da BigQuery utilizzando il connettore Spark-BigQuery.

spark.conf.set("viewsEnabled","true")
spark.conf.set("materializationDataset","my-bigquery-dataset")

sdf = spark.read.format('bigquery') \
 .load(query)

Scrivi codice Spark con Gemini Code Assist

Anteprima

Questo prodotto o questa funzionalità sono soggetti ai "Termini dell'offerta pre-GA" nella sezione Termini di servizio generali dei Termini specifici dei servizi. I prodotti e le funzionalità pre-GA sono disponibili "così come sono" e potrebbero avere un supporto limitato. Per ulteriori informazioni, consulta le descrizioni della fase di lancio.

Puoi chiedere a Gemini Code Assist di generare codice PySpark nel tuo notebook. Gemini Code Assist recupera e utilizza le tabelle BigQuery e Dataproc Metastore pertinenti e i relativi schemi per generare una risposta di codice.

Per generare il codice di Gemini Code Assist nel tuo notebook, segui questi passaggi:

1. Inserisci una nuova cella di codice facendo clic su + Codice nella barra degli strumenti. La nuova cella di codice mostra Start coding or generate with AI. Fai clic su Genera.

2. Nell'editor Genera, inserisci un prompt in linguaggio naturale, quindi fai clic su enter. Assicurati di includere la parola chiave spark o pyspark nel prompt.

   Prompt di esempio:

   create a spark dataframe from order_items and filter to orders created in 2024
   

   Esempio di output:

   spark.read.format("bigquery").option("table", "sqlgen-testing.pysparkeval_ecommerce.order_items").load().filter("year(created_at) = 2024").createOrReplaceTempView("order_items")
   df = spark.sql("SELECT * FROM order_items")
   

Suggerimenti per la generazione di codice con Gemini Code Assist

• Per consentire a Gemini Code Assist di recuperare tabelle e schemi pertinenti, attiva la sincronizzazione di Data Catalog per le istanze Dataproc Metastore.

• Assicurati che il tuo account utente abbia accesso a Knowledge Catalog, alle tabelle di query. Per farlo, assegna il ruolo Dataplex Catalog Viewer (roles/dataplex.catalogViewer).

Termina la sessione Spark

Puoi eseguire una delle seguenti azioni per interrompere la sessione di Spark Connect nel notebook di BigQuery Studio:

• Esegui spark.stop() in una cella del notebook.
• Termina il runtime nel notebook:
  1. Fai clic sul selettore di runtime, quindi su Gestisci sessioni.

     

  2. Nella finestra di dialogo Sessioni attive, fai clic sull'icona di interruzione, quindi su Interrompi.

     

Orchestra il codice dei notebook BigQuery Studio

Puoi orchestrare il codice dei notebook di BigQuery Studio nei seguenti modi:

• Pianifica il codice del notebook dalla console Google Cloud (si applicano i prezzi dei notebook).

• Esegui il codice del notebook come workload batch (si applicano i prezzi di Managed Service for Apache Spark).

Pianifica il codice del notebook dalla console Google Cloud

Puoi pianificare il codice del notebook nei seguenti modi:

• Pianifica il notebook.
• Se l'esecuzione di codice del notebook fa parte di un workflow, pianifica il notebook come parte di una pipeline.

Esegui il codice del notebook come workload batch

Completa i seguenti passaggi per eseguire il codice del notebook BigQuery Studio come workload batch.

1. Scarica il codice del notebook in un file in un terminale locale o in Cloud Shell.

   Ti consigliamo di scaricare e lavorare in Cloud Shell, poiché preinstalla editor di testo e altri strumenti e fornisce il supporto di Python integrato.

   1. Nella console Google Cloud , nella pagina BigQuery Studio, apri il notebook nel riquadro Explorer.

   2. Per espandere la barra dei menu, fai clic su keyboard_arrow_down Attiva/disattiva visibilità intestazione.

   3. Fai clic su File > Scarica, quindi su Download.py.

      

2. Genera requirements.txt.

   1. Installa pipreqs nella directory in cui hai salvato il file .py.

      pip install pipreqs
      

   2. Esegui pipreqs per generare requirements.txt.

      pipreqs filename.py
      

   3. Utilizza Google Cloud CLI per copiare il file requirements.txt locale in un bucket in Cloud Storage.

      gcloud storage cp requirements.txt gs://BUCKET/
      

3. Aggiorna il codice della sessione Spark modificando il file .py scaricato.

   1. Rimuovi o commenta i comandi dello script shell.

   2. Rimuovi il codice che configura la sessione Spark, quindi specifica i parametri di configurazione come parametri di invio del workload batch. (consulta Invia un workload batch Spark).

      Esempio:

      • Rimuovi la seguente riga di configurazione della subnet della sessione dal codice:

        session.environment_config.execution_config.subnetwork_uri = "{subnet_name}"
        

      • Quando esegui il workload batch, utilizza il flag --subnet per specificare la subnet.

        gcloud dataproc batches submit pyspark \
        --subnet=SUBNET_NAME
        

   3. Utilizza un semplice snippet di codice per la creazione della sessione.

      • Codice del blocco note scaricato di esempio prima della semplificazione.

        from google.cloud.dataproc_spark_connect import DataprocSparkSession
        from google.cloud.dataproc_v1 import Session
        
        session = Session()
        spark = DataprocSparkSession \
            .builder \
            .appName("CustomSparkSession")
            .dataprocSessionConfig(session) \
            .getOrCreate()
        

      • Codice del workload batch dopo la semplificazione.

        from pyspark.sql import SparkSession
        
        spark = SparkSession \
        .builder \
        .getOrCreate()
        

4. Esegui il workload batch.

   1. Per le istruzioni, consulta Invia il workload batch Spark.

      • Assicurati di includere il flag --deps-bucket per puntare al bucket Cloud Storage che contiene il file requirements.txt.

        Esempio:

      gcloud dataproc batches submit pyspark FILENAME.py \
          --region=REGION \
          --deps-bucket=BUCKET \
          --version=2.3
      

      Note:

      • FILENAME: il nome del file di codice del notebook scaricato e modificato.
      • REGION: la regione di Compute Engine in cui si trova il cluster.
      • BUCKET Il nome del bucket Cloud Storage che contiene il file requirements.txt.
      • --version: versione 2.3 del runtime Spark selezionata per eseguire il workload batch.

5. Esegui il commit del codice.

   1. Dopo aver testato il codice del workload batch, puoi eseguire il commit del file .ipynb o .py nel tuo repository utilizzando il tuo client git, come GitHub, GitLab o Bitbucket, nell'ambito della tua pipeline CI/CD.

6. Pianifica il workload batch con Managed Service for Apache Airflow.

   1. Per istruzioni, consulta Esegui i workload di Managed Service for Apache Spark con Managed Airflow.

Risolvere i problemi del Notebook

Se si verifica un errore in una cella contenente codice Spark, puoi risolvere i problemi facendo clic sul link Visualizzazione dettagliata della sessione interattiva nell'output della cella (vedi gli esempi di conteggio delle parole e di tabella Iceberg).

Quando si verifica un errore del codice del notebook, l'accesso all'ultimo job Spark nell'interfaccia utente di Spark spesso fornisce informazioni aggiuntive per aiutarti a eseguire il debug del job non riuscito.

Problemi noti e soluzioni

Errore: un runtime di notebook creato con la versione Python 3.10 può causare un errore PYTHON_VERSION_MISMATCH quando tenta di connettersi alla sessione Spark.

Soluzione: ricrea il runtime con la versione Python 3.11.

Passaggi successivi

• Demo video di YouTube: Sfrutta la potenza di Apache Spark integrato con BigQuery.
• Utilizza il catalogo di runtime di Lakehouse con Managed Service for Apache Spark
• Utilizza il catalogo di runtime di Lakehouse con Managed Service for Apache Spark