Diese Seite wurde von der Cloud Translation API übersetzt.

Von HBase auf Google Cloud woanders hin migrieren

Auf dieser Seite werden Überlegungen und Verfahren zur Migration zu Bigtable aus einem Apache HBase-Cluster beschrieben, der in einem Google Cloud-Dienst wie Dataproc oder Compute Engine gehostet wird.

Eine Anleitung zum Migrieren von einer externen Apache HBase-Umgebung zu Bigtable finden Sie unter Daten von HBase zu Bigtable migrieren. Weitere Informationen zur Onlinemigration finden Sie unter Von HBase aus in Bigtable replizieren.

Vorteile der Migration von HBase auf Google Cloud zu Bigtable

Mögliche Gründe für die Wahl dieses Migrationspfads:

Sie können Ihre Clientanwendung an der Stelle lassen, an der sie derzeit bereitgestellt ist, und nur die Verbindungskonfiguration ändern.
Ihre Daten verbleiben im Google Cloud-System.
Sie können weiterhin die HBase API verwenden, wenn Sie möchten. Der Cloud Bigtable HBase-Client für Java ist eine vollständig unterstützte Erweiterung der Apache HBase-Bibliothek für Java.
Sie möchten die Vorteile eines verwalteten Dienstes zum Speichern Ihrer Daten nutzen.

Hinweise

In diesem Abschnitt werden einige Punkte erläutert, die Sie vor der Migration bedenken sollten.

Bigtable-Schemadesign

In den meisten Fällen können Sie in Bigtable dasselbe Schemadesign wie in HBase verwenden. Wenn Sie Ihr Schema ändern möchten oder wenn sich Ihr Anwendungsfall ändert, lesen Sie die Konzepte unter Schema entwerfen, bevor Sie Ihre Daten migrieren.

Vorbereitung und Tests

Bevor Sie Ihre Daten migrieren, sollten Sie sich mit den Unterschieden zwischen HBase und Bigtable vertraut machen. Sie sollten sich etwas Zeit nehmen, um zu lernen, wie Sie Ihre Verbindung konfigurieren, um Ihre Anwendung mit Bigtable zu verbinden. Außerdem sollten Sie vor der Migration System- und Funktionstests durchführen, um die Anwendung oder den Dienst zu validieren.

Migrationsschritte

Wenn Sie Daten von HBase zu Bigtable migrieren möchten, erstellen Sie einen HBase-Snapshot und importieren die Daten direkt aus dem HBase-Cluster in Bigtable. Diese Schritte beziehen sich auf einen einzelnen HBase-Cluster und werden in den nächsten Abschnitten ausführlich beschrieben.

Senden von Schreibvorgängen an HBase beenden.
Erstellen Sie Zieltabellen in Bigtable.
HBase-Snapshots erstellen und in Bigtable importieren
Importierte Daten validieren
Aktualisieren Sie die Anwendung, damit Lese- und Schreibvorgänge an Bigtable gesendet werden.

Vorbereitung

Installieren Sie die Google Cloud CLI oder verwenden Sie die Cloud Shell.
Erstellen Sie einen Cloud Storage-Bucket, um die Validierungsausgabedaten zu speichern. Erstellen Sie den Bucket am selben Speicherort, an dem Sie Ihren Dataproc-Job ausführen möchten.
Identifizieren Sie den Hadoop-Cluster, von dem Sie migrieren. Sie müssen die Jobs für Ihre Migration auf einem Dataproc 1.x-Cluster ausführen, der über Netzwerkkonnektivität mit dem NameNode und DataNodes des HBase-Clusters verfügt. Notieren Sie sich die ZooKeeper-Quorumadresse und den Namenode-URI des HBase-Clusters. Sie sind für die Migrationsscripts erforderlich.
Erstellen Sie einen Dataproc-Cluster der Version 1.x im selben Netzwerk wie der Quell-HBase-Cluster. Mit diesem Cluster führen Sie die Import- und Validierungsjobs aus.
Erstellen Sie eine Bigtable-Instanz zum Speichern Ihrer neuen Tabellen. Mindestens ein Cluster in der Bigtable-Instanz muss sich in derselben Region wie der Dataproc-Cluster befinden. Beispiel: us-central1
Rufen Sie das Tool Translation Schema ab:
```
wget BIGTABLE_HBASE_TOOLS_URL
```
Ersetzen Sie BIGTABLE_HBASE_TOOLS_URL durch die URL des neuesten JAR with dependencies, der im Maven-Repository des Tools verfügbar ist. Der Dateiname ähnelt https://repo1.maven.org/maven2/com/google/cloud/bigtable/bigtable-hbase-1.x-tools/2.6.0/bigtable-hbase-1.x-tools-2.6.0-jar-with-dependencies.jar.

