Questa pagina è stata tradotta dall'API Cloud Translation.

Connessione di Databricks a BigQuery

Questo tutorial mostra come connettere una tabella o una vista BigQuery per leggere e scrivere dati da un notebook Databricks. I passaggi sono descritti utilizzando la consoleGoogle Cloud e Databricks Workspaces. Puoi eseguire questi passaggi anche utilizzando gli strumenti a riga di comando gcloud e databricks, anche se queste indicazioni non rientrano nell'ambito di questo tutorial.

Databricks su Google Cloud è un ambiente Databricks ospitato su Google Cloud, in esecuzione su Google Kubernetes Engine (GKE) e che fornisce l'integrazione integrata con BigQuery e altre tecnologie Google Cloud . Se non hai mai utilizzato Databricks, guarda il video Introduzione alla piattaforma di dati unificata Databricks per una panoramica della piattaforma lakehouse Databricks.

Esegui il deployment di Databricks su Google Cloud

Completa i seguenti passaggi per prepararti a eseguire il deployment di Databricks su Google Cloud.

Per configurare l'account Databricks, segui le istruzioni nella documentazione di Databricks, Configurare l'account Databricks su Google Cloud.
Dopo la registrazione, scopri di più su come gestire il tuo account Databricks.

Crea uno spazio di lavoro, un cluster e un blocco note Databricks

I seguenti passaggi descrivono come creare uno spazio di lavoro Databricks, un cluster e un notebook Python per scrivere codice per accedere a BigQuery.

Conferma i prerequisiti di Databricks.
Crea il tuo primo workspace. Nella console dell'account Databricks, fai clic su Crea spazio di lavoro.
Specifica gcp-bq per il nome dello spazio di lavoro e seleziona la regione.
Per determinare l' Google Cloud ID progetto, visita la Google Cloud console, quindi copia il valore nel campo Google Cloud ID progetto.

Vai alla console Google Cloud
Fai clic su Salva per creare lo spazio di lavoro Databricks.
Per creare un cluster Databricks con Databricks Runtime 7.6 o versioni successive, seleziona Cluster nella barra dei menu a sinistra, quindi fai clic su Crea cluster in alto.
Specifica il nome del cluster e le sue dimensioni, quindi fai clic su Opzioni avanzate e specifica l'indirizzo email del tuo Google Cloud account di servizio.
Fai clic su Crea cluster.
Per creare un notebook Python per Databricks, segui le istruzioni riportate in Creare un notebook.

Esecuzione di query su BigQuery da Databricks

Con la configurazione precedente, puoi connettere in modo sicuro Databricks a BigQuery. Databricks utilizza un fork dell'adattatore Google Spark open source per accedere a BigQuery.

Databricks riduce il trasferimento di dati e accelera le query eseguendo automaticamente il push down di determinati predicati di query, ad esempio il filtro sulle colonne nidificate, in BigQuery. Inoltre, la funzionalità aggiuntiva per eseguire prima una query SQL su BigQuery con l'API query() riduce le dimensioni del trasferimento del set di dati risultante.

I seguenti passaggi descrivono come accedere a un set di dati in BigQuery e scrivere i tuoi dati in BigQuery.

Accedere a un set di dati pubblico su BigQuery

BigQuery fornisce un elenco di set di dati pubblici disponibili. Per eseguire query sul set di dati BigQuery Shakespeare che fa parte dei set di dati pubblici, segui questi passaggi:

Per leggere la tabella BigQuery, utilizza il seguente snippet di codice nel notebook Databricks.
```
table = "bigquery-public-data.samples.shakespeare"
df = spark.read.format("bigquery").option("table",table).load()
df.createOrReplaceTempView("shakespeare")
```
Esegui il codice premendo Shift+Return.

