Utilizzare il connettore Spark BigQuery

Il connettore spark-bigquery viene utilizzato con Apache Spark per leggere e scrivere dati da e in BigQuery. Il connettore sfrutta l'API BigQuery Storage durante la lettura dei dati da BigQuery.

Questo tutorial fornisce informazioni sulla disponibilità del connettore preinstallato e mostra come rendere disponibile una versione specifica del connettore per i job Spark. Il codice di esempio mostra come utilizzare il connettore Spark BigQuery all'interno di un'applicazione Spark.

Utilizza il connettore preinstallato

Il connettore Spark BigQuery è preinstallato ed è disponibile per i job Spark eseguiti su cluster Managed Service for Apache Spark creati con le versioni immagine 2.1 e successive. La versione del connettore preinstallato è elencata nelle pagine di release della versione immagine.

Rendi disponibile una versione specifica del connettore per i job Spark

Se vuoi utilizzare una versione del connettore diversa da quella preinstallata su un cluster con versione immagine 2.1 o successiva o se vuoi installare il connettore su un cluster con versione immagine precedente a 2.1, segui le istruzioni riportate in questa sezione.

Importante: la versione spark-bigquery-connector deve essere compatibile con la versione immagine del cluster Managed Service for Apache Spark. Consulta la matrice di compatibilità delle immagini del connettore con Managed Service for Apache Spark.

Cluster con versione immagine 2.1 e successive

Quando crei un cluster Managed Service for Apache Spark con una versione immagine 2.1 o successiva, specifica la versione del connettore come metadati del cluster.

Esempio di gcloud CLI:

gcloud dataproc clusters create CLUSTER_NAME \
    --region=REGION \
    --image-version=2.2 \
    --metadata=SPARK_BQ_CONNECTOR_VERSION or SPARK_BQ_CONNECTOR_URL\
    other flags

Note:

  • SPARK_BQ_CONNECTOR_VERSION: specifica una versione del connettore. Le versioni del connettore Spark BigQuery sono elencate nella pagina spark-bigquery-connector/releases su GitHub.

    Esempio:

    --metadata=SPARK_BQ_CONNECTOR_VERSION=0.42.1
    
  • SPARK_BQ_CONNECTOR_URL: specifica un URL che rimanda al file jar in Cloud Storage. Puoi specificare l'URL di un connettore elencato nella colonna link in Download e utilizzo del connettore su GitHub o il percorso di una posizione di Cloud Storage in cui hai inserito un file jar del connettore personalizzato.

    Esempi:

    --metadata=SPARK_BQ_CONNECTOR_URL=gs://spark-lib/bigquery/spark-3.5-bigquery-0.42.1.jar
    --metadata=SPARK_BQ_CONNECTOR_URL=gs://PATH_TO_CUSTOM_JAR
    

Cluster con versione immagine 2.0 e precedenti

Puoi rendere disponibile il connettore Spark BigQuery per la tua applicazione in uno dei seguenti modi:

  1. Installa il connettore spark-bigquery nella directory dei jar Spark di ogni nodo utilizzando l'azione di inizializzazione dei connettori Managed Service for Apache Spark quando crei il cluster.

  2. Fornisci l'URL del file jar del connettore quando invii il job al cluster utilizzando la console Cloud de Confiance , gcloud CLI o l'API Managed Service for Apache Spark.

    Console

    Utilizza l'elemento File jar del job Spark nella pagina Invia un job di Managed Service for Apache Spark.

    gcloud

    Utilizza il flag gcloud dataproc jobs submit spark --jars.

    API

    Utilizza il campo SparkJob.jarFileUris.

    Come specificare il file jar del connettore durante l'esecuzione di job Spark su cluster con versione immagine precedente alla 2.0

    • Specifica il file jar del connettore sostituendo le informazioni sulla versione di Scala e del connettore nella seguente stringa URI:
      gs://spark-lib/bigquery/spark-bigquery-with-dependencies_SCALA_VERSION-CONNECTOR_VERSION.jar
      
    • Utilizza Scala 2.12 con le versioni immagine di Managed Service for Apache Spark 1.5+
      gs://spark-lib/bigquery/spark-bigquery-with-dependencies_2.12-CONNECTOR_VERSION.jar
      
      Esempio di gcloud CLI:
      gcloud dataproc jobs submit spark \
          --jars=gs://spark-lib/bigquery/spark-bigquery-with-dependencies_2.12-0.23.2.jar \
          -- job args
      
    • Utilizza Scala 2.11 con le versioni immagine di Managed Service for Apache Spark 1.4 e precedenti:
      gs://spark-lib/bigquery/spark-bigquery-with-dependencies_2.11-CONNECTOR_VERSION.jar
      
      Esempio di gcloud CLI:
      gcloud dataproc jobs submit spark \
          --jars=gs://spark-lib/bigquery/spark-bigquery-with-dependencies_2.11-0.23.2.jar \
          -- job-args
      
  3. Includi il file JAR del connettore nella tua applicazione Spark Scala o Java come dipendenza (consulta Compilazione con il connettore).

