"Managed Service for Apache Spark" is the new name for the product formerly known as "Dataproc on Compute Engine" (cluster deployment) and "Google Cloud Serverless for Apache Spark" (serverless deployment).

Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Utiliser Apache Spark avec HBase sur Managed Service pour Apache Spark

Obsolète : À partir de Managed Service pour Apache Spark version 2.1, vous ne pouvez plus utiliser le composant HBase facultatif. Managed Service pour Apache Spark version 1.5 et Managed Service pour Apache Spark version 2.0 proposent une version bêta de HBase sans assistance. Toutefois, en raison de la nature éphémère des clusters Managed Service pour Apache Spark, l'utilisation de HBase n'est pas recommandée.

Objectifs

Ce tutoriel vous explique comment :

Créer un cluster Managed Service pour Apache Spark, en installant Apache HBase et Apache ZooKeeper sur le cluster
Créer une table HBase à l'aide du shell HBase exécuté sur le nœud maître du cluster Managed Service pour Apache Spark
Utiliser Cloud Shell pour envoyer une tâche Spark Java ou PySpark à Managed Service pour Apache Spark, qui écrit des données dans la table HBase, puis les lit

Coûts

Dans ce tutoriel, vous utilisez les composants facturables de suivants Google Cloud:

Obtenez une estimation des coûts en fonction de votre utilisation prévue, utilisez le simulateur de coût.

Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai sans frais.

Avant de commencer

Si ce n'est pas déjà fait, créez un projet Google Cloud Platform.

Connectez-vous à votre Google Cloud compte. Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits sans frais pour exécuter, tester et déployer des charges de travail.

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

Créer un cluster Managed Service pour Apache Spark

