Como usar o Apache Hive no Cloud Dataproc

Neste tutorial, você verá como usar o Apache Hive no Cloud Dataproc de maneira eficiente e flexível, armazenando dados do Hive no Cloud Storage e hospedando o metastore do Hive em um banco de dados MySQL no Cloud SQL. Essa separação entre recursos de computação e armazenamento oferece algumas vantagens:

  • Flexibilidade e agilidade: é possível personalizar configurações de cluster para cargas de trabalho específicas do Hive e escalonar cada cluster de maneira independente para mais ou para menos, conforme necessário.
  • Economia de custos: é possível criar um cluster efêmero quando for preciso executar um job do Hive e excluí-lo quando o job for concluído. Os recursos que seu job exige ficam ativos somente quando estão sendo usados, então você paga apenas pelo que usa. Também é possível usar VMs preemptivas para processamento de dados não críticos ou criar clusters muito grandes com um custo total menor.

O Hive é um conhecido sistema de armazenamento de dados de código aberto, desenvolvido no Apache Hadoop. O Hive oferece uma linguagem de consulta do tipo SQL, chamada HiveQL, usada para analisar conjuntos de dados grandes e estruturados. O metastore do Hive contém metadados sobre as tabelas do Hive, como o esquema e a localização delas. Em situações em que o MySQL é comumente usado como um back-end para o metastore do Hive, o Cloud SQL facilita a configuração, a manutenção, o gerenciamento e a administração dos bancos de dados relacionais no Google Cloud Platform (GCP).

O Cloud Dataproc é um serviço rápido, fácil de usar e totalmente gerenciado no GCP para execução das cargas de trabalho do Apache Spark e do Apache Hadoop, de maneira simples e econômica. Embora as instâncias do Cloud Dataproc possam permanecer sem estado, recomendamos que você mantenha os dados do Hive no Cloud Storage e o metastore do Hive no MySQL, no Cloud SQL.

Objetivos

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

Custos

Neste tutorial, serão utilizados os seguintes componentes faturáveis do Google Cloud Platform:

  • Cloud Dataproc
  • Cloud Storage
  • Cloud SQL

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

Os novos usuários do GCP podem estar qualificados para uma avaliação gratuita.

Antes de começar

Criar um novo projeto

  1. No Console do GCP, acesse a página do seletor de projetos.

    Acesse a página do seletor de projetos

  2. Selecione ou crie um projeto do GCP.

Ativar faturamento

Inicializar o ambiente

  1. Inicie uma instância do Cloud Shell:

    ACESSAR o Cloud Shell

  2. No Cloud Shell, defina a zona padrão do Compute Engine como a zona onde você criará seus clusters do Cloud Dataproc. Neste tutorial, usamos a zona us-central1-a na região us-central1.

    export REGION=us-central1
    export ZONE=us-central1-a
    gcloud config set compute/zone $ZONE
  3. Ative as APIs Admin Cloud Dataproc e Cloud SQL executando este comando no Cloud Shell:

    gcloud services enable dataproc.googleapis.com sqladmin.googleapis.com

Arquitetura de referência

Para simplificar, neste tutorial você implanta todos os serviços de computação e armazenamento na mesma região do GCP para minimizar os custos de latência de rede e de transporte de rede. A figura 1 apresenta a arquitetura deste tutorial.

Diagrama de uma arquitetura de região única.
Figura 1. Exemplo de uma arquitetura Hive de região única

Com essa arquitetura, o ciclo de vida de uma consulta do Hive segue estas etapas:

  1. O cliente Hive envia uma consulta para um servidor Hive que é executado em um cluster efêmero do Cloud Dataproc.
  2. O servidor processa a consulta e solicita metadados do serviço metastore.
  3. O serviço metastore busca os metadados do Hive do Cloud SQL por meio do Cloud SQL Proxy.
  4. O servidor carrega dados do armazenamento do Hive, localizado em um intervalo regional no Cloud Storage.
  5. O servidor retorna o resultado para o cliente.

Considerações para arquiteturas de várias regiões