Calcola i costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Cloud de Confiance by S3NS:

  • Managed Service for Apache Spark
  • BigQuery
  • Cloud Storage

Leggere e scrivere dati da e in BigQuery

Questo esempio legge i dati da BigQuery in un DataFrame Spark per eseguire un conteggio delle parole utilizzando l'API dell'origine dati standard.

Il connettore legge i dati da BigQuery utilizzando l'API BigQuery Storage Read, che legge direttamente dai file di dati della tabella in modo distribuito.

Il connettore scrive i dati in BigQuery in una delle due modalità: DIRECT o INDIRECT.

  • DIRECT: utilizza l'API BigQuery Storage Write. Ogni esecutore scrive i propri dati e il driver esegue il commit di tutti i dati in attesa nella tabella.
  • INDIRECT: memorizza i dati in una tabella temporanea di Cloud Storage, quindi attiva un job di caricamento BigQuery per copiare i dati in BigQuery in un'unica operazione.

Quando utilizzi la modalità INDIRECT, il connettore tenta di eliminare i file temporanei una volta completata l'operazione di caricamento di BigQuery e di nuovo quando l'applicazione Spark termina. Se il job non va a buon fine, rimuovi manualmente i file temporanei di Cloud Storage rimanenti. In genere, i file BigQuery temporanei si trovano in gs://[bucket]/.spark-bigquery-[jobid]-[UUID].

Configura la fatturazione

Per impostazione predefinita, l'utilizzo dell'API viene fatturato al progetto associato alle credenziali o al account di servizio. Per fatturare un progetto diverso, imposta la seguente configurazione: spark.conf.set("parentProject", "<BILLED-GCP-PROJECT>").

Può anche essere aggiunto a un'operazione di lettura o scrittura, come segue: .option("parentProject", "<BILLED-GCP-PROJECT>").

Esegui il codice

Prima di eseguire questo esempio, crea un set di dati denominato "wordcount_dataset" o modifica il set di dati di output nel codice in un set di dati BigQuery esistente nel tuo progettoCloud de Confiance by S3NS .

Utilizza il comando bq per creare wordcount_dataset:

bq mk wordcount_dataset

Utilizza il comando Google Cloud CLI per creare un bucket Cloud Storage, che verrà utilizzato per l'esportazione in BigQuery:

gcloud storage buckets create gs://[bucket]