So finden Sie die URL oder laden die JAR-Datei manuell herunter:
1. Rufen Sie das Repository auf
2. Klicken Sie auf Durchsuchen, um die Repositorydateien aufzurufen.
3. Klicken Sie auf die neueste Versionsnummer.
4. Identifizieren Sie den JAR with dependencies file (normalerweise oben).
5. Klicken Sie mit der rechten Maustaste und kopieren Sie die URL oder klicken Sie, um die Datei herunterzuladen.
Rufen Sie das MapReduce-Tool auf, das Sie für die Import- und Validierungsjobs verwenden:
```
wget BIGTABLE_MAPREDUCE_URL
```
Ersetzen Sie BIGTABLE_MAPREDUCE_URL durch die URL des neuesten shaded-byo JAR, der im Maven-Repository des Tools verfügbar ist. Der Dateiname ähnelt https://repo1.maven.org/maven2/com/google/cloud/bigtable/bigtable-hbase-1.x-mapreduce/2.6.0/bigtable-hbase-1.x-mapreduce-2.6.0-shaded-byo-hadoop.jar.

So finden Sie die URL oder laden die JAR-Datei manuell herunter:
1. Rufen Sie das Repository auf
2. Klicken Sie auf die neueste Versionsnummer.
3. Klicken Sie auf Downloads.
4. Bewegen Sie den Mauszeiger über shaded-byo-hadoop.jar.
5. Klicken Sie mit der rechten Maustaste und kopieren Sie die URL oder klicken Sie, um die Datei herunterzuladen.
Legen Sie die folgenden Umgebungsvariablen fest:
```
#Google Cloud

export PROJECT_ID=PROJECT_ID
export REGION=REGION

##Cloud Bigtable

export BIGTABLE_INSTANCE_ID=BIGTABLE_INSTANCE_ID

##Dataproc

export DATAPROC_CLUSTER_ID=DATAPROC_CLUSTER_NAME

#Cloud Storage

export BUCKET_NAME="gs://BUCKET_NAME"
export STORAGE_DIRECTORY="$BUCKET_NAME/hbase-migration"

#HBase

export ZOOKEEPER_QUORUM=ZOOKEPER_QUORUM
export ZOOKEEPER_PORT=2181
export ZOOKEEPER_QUORUM_AND_PORT="$ZOOKEEPER_QUORUM:$ZOOKEEPER_PORT"
export MIGRATION_SOURCE_NAMENODE_URI=MIGRATION_SOURCE_NAMENODE_URI
export MIGRATION_SOURCE_TMP_DIRECTORY=${MIGRATION_SOURCE_NAMENODE_URI}/tmp
export MIGRATION_SOURCE_DIRECTORY=${MIGRATION_SOURCE_NAMENODE_URI}/hbase

#JAR files

export TRANSLATE_JAR=TRANSLATE_JAR
export MAPREDUCE_JAR=MAPREDUCE_JAR
```
Ersetzen Sie die Platzhalter durch die Werte für Ihre Migration.

