Esta página se ha traducido con Cloud Translation API.

Conectar Datablocks con BigQuery

En este tutorial se explica cómo conectar una tabla o una vista de BigQuery para leer y escribir datos desde un cuaderno de Databricks. Los pasos se describen con la consolaGoogle Cloud y los espacios de trabajo de Databricks. También puedes seguir estos pasos con las herramientas de línea de comandos gcloud y databricks, aunque no se explican en este tutorial.

Databricks en Google Cloud es un entorno de Databricks alojado en Google Cloud, que se ejecuta en Google Kubernetes Engine (GKE) y proporciona integración integrada con BigQuery y otras tecnologías de Google Cloud . Si no conoces Databricks, consulta el vídeo Introduction to Databricks Unified Data Platform (Introducción a la plataforma de datos unificada de Databricks) para obtener una descripción general de la plataforma de lakehouse de Databricks.

Desplegar Databricks en Google Cloud

Sigue estos pasos para preparar la implementación de Databricks en Google Cloud.

Para configurar tu cuenta de Databricks, sigue las instrucciones de la documentación de Databricks, Configurar tu cuenta de Databricks on Google Cloud.
Después de registrarte, consulta más información sobre cómo gestionar tu cuenta de Databricks.

Crear un espacio de trabajo, un clúster y un cuaderno de Databricks

En los pasos que se incluyen a continuación se describe cómo crear un espacio de trabajo de Databricks, un clúster y un cuaderno de Python para escribir código que acceda a BigQuery.

Confirma los requisitos previos de Databricks.
Crea tu primer espacio de trabajo. En la consola de la cuenta de Databricks, haz clic en Crear espacio de trabajo.
Especifica gcp-bq en Nombre del espacio de trabajo y selecciona tu región.
Para determinar el Google Cloud ID de tu proyecto, ve a la Google Cloud consola y copia el valor en el campo Google Cloud ID de proyecto.

Ir a la Google Cloud consola
Haz clic en Guardar para crear tu espacio de trabajo de Databricks.
Para crear un clúster de Databricks con Databricks Runtime 7.6 o una versión posterior, en la barra de menú de la izquierda, selecciona Clústeres y, a continuación, haz clic en Crear clúster en la parte superior.
Especifica el nombre y el tamaño del clúster, haz clic en Opciones avanzadas y especifica la dirección de correo de tu cuenta de servicio. Google Cloud
Haz clic en Crear clúster.
Para crear un cuaderno de Python para Databricks, sigue las instrucciones que se indican en Crear un cuaderno.

Consultar BigQuery desde Databricks

Con la configuración anterior, puede conectar Databricks con BigQuery de forma segura. Databricks usa una bifurcación del adaptador de Google Spark de código abierto para acceder a BigQuery.

Databricks reduce la transferencia de datos y acelera las consultas al enviar automáticamente a BigQuery determinados predicados de consulta, como el filtrado de columnas anidadas. Además, la función añadida para ejecutar primero una consulta de SQL en BigQuery con la API query() reduce el tamaño de la transferencia del conjunto de datos resultante.

En los pasos que se incluyen a continuación se describe cómo acceder a un conjunto de datos de BigQuery y escribir tus propios datos en BigQuery.

Acceder a un conjunto de datos público en BigQuery

BigQuery proporciona una lista de conjuntos de datos públicos disponibles. Para consultar el conjunto de datos de Shakespeare de BigQuery, que forma parte de los conjuntos de datos públicos, sigue estos pasos:

Para leer la tabla de BigQuery, usa el siguiente fragmento de código en tu cuaderno de Databricks.
```
table = "bigquery-public-data.samples.shakespeare"
df = spark.read.format("bigquery").option("table",table).load()
df.createOrReplaceTempView("shakespeare")
```
Ejecuta el código pulsando Shift+Return.

Ahora puedes consultar tu tabla de BigQuery a través de Spark DataFrame (df). Por ejemplo, usa lo siguiente para mostrar las tres primeras filas del DataFrame:
```
df.show(3)
```
Para consultar otra tabla, actualiza la variable table.
Una de las características principales de los cuadernos de Databricks es que puedes combinar celdas de diferentes lenguajes, como Scala, Python y SQL, en un mismo cuaderno.

La siguiente consulta SQL te permite visualizar el recuento de palabras en Shakespeare después de ejecutar la celda anterior que crea la vista temporal.
```
%sql
SELECT word, SUM(word_count) AS word_count FROM words GROUP BY word ORDER BY word_count DESC LIMIT 12
```
Nota: La salida tiene formato tabular de forma predeterminada. Para cambiarlo a un gráfico de barras, haz clic en el icono de gráfico de barras para seleccionar una de las visualizaciones de Databricks disponibles.

La celda de arriba ejecuta una consulta de Spark SQL en el dataframe de tu clúster de Databricks, no en BigQuery. La ventaja de este enfoque es que el análisis de datos se realiza a nivel de Spark, no se emiten más llamadas a la API de BigQuery y no se incurre en costes adicionales de BigQuery.
Como alternativa, puedes delegar la ejecución de una consulta SQL en BigQuery con la API query() y optimizarla para reducir el tamaño de transferencia del DataFrame resultante. A diferencia del ejemplo anterior, en el que el procesamiento se hizo en Spark, si usas este enfoque, se aplicarán los precios y las optimizaciones de consultas para ejecutar la consulta en BigQuery.

En el ejemplo siguiente se usa Scala, la API query() y el conjunto de datos público de Shakespeare en BigQuery para calcular las cinco palabras más comunes en las obras de Shakespeare. Antes de ejecutar el código, debe crear un conjunto de datos vacío en BigQuery llamado mdataset al que pueda hacer referencia el código. Para obtener más información, consulta el artículo sobre cómo escribir datos en 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)
```
Para ver más ejemplos de código, consulta el cuaderno de ejemplo de Databricks BigQuery.

Escribir datos en BigQuery

Las tablas de BigQuery se encuentran en conjuntos de datos. Antes de poder escribir datos en una tabla de BigQuery, debe crear un conjunto de datos en BigQuery. Para crear un conjunto de datos para un cuaderno de Python de Databricks, sigue estos pasos:

Ve a la página de BigQuery en la Google Cloud consola.

Ir a BigQuery
Abre la opción Acciones, haz clic en Crear conjunto de datos y, a continuación, ponle un nombre together.
En el cuaderno de Python de Databricks, crea un dataframe de Spark sencillo a partir de una lista de Python con tres entradas de cadena mediante el siguiente fragmento de código:
```
from pyspark.sql.types import StringType
mylist = ["Google", "Databricks", "better together"]

df = spark.createDataFrame(mylist, StringType())
```
Añade otra celda al cuaderno para escribir el dataframe de Spark del paso anterior en la tabla de BigQuery myTable del conjunto de datos together. La tabla se crea o se sobrescribe. Usa el nombre del cubo que has especificado antes.
```
bucket = YOUR_BUCKET_NAME
table = "together.myTable"

df.write
  .format("bigquery")
  .option("temporaryGcsBucket", bucket)
  .option("table", table)
  .mode("overwrite").save()
```
Para verificar que has escrito los datos correctamente, consulta y muestra tu tabla de BigQuery a través del DataFrame de Spark (df):
```
display(spark.read.format("bigquery").option("table", table).load)
```