Configurar o Spark e o Hive com o catálogo de ambientes de execução do Lakehouse

Visualizar

Este recurso está sujeito aos Termos das Soluções Pré-GA na seção Termos Gerais de Serviço dos Termos Específicos de Serviço. Os recursos pré-GA estão disponíveis "no estado em que se encontram" e podem ter suporte limitado. Para mais informações, consulte as descrições da fase de lançamento.

Neste documento, explicamos como configurar o Apache Spark e o Apache Hive para usar o catálogo do ambiente de execução do Lakehouse. Você vai aprender a criar um catálogo do Apache Hive, configurar suas sessões do Spark para se conectar ao metastore e executar cargas de trabalho para criar tabelas que podem ser consultadas diretamente no BigQuery.

Antes de começar

1. Leia Sobre os catálogos do Hive no catálogo do ambiente de execução do Lakehouse para entender como o Spark se conecta ao catálogo do ambiente de execução do Lakehouse.
2. Revise Formatos de armazenamento e tipos de dados compatíveis.
3. Consulte Limitações e considerações.
Faça login na sua conta do Google Cloud . Se você começou a usar o Google Cloudagora, crie uma conta para avaliar o desempenho dos nossos produtos em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.

Verify that billing is enabled for your Google Cloud project.

Enable the Lakehouse, Managed Service for Apache Spark APIs, if any are not already enabled.

Roles required to enable APIs

To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). Learn how to grant roles.

Enable the APIs

Verify that billing is enabled for your Google Cloud project.

Enable the Lakehouse, Managed Service for Apache Spark APIs, if any are not already enabled.

Roles required to enable APIs

To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). Learn how to grant roles.

Enable the APIs

Funções exigidas

Para receber as permissões necessárias a fim de usar o catálogo de tempo de execução do Lakehouse, peça que o admin conceda a você os seguintes papéis do IAM no projeto:

• Crie um cluster do Serviço Gerenciado para Apache Spark: Editor do Dataproc (roles/dataproc.editor)
• Conta de serviço do cluster:
  • Worker do Dataproc (roles/dataproc.worker)
  • Usuário de objetos do Storage (roles/storage.objectUser)
  • Editor do BigLake (roles/biglake.editor)
  • Consumidor do Service Usage (roles/serviceusage.serviceUsageConsumer)
• Acesso de gravação a todos os recursos do catálogo de ambientes de execução do Lakehouse: Editor do BigLake (roles/biglake.editor)
• Acesso somente leitura a todos os recursos do catálogo do ambiente de execução do Lakehouse: Leitor do BigLake (roles/biglake.viewer)

Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Também é possível conseguir as permissões necessárias usando papéis personalizados ou outros papéis predefinidos.

Para instruções, consulte Conceder um único papel.

Fluxo de trabalho geral

Para usar o catálogo do ambiente de execução do Lakehouse com o Spark e o Hive, siga este fluxo de trabalho geral:

1. Crie um catálogo Hive do Lakehouse.
2. Configure sua sessão do Spark usando a ferramenta de sua preferência, como o Serviço Gerenciado para Apache Spark ou o BigQuery Studio.
3. Realize operações de banco de dados e tabela na sua sessão do Spark.
4. Envie cargas de trabalho em lote para o Serviço Gerenciado para Apache Spark e consulte as tabelas resultantes diretamente do BigQuery.

Criar um catálogo Hive do Lakehouse

Para usar o catálogo do ambiente de execução do Lakehouse com o Spark e o Hive, primeiro crie um catálogo do Hive.

Um catálogo do Hive do Lakehouse é uma coleção de bancos de dados do Hive. Antes de executar jobs do Spark, crie um catálogo para registrá-lo com o metastore do Lakehouse. O catálogo tem um nome e um local do Cloud Storage onde os dados do Hive residem.

Console

1. No console do Google Cloud , abra a página Lakehouse.

   Acessar o Lakehouse