Google Cloud:
- PROJECT_ID: das Google Cloud-Projekt, in dem sich Ihre Bigtable-Instanz befindet.
- REGION: die Region, die den Dataproc-Cluster enthält, der die Import- und Validierungsjobs ausführt.
Bigtable:
- BIGTABLE_INSTANCE_ID: die ID der Bigtable-Instanz, in die Sie Ihre Daten importieren.
Dataproc:
- DATAPROC_CLUSTER_ID: die ID des Dataproc-Clusters, in dem die Import- und Validierungsjobs ausgeführt werden
Cloud Storage:
- BUCKET_NAME: der Name des Cloud Storage-Buckets, in dem Sie die Snapshots speichern.
HBase:
- ZOOKEEPER_QUORUM: der Zookeeper-Host, zu dem das Tool eine Verbindung herstellt, im Format host1.myownpersonaldomain.com.
- MIGRATION_SOURCE_NAMENODE_URI: der URI für den NameNode des HBase-Clusters im Format hdfs://host1.myownpersonaldomain.com:8020
JAR-Dateien
- TRANSLATE_JAR: der Name und die Versionsnummer der JAR-Datei bigtable hbase tools, die Sie von Maven heruntergeladen haben. Der Wert sollte in etwa so aussehen: bigtable-hbase-1.x-tools-2.6.0-jar-with-dependencies.jar.
- MAPREDUCE_JAR: der Name und die Versionsnummer der JAR-Datei bigtable hbase mapreduce, die Sie von Maven heruntergeladen haben. Der Wert sollte in etwa so aussehen: bigtable-hbase-1.x-mapreduce-2.6.0-shaded-byo-hadoop.jar.
(Optional) Führen Sie den Befehl printenv aus, um zu prüfen, ob die Variablen richtig festgelegt wurden. Damit können Sie alle Umgebungsvariablen aufrufen.

Senden von Schreibvorgängen an HBase beenden

Bevor Sie Snapshots Ihrer HBase-Tabellen erstellen, beenden Sie das Senden von Schreibvorgängen an Ihren HBase-Cluster.

Zieltabellen in Bigtable erstellen

Als Nächstes erstellen Sie in Ihrer Bigtable-Instanz für jede HBase-Tabelle, die Sie migrieren, eine Zieltabelle. Verwenden Sie ein Konto mit der Berechtigung bigtable.tables.create für die Instanz.

In dieser Anleitung wird das Bigtable Schema Translation-Tool verwendet, das die Tabelle automatisch für Sie erstellt. Wenn Ihr Bigtable-Schema jedoch nicht genau mit dem HBase-Schema übereinstimmen soll, können Sie mit der cbt-Befehlszeile oder der Google Cloud Console eine Tabelle erstellen.

Das Bigtable Schema Translation-Tool erfasst das Schema der HBase-Tabelle, einschließlich Tabellenname, Spaltenfamilien, Richtlinien für die automatische Speicherbereinigung und Splits. Anschließend wird eine ähnliche Tabelle in Bigtable erstellt.

Führen Sie für jede zu importierende Tabelle den folgenden Befehl aus, um das Schema von HBase in Bigtable zu kopieren.

java \
 -Dgoogle.bigtable.project.id=$PROJECT_ID \
 -Dgoogle.bigtable.instance.id=$BIGTABLE_INSTANCE_ID \
 -Dgoogle.bigtable.table.filter=TABLE_NAME \
 -Dhbase.zookeeper.quorum=$ZOOKEEPER_QUORUM \
 -Dhbase.zookeeper.property.clientPort=$ZOOKEEPER_PORT \
 -jar $TRANSLATE_JAR

Ersetzen Sie TABLE_NAME durch den Namen der HBase-Tabelle, die Sie importieren. Das Schema Translation-Tool verwendet diesen Namen für die neue Bigtable-Tabelle.

Optional können Sie TABLE_NAME auch durch einen regulären Ausdruck wie „.*“ ersetzen, der alle zu erstellenden Tabellen erfasst, und dann den Befehl nur einmal ausführen.

HBase-Tabellen-Snapshots erstellen und in Bigtable importieren

Führen Sie folgende Schritte für jede Tabelle aus, die Sie zu Bigtable migrieren möchten.