Ora puoi eseguire query sulla tabella BigQuery tramite Spark DataFrame (df). Ad esempio, utilizza il seguente comando per mostrare le prime tre righe del DataFrame:
```
df.show(3)
```
Per eseguire una query su un'altra tabella, aggiorna la variabile table.
Una funzionalità chiave dei notebook Databricks è la possibilità di combinare le celle di linguaggi diversi come Scala, Python e SQL in un unico notebook.

La seguente query SQL consente di visualizzare il conteggio delle parole in Shakespeare dopo aver eseguito la cella precedente che crea la visualizzazione temporanea.
```
%sql
SELECT word, SUM(word_count) AS word_count FROM words GROUP BY word ORDER BY word_count DESC LIMIT 12
```
Nota: l'output è in formato tabellare per impostazione predefinita. Per passare a un grafico a barre, fai clic sull'icona del grafico a barre per selezionare una delle visualizzazioni Databricks disponibili.

La cella precedente esegue una query Spark SQL sul dataframe nel cluster Databricks, non in BigQuery. Il vantaggio di questo approccio è che l'analisi dei dati avviene a livello di Spark, non vengono emessi ulteriori chiamate API BigQuery e non vengono sostenuti costi BigQuery aggiuntivi.
In alternativa, puoi delegare l'esecuzione di una query SQL a BigQuery con l'API query() e ottimizzare per ridurre le dimensioni del trasferimento del data frame risultante. A differenza dell'esempio precedente, in cui l'elaborazione è stata eseguita in Spark, se utilizzi questo approccio, i prezzi e le ottimizzazioni delle query si applicano all'esecuzione della query su BigQuery.

L'esempio riportato di seguito utilizza Scala, l'API query() e il set di dati pubblico Shakespeare in BigQuery per calcolare le cinque parole più comuni nelle opere di Shakespeare. Prima di eseguire il codice, devi prima creare un set di dati vuoto in BigQuery chiamato mdataset a cui il codice può fare riferimento. Per ulteriori informazioni, consulta Scrittura di dati in BigQuery.
```
%scala
// public dataset
val table = "bigquery-public-data.samples.shakespeare"

// existing dataset where the Google Cloud user has table creation permission
val tempLocation = "mdataset"
// query string
val q = s"""SELECT word, SUM(word_count) AS word_count FROM ${table}
    GROUP BY word ORDER BY word_count DESC LIMIT 10 """

// read the result of a GoogleSQL query into a DataFrame
val df2 =
  spark.read.format("bigquery")
  .option("query", q)
  .option("materializationDataset", tempLocation)
  .load()

// show the top 5 common words in Shakespeare
df2.show(5)
```
Per altri esempi di codice, consulta il notebook di esempio BigQuery di Databricks.

Scrivere dati in BigQuery

Le tabelle BigQuery esistono nei set di dati. Prima di poter scrivere dati in una tabella BigQuery, devi creare un nuovo set di dati in BigQuery. Per creare un set di dati per un notebook Python Databricks, segui questi passaggi:

Vai alla pagina BigQuery nella console Google Cloud .

Vai a BigQuery
Espandi l'opzione Azioni, fai clic su Crea set di dati e poi assegna un nome together.

Nel notebook Python di Databricks, crea un semplice dataframe Spark da un elenco Python con tre voci stringa utilizzando il seguente snippet di codice:

from pyspark.sql.types import StringType
mylist = ["Google", "Databricks", "better together"]

df = spark.createDataFrame(mylist, StringType())

Aggiungi un'altra cella al notebook che scrive il dataframe Spark dal passaggio precedente nella tabella BigQuery myTable nel set di dati together. La tabella viene creata o sovrascritta. Utilizza il nome del bucket specificato in precedenza.
```
bucket = YOUR_BUCKET_NAME
table = "together.myTable"

df.write
  .format("bigquery")
  .option("temporaryGcsBucket", bucket)
  .option("table", table)
  .mode("overwrite").save()
```
Per verificare di aver scritto correttamente i dati, esegui una query e visualizza la tabella BigQuery tramite Spark DataFrame (df):
```
display(spark.read.format("bigquery").option("table", table).load)
```