2. Clique em Criar catálogo.

3. Selecione catálogo do ambiente de execução do Lakehouse.

4. Em Tipo de catálogo, selecione Metastore do Hive.

5. No campo Selecionar um bucket do Cloud Storage, insira o nome do bucket que será usado com seu catálogo. Ou clique em Procurar para escolher um bucket ou criar um novo.

6. Em ID do catálogo, dê um nome ao catálogo Hive do Lakehouse.

7. Em Local principal, especifique a mesma região do bucket.

8. Clique em Criar.

gcloud

Para criar um catálogo do Hive, execute o seguinte comando:

gcloud beta biglake hive catalogs create LAKEHOUSE_CATALOG_ID \
    --project=PROJECT_ID \
    --location-uri="gs://GCS_WAREHOUSE_PATH" \
    --primary-location=REGION \
    --description="DESCRIPTION"

Substitua:

• LAKEHOUSE_CATALOG_ID: o nome do catálogo do Hive.

• GCS_WAREHOUSE_PATH: o caminho do Cloud Storage que armazena seu data warehouse do Hive.

• PROJECT_ID: o ID do projeto do Google Cloud.

• REGION: a região principal do metastore. Para buckets de região única, ela precisa corresponder à região do bucket. Para buckets birregionais ou multirregionais, ela precisa ser uma das regiões constituintes e onde a réplica principal do metastore está localizada. A outra região se torna a réplica secundária.

• DESCRIPTION: uma descrição do catálogo.

curl

1. Para criar um catálogo do Hive, execute o seguinte comando:

curl -X POST -s -i -H "Authorization: Bearer $(gcloud auth print-access-token)" \
-d '{"locationUri": "gs://GCS_WAREHOUSE_PATH", "description": "DESCRIPTION"}' \
-H "Content-Type:application/json" \ "https://biglake.googleapis.com/hive/v1beta/projects/PROJECT_ID/catalogs?hiveCatalogId=LAKEHOUSE_CATALOG_ID&primary_location=REGION"

Substitua:

• LAKEHOUSE_CATALOG_ID: o nome do catálogo do Hive.

• GCS_WAREHOUSE_PATH: o caminho do Cloud Storage que armazena seu data warehouse do Hive.

• PROJECT_ID: o ID do projeto Google Cloud .

