Implantar o Apache Hive no Dataproc

Last reviewed 2023-05-08 UTC

Neste documento, descrevemos como implantar a arquitetura em Usar o Apache Hive no Dataproc

Este documento é destinado a arquitetos de nuvem e engenheiros de dados interessados em implantar o Apache Hive no Dataproc e o metastore Hive no Cloud SQL.

Arquitetura

Neste guia de implantação, você implanta todos os serviços de computação e armazenamento na mesma região do Google Cloud para minimizar a latência e os custos de transporte da rede.

O diagrama a seguir mostra o ciclo de vida de uma consulta do Hive.

Diagrama de uma arquitetura de região única.

No diagrama, o cliente Hive envia uma consulta, que é processada, buscada e retornada. O processamento ocorre no servidor Hive. Os dados são solicitados e recuperados de um armazenamento do Hive armazenado em um bucket regional no Cloud Storage.

Objetivos

Criar uma instância do MySQL no Cloud SQL para o metastore do Hive.
Implantar servidores Hive no Dataproc.
Instalar o Cloud SQL Proxy nas instâncias do cluster do Dataproc.
Carregar dados do Hive para o Cloud Storage.
Executar consultas do Hive em vários clusters do Dataproc.

Custos

A implantação usa os seguintes componentes faturáveis do Google Cloud:

Dataproc
Cloud Storage
Cloud SQL

Use a calculadora de preços para gerar uma estimativa de custo com base no uso previsto.

Novos usuários do Google Cloud podem estar qualificados para uma avaliação gratuita.

Ao concluir a implantação, exclua os recursos criados para evitar a continuidade do faturamento. Para mais informações, consulte Limpeza.

Antes de começar

No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

Observação: se você não pretende manter os recursos criados nesta implantação, crie um projeto novo em vez de selecionar um que já existe. Depois de concluir a implantação, exclua o projeto para remover todos os recursos associados a ele.

Acessar o seletor de projetos
Verifique se a cobrança está ativada para o seu projeto do Google Cloud. Saiba como verificar se o faturamento está ativado em um projeto.

Inicializar o ambiente

Inicie uma instância do Cloud Shell:

Acesse o Cloud Shell
No Cloud Shell, defina a zona padrão do Compute Engine como a zona em que os clusters do Dataproc serão criados.
```
export PROJECT=$(gcloud info --format='value(config.project)')
export REGION=REGION
export ZONE=ZONE
gcloud config set compute/zone ${ZONE}
```
Substitua:
- REGION: a região em que você quer criar o cluster, como us-central1.
- ZONE: a zona em que você quer criar o cluster, como us-central1-a.
Ative as APIs Admin do Dataproc e do Cloud SQL executando este comando no Cloud Shell:
```
gcloud services enable dataproc.googleapis.com sqladmin.googleapis.com
```

(Opcional) Como criar o bucket de armazenamento de dados

Se você não tiver um bucket do Cloud Storage para armazenar dados do Hive, crie um bucket de warehouse (é possível executar os seguintes comandos no Cloud Shell) substituindo BUCKET_NAME por um nome de bucket exclusivo:

export WAREHOUSE_BUCKET=BUCKET_NAME
gcloud storage buckets create gs://${WAREHOUSE_BUCKET} --location=${REGION}

Como criar a instância do Cloud SQL

Nesta seção, você cria uma nova instância do Cloud SQL que será usada posteriormente para hospedar o metastore do Hive.

No Cloud Shell, crie uma nova instância do Cloud SQL:

gcloud sql instances create hive-metastore \
    --database-version="MYSQL_5_7" \
    --activation-policy=ALWAYS \
    --zone ${ZONE}

Isso pode demorar alguns minutos.

Como criar um cluster do Dataproc

Crie o primeiro cluster do Dataproc, substituindo CLUSTER_NAME por um nome como hive-cluster:

gcloud dataproc clusters create CLUSTER_NAME \
    --scopes sql-admin \
    --region ${REGION} \
    --initialization-actions gs://goog-dataproc-initialization-actions-${REGION}/cloud-sql-proxy/cloud-sql-proxy.sh \
    --properties "hive:hive.metastore.warehouse.dir=gs://${WAREHOUSE_BUCKET}/datasets" \
    --metadata "hive-metastore-instance=${PROJECT}:${REGION}:hive-metastore" \
    --metadata "enable-cloud-sql-proxy-on-workers=false"

Observações:

