"Managed Service for Apache Spark" è il nuovo nome del prodotto precedentemente noto come "Dataproc on Compute Engine" (deployment del cluster) e "Google Cloud Serverless for Apache Spark" (deployment serverless).

Utilizza Apache Spark con HBase su Managed Service per Apache Spark

Obsoleto: A partire dalla versione 2.1 di Managed Service for Apache Spark, non puoi più utilizzare il componente HBase facoltativo. Managed Service for Apache Spark versione 1.5 e Managed Service for Apache Spark versione 2.0 offrono una versione beta di HBase senza supporto. Tuttavia, a causa della natura effimera dei cluster Managed Service for Apache Spark, l'utilizzo di HBase non è consigliato.

Obiettivi

Questo tutorial mostra come:

Creare un cluster Managed Service for Apache Spark, installando Apache HBase e Apache ZooKeeper sul cluster
Creare una tabella HBase utilizzando la shell HBase in esecuzione sul nodo master del cluster Managed Service for Apache Spark
Utilizzare Cloud Shell per inviare un job Spark Java o PySpark al servizio Managed Service for Apache Spark che scrive i dati nella tabella HBase e poi li legge

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il calcolatore prezzi.

I nuovi Google Cloud utenti potrebbero avere diritto a una prova senza costi.

Prima di iniziare

Se non l'hai già fatto, crea un progetto Google Cloud Platform.

Accedi al tuo Google Cloud account. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti senza costi per l'esecuzione, il test e il deployment dei workload.

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

Crea un cluster Managed Service for Apache Spark

Esegui il seguente comando in un terminale della sessione Cloud Shell per:
- Installare i componenti HBase e ZooKeeper
- Eseguire il provisioning di tre nodi worker (per eseguire il codice in questo tutorial sono consigliati da tre a cinque worker)
- Abilitare il gateway dei componenti
- Utilizzare la versione dell'immagine 2.0
- Utilizzare il flag --properties per aggiungere la configurazione HBase e la libreria HBase ai classpath del driver e dell'executor 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/*'

Verifica l'installazione del connettore

Dalla Google Cloud consolle o da un terminale della sessione Cloud Shell, esegui SSH nel nodo master del cluster Managed Service for Apache Spark.

Verifica l'installazione del connettore Apache HBase Spark sul nodo master:

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

Esempio di output:

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

Tieni aperto il terminale della sessione SSH per:
1. Creare una tabella HBase
2. (Utenti Java): eseguire comandi sul nodo master del cluster per determinare le versioni dei componenti installati su il cluster
3. Scansionare la tabella HBase dopo aver eseguito il codice

Crea una tabella HBase

Esegui i comandi elencati in questa sezione nel terminale della sessione SSH del nodo master che hai aperto nel passaggio precedente.

Apri la shell HBase:
```
hbase shell
```
Crea una tabella HBase "my-table" con una famiglia di colonne "cf":
```
create 'my_table','cf'
```
1. Per confermare la creazione della tabella, nella Google Cloud console, fai clic su HBase nei Google Cloud link del gateway dei componenti della console per aprire l'interfaccia utente di Apache HBase. my-table è elencata nella sezione Tabelle della pagina Home.

Visualizza il codice 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()

Esegui il codice

Apri un terminale della sessione Cloud Shell.

Nota: esegui i comandi elencati in questa sezione in un terminale della sessione Cloud Shell. Cloud Shell ha preinstallato gli strumenti richiesti da questo tutorial, tra cui gcloud CLI, git, Apache Maven, Java e Python, oltre ad altri strumenti.
Clona il repository GitHub GoogleCloudDataproc/cloud-dataproc nel terminale della sessione Cloud Shell:
```
git clone https://github.com/GoogleCloudDataproc/cloud-dataproc.git
```

Passa alla directory cloud-dataproc/spark-hbase:

cd cloud-dataproc/spark-hbase

Esempio di output:

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

Invia il job Managed Service for Apache Spark.

Java

Imposta le versioni dei componenti nel file pom.xml.
1. La pagina delle versioni di rilascio di Managed Service for Apache Spark 2.0.x elenca le versioni dei componenti Scala, Spark e HBase installate con le quattro versioni secondarie 2.0 più recenti e le ultime quattro versioni secondarie dell'immagine.
  1. Per trovare la versione secondaria del cluster della versione dell'immagine 2.0, fai clic sul nome del cluster nella pagina Cluster della Google Cloud console per aprire la pagina Dettagli cluster, in cui è elencata la **versione dell'immagine** del cluster.
