English
Deutsch
Español
Español – América Latina
Français
Indonesia
Italiano
Português
Português – Brasil
中文 – 简体
中文 – 繁體
日本語
한국어

Console

Esta página foi traduzida pela API Cloud Translation.

Use o Apache Spark com o HBase no Dataproc

<0x A versão 1.5 do Dataproc e a versão 2.0 do Dataproc oferecem uma versão beta do HBase sem suporte. No entanto, devido à natureza efémera dos clusters do Dataproc, não é recomendável usar o HBase.

Objetivos

Este tutorial mostra como:

Crie um cluster do Dataproc, instalando o Apache HBase e o Apache ZooKeeper no cluster
Crie uma tabela HBase com o shell HBase em execução no nó principal do cluster Dataproc
Use o Cloud Shell para enviar uma tarefa do Spark Java ou PySpark para o serviço Dataproc que escreve dados na tabela HBase e, em seguida, lê dados da mesma

Custos

Neste documento, usa os seguintes componentes faturáveis do Google Cloud:

Para gerar uma estimativa de custos com base na sua utilização projetada, use a calculadora de preços.

Os novos Google Cloud utilizadores podem ser elegíveis para uma avaliação gratuita.

Antes de começar

Se ainda não o fez, crie um projeto da Google Cloud Platform.

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the Dataproc and Compute Engine APIs.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the APIs

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the Dataproc and Compute Engine APIs.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the APIs

Crie um cluster do Dataproc

Execute o seguinte comando num terminal de sessão do Cloud Shell para:
- Instale os componentes HBase e ZooKeeper
- Aprovisione três nós de trabalho (recomenda-se que tenha entre três e cinco trabalhadores para executar o código neste tutorial)
- Ative o Component Gateway
- Use a versão 2.0 da imagem
- Use a flag --properties para adicionar a configuração do HBase e a biblioteca do HBase aos caminhos de classe do controlador e do executor do Spark.

gcloud dataproc clusters create cluster-name \
    --region=region \
    --optional-components=HBASE,ZOOKEEPER \
    --num-workers=3 \
    --enable-component-gateway \
    --image-version=2.0 \
    --properties='spark:spark.driver.extraClassPath=/etc/hbase/conf:/usr/lib/hbase/*,spark:spark.executor.extraClassPath=/etc/hbase/conf:/usr/lib/hbase/*'

Valide a instalação do conetor

A partir da Google Cloud consola ou de um terminal de sessão do Cloud Shell, use SSH no nó principal do cluster do Dataproc.

Valide a instalação do conetor Apache HBase Spark no nó principal:

ls -l /usr/lib/spark/jars | grep hbase-spark

Exemplo de saída:

-rw-r--r-- 1 root root size date time hbase-spark-connector.version.jar

Mantenha o terminal da sessão SSH aberto para:
1. Crie uma tabela HBase
2. (Utilizadores de Java): execute comandos no nó principal do cluster para determinar as versões dos componentes instalados no cluster
3. Leia a sua tabela Hbase depois de executar o código

Crie uma tabela HBase

Execute os comandos indicados nesta secção no terminal da sessão SSH do nó principal que abriu no passo anterior.

Abra a shell do HBase:
```
hbase shell
```
Crie uma tabela "my-table" do HBase com uma família de colunas "cf":
```
create 'my_table','cf'
```
1. Para confirmar a criação da tabela, na Google Cloud consola, clique em HBase nos Google Cloud links do Component Gateway da consola para abrir a IU do Apache HBase. my-table é apresentado na secção Tabelas da página Página inicial.

Veja o código do Spark

Java

package hbase;

import org.apache.hadoop.hbase.spark.datasources.HBaseTableCatalog;
import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.SparkSession;

import java.io.Serializable;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

public class SparkHBaseMain {
    public static class SampleData implements Serializable {
        private String key;
        private String name;


        public SampleData(String key, String name) {
            this.key = key;
            this.name = name;
        }