Führen Sie dazu diesen Befehl aus:
```
echo "snapshot 'HBASE_TABLE_NAME', 'HBASE_SNAPSHOT_NAME'" | hbase shell -n
```
Dabei gilt:
- HBASE_TABLE_NAME: der Name der HBase-Tabelle, die Sie zu Bigtable migrieren.
- HBASE_SNAPSHOT_NAME ist der Name des neuen Snapshots.
Importieren Sie den Snapshot durch Ausführen des folgenden Befehls:
```
gcloud dataproc jobs submit hadoop \
    --cluster $DATAPROC_CLUSTER_ID \
    --region $REGION \
    --project $PROJECT_ID \
    --jar $MAPREDUCE_JAR \
    -- \
    import-snapshot \
    -Dgoogle.bigtable.project.id=$PROJECT_ID \
    -Dgoogle.bigtable.instance.id=$BIGTABLE_INSTANCE_ID \
    HBASE_SNAPSHOT_NAME \
    $MIGRATION_SOURCE_DIRECTORY \
    BIGTABLE_TABLE_NAME \
    $MIGRATION_SOURCE_TMP_DIRECTORY
```
Dabei gilt:
- HBASE_SNAPSHOT_NAME ist der Name, den Sie dem Snapshot der zu importierenden Tabelle zugewiesen haben
- BIGTABLE_TABLE_NAME ist der Name der Bigtable-Tabelle, in die Sie Daten importieren.
Nachdem Sie den Befehl ausgeführt haben, stellt das Tool den HBase-Snapshot im Quellcluster wieder her und importiert ihn dann. Es kann einige Minuten dauern, bis der Snapshot wiederhergestellt ist, je nach Größe des Snapshots.

Beim Importieren der Daten sind die folgenden zusätzlichen Optionen verfügbar:

Legen Sie clientbasierte Zeitüberschreitungen für gepufferte Mutator-Anfragen fest (Standard: 600000 ms). Sehen Sie sich folgendes Beispiel an:
```
-Dgoogle.bigtable.rpc.use.timeouts=true
-Dgoogle.bigtable.mutate.rpc.timeout.ms=600000
```
Ziehen Sie eine latenzbasierte Drosselung in Betracht, die die Auswirkungen reduzieren kann, die der Import-Batchjob auf andere Arbeitslasten haben kann. Die Drosselung sollte für Ihren Migrationsfall getestet werden. Sehen Sie sich folgendes Beispiel an:
```
-Dgoogle.bigtable.buffered.mutator.throttling.enable=true
-Dgoogle.bigtable.buffered.mutator.throttling.threshold.ms=100
```
Ändern Sie die Anzahl der Zuordnungsaufgaben, die eine einzelne HBase-Region lesen. Standard sind 2 Zuordnungsaufgaben pro Region. Sehen Sie sich folgendes Beispiel an:
```
-Dgoogle.bigtable.import.snapshot.splits.per.region=3
```
Legen Sie zusätzliche MapReduce-Konfigurationen als Properties fest. Sehen Sie sich folgendes Beispiel an:
```
-Dmapreduce.map.maxattempts=4
-Dmapreduce.map.speculative=false
-Dhbase.snapshot.thread.pool.max=20
```

Beachten Sie beim Importieren die folgenden Tipps:

Achten Sie darauf, dass genügend Dataproc-Cluster-Worker vorhanden sind, um Map-Importaufgaben parallel auszuführen, damit die Leistung beim Datenupload verbessert wird. Standardmäßig führt ein n1-standard-8-Dataproc-Worker acht Importaufgaben aus. Mit genügend Workern wird sichergestellt, dass der Importjob über genügend Compute-Leistung verfügt, um den Vorgang in einer akzeptablen Zeit abzuschließen, aber nicht so viel Leistung, dass die Bigtable-Instanz überlastet wird.
- Wenn Sie die Bigtable-Instanz nicht auch für eine andere Arbeitslast verwenden, multiplizieren Sie die Anzahl der Knoten in der Bigtable-Instanz mit 3 und teilen Sie dann durch 8 (mit n1-standard-8 Dataproc-Workern). Verwenden Sie das Ergebnis als Anzahl der Dataproc-Worker.
- Wenn Sie die Instanz gleichzeitig mit dem Import Ihrer HBase-Daten für eine andere Arbeitslast verwenden, reduzieren Sie den Wert von Dataproc-Workern oder erhöhen Sie die Anzahl der Bigtable-Knoten, um die Anforderungen der Arbeitslasten zu erfüllen.
Achten Sie während des Imports auf die CPU-Auslastung der Bigtable-Instanz. Wenn die CPU-Auslastung in der Bigtable-Instanz zu hoch ist, müssen Sie ggf. weitere Knoten hinzufügen. Durch das Hinzufügen von Knoten wird die CPU-Auslastung sofort verbessert. Es kann jedoch bis zu 20 Minuten nach dem Hinzufügen der Knoten dauern, bis die optimale Leistung erzielt wird.

Weitere Informationen zum Überwachen der Bigtable-Instanz finden Sie unter Bigtable-Instanzen überwachen.