2. In alternativa, puoi eseguire i seguenti comandi in un terminale della sessione SSH dal nodo master del cluster per determinare le versioni dei componenti:
  1. Controlla la versione di Scala:
```
scala -version
```
  2. Controlla la versione di Spark (control-D per uscire):
```
spark-shell
```
  3. Controlla la versione di HBase:
```
hbase version
```
  4. Identifica le dipendenze della versione di Spark, Scala e HBase nel file 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 è la versione corrente del connettore Spark HBase; lascia invariato questo numero di versione.
3. Modifica il file pom.xml nell'editor di Cloud Shell per inserire i numeri di versione corretti di Scala, Spark e HBase. Al termine della modifica, fai clic su Apri terminale per tornare alla riga di comando del terminale Cloud Shell.
```
cloudshell edit .
```
4. Passa a Java 8 in Cloud Shell. Questa versione JDK è necessaria per creare il codice (puoi ignorare eventuali messaggi di avviso dei plug-in):
```
sudo update-java-alternatives -s java-1.8.0-openjdk-amd64 && export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64
```
5. Verifica l'installazione di Java 8:
```
java -version
```
  Esempio di output:
```
openjdk version "1.8..."
 
```
Crea il file jar:
```
mvn clean package
```
Il file .jar viene inserito nella sottodirectory /target (ad esempio, target/spark-hbase-1.0-SNAPSHOT.jar.

Invia il job.

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

--jars: inserisci il nome del file .jar dopo "target/" e prima di ".jar".
Se non hai impostato i classpath HBase del driver e dell'executor Spark quando hai creato il cluster, devi impostarli a ogni invio del job includendo il seguente ‑‑properties flag nel comando di invio del job:
```
--properties='spark.driver.extraClassPath=/etc/hbase/conf:/usr/lib/hbase/*,spark.executor.extraClassPath=/etc/hbase/conf:/usr/lib/hbase/*'
       
```

Visualizza l'output della tabella HBase nell'output del terminale della sessione Cloud Shell:

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

Python

Invia il job.

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

Se non hai impostato i classpath HBase del driver e dell'executor Spark quando hai creato il cluster, devi impostarli a ogni invio del job includendo il seguente ‑‑properties flag nel comando di invio del job:
```
--properties='spark.driver.extraClassPath=/etc/hbase/conf:/usr/lib/hbase/*,spark.executor.extraClassPath=/etc/hbase/conf:/usr/lib/hbase/*'
       
```

Visualizza l'output della tabella HBase nell'output del terminale della sessione Cloud Shell:

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

Scansiona la tabella HBase

Puoi scansionare i contenuti della tabella HBase by running i seguenti comandi nel terminale della sessione SSH del nodo master che hai aperto in Verifica l'installazione del connettore:

Apri la shell HBase:
```
hbase shell
```

Scansiona "my-table":

scan 'my_table'

Esempio di output:

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

Libera spazio

Al termine del tutorial, puoi eliminare le risorse che hai creato in modo che non utilizzino più la quota generando addebiti. Le seguenti sezioni descrivono come eliminare o disattivare queste risorse.

Elimina il progetto

Il modo più semplice per eliminare la fatturazione è eliminare il progetto creato per il tutorial.

Per eliminare il progetto:

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:

L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per, le attività descritte in questo documento, eliminerai anche tutto il lavoro che hai svolto nel progetto.
Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un URL appspot.com, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, puoi riutilizzare i progetti ed evitare così di superare i limiti di quota.

Nella Google Cloud console, vai alla pagina Gestisci risorse.
Vai a Gestisci risorse
Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
Nella finestra di dialogo, digita l'ID progetto e fai clic su Chiudi per eliminare il progetto.

Elimina il cluster

Per eliminare il cluster:

gcloud dataproc clusters delete cluster-name \
    --region=${REGION}

Salvo quando diversamente specificato, i contenuti di questa pagina sono concessi in base alla licenza Creative Commons Attribution 4.0, mentre gli esempi di codice sono concessi in base alla licenza Apache 2.0. Per ulteriori dettagli, consulta le norme del sito di Google Developers. Java è un marchio registrato di Oracle e/o delle sue consociate.

Ultimo aggiornamento 2026-04-30 UTC.

Utilizza Apache Spark con HBase su Managed Service per Apache Spark Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Obiettivi

Costi

Prima di iniziare

Crea un cluster Managed Service for Apache Spark

Verifica l'installazione del connettore

Crea una tabella HBase

Visualizza il codice Spark

Java

Python

Esegui il codice

Java

Python

Scansiona la tabella HBase

Libera spazio

Elimina il progetto

Elimina il cluster

Utilizza Apache Spark con HBase su Managed Service per Apache Spark