Se usó la API de Cloud Translation para traducir esta página.

Conecta Databricks a BigQuery

En este instructivo, se muestra cómo conectar una vista o tabla de BigQuery para leer y escribir datos desde un notebook de Datalab. Los pasos se describen con la consola deGoogle Cloud y los Databricks Workspaces. También puedes seguir estos pasos con las herramientas de línea de comandos de gcloud y databricks, aunque esta guía está fuera del alcance de este instructivo.

Databricks en Google Cloud es un entorno de Databricks alojado en Google Cloud, que se ejecuta en Google Kubernetes Engine (GKE) y que proporciona integración incorporada a BigQuery y otras tecnologías de Google Cloud . Si no estás familiarizado con Databricks, mira el video Introduction to Databricks Unified Data Platform para obtener una descripción general de la plataforma de lakehouse de Databricks.

Implementa Databricks en Google Cloud

Completa los siguientes pasos para prepararte para implementar Databricks en Google Cloud.

Para configurar tu cuenta de Databricks, sigue las instrucciones en la documentación de Databricks, Configura tu cuenta de Databricks en Google Cloud.
Después de registrarte, obtén más información para administrar tu cuenta de Databricks.

Crea un lugar de trabajo, un clúster y un notebook de Databricks

En los pasos siguientes, se describe cómo crear un lugar de trabajo de Databricks, un clúster y un notebook de Python para escribir el código a fin de acceder a BigQuery.

Confirma los requisitos de Databrick.
Crea tu primer lugar de trabajo. En la consola de la cuenta de Databricks, haz clic en Crear lugares de trabajo.
Especifica gcp-bq para el Nombre del lugar de trabajo y selecciona tu Región.
Para determinar el ID de tu proyecto Google Cloud , visita la consola Google Cloud y, luego, copia el valor en el campo ID del proyectoGoogle Cloud .

Ir a la Google Cloud consola
Haz clic en Guardar para crear tu lugar de trabajo de Databricks.
Para crear un clúster de Databricks con el entorno de ejecución de Databricks 7.6 o una versión posterior, en la barra de menú de la izquierda, selecciona Clústeres y, luego, haz clic en Crear clúster en la parte superior.
Especifica el nombre de tu clúster y su tamaño, luego, haz clic en Opciones avanzadas y especifica las direcciones de correo electrónico de tu cuenta de servicio de Google Cloud.
Haz clic en Crear clúster.
A fin de crear un notebook de Python para Databricks, sigue las instrucciones en Create a notebook.

Consulta BigQuery desde Databricks

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

Databricks reduce la transferencia de datos y acelera las consultas por medio de la eliminación automática de ciertos predicados de consulta, por ejemplo, el filtrado en columnas anidadas a BigQuery. Además, la capacidad adicional de ejecutar primero una consulta de SQL en BigQuery con la API de query() reduce el tamaño de transferencia del conjunto de datos resultante.

En los siguientes pasos, se describe cómo acceder a un conjunto de datos en BigQuery y escribir tus propios datos en BigQuery.

Accede a un conjunto de datos públicos en BigQuery

BigQuery proporciona una lista de los conjuntos de datos públicos disponibles. Para consultar el conjunto de datos de BigQuery Shakespeare, 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 notebook de Databricks.
```
table = "bigquery-public-data.samples.shakespeare"
df = spark.read.format("bigquery").option("table",table).load()
df.createOrReplaceTempView("shakespeare")
```
Para ejecutar el código, presiona Shift+Return.

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

En la siguiente consulta de SQL, se puede 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: El resultado está en formato tabular de forma predeterminada. Para cambiarla a un gráfico de barras, haz clic en el ícono del grafo de barras a fin de seleccionar entre las visualizaciones disponibles de Databricks.

La celda anterior ejecuta una consulta de Spark SQL en el marco de datos de tu clúster de Databricks, no en BigQuery. El beneficio de este enfoque es que el análisis de datos se produce en un nivel de Spark, no se emiten más llamadas a la API de BigQuery y no se generan costos adicionales de BigQuery.
Como alternativa, puedes delegar la ejecución de una consulta de SQL a BigQuery con la API de query() y optimizar para reducir el tamaño de transferencia del marco de datos resultante. A diferencia del ejemplo anterior, en el que el procesamiento se realizó en Spark, si usas este enfoque, los precios y las optimizaciones de consultas se aplican para ejecutar la consulta en BigQuery.

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

Escribe datos en BigQuery

Las tablas de BigQuery existen en los conjuntos de datos. Antes de poder escribir datos en una tabla de BigQuery, debes crear un conjunto de datos nuevo en BigQuery. Si deseas crear un conjunto de datos para un notebook de Python de Databricks, sigue estos pasos:

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

Ir a BigQuery
Expande la opción Acciones, haz clic en Crear conjunto de datos (Create dataset) y, luego, asígnale el nombre together.
En el notebook de Python de Databricks, crea un marco de datos de Spark simple desde una lista de Python con tres entradas de string mediante el siguiente fragmento de código:
```
from pyspark.sql.types import StringType
mylist = ["Google", "Databricks", "better together"]

df = spark.createDataFrame(mylist, StringType())
```
Agrega otra celda a tu notebook que escriba el marco de datos de Spark del paso anterior en la tabla myTable de BigQuery en el conjunto de datos together. La tabla se creará o se reemplazará. Usa el nombre de bucket que especificaste antes.
```
bucket = YOUR_BUCKET_NAME
table = "together.myTable"

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