        public SampleData() {
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public String getKey() {
            return key;
        }

        public void setKey(String key) {
            this.key = key;
        }
    }
    public static void main(String[] args) {
        // Init SparkSession
        SparkSession spark = SparkSession
                .builder()
                .master("yarn")
                .appName("spark-hbase-tutorial")
                .getOrCreate();

        // Data Schema
        String catalog = "{"+"\"table\":{\"namespace\":\"default\", \"name\":\"my_table\"}," +
                "\"rowkey\":\"key\"," +
                "\"columns\":{" +
                "\"key\":{\"cf\":\"rowkey\", \"col\":\"key\", \"type\":\"string\"}," +
                "\"name\":{\"cf\":\"cf\", \"col\":\"name\", \"type\":\"string\"}" +
                "}" +
                "}";

        Map<String, String> optionsMap = new HashMap<String, String>();
        optionsMap.put(HBaseTableCatalog.tableCatalog(), catalog);

        Dataset<Row> ds= spark.createDataFrame(Arrays.asList(
                new SampleData("key1", "foo"),
                new SampleData("key2", "bar")), SampleData.class);

        // Write to HBase
        ds.write()
                .format("org.apache.hadoop.hbase.spark")
                .options(optionsMap)
                .option("hbase.spark.use.hbasecontext", "false")
                .mode("overwrite")
                .save();

        // Read from HBase
        Dataset dataset = spark.read()
                .format("org.apache.hadoop.hbase.spark")
                .options(optionsMap)
                .option("hbase.spark.use.hbasecontext", "false")
                .load();
        dataset.show();
    }
}

Python

from pyspark.sql import SparkSession

# Initialize Spark Session
spark = SparkSession \
  .builder \
  .master('yarn') \
  .appName('spark-hbase-tutorial') \
  .getOrCreate()

data_source_format = ''

# Create some test data
df = spark.createDataFrame(
    [
        ("key1", "foo"),
        ("key2", "bar"),
    ],
    ["key", "name"]
)

# Define the schema for catalog
catalog = ''.join("""{
    "table":{"namespace":"default", "name":"my_table"},
    "rowkey":"key",
    "columns":{
        "key":{"cf":"rowkey", "col":"key", "type":"string"},
        "name":{"cf":"cf", "col":"name", "type":"string"}
    }
}""".split())

# Write to HBase
df.write.format('org.apache.hadoop.hbase.spark').options(catalog=catalog).option("hbase.spark.use.hbasecontext", "false").mode("overwrite").save()

# Read from HBase
result = spark.read.format('org.apache.hadoop.hbase.spark').options(catalog=catalog).option("hbase.spark.use.hbasecontext", "false").load()
result.show()

Executar o código

Abra um terminal de sessão do Cloud Shell.

Nota: execute os comandos indicados nesta secção num terminal de sessão do Cloud Shell. O Cloud Shell tem as ferramentas necessárias para este tutorial pré-instaladas, incluindo a CLI gcloud, o git, o Apache Maven, o Java e o Python, além de outras ferramentas.
Clone o repositório do GitHub GoogleCloudDataproc/cloud-dataproc para o terminal da sessão do Cloud Shell:
```
git clone https://github.com/GoogleCloudDataproc/cloud-dataproc.git
```

Altere para o diretório cloud-dataproc/spark-hbase:

cd cloud-dataproc/spark-hbase

Exemplo de saída:

user-name@cloudshell:~/cloud-dataproc/spark-hbase (project-id)$

Envie a tarefa do Dataproc.

Java

Defina as versões dos componentes no ficheiro pom.xml.
1. A página Versões de lançamento do Dataproc 2.0.x apresenta as versões dos componentes Scala, Spark e HBase instalados com as quatro subversões 2.0 de imagem mais recentes e a última.
  1. Para encontrar a versão secundária do cluster da versão de imagem 2.0, clique no nome do cluster na página Clusters na Google Cloud consola para abrir a página Detalhes do cluster, onde a versão de imagem do cluster é apresentada.
2. Em alternativa, pode executar os seguintes comandos num terminal de sessão SSH a partir do nó principal do cluster para determinar as versões dos componentes:
  1. Verifique a versão do Scala:
```
scala -version
```
  2. Verifique a versão do Spark (prima Control + D para sair):
```
spark-shell
```
  3. Verifique a versão do HBase:
```
hbase version
```
  4. Identifique as dependências de versão do Spark, Scala e HBase no Maven pom.xml:
```
<properties>
  <scala.version>scala full version (for example, 2.12.14)</scala.version>
  <scala.main.version>scala main version (for example, 2.12)</scala.main.version>
  <spark.version>spark version (for example, 3.1.2)</spark.version>
  <hbase.client.version>hbase version (for example, 2.2.7)</hbase.client.version>
  <hbase-spark.version>1.0.0(the current Apache HBase Spark Connector version)>
</properties>
```
    Nota: hbase-spark.version é a versão atual do conector do Spark HBase; deixe este número da versão inalterado.
3. Edite o ficheiro pom.xml no editor do Cloud Shell para inserir os números de versão corretos do Scala, Spark e HBase. Clique em Abrir terminal quando terminar a edição para voltar à linha de comandos do terminal do Cloud Shell.
```
cloudshell edit .
```
4. Mude para o Java 8 no Cloud Shell. Esta versão do JDK é necessária para criar o código (pode ignorar quaisquer mensagens de aviso de plug-ins):
```
sudo update-java-alternatives -s java-1.8.0-openjdk-amd64 && export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64
```
5. Valide a instalação do Java 8:
```
java -version
```
  Exemplo de saída:
```
openjdk version "1.8..."
 
```
Crie o ficheiro jar:
```
mvn clean package
```
O ficheiro .jar é colocado no subdiretório /target (por exemplo, target/spark-hbase-1.0-SNAPSHOT.jar.

Envie o trabalho.

gcloud dataproc jobs submit spark \
    --class=hbase.SparkHBaseMain  \
    --jars=target/filename.jar \
    --region=cluster-region \
    --cluster=cluster-name

--jars: insira o nome do ficheiro .jar após "target/" e antes de ".jar".
Se não definiu os caminhos de classe do HBase do controlador e do executor do Spark quando criou o cluster, tem de defini-los com cada envio de tarefa, incluindo a seguinte flag ‑‑properties no comando de envio de tarefa:
```
--properties='spark.driver.extraClassPath=/etc/hbase/conf:/usr/lib/hbase/*,spark.executor.extraClassPath=/etc/hbase/conf:/usr/lib/hbase/*'
       
```

Veja a saída da tabela HBase na saída do terminal da sessão do Cloud Shell:

Waiting for job output...
...
+----+----+
| key|name|
+----+----+
|key1| foo|
|key2| bar|
+----+----+

Python

Envie o trabalho.

gcloud dataproc jobs submit pyspark scripts/pyspark-hbase.py \
    --region=cluster-region \
    --cluster=cluster-name

Se não definiu os caminhos de classe do HBase do controlador e do executor do Spark quando criou o cluster, tem de defini-los com cada envio de tarefa, incluindo a seguinte flag ‑‑properties no comando de envio de tarefa:
```
--properties='spark.driver.extraClassPath=/etc/hbase/conf:/usr/lib/hbase/*,spark.executor.extraClassPath=/etc/hbase/conf:/usr/lib/hbase/*'
       
```

Veja a saída da tabela HBase na saída do terminal da sessão do Cloud Shell:

Waiting for job output...
...
+----+----+
| key|name|
+----+----+
|key1| foo|
|key2| bar|
+----+----+

Analise a tabela HBase

Pode analisar o conteúdo da sua tabela HBase executando os seguintes comandos no terminal da sessão SSH do nó principal que abriu em Verifique a instalação do conector:

Abra a shell do HBase:
```
hbase shell
```
Analisar "my-table":
```
scan 'my_table'
```
Exemplo de saída:
```
ROW               COLUMN+CELL
 key1             column=cf:name, timestamp=1647364013561, value=foo
 key2             column=cf:name, timestamp=1647364012817, value=bar
2 row(s)
Took 0.5009 seconds
```
Limpar

Depois de concluir o tutorial, pode limpar os recursos que criou para que deixem de usar a quota e incorrer em custos. As secções seguintes descrevem como eliminar ou desativar estes recursos.

Elimine o projeto

A forma mais fácil de eliminar a faturação é eliminar o projeto que criou para o tutorial.

Para eliminar o projeto:
1. In the Google Cloud console, go to the Manage resources page.
  Go to Manage resources
2. In the project list, select the project that you want to delete, and then click Delete.
3. In the dialog, type the project ID, and then click Shut down to delete the project.
Elimine o cluster
- Para eliminar o cluster:
```
gcloud dataproc clusters delete cluster-name \
    --region=${REGION}
```

Exceto em caso de indicação contrária, o conteúdo desta página é licenciado de acordo com a Licença de atribuição 4.0 do Creative Commons, e as amostras de código são licenciadas de acordo com a Licença Apache 2.0. Para mais detalhes, consulte as políticas do site do Google Developers. Java é uma marca registrada da Oracle e/ou afiliadas.

Última atualização 2025-09-29 UTC.

Use o Apache Spark com o HBase no Dataproc Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Objetivos

Custos

Antes de começar

Crie um cluster do Dataproc

Valide a instalação do conetor

Crie uma tabela HBase

Veja o código do Spark

Java

Python

Executar o código

Java

Python

Analise a tabela HBase

Limpar

Elimine o projeto

Elimine o cluster

Use o Apache Spark com o HBase no Dataproc