Exécutez la commande suivante dans un terminal de session Cloud Shell pour :
- installer les composants HBase et ZooKeeper ;
- provisionner trois nœuds de calcul (trois à cinq nœuds de calcul sont recommandés pour exécuter le code de ce tutoriel) ;
- activer le Component Gateway ;
- utiliser la version d'image 2.0 ;
- utiliser l'indicateur --properties pour ajouter la configuration HBase et la bibliothèque HBase aux chemins de classe du pilote et de l'exécuteur 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/*'

Vérifier l'installation du connecteur

Depuis la Google Cloud console ou un terminal de session Cloud Shell, connectez-vous en SSH au nœud maître du cluster Managed Service pour Apache Spark.

Vérifiez l'installation du connecteur Apache HBase Spark sur le nœud maître :

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

Exemple de résultat :

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

Laissez le terminal de session SSH ouvert pour :
1. créer une table HBase ;
2. (utilisateurs Java) exécuter des commandes sur le nœud maître du cluster pour déterminer les versions des composants installés sur le cluster ;
3. analyser votre table HBase après avoir exécuté le code

Créer une table HBase

Exécutez les commandes listées dans cette section dans le terminal de session SSH du nœud maître que vous avez ouvert à l'étape précédente.

Ouvrez le shell HBase :
```
hbase shell
```
Créez une table HBase "my-table" avec une famille de colonnes "cf" :
```
create 'my_table','cf'
```
1. Pour confirmer la création de la table, dans la Google Cloud console, cliquez sur HBase dans les Google Cloud liens du Component Gateway de la console pour ouvrir l'interface utilisateur Apache HBase. my-table est listée dans la section Tables (Tables) de la page Home (Accueil).

Afficher le code 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()

Exécuter le code

Ouvrez un terminal de session Cloud Shell.

Remarque : Exécutez les commandes listées dans cette section dans un terminal de session Cloud Shell. Cloud Shell est préinstallé avec les outils requis par ce tutoriel, y compris gcloud CLI, git, Apache Maven, Java, et Python, ainsi que d'autres outils.
Clonez le dépôt GitHub GoogleCloudDataproc/cloud-dataproc dans votre terminal de session Cloud Shell :
```
git clone https://github.com/GoogleCloudDataproc/cloud-dataproc.git
```

Accédez au répertoire cloud-managed-spark/spark-hbase :

cd cloud-managed-spark/spark-hbase

Exemple de résultat :

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

Envoyez la tâche Managed Service pour Apache Spark.

Java

Définissez les versions des composants dans le fichier pom.xml.
1. La page des versions de Managed Service pour Apache Spark 2.0.x liste les versions des composants Scala, Spark et HBase installés avec les quatre dernières versions mineures de l'image 2.0.
  1. Pour trouver la version mineure de votre cluster de version d'image 2.0, cliquez sur le nom du cluster sur la page Clusters de la Google Cloud console pour ouvrir la page Cluster details (Détails du cluster), où la Image version (Version de l'image) du cluster est listée.
2. Vous pouvez également exécuter les commandes suivantes dans un terminal de session SSH à partir du nœud maître de votre cluster pour déterminer les versions des composants :
  1. Vérifiez la version de Scala :
```
scala -version
```
  2. Vérifiez la version de Spark (Ctrl+D pour quitter) :
```
spark-shell
```
  3. Vérifiez la version de HBase :
```
hbase version
```
  4. Identifiez les dépendances de version de Spark, Scala et HBase dans le fichier 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>
```
    Remarque : hbase-spark.version correspond à la version actuelle du connecteur Spark HBase. Ne modifiez pas ce numéro de version.
3. Modifiez le fichier pom.xml dans l'éditeur Cloud Shell pour insérer les numéros de version corrects de Scala, Spark et HBase. Cliquez sur Open Terminal (Ouvrir le terminal) lorsque vous avez terminé la modification pour revenir à la ligne de commande du terminal Cloud Shell.
```
cloudshell edit .
```
4. Passez à Java 8 dans Cloud Shell. Cette version du JDK est nécessaire pour compiler le code (vous pouvez ignorer tous les messages d'avertissement concernant les plug-ins) :
```
sudo update-java-alternatives -s java-1.8.0-openjdk-amd64 && export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64
```
5. Vérifiez l'installation de Java 8 :
```
java -version
```
  Exemple de résultat :
```
openjdk version "1.8..."
 
```
Compilez le fichier jar :
```
mvn clean package
```
Le fichier .jar est placé dans le sous-répertoire /target (par exemple, target/spark-hbase-1.0-SNAPSHOT.jar.
Envoyez la tâche.
```
gcloud dataproc jobs submit spark \
    --class=hbase.SparkHBaseMain  \
    --jars=target/filename.jar \
    --region=cluster-region \
    --cluster=cluster-name
```
- --jars : insérez le nom de votre fichier .jar après "target/" et avant ".jar".
- Si vous n'avez pas défini les chemins de classe HBase du pilote et de l'exécuteur Spark lorsque vous avez créé votre cluster, vous devez les définir à chaque envoi de tâche en incluant l'indicateur ‑‑properties suivant dans votre commande d'envoi de tâche :
```
--properties='spark.driver.extraClassPath=/etc/hbase/conf:/usr/lib/hbase/*,spark.executor.extraClassPath=/etc/hbase/conf:/usr/lib/hbase/*'
       
```

Affichez la sortie de la table HBase dans la sortie du terminal de session Cloud Shell :

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

Python

Envoyez la tâche.
```
gcloud dataproc jobs submit pyspark scripts/pyspark-hbase.py \
    --region=cluster-region \
    --cluster=cluster-name
```
- Si vous n'avez pas défini les chemins de classe HBase du pilote et de l'exécuteur Spark lorsque vous avez créé votre cluster, vous devez les définir à chaque envoi de tâche en incluant l'indicateur ‑‑properties suivant dans votre commande d'envoi de tâche :
```
--properties='spark.driver.extraClassPath=/etc/hbase/conf:/usr/lib/hbase/*,spark.executor.extraClassPath=/etc/hbase/conf:/usr/lib/hbase/*'
       
```

Affichez la sortie de la table HBase dans la sortie du terminal de session Cloud Shell :

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

Analyser la table HBase

Vous pouvez analyser le contenu de votre table HBase en exécutant les commandes suivantes dans le terminal de session SSH du nœud maître que vous avez ouvert dans Vérifier l'installation du connecteur :

Ouvrez le shell HBase :
```
hbase shell
```

Analysez "my-table" :

scan 'my_table'

Exemple de résultat :

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

Libérer de l'espace

Une fois le tutoriel terminé, vous pouvez procéder au nettoyage des ressources que vous avez créées afin qu'elles ne soient plus comptabilisées dans votre quota et qu'elles ne vous soient plus facturées. Dans les sections suivantes, nous allons voir comment supprimer ou désactiver ces ressources.

Supprimer le projet

Le moyen le plus simple d'empêcher la facturation est de supprimer le projet que vous avez créé pour ce tutoriel.

Pour supprimer le projet :

Attention : La suppression d'un projet aura les effets suivants :

Tout le contenu du projet est supprimé. Si vous avez utilisé un projet existant pour les tâches décrites dans ce document et que vous le supprimez, vous supprimerez également tout autre travail effectué dans le projet.
Les ID de projets personnalisés sont perdus. Lorsque vous avez créé ce projet, vous avez peut-être créé un ID de projet personnalisé que vous souhaitez utiliser à l'avenir. Pour conserver les URL qui utilisent l'ID de projet, telle qu'une URL appspot.com, supprimez les ressources sélectionnées dans le projet au lieu de supprimer l'ensemble du projet.

Si vous envisagez d'explorer plusieurs architectures, tutoriels et guides de démarrage rapide, réutiliser des projets peut vous aider à ne pas dépasser les limites de quotas des projets.

Dans la Google Cloud console, accédez à la page Gérer les ressources.
Accéder à la page "Gérer les ressources"
Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez Arrêter pour supprimer le projet.

Supprimer le cluster

Pour supprimer le cluster :

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

Sauf indication contraire, le contenu de cette page est régi par une licence Creative Commons Attribution 4.0, et les échantillons de code sont régis par une licence Apache 2.0. Pour en savoir plus, consultez les Règles du site Google Developers. Java est une marque déposée d'Oracle et/ou de ses sociétés affiliées.

Dernière mise à jour le 2026/06/15 (UTC).

Utiliser Apache Spark avec HBase sur Managed Service pour Apache Spark Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Objectifs

Coûts

Avant de commencer

Créer un cluster Managed Service pour Apache Spark

Vérifier l'installation du connecteur

Créer une table HBase

Afficher le code Spark

Java

Python

Exécuter le code

Java

Python

Analyser la table HBase

Libérer de l'espace

Supprimer le projet

Supprimer le cluster

Utiliser Apache Spark avec HBase sur Managed Service pour Apache Spark