Esta página foi traduzida pela API Cloud Translation.

Como conectar o Databricks ao BigQuery

Neste tutorial, mostramos como conectar uma tabela ou visualização do BigQuery para ler e gravar dados de um notebook do Databricks. As etapas são descritas usando o console doGoogle Cloud e os espaços de trabalho do Databricks. Também é possível executar essas etapas usando as ferramentas de linha de comando gcloud e databricks, embora essa orientação esteja fora do escopo deste tutorial.

O Databricks no Google Cloud é um ambiente do Databricks hospedado no Google Cloud, executado no Google Kubernetes Engine (GKE) e que oferece integração interna com o BigQuery e outras tecnologias do Google Cloud . Se você é novo no Databricks, assista ao vídeo Introdução à Databricks Unified Data Platform para ter uma visão geral da plataforma de lakehouse do Databricks.

Implantar o Databricks em Google Cloud

Conclua as etapas a seguir para se preparar para implantar o Databricks no Google Cloud.

Para configurar sua conta do Databricks, siga as instruções na documentação do Databricks, Configurar sua conta do Databricks no Google Cloud.
Depois de se inscrever, saiba mais sobre como Gerenciar sua conta da Databricks.

Crie um espaço de trabalho, um cluster e um notebook do Databricks

Nas etapas a seguir, descrevemos como criar um espaço de trabalho do Databricks, um cluster e um notebook do Python para gravar códigos para acessar o BigQuery.

Confirme os pré-requisitos do Databrick.
Crie seu primeiro espaço de trabalho. No console da conta do Databricks, clique em Criar espaço de trabalho.
Especifique gcp-bq como Nome do espaço de trabalho e selecione sua Região.
Para determinar o ID do projeto do Google Cloud , acesse o console do Google Cloud e copie o valor para o campo ID do projeto doGoogle Cloud .

Acessar o console do Google Cloud
Clique em Salvar para criar seu espaço de trabalho do Databricks.
Para criar um cluster do Databricks com o ambiente de execução do Databricks 7.6 ou posterior, na barra de menu à esquerda, selecione Clusters e depois clique em Criar cluster na parte superior.
Especifique o nome e o tamanho do cluster, clique em Opções avançadas e especifique os endereços de e-mail da sua conta de serviço Google Cloud.
Clique em Criar cluster.
Para criar um notebook Python para o Databricks, siga as instruções em Criar um notebook.

Como consultar o BigQuery no Databricks

Com a configuração acima, você pode conectar o Databricks com segurança ao BigQuery. O Databricks usa uma bifurcação do adaptador Google Spark de código aberto para acessar o BigQuery.

O Databricks reduz a transferência de dados e acelera as consultas com o push-down automático de determinados predicados de consulta, como a filtragem de colunas aninhadas no BigQuery. Além disso, o recurso adicionado para executar primeiro uma consulta SQL no BigQuery com a API query() reduz o tamanho da transferência do conjunto de dados resultante.

Nas etapas a seguir, descrevemos como acessar um conjunto de dados no BigQuery e gravar seus próprios dados no BigQuery.

Acessar um conjunto de dados público no BigQuery

O BigQuery fornece uma lista de conjuntos de dados públicos disponíveis. Para consultar o conjunto de dados de Shakespeare do BigQuery, que faz parte dos conjuntos de dados públicos, siga estas etapas:

Para ler a tabela do BigQuery, use o snippet de código a seguir no notebook do Databricks.
```
table = "bigquery-public-data.samples.shakespeare"
df = spark.read.format("bigquery").option("table",table).load()
df.createOrReplaceTempView("shakespeare")
```
Execute o código pressionando Shift+Return.

Agora é possível consultar a tabela do BigQuery com o Spark DataFrame (df). Por exemplo, use o código abaixo para mostrar as três primeiras linhas do dataframe:
```
df.show(3)
```
Para consultar outra tabela, atualize a variável table.
Um recurso importante dos notebooks do Databricks é que você pode misturar as células de diferentes linguagens, como Scala, Python e SQL, em um único notebook.

A consulta SQL a seguir permite visualizar a contagem de palavras em Shakespeare depois de executar a célula anterior que cria a visualização temporária.
```
%sql
SELECT word, SUM(word_count) AS word_count FROM words GROUP BY word ORDER BY word_count DESC LIMIT 12
```
Observação: a saída está no formato tabular por padrão. Para alterá-lo para um gráfico de barras, clique no ícone do gráfico de barras para selecionar uma das visualizações do Databricks disponíveis.

A célula acima executa uma consulta SQL do Spark no DataFrame no cluster do Databricks, não no BigQuery. A vantagem dessa abordagem é que a análise de dados ocorre no nível do Spark, nenhuma outra chamada de API do BigQuery é emitida, e você não tem custos adicionais com o BigQuery.
Como alternativa, é possível delegar a execução de uma consulta SQL ao BigQuery com a API query() e otimizar para reduzir o tamanho da transferência do frame de dados resultante. Diferentemente do exemplo acima, em que o processamento foi feito no Spark, se você usar essa abordagem, as otimizações de preço e de consulta serão aplicadas para executar a consulta no BigQuery.

O exemplo abaixo usa Scala, a API query() e o conjunto de dados público de Shakespeare no BigQuery para calcular as cinco palavras mais comuns nas obras de Shakespeare. Antes de executar o código, primeiro é necessário criar um conjunto de dados vazio no BigQuery chamado mdataset, que pode ser referenciado pelo código. Para mais informações, consulte Como gravar dados no 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 mais exemplos de código, consulte o Notebook de exemplo do Databricks no BigQuery.

Como gravar dados no BigQuery

As tabelas do BigQuery estão em conjuntos de dados. Antes de gravar dados em uma tabela do BigQuery, crie um novo conjunto de dados no BigQuery. Para criar um conjunto de dados para um notebook Python do Databricks, siga estas etapas:

Acesse a página do BigQuery no console Google Cloud .

Acessar o BigQuery
Expanda a opção Ações, clique em Criar conjunto de dados e, em seguida, nomeie-o como together.
No notebook Python do Databricks, crie um DataFrame simples do Spark a partir de uma lista do Python com três entradas de string usando o snippet de código a seguir:
```
from pyspark.sql.types import StringType
mylist = ["Google", "Databricks", "better together"]

df = spark.createDataFrame(mylist, StringType())
```
Adicione outra célula ao notebook que grava o DataFrame do Spark da etapa anterior na tabela myTable do BigQuery no conjunto de dados together. A tabela será criada ou substituída. Use o nome do bucket especificado anteriormente.
```
bucket = YOUR_BUCKET_NAME
table = "together.myTable"

df.write
  .format("bigquery")
  .option("temporaryGcsBucket", bucket)
  .option("table", table)
  .mode("overwrite").save()
```
Para verificar se você gravou os dados com sucesso, consulte e exiba sua tabela do BigQuery com o DataFrame do Spark (df):
```
display(spark.read.format("bigquery").option("table", table).load)
```