"Serviço gerenciado para Apache Spark" é o novo nome do produto antes conhecido como "Dataproc no Compute Engine" (implantação de cluster) e "Google Cloud Serverless para Apache Spark" (implantação sem servidor).

Usar o Apache Spark com o HBase no Managed Service for Apache Spark

{ O Serviço Gerenciado para Apache Spark versão 1.5 e o Serviço Gerenciado para Apache Spark versão 2.0 oferecem uma versão Beta do HBase sem suporte. No entanto, devido à natureza efêmera dos clusters do Serviço Gerenciado para Apache Spark, o uso do HBase não é recomendado.

Objetivos

Neste tutorial, mostramos como fazer as seguintes tarefas:

Criar um cluster do Serviço Gerenciado para Apache Spark, instalando o Apache HBase e o Apache ZooKeeper no cluster
Criar uma tabela do HBase usando o shell do HBase em execução no nó mestre do cluster do Serviço Gerenciado para Apache Spark
Usar o Cloud Shell para enviar um job do Spark Java ou PySpark ao Serviço Gerenciado para Apache Spark que grava dados na tabela do HBase e, em seguida, lê dados dela

Custos

Neste documento, você vai usar os seguintes componentes faturáveis do Google Cloud:

Para gerar uma estimativa de custo baseada na projeção de uso, use a calculadora de preços.

Novos usuários do Google Cloud podem estar qualificados para um teste sem custo financeiro.

Antes de começar

Se ainda não tiver feito, crie um projeto do Google Cloud Platform.

Faça login na sua Google Cloud conta do. Se você começou a usar o Google Cloud, 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.

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 role (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 role (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

Criar um cluster do Serviço Gerenciado para Apache Spark

Execute o comando a seguir em um terminal de sessão do Cloud Shell para:
- Instalar os componentes do HBase e do ZooKeeper
- Provisionar três nós de trabalho (três a cinco workers são recomendados para executar o código neste tutorial)
- Ativar o Gateway de componentes
- Usar a versão de imagem 2.0
- Usar a flag --properties para adicionar a configuração e a biblioteca do HBase aos caminhos de classe do driver 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/*'

Verificar a instalação do conector

No Google Cloud console ou em um terminal de sessão do Cloud Shell, use SSH no nó mestre do cluster do Serviço Gerenciado para Apache Spark.

Verifique a instalação do conector do Apache HBase Spark no nó mestre:

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 de sessão SSH aberto para:
1. Criar uma tabela do HBase
2. (Usuários Java): execute comandos no nó mestre do cluster para determinar as versões dos componentes instalados no cluster
3. Verificar a tabela do HBase depois de você executar o código

Criar uma tabela do HBase

Execute os comandos listados nesta seção no terminal de sessão SSH do nó mestre que você abriu na etapa anterior.

Abra o shell do HBase:
```
hbase shell
```
Crie uma tabela do HBase "my-table" com um grupo de colunas "cf":
```
create 'my_table','cf'
```
1. Para confirmar a criação da tabela, no Google Cloud console, clique em HBase nos Google Cloud links do Gateway de componentes do console para abrir a interface do Apache HBase. my-table está listada na seção Tabelas da página Início.

Conferir 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.

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

Mude 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 o job do Serviço Gerenciado para Apache Spark.

Java

Defina as versões dos componentes no arquivo pom.xml.
1. A página de versões do Serviço Gerenciado para Apache Spark 2.0.x lista as versões dos componentes Scala, Spark e HBase instalados com as quatro versões secundárias mais recentes e anteriores da imagem 2.0.
  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 no Google Cloud console para abrir a página Detalhes do cluster, em que a versão da imagem do cluster está listada.
2. Como alternativa, você pode executar os comandos a seguir em um terminal de sessão SSH do nó mestre 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 (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>
```
    Observação: hbase-spark.version é a versão atual do conector do Spark HBase. Deixe esse número de versão inalterado.
3. Edite o arquivo 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 de editar para retornar à linha de comando do terminal do Cloud Shell.
```
cloudshell edit .
```
4. Mude para o Java 8 no Cloud Shell. Essa versão do JDK é necessária para criar o código. Ignore todas as mensagens de aviso do plug-in:
```
sudo update-java-alternatives -s java-1.8.0-openjdk-amd64 && export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64
```
5. Verifique a instalação do Java 8:
```
java -version
```
  Exemplo de saída:
```
openjdk version "1.8..."
 
```
Crie o arquivo jar:
```
mvn clean package
```
O arquivo .jar é colocado no subdiretório /target, por exemplo, target/spark-hbase-1.0-SNAPSHOT.jar.

Envie o job.

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

--jars: insira o nome do arquivo .jar após "target/" e antes de ".jar".
Se você não definiu os caminhos de classe do HBase do driver e do executor do Spark ao criar o cluster, é necessário defini-los com cada envio de job, incluindo a seguinte flag ‑‑properties no comando de envio do job:
```
--properties='spark.driver.extraClassPath=/etc/hbase/conf:/usr/lib/hbase/*,spark.executor.extraClassPath=/etc/hbase/conf:/usr/lib/hbase/*'
       
```

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

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

Python

Envie o job.

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

Se você não definiu os caminhos de classe do HBase do driver e do executor do Spark ao criar o cluster, é necessário defini-los com cada envio de job, incluindo a seguinte flag ‑‑properties no comando de envio do job:
```
--properties='spark.driver.extraClassPath=/etc/hbase/conf:/usr/lib/hbase/*,spark.executor.extraClassPath=/etc/hbase/conf:/usr/lib/hbase/*'
       
```

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

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

Verificar a tabela do HBase

É possível verificar o conteúdo da tabela do HBase executando os comandos a seguir no terminal de sessão SSH do nó mestre que você abriu em Verificar a instalação do conector:

Abra o shell do HBase:
```
hbase shell
```

Verifique "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, você pode limpar os recursos que criou para que eles parem de usar a cota e gerar cobranças. Nas seções a seguir, você aprenderá a excluir e desativar esses recursos.

Exclua o projeto

O jeito mais fácil de evitar cobranças é excluindo o projeto que você criou para o tutorial.

Para excluir o projeto:

No Google Cloud console, acesse a página Gerenciar recursos.
Acessar "Gerenciar recursos"
Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir.
Na caixa de diálogo, digite o ID do projeto e clique em Desligar para excluir o projeto.

excluir o cluster

Para excluir 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 2026-04-30 UTC.

Usar o Apache Spark com o HBase no Managed Service for Apache Spark 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

Criar um cluster do Serviço Gerenciado para Apache Spark

Verificar a instalação do conector

Criar uma tabela do HBase

Conferir o código do Spark

Java

Python

Executar o código

Java

Python

Verificar a tabela do HBase

Limpar

Exclua o projeto

excluir o cluster

Usar o Apache Spark com o HBase no Managed Service for Apache Spark