Importierte Daten in Bigtable validieren

Als Nächstes validieren Sie die Datenmigration. Führen Sie dazu einen Hash-Vergleich zwischen der Quell- und der Zieltabelle durch, um bezüglich der Integrität der migrierten Daten größeres Vertrauen zu gewinnen. Führen Sie zuerst den Job hash-table aus, um Hashes von Zeilenbereichen in der Quelltabelle zu generieren. Führen Sie dann den sync-table-Job aus, um Hashes aus Bigtable zu berechnen und mit der Quelle abzugleichen.

Führen Sie für jede Tabelle, die Sie migrieren, den folgenden Befehl aus, um Hash-Werte zur Validierung zu erstellen:

gcloud dataproc jobs submit hadoop \
  --project $PROJECT_ID \
  --cluster $DATAPROC_CLUSTER_ID \
  --region $REGION \
  --jar $MAPREDUCE_JAR \
  -- \
  hash-table \
  -Dhbase.zookeeper.quorum=$ZOOKEEPER_QUORUM_AND_PORT \
  HBASE_TABLE_NAME \
  $STORAGE_DIRECTORY/HBASE_TABLE_NAME/hash-output/

Ersetzen Sie HBASE_TABLE_NAME durch den Namen der HBase-Tabelle, für die Sie den Snapshot erstellt haben.

Führen Sie in der Befehlszeile folgenden Befehl aus:

gcloud dataproc jobs submit hadoop \
  --project $PROJECT_ID \
  --cluster $DATAPROC_CLUSTER_ID \
  --region $REGION \
 --jar $MAPREDUCE_JAR \
 -- \
 sync-table \
 --sourcezkcluster=$ZOOKEEPER_QUORUM_AND_PORT:/hbase \
 --targetbigtableproject=$PROJECT_ID \
 --targetbigtableinstance=$BIGTABLE_INSTANCE_ID \
 $STORAGE_DIRECTORY/HBASE_TABLE_NAME/hash-output/ \
 HBASE_TABLE_NAME \
 BIGTABLE_TABLE_NAME

Dabei gilt:

HBASE_TABLE_NAME: der Name der HBase-Tabelle, aus der Sie importieren
BIGTABLE_TABLE_NAME: der Name der Bigtable-Tabelle, in die Sie importieren

Optional können Sie dem Befehl --dryrun=false hinzufügen, wenn Sie die Synchronisierung zwischen Quelle und Ziel für abweichende Hashbereiche möchten.

Wenn der sync-table-Job abgeschlossen ist, werden die Zähler für den Job in der Google Cloud Console angezeigt, in der der Job ausgeführt wurde. Wenn der Importjob alle Daten erfolgreich importiert, hat der Wert für HASHES_MATCHED einen Wert und der Wert für HASHES_NOT_MATCHED ist 0.

Wenn HASHES_NOT_MATCHED einen Wert anzeigt, können Sie sync-table im Debug-Modus noch einmal ausführen, um die abweichenden Bereiche und Details auf Zellenebene wie Source missing cell, Target missing cell oder Different values auszugeben. Konfigurieren Sie --properties mapreduce.map.log.level=DEBUG, um den Debug-Modus zu aktivieren. Nachdem der Job ausgeführt wurde, verwenden Sie Cloud Logging und suchen Sie nach dem Ausdruck jsonPayload.class="org.apache.hadoop.hbase.mapreduce.SyncTable", um abweichende Zellen zu prüfen.

Sie können den Importjob noch einmal versuchen oder die Quell- und Zieltabellen mit SyncTable synchronisieren, indem Sie dryrun=false festlegen. Lesen Sie den Artikel HBase SyncTable und informieren Sie sich über die zusätzlichen Konfigurationsoptionen, bevor Sie fortfahren.

SyncTable-Ergebnisse in Cloud Logging

Anwendung so aktualisieren, dass Lese- und Schreibvorgänge an Bigtable gesendet werden

Nachdem Sie die Daten für jede Tabelle im Cluster validiert haben, können Sie Ihre Anwendungen so konfigurieren, dass der gesamte Traffic an Bigtable weitergeleitet wird. Danach wird der HBase-Cluster verworfen.

Sobald die Migration abgeschlossen ist, können Sie die Snapshots löschen.