Scala

  1. Esamina il codice e sostituisci il segnaposto [bucket] con il bucket Cloud Storage che hai creato in precedenza.
    /*
     * Remove comment if you are not running in spark-shell.
     *
    import org.apache.spark.sql.SparkSession
    val spark = SparkSession.builder()
      .appName("spark-bigquery-demo")
      .getOrCreate()
    */
    
    // Use the Cloud Storage bucket for temporary BigQuery export data used
    // by the connector.
    val bucket = "[bucket]"
    spark.conf.set("temporaryGcsBucket", bucket)
    // Enable reading from BigQuery views and materializing query results.
    spark.conf.set("viewsEnabled", "true")
    spark.conf.set("materializationDataset", "wordcount_dataset")
    
    // Load data in from BigQuery. See
    // https://github.com/GoogleCloudDataproc/spark-bigquery-connector#properties
    // for option information.
    val wordsDF =
      spark.read.bigquery("bigquery-public-data:samples.shakespeare")
      .cache()
    
    wordsDF.createOrReplaceTempView("words")
    
    // Perform word count.
    val wordCountDF = spark.sql(
      "SELECT word, SUM(word_count) AS word_count FROM words GROUP BY word")
    wordCountDF.show()
    wordCountDF.printSchema()
    
    // Saving the data to BigQuery.
    (wordCountDF.write.format("bigquery")
      .save("wordcount_dataset.wordcount_output"))
  2. Esegui il codice sul tuo cluster
    1. Utilizza SSH per connetterti al nodo master del cluster Managed Service for Apache Spark
      1. Vai alla pagina Cluster di Managed Service for Apache Spark nella console Cloud de Confiance , quindi fai clic sul nome del tuo cluster Pagina Cluster Dataproc nella console Cloud.
      2. Nella pagina Dettagli cluster, seleziona la scheda Istanze VM. Quindi, fai clic su SSH a destra del nome del nodo master del cluster> Pagina dei dettagli del cluster Dataproc nella console Cloud.
        Si apre una finestra del browser nella tua home directory sul nodo master
            Connected, host fingerprint: ssh-rsa 2048 ...
            ...
            user@clusterName-m:~$
            
    2. Crea wordcount.scala con l'editor di testo preinstallato vi, vim o nano, quindi incolla il codice Scala dall'elenco di codice Scala
      nano wordcount.scala
        
    3. Avvia il REPL spark-shell.
      $ spark-shell --jars=gs://spark-lib/bigquery/spark-bigquery-latest_2.12.jar
      ...
      Using Scala version ...
      Type in expressions to have them evaluated.
      Type :help for more information.
      ...
      Spark context available as sc.
      ...
      SQL context available as sqlContext.
      scala>
      
    4. Esegui wordcount.scala con il comando :load wordcount.scala per creare la tabella BigQuery wordcount_output. L'elenco di output mostra 20 righe dell'output del conteggio parole.
      :load wordcount.scala
      ...
      +---------+----------+
      |     word|word_count|
      +---------+----------+
      |     XVII|         2|
      |    spoil|        28|
      |    Drink|         7|
      |forgetful|         5|
      |   Cannot|        46|
      |    cures|        10|
      |   harder|        13|
      |  tresses|         3|
      |      few|        62|
      |  steel'd|         5|
      | tripping|         7|
      |   travel|        35|
      |   ransom|        55|
      |     hope|       366|
      |       By|       816|
      |     some|      1169|
      |    those|       508|
      |    still|       567|
      |      art|       893|
      |    feign|        10|
      +---------+----------+
      only showing top 20 rows
      
      root
       |-- word: string (nullable = false)
       |-- word_count: long (nullable = true)
      

      Per visualizzare l'anteprima della tabella di output, apri la pagina BigQuery, seleziona la tabella wordcount_output e fai clic su Anteprima. Visualizza l'anteprima della tabella nella pagina Explorer di BigQuery nella console Cloud.

