Docs Support

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

Kontakt Jetzt kostenlos testen

Diese Seite wurde von der Cloud Translation API übersetzt.

Apache Spark mit HBase auf Dataproc verwenden

Lernziele

In dieser Anleitung wird Folgendes erläutert:

Dataproc-Cluster erstellen, Apache HBase installieren und Apache ZooKeeper auf dem Cluster
HBase-Tabelle mit HBase Shell erstellen, die auf dem Master-Knoten von ausgeführt wird Dataproc-Cluster
Senden Sie mit Cloud Shell einen Java- oder PySpark Spark-Job an den Dataproc-Dienst, der Daten schreibt und dann liest Daten aus der HBase-Tabelle

Kosten

In diesem Dokument verwenden Sie die folgenden kostenpflichtigen Komponenten von Google Cloud:

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen. Neuen Google Cloud-Nutzern steht möglicherweise eine kostenlose Testversion zur Verfügung.

Hinweis

Erstellen Sie ein Google Cloud Platform-Projekt, falls dies noch nicht geschehen ist.

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.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the Dataproc and Compute Engine APIs.

Enable the APIs

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

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the Dataproc and Compute Engine APIs.

Enable the APIs

Dataproc-Cluster erstellen

Führen Sie den folgenden Befehl in einer Cloud Shell-Sitzungsterminal zu:
- HBase- und ZooKeeper-Komponenten installieren
- Stellen Sie drei Worker-Knoten bereit (drei bis fünf Worker werden für Code in dieser Anleitung ausführen)
- Component Gateway aktivieren
- Image-Version 2.0 verwenden
- Verwenden Sie das Flag --properties, um die HBase-Konfiguration und die HBase-Bibliothek hinzuzufügen. den Spark-Treiber und den Executor-Klassenpfaden.

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/*'

Installation des Connectors prüfen

Führen Sie in der Google Cloud Console oder einem Cloud Shell-Sitzungsterminal folgende Schritte aus: Stellen Sie eine SSH-Verbindung zum Masterknoten des Dataproc-Clusters her.

Überprüfen Sie die Installation des Apache HBase Spark-Connectors auf dem Master-Knoten:

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

Beispielausgabe:

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

Lassen Sie das Terminal der SSH-Sitzung geöffnet, um:
1. HBase-Tabelle erstellen
2. (Java-Nutzer): Befehle auf dem Masterknoten des Clusters ausführen, um die Versionen der im Cluster installierten Komponenten zu ermitteln
3. Hbase-Tabelle scannen, nachdem Sie Code ausführen

HBase-Tabelle erstellen

Führen Sie die in diesem Abschnitt aufgeführten Befehle im Terminal der SSH-Sitzung des Masterknotens aus, die Sie im vorherigen Schritt geöffnet haben.

Öffnen Sie die HBase-Shell:
```
hbase shell
```
Erstellen Sie eine HBase-Tabelle „my-table“ mit der Spaltenfamilie „cf“:
```
create 'my_table','cf'
```
1. Bestätigen Sie die Tabellenerstellung, indem Sie in der Google Cloud Console unter Google Cloud Console-Links zum Komponenten-Gateway auf HBase klicken, um die Apache HBase-Benutzeroberfläche zu öffnen. my-table wird auf der Seite Startseite im Bereich Tabellen aufgeführt.

Spark-Code ansehen

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

Code ausführen

Öffnen Sie ein Terminal für eine Cloud Shell-Sitzung.

Hinweis: Führen Sie die hier aufgeführten Befehle in einem Cloud Shell-Sitzungsterminal. Cloud Shell bietet die Tools, die für dieses Tutorials bereits vorinstalliert, gcloud CLI, git Apache Maven Java und Python sowie weitere Tools.
Klonen Sie das GitHub-Repository GoogleCloudDataproc/cloud-dataproc in das Terminal Ihrer Cloud Shell-Sitzung:
```
git clone https://github.com/GoogleCloudDataproc/cloud-dataproc.git
```

Wechseln Sie in das Verzeichnis cloud-dataproc/spark-hbase:

cd cloud-dataproc/spark-hbase

Beispielausgabe:

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

Senden Sie den Dataproc-Job.

Java

Komponentenversionen in Datei pom.xml festlegen.
1. Auf der Seite Dataproc-Releaseversionen 2.0.x sind die Versionen der Scala-, Spark- und HBase-Komponenten aufgeführt, die mit der neuesten und den letzten vier untergeordneten Minor-Versionen von Image 2.0 installiert wurden.
  1. So ermitteln Sie die Sub-Minor-Version Ihres Clusters mit 2.0-Image-Version: auf den Clusternamen im Seite Cluster in der Google Cloud Console, um die Seite Clusterdetails zu öffnen, auf der der Die Image-Version des Clusters wird aufgeführt.
2. Alternativ können Sie die folgenden Befehle in einem SSH-Sitzungsterminal vom Masterknoten Ihres Clusters ausführen, um die Komponentenversionen zu ermitteln:
  1. Überprüfen Sie die Scala-Version:
```
scala -version
```
  2. Spark-Version prüfen (zum Beenden Strg-D drücken):
```
spark-shell
```
  3. HBase-Version prüfen:
```
hbase version
```
  4. Ermitteln Sie die Abhängigkeiten von Spark, Scala und HBase-Versionen in der 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>
```
    Hinweis: hbase-spark.version ist die aktuelle Version des Spark HBase-Connectors. lassen Sie diese Versionsnummer unverändert.
3. Bearbeiten Sie die Datei pom.xml im Cloud Shell-Editor, um den Parameter die korrekte Scala-, Spark- und HBase-Versionsnummer. Klicken Sie auf Terminal öffnen, wenn Sie mit der Bearbeitung fertig sind, um zu der Befehlszeile des Cloud Shell-Terminals.
```
cloudshell edit .
```
4. Wechseln Sie in Cloud Shell zu Java 8. Diese JDK-Version ist erforderlich, um Erstellen Sie den Code (Sie können sämtliche Plug-in-Warnmeldungen ignorieren):
```
sudo update-java-alternatives -s java-1.8.0-openjdk-amd64 && export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64
```
5. Überprüfen Sie die Java 8-Installation:
```
java -version
```
  Beispielausgabe:
```
openjdk version "1.8..."
 
```
Erstellen Sie die Datei jar:
```
mvn clean package
```
Die Datei .jar wird im Unterverzeichnis /target abgelegt, z. B. target/spark-hbase-1.0-SNAPSHOT.jar
Senden Sie den Job.
```
gcloud dataproc jobs submit spark \
    --class=hbase.SparkHBaseMain  \
    --jars=target/filename.jar \
    --region=cluster-region \
    --cluster=cluster-name
```
- --jars: Geben Sie den Namen Ihrer .jar-Datei nach „target/“ ein. und vor ".jar".
- Wenn Sie die Spark-Treiber und Executor-HBase-Klassenpfade beim Erstellen den Cluster erstellt, müssen Sie sie bei jeder Jobübermittlung festlegen, indem Sie den Parameter folgendes ‑‑properties-Flag im Befehl zum Senden des Jobs:
```
--properties='spark.driver.extraClassPath=/etc/hbase/conf:/usr/lib/hbase/*,spark.executor.extraClassPath=/etc/hbase/conf:/usr/lib/hbase/*'
       
```

HBase-Tabellenausgabe in der Terminalausgabe der Cloud Shell-Sitzung ansehen:

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

Python

Senden Sie den Job.

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

Wenn Sie die Spark-Treiber und Executor-HBase-Klassenpfade beim Erstellen den Cluster erstellt, müssen Sie sie bei jeder Jobübermittlung festlegen, indem Sie den Parameter folgendes ‑‑properties-Flag im Befehl zum Senden des Jobs:
```
--properties='spark.driver.extraClassPath=/etc/hbase/conf:/usr/lib/hbase/*,spark.executor.extraClassPath=/etc/hbase/conf:/usr/lib/hbase/*'
       
```

Sehen Sie sich die Ausgabe der HBase-Tabelle in der Ausgabe des Cloud Shell-Sitzungsterminals an:

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

HBase-Tabelle scannen

Sie können den Inhalt Ihrer HBase-Tabelle scannen, indem Sie die folgenden Befehle im Terminal der SSH-Sitzung des Masterknotens ausführen, die Sie unter Verbindungsinstallation prüfen geöffnet haben:

Öffnen Sie die HBase-Shell:
```
hbase shell
```

Tabelle „my-table“ scannen:

scan 'my_table'

Beispielausgabe:

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

Bereinigen

Nachdem Sie die Anleitung abgeschlossen haben, können Sie die erstellten Ressourcen bereinigen, damit sie keine Kontingente mehr nutzen und keine Gebühren mehr anfallen. In den folgenden Abschnitten erfahren Sie, wie Sie diese Ressourcen löschen oder deaktivieren.

Projekt löschen

Am einfachsten vermeiden Sie weitere Kosten durch Löschen des für die Anleitung erstellten Projekts.

So löschen Sie das Projekt:

Achtung: Das Löschen von Projekten hat folgende Auswirkungen:

Alle Inhalte des Projekts werden gelöscht. Wenn Sie für die Aufgaben in diesem Dokument ein bereits bestehendes Projekt verwendet haben und dieses löschen, werden auch alle anderen im Rahmen des Projekts erstellten Daten gelöscht.
Benutzerdefinierte Projekt-IDs gehen verloren. Beim Erstellen dieses Projekts haben Sie möglicherweise eine benutzerdefinierte Projekt-ID erstellt, die Sie weiterhin verwenden möchten. Damit die URLs, die die Projekt-ID nutzen, z. B. eine appspot.com-URL, erhalten bleiben, sollten Sie ausgewählte Ressourcen innerhalb des Projekts löschen, statt das gesamte Projekt.

Wenn Sie mehrere Architekturen, Anleitungen und Kurzanleitungen durcharbeiten möchten, können Sie die Überschreitung von Projektkontingenten verhindern, indem Sie Projekte wiederverwenden.

In the Google Cloud console, go to the Manage resources page.
Go to Manage resources
In the project list, select the project that you want to delete, and then click Delete.
In the dialog, type the project ID, and then click Shut down to delete the project.

Cluster löschen

So löschen Sie den Cluster:

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

Sofern nicht anders angegeben, sind die Inhalte dieser Seite unter der Creative Commons Attribution 4.0 License und Codebeispiele unter der Apache 2.0 License lizenziert. Weitere Informationen finden Sie in den Websiterichtlinien von Google Developers. Java ist eine eingetragene Marke von Oracle und/oder seinen Partnern.

Zuletzt aktualisiert: 2024-11-20 (UTC).