Neste tutorial, nosso foco está em uma arquitetura de região única. Uma arquitetura de várias regiões pode ser levada em conta se for preciso executar servidores Hive em diferentes regiões geográficas. Nesse caso, crie clusters separados do Cloud Dataproc dedicados a hospedar o serviço metastore e que residam na mesma região da instância do Cloud SQL. Às vezes, grandes volumes de solicitações podem ser enviados pelo serviço metastore ao banco de dados MySQL. Portanto, é essencial manter o serviço de metastore geograficamente próximo ao banco de dados MySQL para proteger o desempenho e minimizar o impacto. Em comparação, o servidor Hive geralmente envia muito menos solicitações para o serviço metastore. Portanto, pode ser mais aceitável que o servidor Hive e o serviço metastore residam em regiões diferentes, mesmo que a latência aumente.

O serviço metastore pode ser executado apenas em nós principais do Cloud Dataproc, não em nós de trabalho. O Cloud Dataproc impõe um mínimo de dois nós de trabalho em clusters padrão e em clusters de alta disponibilidade. Para evitar o desperdício de recursos em nós de trabalho não utilizados, crie um cluster de nó único para o serviço metastore. Para conseguir alta disponibilidade, crie vários clusters de nó único.

O proxy do Cloud SQL precisa ser instalado somente nos clusters de serviço do metastore, porque somente os clusters de serviço do metastore precisam se conectar diretamente à instância do Cloud SQL. Em seguida, os servidores Hive apontam para os clusters de serviço do metastore ao definir a propriedade (em inglês) hive.metastore.uris para a lista separada por vírgula de URIs. Por exemplo:

thrift://metastore1:9083,thrift://metastore2:9083

Pense também no uso de um intervalo multirregional se os dados do Hive precisarem ser acessados dos servidores Hive, localizados em vários locais. A escolha entre os intervalos regionais e multirregionais depende do seu caso de uso. Você precisa equilibrar os custos de latência, disponibilidade e largura de banda. Para saber mais detalhes, consulte a documentação sobre considerações de localização.

Na Figura 2, apresentamos um exemplo de uma arquitetura multirregional.

Diagrama de uma arquitetura Hive multirregional.
Figura 2. Exemplo de uma arquitetura Hive multirregional

Como vê, o cenário multirregional é um pouco mais complexo. Para manter a concisão deste tutorial, usamos uma arquitetura de região única.

Como criar um intervalo de armazenamento de dados

A primeira etapa é criar um intervalo de armazenamento de dados que hospedará os dados do Hive e será compartilhado por todos os servidores do Hive.

Para criar o intervalo de armazenamento de dados, execute os seguintes comandos no Cloud Shell:

export PROJECT=$(gcloud info --format='value(config.project)')
gsutil mb -l $REGION gs://$PROJECT-warehouse

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 \
    --gce-zone $ZONE

Isso pode demorar alguns minutos.

Como criar um cluster do Cloud Dataproc

Crie o primeiro cluster do Cloud Dataproc:

gcloud dataproc clusters create hive-cluster \
    --scopes sql-admin \
    --image-version 1.3 \
    --initialization-actions gs://dataproc-initialization-actions/cloud-sql-proxy/cloud-sql-proxy.sh \
    --properties hive:hive.metastore.warehouse.dir=gs://$PROJECT-warehouse/datasets \
    --metadata "hive-metastore-instance=$PROJECT:$REGION:hive-metastore"

Observações:

  • Forneça o escopo de acesso sql-admin para permitir que instâncias de cluster acessem a API Admin do Cloud SQL.
  • Especifique a versão 1.3 da imagem do cluster (versão mais recente disponível no momento em que este tutorial foi escrito).
  • Forneça o URI ao intervalo de armazenamento de dados do Hive na propriedade hive:hive.metastore.warehouse.dir. Isso configura os servidores Hive para ler e gravar no local correto.
  • Forneça a ação de inicialização do Cloud SQL Proxy que o Cloud Dataproc executa automaticamente em todas as instâncias do cluster. Veja o que ocorre com essa ação:

    • É feita a instalação do Cloud SQL Proxy.
    • É estabelecida uma conexão segura com a instância do Cloud SQL, especificada no parâmetro de metadados hive-metastore-instance.
    • São criados o usuário do hive e o banco de dados do metastore do Hive.

    Veja o código completo (em inglês)da ação de inicialização do Cloud SQL Proxy no GitHub.

  • Para simplificar, neste tutorial usamos apenas uma instância mestre. Para aumentar a resiliência nas cargas de trabalho de produção, pense na criação de um cluster com três instâncias mestres usando o modo de alta disponibilidade do Cloud Dataproc.