PySpark

  1. Esamina il codice e sostituisci il segnaposto [bucket] con il bucket Cloud Storage che hai creato in precedenza.
    #!/usr/bin/env python
    
    """BigQuery I/O PySpark example."""
    
    from pyspark.sql import SparkSession
    
    spark = SparkSession \
      .builder \
      .master('yarn') \
      .appName('spark-bigquery-demo') \
      .getOrCreate()
    
    # Use the Cloud Storage bucket for temporary BigQuery export data used
    # by the connector.
    bucket = "[bucket]"
    spark.conf.set('temporaryGcsBucket', bucket)
    # Enable reading from BigQuery views and materializing query results.
    spark.conf.set('viewsEnabled', 'true')
    spark.conf.set('materializationDataset', 'wordcount_dataset')
    
    # Load data from BigQuery.
    words = spark.read.format('bigquery') \
      .load('bigquery-public-data:samples.shakespeare')
    words.createOrReplaceTempView('words')
    
    # Perform word count.
    word_count = spark.sql(
        'SELECT word, SUM(word_count) AS word_count FROM words GROUP BY word')
    word_count.show()
    word_count.printSchema()
    
    # Save the data to BigQuery
    word_count.write.format('bigquery') \
      .save('wordcount_dataset.wordcount_output')
  2. Esegui il codice sul cluster
    1. Utilizza SSH per connetterti al nodo master del cluster Managed Service for Apache Spark
      1. Vai alla pagina Cluster di Managed Service for Apache Spark nella console Cloud de Confiance , quindi fai clic sul nome del tuo cluster Pagina Cluster nella console Cloud.
      2. Nella pagina Dettagli cluster, seleziona la scheda Istanze VM. Quindi, fai clic su SSH a destra del nome del nodo master del cluster Seleziona SSH nella riga del nome del cluster nella pagina dei dettagli del cluster nella console Cloud.
        Si apre una finestra del browser nella tua home directory sul nodo master
            Connected, host fingerprint: ssh-rsa 2048 ...
            ...
            user@clusterName-m:~$
            
    2. Crea wordcount.py con l'editor di testo preinstallato vi, vim o nano, quindi incolla il codice PySpark dall'elenco di codici PySpark
      nano wordcount.py
      
    3. Esegui wordcount con spark-submit per creare la tabella BigQuery wordcount_output. L'elenco di output mostra 20 righe dell'output del conteggio parole.
      spark-submit --jars gs://spark-lib/bigquery/spark-bigquery-latest_2.12.jar wordcount.py
      ...
      +---------+----------+
      |     word|word_count|
      +---------+----------+
      |     XVII|         2|
      |    spoil|        28|
      |    Drink|         7|
      |forgetful|         5|
      |   Cannot|        46|
      |    cures|        10|
      |   harder|        13|
      |  tresses|         3|
      |      few|        62|
      |  steel'd|         5|
      | tripping|         7|
      |   travel|        35|
      |   ransom|        55|
      |     hope|       366|
      |       By|       816|
      |     some|      1169|
      |    those|       508|
      |    still|       567|
      |      art|       893|
      |    feign|        10|
      +---------+----------+
      only showing top 20 rows
      
      root
       |-- word: string (nullable = false)
       |-- word_count: long (nullable = true)
      

      Per visualizzare l'anteprima della tabella di output, apri la pagina BigQuery, seleziona la tabella wordcount_output e fai clic su Anteprima. Visualizza l'anteprima della tabella nella pagina Explorer di BigQuery nella console Cloud.

Suggerimenti per la risoluzione dei problemi

Puoi esaminare i log dei job in Cloud Logging e in Esplora job di BigQuery per risolvere i problemi dei job Spark che utilizzano il connettore BigQuery.

  • I log del driver di Managed Service for Apache Spark contengono una voce BigQueryClient con i metadati di BigQuery che includono jobId:

    ClassNotFoundException INFO BigQueryClient:.. jobId: JobId{project=PROJECT_ID, job=JOB_ID, location=LOCATION}
    
  • Offerte di lavoro BigQuery contenereManaged Service for Apache Spark_job_id EManaged Service for Apache Spark_job_uuid etichette:

    • Logging:
      protoPayload.serviceData.jobCompletedEvent.job.jobConfiguration.labels.dataproc_job_id="JOB_ID"
      protoPayload.serviceData.jobCompletedEvent.job.jobConfiguration.labels.dataproc_job_uuid="JOB_UUID"
      protoPayload.serviceData.jobCompletedEvent.job.jobName.jobId="JOB_NAME"
      
    • Explorer job BigQuery: fai clic su un ID job per visualizzare i dettagli del job in Etichette in Informazioni job.

Passaggi successivi