• REGION: a região principal do metastore. Para buckets de região única, ela precisa corresponder à região do bucket. Para buckets birregionais ou multirregionais, ela precisa ser uma das regiões constituintes e onde a réplica principal do metastore está localizada. A outra região se torna a réplica secundária.

  Para rotear solicitações do catálogo do Hive diretamente para uma região específica por motivos de residência e soberania de dados, use endpoints regionais (https://biglake.LOCATION.rep.googleapis.com).

• DESCRIPTION: uma descrição do catálogo.

Configurar e usar o Spark e o Hive

Para usar o catálogo do ambiente de execução do Lakehouse, configure sua sessão do Spark com propriedades específicas. É possível definir essas propriedades ao criar um cluster do Serviço Gerenciado para Apache Spark ou especificá-las sempre que você criar uma sessão.

Essas propriedades incluem detalhes como a fábrica de clientes, o ID do projeto Google Cloud, o catálogo padrão e o diretório do depósito. Depois que a sessão é estabelecida, você pode realizar operações fundamentais, como listar bancos de dados existentes, criar novos bancos de dados, definir tabelas e inserir dados.

spark-sql

1. Use SSH para se conectar ao nó principal do cluster do Serviço Gerenciado para Apache Spark.

2. Execute spark-sql na linha de comando com as seguintes propriedades para iniciar uma sessão interativa do Spark SQL:

   spark-sql \
       --conf spark.hive.metastore.client.factory.class=com.google.cloud.bigquery.metastore.client.BigLakeMetastoreClientFactory \
       --conf spark.hive.metastore.blms.project.id=PROJECT_ID \
       --conf spark.hive.metastore.blms.catalog.default=LAKEHOUSE_CATALOG_ID \
       --conf spark.hive.metastore.warehouse.dir=gs://GCS_WAREHOUSE_PATH
   

3. Depois que a sessão é iniciada, o Spark se conecta ao catálogo do ambiente de execução do Lakehouse.

   Execute os comandos a seguir para criar e consultar recursos:

   
   -- Show all the databases in the current project.
   SHOW DATABASES;
   
   -- Create a database.
   CREATE DATABASE spark_blms_database;
   
   -- Create a Parquet datasource table.
   CREATE TABLE spark_blms_database.parquet_quick_start (id INT, name STRING) USING PARQUET;
   
   -- Insert data into the table.
   INSERT INTO TABLE spark_blms_database.parquet_quick_start VALUES (1, 'my-first-user');
   

   Substitua:

   • PROJECT_ID: o ID do projeto do Google Cloud .

   • LAKEHOUSE_CATALOG_ID: o nome do catálogo do Hive.

   • GCS_WAREHOUSE_PATH: o caminho do Cloud Storage que armazena seu data warehouse do Hive.

Jupyter Notebook

1. Siga as instruções para executar um notebook do Jupyter em um cluster do Serviço Gerenciado para Apache Spark.
2. Acesse a interface da Web do Jupyter na guia Interfaces da Web da página de detalhes do cluster no console do Google Cloud .

3. Em um novo notebook, crie uma sessão do Spark e execute as seguintes consultas:

   from pyspark.sql import SparkSession
   
   # If a Spark session exists, stop it first by running spark.stop()
   spark = SparkSession.builder\
       .master("local")\
       .appName("Lakehouse runtime catalog tutorial")\
       .config("spark.hive.metastore.client.factory.class", "com.google.cloud.bigquery.metastore.client.BigLakeMetastoreClientFactory")\
       .config("spark.hive.metastore.blms.project.id", "PROJECT_ID")\
       .config("spark.hive.metastore.warehouse.dir", "gs://GCS_WAREHOUSE_PATH")\
       .config("spark.hive.metastore.blms.catalog.default", "LAKEHOUSE_CATALOG_ID")\
       .getOrCreate()
   
   # Show all the databases.
   df = spark.sql("SHOW DATABASES;")
   df.show()
   
   # Create a database.
   spark.sql("CREATE DATABASE jupyter_blms_db")
   
   # Create a Parquet datasource table.
   spark.sql("CREATE TABLE jupyter_blms_db.parquet_table(id INT, name STRING) USING PARQUET")
   
   # Insert data into the table.
   spark.sql("INSERT INTO TABLE jupyter_blms_db.parquet_table VALUES (1, 'my-first-user');")
   
   # Query from table.
   spark.sql("SELECT * FROM jupyter_blms_db.parquet_table;").show()
   

   Substitua:

   • PROJECT_ID: o ID do projeto do Google Cloud .

   • GCS_WAREHOUSE_PATH: o caminho do Cloud Storage que armazena seu data warehouse do Hive.

   • LAKEHOUSE_CATALOG_ID: o nome do catálogo do Hive.

Notebook do BigQuery

1. No console Google Cloud , acesse o BigQuery.

   Acessar o BigQuery

2. No painel Explorer, clique em + ADICIONAR e em Notebook Python.

3. Em uma célula de código, configure a sessão do Serviço Gerenciado para Apache Spark e as propriedades do catálogo do ambiente de execução do Lakehouse:

   from google.cloud.dataproc_spark_connect import DataprocSparkSession
   from google.cloud.dataproc_v1 import Session
   import os
   
   os.environ['DATAPROC_SPARK_CONNECT_DEFAULT_DATASOURCE'] = ""
   
   session = Session()
   session.environment_config.execution_config.ttl = {"seconds": 864000}
   session.runtime_config.version = "2.3"
   session.runtime_config.properties = {
    "spark.hive.metastore.blms.project.id": "PROJECT_ID",
    "spark.hive.metastore.blms.catalog.default": "LAKEHOUSE_CATALOG_ID",
    "spark.hive.metastore.warehouse.dir": "gs://GCS_WAREHOUSE_PATH",
    "spark.hive.metastore.client.factory.class": "com.google.cloud.bigquery.metastore.client.BigLakeMetastoreClientFactory",
    "spark.sql.catalogImplementation": "hive"
   }
   
   spark = DataprocSparkSession.builder.dataprocSessionConfig(session).getOrCreate()
   print("Spark session created successfully")
   

4. Em outra célula de código, crie um banco de dados e uma tabela:

   # Create a database
   spark.sql("CREATE DATABASE bq_spark_blms_database;")
   
   # Create a parquet datasource table
   spark.sql("CREATE TABLE bq_spark_blms_database.parquet_quick_start (id INT, name STRING) USING PARQUET;")
   
   # Insert data into the table
   spark.sql("INSERT INTO TABLE bq_spark_blms_database.parquet_quick_start VALUES (1, 'my-first-user');")
   
   # Query from table
   spark.sql("select * from bq_spark_blms_database.parquet_quick_start;").show()
   

   Substitua:

   • PROJECT_ID: o ID do projeto do Google Cloud .

   • GCS_WAREHOUSE_PATH: o caminho do Cloud Storage que armazena seu data warehouse do Hive.

   • LAKEHOUSE_CATALOG_ID: o nome do catálogo do Hive.

CLI do Hive

Para usar a CLI do Hive, configure-a para se conectar ao metastore. Você pode fazer isso de duas maneiras:

• Opção 1: configuração permanente. Atualize o arquivo /etc/hive/conf/hive-site.xml no nó principal.
• Opção 2: configuração temporária. Forneça flags de configuração ao iniciar a CLI.

Para configurar a CLI e executar sua sessão de consulta, siga estas etapas:

1. Use SSH para se conectar ao nó principal do cluster do Serviço Gerenciado para Apache Spark.

2. Dependendo do seu método de configuração, faça o seguinte:

   • Para configurar permanentemente (opção 1):

     1. Abra /etc/hive/conf/hive-site.xml no nó principal e adicione as seguintes propriedades:

        <property>
            <name>hive.metastore.blms.project.id</name>
            <value>PROJECT_ID</value>
            <description></description>
        </property>
        
        <property>
            <name>hive.metastore.client.factory.class</name>
            <value>com.google.cloud.bigquery.metastore.client.BigLakeMetastoreClientFactory</value>
            <description></description>
        </property>
        <property>
            <name>hive.metastore.blms.catalog.default</name>
            <value>LAKEHOUSE_CATALOG_ID</value>
            <description></description>
        </property>
        <property>
            <name>hive.metastore.warehouse.dir</name>
            <value>gs://GCS_WAREHOUSE_PATH</value>
            <description></description>
        </property>
        

     2. Inicie a CLI do Hive:

        hive
        

   • Para configurar temporariamente na inicialização (opção 2): inicie a CLI do Hive com flags de configuração:

     hive \
     --hiveconf hive.metastore.blms.project.id="PROJECT_ID" \
     --hiveconf hive.metastore.blms.catalog.default="LAKEHOUSE_CATALOG_ID" \
     --hiveconf hive.metastore.client.factory.class=com.google.cloud.bigquery.metastore.client.BigLakeMetastoreClientFactory \
     --hiveconf hive.metastore.warehouse.dir="gs://GCS_WAREHOUSE_PATH"
     

3. Em seguida, execute os seguintes comandos na sessão da CLI do Hive:

   show databases;
   create database hive_query_test;
   create table hive_query_test.parquet_table (id INT, name STRING) stored as PARQUET;
   select * from hive_query_test.parquet_table;
   

   Substitua:

   • PROJECT_ID: o ID do projeto do Google Cloud .

   • LAKEHOUSE_CATALOG_ID: o nome do catálogo do Hive.

   • GCS_WAREHOUSE_PATH: o caminho do Cloud Storage que armazena seu data warehouse do Hive.

Enviar um job em lote do Serviço Gerenciado para Apache Spark

É possível enviar uma carga de trabalho em lote do PySpark para o Serviço Gerenciado para Apache Spark que usa o catálogo do ambiente de execução do Lakehouse.

Esse snippet do PySpark inicializa uma sessão do Spark configurada para se conectar ao catálogo do ambiente de execução do Lakehouse. Ele define propriedades essenciais,como a fábrica de clientes do Lakehouse, o ID do projeto Google Cloud , o catálogo padrão e o diretório do data warehouse. Depois de estabelecer a sessão, o código demonstra como listar bancos de dados atuais, criar um novo banco de dados e definir uma tabela formatada em Parquet nesse banco de dados usando comandos do Spark SQL.

1. Crie um arquivo Python com um job do PySpark:

   from pyspark.sql import SparkSession
   
   spark = (
       SparkSession.builder.appName("Lakehouse runtime catalog tutorial")
       .config(
          "spark.hive.metastore.client.factory.class",
   "com.google.cloud.bigquery.metastore.client.BigLakeMetastoreClientFactory")
       .config("spark.hive.metastore.blms.project.id", "PROJECT_ID")
       .config("spark.hive.metastore.blms.catalog.default", "LAKEHOUSE_CATALOG_ID")
       .config(
           "spark.hive.metastore.warehouse.dir",
           "gs://GCS_WAREHOUSE_PATH",
       )
       .enableHiveSupport()
       .getOrCreate()
   )
   
   # Show all the databases.
   spark.sql("SHOW DATABASES;").show()
   
   # Create a database.
   spark.sql("CREATE DATABASE dp_serverless_test")
   
   # Create a Parquet datasource table.
   spark.sql(
           "CREATE TABLE dp_serverless_test.parquet_table(id INT, name STRING) USING"
           " PARQUET"
       )
   
   # Query from table.
   spark.sql("SELECT * from  dp_serverless_test.parquet_table").show()
   

   Substitua:

   • PROJECT_ID: o ID do projeto Google Cloud .

   • LAKEHOUSE_CATALOG_ID: o nome do catálogo do Hive.

   • GCS_WAREHOUSE_PATH: o caminho do Cloud Storage que armazena seu data warehouse do Hive.

2. Envie o job em lote:

   gcloud dataproc batches submit pyspark PYTHON_SCRIPT_FILE \
       --version=2.2 \
       --project=PROJECT_ID \
       --region=REGION \
       --deps-bucket=gs://CLOUD_STORAGE_BUCKET
   

   Substitua:

   • PYTHON_SCRIPT_FILE: o caminho para o arquivo de aplicativo PySpark. Pode ser um caminho local ou o caminho do objeto do Cloud Storage.
   • PROJECT_ID: o ID do projeto.
   • REGION: a região em que o job em lote será executado.
   • CLOUD_STORAGE_BUCKET: o nome do bucket do Cloud Storage usado para preparar as dependências de qualquer carga de trabalho.

Consultar a tabela no BigQuery

Depois de criar recursos do Spark no catálogo do ambiente de execução do Lakehouse, você pode consultá-los no BigQuery Studio.

1. No console Google Cloud , acesse o BigQuery.

   Acessar o BigQuery

2. No editor de consultas, digite a seguinte instrução:

   SELECT * FROM `PROJECT_ID.LAKEHOUSE_CATALOG_ID.DATABASE_NAME.TABLE_NAME`;
   

   Substitua:

   • PROJECT_ID: o ID do projeto.
   • LAKEHOUSE_CATALOG_ID: o nome do catálogo do Hive.
   • DATABASE_NAME: o nome do banco de dados.
   • TABLE_NAME: o nome da sua tabela.