Você fornece o escopo de acesso sql-admin para permitir que as instâncias do cluster acessem a API Admin do Cloud SQL.
Coloque a ação de inicialização em um script armazenado em um bucket do Cloud Storage e referencie esse bucket com a sinalização --initialization-actions. Para mais informações, consulte Ações de inicialização: considerações e diretrizes importantes.
Você fornece o URI para o intervalo do armazenamento do Hive na propriedade hive:hive.metastore.warehouse.dir. Isso configura os servidores Hive para ler e gravar no local correto. Essa propriedade precisa conter pelo menos um diretório (por exemplo, gs://my-bucket/my-directory). O Hive não funcionará corretamente se esta propriedade estiver definida como um nome de bucket sem um diretório (por exemplo, gs://my-bucket).
Especifique enable-cloud-sql-proxy-on-workers=false para garantir que o Cloud SQL Proxy seja executado somente em nós mestres, o que é suficiente para que o serviço metastore Hive funcione e evita cargas desnecessárias no Cloud SQL.
Você fornece a ação de inicialização do Cloud SQL Proxy que o Dataproc executa automaticamente em todas as instâncias do cluster. Veja o que ocorre com essa ação:
- Instala o Cloud SQL Proxy.
- Estabelece uma conexão segura com a instância do Cloud SQL especificada no parâmetro de metadados hive-metastore-instance.
- Cria o usuário hive e o banco de dados do metastore do Hive.
Veja o código completo da ação de inicialização do Cloud SQL Proxy no GitHub.
Nesta implantação, usamos uma instância do Cloud SQL com endereço IP público. Se, em vez disso, você usar uma instância com apenas um endereço IP particular, será possível forçar o proxy a usar o endereço IP particular transmitindo o parâmetro --metadata "use-cloud-sql-private-ip=true".

Como criar uma tabela Hive

Nesta seção, você carrega um conjunto de dados de amostra no bucket de armazenamento de dados, cria uma nova tabela Hive e executa algumas consultas do HiveQL nesse conjunto de dados.

Copie o conjunto de dados de amostra para o bucket do armazenamento de dados:
```
gcloud storage cp gs://hive-solution/part-00000.parquet \
gs://${WAREHOUSE_BUCKET}/datasets/transactions/part-00000.parquet
```
O conjunto de dados de amostra é compactado no formato Parquet e contém milhares de registros fictícios de transações bancárias, com três colunas: data, valor e tipo de transação.

Crie uma tabela Hive externa para o conjunto de dados:

gcloud dataproc jobs submit hive \
    --cluster CLUSTER_NAME \
    --region ${REGION} \
    --execute "
      CREATE EXTERNAL TABLE transactions
      (SubmissionDate DATE, TransactionAmount DOUBLE, TransactionType STRING)
      STORED AS PARQUET
      LOCATION 'gs://${WAREHOUSE_BUCKET}/datasets/transactions';"

Como executar consultas do Hive

É possível usar diferentes ferramentas no Dataproc para executar consultas do Hive. Nesta seção, você aprende como realizar consultas usando as seguintes ferramentas:

API de jobs do Hive do Dataproc
Beeline, um conhecido cliente de linha de comando, baseado no SQLLine
SparkSQL, API do Apache Spark para consultar dados estruturados

Em cada seção, você executa uma consulta de amostra.

Como consultar o Hive com a API Jobs do Dataproc

Execute a seguinte consulta HiveQL simples para verificar se o arquivo parquet está vinculado corretamente à tabela Hive:

gcloud dataproc jobs submit hive \
    --cluster CLUSTER_NAME \
    --region ${REGION} \
    --execute "
      SELECT *
      FROM transactions
      LIMIT 10;"

A saída inclui estes elementos:

+-----------------+--------------------+------------------+
| submissiondate  | transactionamount  | transactiontype  |
+-----------------+--------------------+------------------+
| 2017-12-03      | 1167.39            | debit            |
| 2017-09-23      | 2567.87            | debit            |
| 2017-12-22      | 1074.73            | credit           |
| 2018-01-21      | 5718.58            | debit            |
| 2017-10-21      | 333.26             | debit            |
| 2017-09-12      | 2439.62            | debit            |
| 2017-08-06      | 5885.08            | debit            |
| 2017-12-05      | 7353.92            | authorization    |
| 2017-09-12      | 4710.29            | authorization    |
| 2018-01-05      | 9115.27            | debit            |
+-----------------+--------------------+------------------+

Como fazer uma consulta do Hive com o Beeline

Abra uma sessão SSH com a instância mestre do Dataproc (CLUSTER_NAME-m):
```
gcloud compute ssh CLUSTER_NAME-m
```
No prompt de comando da instância mestre, abra uma sessão do Beeline:
```
beeline -u "jdbc:hive2://localhost:10000"
```
Observações:
- Também é possível fazer referência ao nome da instância mestre como host em vez de localhost:
```
beeline -u "jdbc:hive2://CLUSTER_NAME-m:10000"
```
- Se estivesse usando o modo de alta disponibilidade com três mestres, você teria que usar o seguinte comando:
```
beeline -u "jdbc:hive2://CLUSTER_NAME-m-0:2181,CLUSTER_NAME-m-1:2181,CLUSTER_NAME-m-2:2181/;serviceDiscoveryMode=zooKeeper;zooKeeperNamespace=hiveserver2"
```

Quando a solicitação do Beeline aparecer, execute a seguinte consulta do HiveQL:

SELECT TransactionType, AVG(TransactionAmount) AS AverageAmount
FROM transactions
WHERE SubmissionDate = '2017-12-22'
GROUP BY TransactionType;

A saída inclui estes elementos:

+------------------+--------------------+
| transactiontype  |   averageamount    |
+------------------+--------------------+
| authorization    | 4890.092525252529  |
| credit           | 4863.769269565219  |
| debit            | 4982.781458176331  |
+------------------+--------------------+

Feche a sessão do Beeline:
```
!quit
```
Feche a conexão SSH:
```
exit
```

Como fazer uma consulta do Hive com o SparkSQL

Abra uma sessão SSH com a instância mestre do Dataproc:
```
gcloud compute ssh CLUSTER_NAME-m
```
No prompt de comando da instância mestre, abra uma nova sessão do shell do PySpark:
```
pyspark
```

Quando o prompt do shell do PySpark aparecer, digite o seguinte código do Python:

from pyspark.sql import HiveContext
hc = HiveContext(sc)
hc.sql("""
SELECT SubmissionDate, AVG(TransactionAmount) as AvgDebit
FROM transactions
WHERE TransactionType = 'debit'
GROUP BY SubmissionDate
HAVING SubmissionDate >= '2017-10-01' AND SubmissionDate < '2017-10-06'
ORDER BY SubmissionDate
""").show()

A saída inclui estes elementos:

+-----------------+--------------------+
| submissiondate  |      avgdebit      |
+-----------------+--------------------+
| 2017-10-01      | 4963.114920399849  |
| 2017-10-02      | 5021.493300510582  |
| 2017-10-03      | 4982.382279569891  |
| 2017-10-04      | 4873.302702503676  |
| 2017-10-05      | 4967.696333583777  |
+-----------------+--------------------+

Feche a sessão do PySpark:
```
exit()
```
Feche a conexão SSH:
```
exit
```

Como inspecionar o metastore do Hive

Agora você verifica se o metastore do Hive no Cloud SQL contém informações sobre a tabela transactions.

No Cloud Shell, inicie uma nova sessão do MySQL na instância do Cloud SQL:
```
gcloud sql connect hive-metastore --user=root
```
Quando for solicitada a senha do usuário root, não digite nada e pressione a tecla RETURN. Para simplificar esta implantação, você não definiu nenhuma senha para o usuário root. Para conseguir informações sobre como configurar uma senha para proteger ainda mais o banco de dados do metastore, consulte a documentação do Cloud SQL. Na ação de inicialização do Cloud SQL Proxy, também é fornecido um mecanismo para proteger senhas por meio de criptografia. Para ver mais informações, consulte o repositório de códigos (em inglês) da ação.
No prompt de comando do MySQL, torne hive_metastore o banco de dados padrão para o restante da sessão:
```
USE hive_metastore;
```

Verifique se o local do intervalo do armazenamento de dados está registrado no metastore:

SELECT DB_LOCATION_URI FROM DBS;

A saída é assim:

+-------------------------------------+
| DB_LOCATION_URI                     |
+-------------------------------------+
| gs://[WAREHOUSE_BUCKET]/datasets   |
+-------------------------------------+

Verifique se a tabela está referenciada corretamente no metastore:

SELECT TBL_NAME, TBL_TYPE FROM TBLS;

A saída é assim:

+--------------+----------------+
| TBL_NAME     | TBL_TYPE       |
+--------------+----------------+
| transactions | EXTERNAL_TABLE |
+--------------+----------------+

Verifique se as colunas da tabela também estão referenciadas corretamente:

SELECT COLUMN_NAME, TYPE_NAME
FROM COLUMNS_V2 c, TBLS t
WHERE c.CD_ID = t.SD_ID AND t.TBL_NAME = 'transactions';

A saída é assim:

+-------------------+-----------+
| COLUMN_NAME       | TYPE_NAME |
+-------------------+-----------+
| submissiondate    | date      |
| transactionamount | double    |
| transactiontype   | string    |
+-------------------+-----------+

Verifique se o formato de entrada e o local também estão corretamente referenciados:

SELECT INPUT_FORMAT, LOCATION
FROM SDS s, TBLS t
WHERE s.SD_ID = t.SD_ID AND t.TBL_NAME = 'transactions';

A saída é assim:

+---------------------------------------------------------------+------------------------------------------------+
| INPUT_FORMAT                                                  | LOCATION                                       |
+---------------------------------------------------------------+------------------------------------------------+
| org.apache.hadoop.hive.ql.io.parquet.MapredParquetInputFormat | gs://[WAREHOUSE_BUCKET]/datasets/transactions |
+---------------------------------------------------------------+------------------------------------------------+

Feche a sessão do MySQL:
```
exit
```

Como criar outro cluster do Dataproc

Nesta seção, você criará outro cluster do Dataproc para verificar se é possível que os dados e o metastore do Hive sejam compartilhados entre vários clusters.

Crie um novo cluster do Dataproc:

gcloud dataproc clusters create other-CLUSTER_NAME \
    --scopes cloud-platform \
    --image-version 2.0 \
    --region ${REGION} \
    --initialization-actions gs://goog-dataproc-initialization-actions-${REGION}/cloud-sql-proxy/cloud-sql-proxy.sh \
    --properties "hive:hive.metastore.warehouse.dir=gs://${WAREHOUSE_BUCKET}/datasets" \
    --metadata "hive-metastore-instance=${PROJECT}:${REGION}:hive-metastore"\
    --metadata "enable-cloud-sql-proxy-on-workers=false"

Verifique se o novo cluster pode acessar os dados:

gcloud dataproc jobs submit hive \
    --cluster other-CLUSTER_NAME \
    --region ${REGION} \
    --execute "
      SELECT TransactionType, COUNT(TransactionType) as Count
      FROM transactions
      WHERE SubmissionDate = '2017-08-22'
      GROUP BY TransactionType;"

A saída inclui estes elementos:

+------------------+--------+
| transactiontype  | count  |
+------------------+--------+
| authorization    | 696    |
| credit           | 1722   |
| debit            | 2599   |
+------------------+--------+

Parabéns! Você concluiu as etapas da implantação.

Limpar

Nas seções a seguir, explicamos como evitar cobranças futuras pelo projeto do Google Cloud e pelos recursos do Apache Hive e do Dataproc usados nessa implantação.

Excluir o projeto do Google Cloud

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados nessa implantação, exclua o projeto do Google Cloud.

Cuidado: excluir um projeto tem os seguintes efeitos:

Tudo no projeto é excluído. Se você tiver usado um projeto existente para as tarefas neste documento, a exclusão dele incluirá a exclusão de quaisquer outros trabalhos feitos no projeto.
Os IDs do projeto personalizados são perdidos. Ao criar o projeto, você pode ter criado um código do projeto personalizado para ser usado no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, exclua recursos específicos do projeto, em vez de excluir o projeto inteiro.

Se você planeja passar por várias arquiteturas, tutoriais ou guias de início rápido, a reutilização de projetos pode evitar que você exceda os limites da cota do projeto.

In the Google Cloud console, go to the Manage resources page.
Go to Manage resources
In the project list, select the project that you want to delete, and then click Delete.
In the dialog, type the project ID, and then click Shut down to delete the project.

Como excluir recursos individuais

Execute os seguintes comandos no Cloud Shell para excluir recursos individuais em vez de excluir todo o projeto:

gcloud dataproc clusters delete CLUSTER_NAME --region ${REGION} --quiet
gcloud dataproc clusters delete other-CLUSTER_NAME --region ${REGION} --quiet
gcloud sql instances delete hive-metastore --quiet
gcloud storage rm gs://${WAREHOUSE_BUCKET}/datasets --recursive

A seguir

Teste o BigQuery, o armazenamento de dados corporativo de custo reduzido do Google, altamente escalonável e sem servidor.
Confira este guia sobre como migrar cargas de trabalho do Hadoop para o Google Cloud.
Confira esta ação de inicialização para mais detalhes sobre como usar o HCatalog do Hive no Dataproc.
Aprenda a configurar o Cloud SQL para alta disponibilidade e aumentar a confiabilidade do serviço.
Para mais arquiteturas de referência, diagramas e práticas recomendadas, confira a Central de arquitetura do Cloud.