Como criar uma tabela Hive

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

  1. Copie o conjunto de dados de amostra para o intervalo do armazenamento de dados:

    gsutil cp gs://hive-solution/part-00000.parquet \
    gs://$PROJECT-warehouse/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.

  2. Crie uma tabela Hive externa para o conjunto de dados:

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

Como executar consultas do Hive

Há diferentes ferramentas dentro do Cloud Dataproc que podem ser usadas para executar as consultas do Hive. Nesta seção, você aprende como realizar consultas usando as seguintes ferramentas:

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

Como fazer uma consulta do Hive com a API Jobs do Cloud Dataproc

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

gcloud dataproc jobs submit hive \
    --cluster hive-cluster \
    --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

  1. Abra uma sessão SSH com a instância mestre do Cloud Dataproc:

    gcloud compute ssh hive-cluster-m
  2. 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 referenciar o nome da instância mestre como o host, em vez de localhost:

      beeline -u "jdbc:hive2://hive-cluster-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"
  3. 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  |
    +------------------+--------------------+
  4. Feche a sessão do Beeline:

    !quit
  5. Feche a conexão SSH:

    exit

Como fazer uma consulta do Hive com o SparkSQL

  1. Abra uma sessão SSH com a instância mestre do Cloud Dataproc:

    gcloud compute ssh hive-cluster-m
  2. No prompt de comando da instância mestre, abra uma nova sessão do shell do PySpark:

    pyspark
  3. 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  |
    +-----------------+--------------------+
  4. Feche a sessão do PySpark:

    exit()
  5. 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 de transactions.

  1. 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 apenas pressione a tecla RETURN. Para manter a simplicidade neste tutorial, 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.

  2. No prompt de comando do MySQL, torne hive_metastore o banco de dados padrão para o resto da sessão:

    USE hive_metastore;
  3. 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://[PROJECT]-warehouse/datasets   |
    +-------------------------------------+
  4. 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 |
    +--------------+----------------+
  5. 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    |
    +-------------------+-----------+
  6. 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://[PROJECT]-warehouse/datasets/transactions |
    +---------------------------------------------------------------+------------------------------------------------+
    
  7. Feche a sessão do MySQL:

    exit

Como criar outro cluster do Cloud Dataproc

Nesta seção, você cria outro cluster do Cloud Dataproc para verificar se os dados do Hive e o metastore do Hive podem ser compartilhados entre vários clusters.

  1. Crie um novo cluster do Cloud Dataproc:

    gcloud dataproc clusters create other-hive-cluster \
        --scopes cloud-platform \
        --image-version 1.3 \
        --initialization-actions gs://dataproc-initialization-actions/cloud-sql-proxy/cloud-sql-proxy.sh \
        --metadata  "hive-metastore-instance=$PROJECT:$REGION:hive-metastore"

    Não forneça uma referência ao intervalo do armazenamento de dados do Hive como você fez anteriormente, quando criou o primeiro cluster com a propriedade hive:hive.metastore.warehouse.dir. O local do intervalo já está registrado no metastore do Hive, como você verificou na seção anterior.

  2. Verifique se o novo cluster pode acessar os dados:

    gcloud dataproc jobs submit hive \
        --cluster other-hive-cluster \
        --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   |
    +------------------+--------+

Você concluiu o tutorial.

Como fazer a limpeza

Para evitar que os recursos usados nesse tutorial sejam cobrados na conta do Google Cloud Platform:

Para evitar cobranças na sua conta do GCP pelos recursos usados neste guia de início rápido, siga estas etapas:

  • Limpe todos os recursos que você criou para não ser cobrado por eles no futuro. A maneira mais fácil de evitar o faturamento é excluir o projeto criado para o tutorial.
  • Como alternativa, exclua os recursos individuais.

Como excluir o projeto

  1. No Console do GCP, acesse a página Gerenciar recursos.

    Acessar a página Gerenciar recursos

  2. Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir .
  3. Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

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 hive-cluster --quiet
gcloud dataproc clusters delete other-hive-cluster --quiet
gcloud sql instances delete hive-metastore --quiet
gsutil rm -r gs://$PROJECT-warehouse

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 as cargas de trabalho do Hadoop para o GCP.
  • Confira esta ação de inicialização (em inglês) para mais detalhes sobre como usar o Hive HCatalog no Cloud Dataproc.
  • Aprenda a configurar o Cloud SQL para alta disponibilidade e aumentar a confiabilidade do serviço.
  • Teste outros recursos do Google Cloud Platform. Veja nossos tutoriais.