Bermigrasi dari HBase di Google Cloud

Halaman ini menjelaskan pertimbangan dan proses untuk bermigrasi ke Bigtable dari cluster Apache HBase yang dihosting di layanan Google Cloud, seperti Dataproc atau Compute Engine.

Untuk panduan tentang migrasi dari lingkungan Apache HBase eksternal ke Bigtable, lihat Memigrasikan Data dari HBase ke Bigtable. Untuk mempelajari migrasi online, lihat Mereplikasi dari HBase dari HBase ke Bigtable.

Alasan bermigrasi dari HBase di Google Cloud ke Bigtable

Alasan Anda mungkin memilih jalur migrasi ini mencakup hal-hal berikut:

Anda dapat membiarkan aplikasi klien di tempatnya saat ini di-deploy, dengan hanya mengubah konfigurasi koneksi.
Data Anda tetap berada di ekosistem Google Cloud.
Anda dapat terus menggunakan HBase API jika menginginkannya. Klien HBase Cloud Bigtable untuk Java adalah ekstensi library Apache HBase yang didukung sepenuhnya untuk Java.
Anda ingin mendapatkan manfaat dari menggunakan layanan terkelola untuk menyimpan data.

Pertimbangan

Bagian ini menyarankan beberapa hal yang perlu ditinjau dan dipikirkan sebelum Anda memulai migrasi.

Desain skema Bigtable

Pada umumnya, Anda dapat menggunakan desain skema yang sama di Bigtable seperti di HBase. Jika Anda ingin mengubah skema atau jika kasus penggunaan Anda berubah, tinjau konsep yang diuraikan dalam Mendesain skema sebelum memigrasikan data.

Persiapan dan pengujian

Sebelum memigrasikan data, pastikan Anda memahami perbedaan antara HBase dan Bigtable. Anda harus meluangkan waktu untuk mempelajari cara mengonfigurasi koneksi agar dapat menghubungkan aplikasi ke Bigtable. Selain itu, sebaiknya lakukan pengujian sistem dan fungsi sebelum migrasi untuk memvalidasi aplikasi atau layanan.

Langkah-langkah migrasi

Untuk memigrasikan data dari HBase ke Bigtable, Anda perlu mengambil snapshot HBase dan mengimpor data secara langsung dari cluster HBase ke Bigtable. Langkah-langkah ini ditujukan untuk satu cluster HBase dan akan dijelaskan secara mendetail di beberapa bagian berikutnya.

Berhenti mengirim penulisan ke HBase.
Buat tabel tujuan di Bigtable.
Mengambil snapshot HBase dan mengimpornya ke Bigtable.
Validasi data yang diimpor.
Update aplikasi untuk mengirim pembacaan dan penulisan ke Bigtable.

gambar

Sebelum memulai

Instal Google Cloud CLI atau gunakan Cloud Shell.
Buat bucket Cloud Storage untuk menyimpan data output validasi Anda. Buat bucket di lokasi yang sama dengan tempat Anda berencana menjalankan tugas Dataproc.
Identifikasi cluster Hadoop tempat Anda bermigrasi. Anda harus menjalankan tugas untuk migrasi di cluster Dataproc 1.x yang memiliki konektivitas jaringan ke Namenode dan Datanode cluster HBase. Catat alamat ZooKeeper Quorum dan URI Namenode cluster HBase, yang diperlukan untuk skrip migrasi.
Buat cluster Dataproc versi 1.x di jaringan yang sama dengan cluster HBase sumber. Anda menggunakan cluster ini untuk menjalankan tugas impor dan validasi.
Buat instance Bigtable untuk menyimpan tabel baru Anda. Setidaknya satu cluster di instance Bigtable juga harus berada di region yang sama dengan cluster Dataproc. Contoh: us-central1
Dapatkan alat Schema Translation:
```
wget BIGTABLE_HBASE_TOOLS_URL
```
Ganti BIGTABLE_HBASE_TOOLS_URL dengan URL JAR with dependencies terbaru yang tersedia di repositori Maven alat. Nama filenya mirip dengan 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.

Untuk menemukan URL atau mendownload JAR secara manual, lakukan langkah berikut:
1. Buka repositori.
2. Klik Browse untuk melihat file repositori.
3. Klik nomor versi terbaru.
4. Identifikasi JAR with dependencies file (biasanya di bagian atas).
5. Klik kanan dan salin URL, atau klik untuk mendownload file.
Dapatkan alat MapReduce, yang Anda gunakan untuk tugas impor dan validasi:
```
wget BIGTABLE_MAPREDUCE_URL
```
Ganti BIGTABLE_MAPREDUCE_URL dengan URL shaded-byo JAR terbaru yang tersedia di repositori Maven alat. Nama filenya mirip dengan 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.

Untuk menemukan URL atau mendownload JAR secara manual, lakukan langkah berikut:
1. Buka repositori.
2. Klik nomor versi terbaru.
3. Klik Download.
4. Arahkan kursor ke shaded-byo-hadoop.jar.
5. Klik kanan dan salin URL, atau klik untuk mendownload file.
Tetapkan variabel lingkungan berikut:
```
#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
```
Ganti placeholder dengan nilai untuk migrasi Anda.

Google Cloud:
- PROJECT_ID: project Google Cloud tempat instance Bigtable Anda berada
- REGION: region yang berisi cluster Dataproc yang akan menjalankan tugas impor dan validasi.
Bigtable:
- BIGTABLE_INSTANCE_ID: ID instance Bigtable tempat Anda mengimpor data
Dataproc:
- DATAPROC_CLUSTER_ID: ID cluster Dataproc yang akan menjalankan tugas impor dan validasi
Cloud Storage:
- BUCKET_NAME: nama bucket Cloud Storage tempat Anda menyimpan snapshot
HBase:
- ZOOKEEPER_QUORUM: host ZooKeeper yang akan terhubung dengan alat tersebut, dalam format host1.myownpersonaldomain.com
- MIGRATION_SOURCE_NAMENODE_URI: URI untuk Namenode cluster HBase, dalam format hdfs://host1.myownpersonaldomain.com:8020
File JAR
- TRANSLATE_JAR: nama dan nomor versi file JAR bigtable hbase tools yang Anda download dari Maven. Nilainya harus terlihat seperti bigtable-hbase-1.x-tools-2.6.0-jar-with-dependencies.jar.
- MAPREDUCE_JAR: nama dan nomor versi file JAR bigtable hbase mapreduce yang Anda download dari Maven. Nilainya harus terlihat seperti bigtable-hbase-1.x-mapreduce-2.6.0-shaded-byo-hadoop.jar.
(Opsional) Untuk mengonfirmasi bahwa variabel telah ditetapkan dengan benar, jalankan perintah printenv untuk melihat semua variabel lingkungan.

Berhenti mengirim penulisan ke HBase

Sebelum mengambil snapshot tabel HBase, hentikan pengiriman penulisan ke cluster HBase.

Membuat tabel tujuan di Bigtable

Langkah selanjutnya adalah membuat tabel tujuan di instance Bigtable Anda untuk setiap tabel HBase yang Anda migrasikan. Gunakan akun yang memiliki izin bigtable.tables.create untuk instance ini.

Panduan ini menggunakan alat Terjemahan Skema Bigtable, yang secara otomatis membuat tabel untuk Anda. Namun, jika tidak ingin skema Bigtable Anda sama persis dengan skema HBase, Anda dapat membuat tabel menggunakan CLI cbt atau Google Cloud Console.

Alat Penafsiran Skema Bigtable menangkap skema tabel HBase, termasuk nama tabel, jenis kolom, kebijakan pembersihan sampah memori, dan pemisahan. Tindakan ini kemudian membuat tabel yang serupa di Bigtable.

Untuk setiap tabel yang ingin Anda impor, jalankan perintah berikut untuk menyalin skema dari HBase ke Bigtable.

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

Ganti TABLE_NAME dengan nama tabel HBase yang Anda impor. Alat Terjemahan Skema menggunakan nama ini untuk tabel Bigtable baru.

Anda juga dapat mengganti TABLE_NAME dengan ekspresi reguler, seperti ".*", yang merekam semua tabel yang ingin Anda buat, lalu menjalankan perintahnya sekali saja.

Mengambil snapshot tabel HBase dan mengimpornya ke Bigtable

Selesaikan langkah-langkah berikut untuk setiap tabel yang ingin Anda migrasikan ke Bigtable.

Jalankan perintah berikut:
```
echo "snapshot 'HBASE_TABLE_NAME', 'HBASE_SNAPSHOT_NAME'" | hbase shell -n
```
Ganti kode berikut:
- HBASE_TABLE_NAME: nama tabel HBase yang Anda migrasikan ke Bigtable.
- HBASE_SNAPSHOT_NAME: nama unik untuk snapshot baru
Impor snapshot dengan menjalankan perintah berikut:
```
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
```
Ganti kode berikut:
- HBASE_SNAPSHOT_NAME: nama yang ditetapkan ke snapshot tabel yang Anda impor
- BIGTABLE_TABLE_NAME: nama tabel Bigtable yang menjadi tujuan impor
Setelah Anda menjalankan perintah, alat ini akan memulihkan snapshot HBase di cluster sumber, lalu mengimpornya. Diperlukan waktu beberapa menit hingga proses memulihkan snapshot selesai, bergantung pada ukuran snapshot.

Opsi tambahan berikut tersedia saat Anda mengimpor data:

Menetapkan waktu tunggu berbasis klien untuk permintaan mutator yang di-buffer (default 600.000 md). Lihat contoh berikut:
```
-Dgoogle.bigtable.rpc.use.timeouts=true
-Dgoogle.bigtable.mutate.rpc.timeout.ms=600000
```
Pertimbangkan throttling berbasis latensi, yang dapat mengurangi dampak yang mungkin ditimbulkan oleh tugas batch impor terhadap beban kerja lain. Throttling harus diuji untuk kasus penggunaan migrasi Anda. Lihat contoh berikut:
```
-Dgoogle.bigtable.buffered.mutator.throttling.enable=true
-Dgoogle.bigtable.buffered.mutator.throttling.threshold.ms=100
```
Ubah jumlah tugas peta yang membaca satu region HBase (default 2 tugas peta per region). Lihat contoh berikut:
```
-Dgoogle.bigtable.import.snapshot.splits.per.region=3
```

Menetapkan konfigurasi MapReduce tambahan sebagai properti. Lihat contoh berikut:

-Dmapreduce.map.maxattempts=4
-Dmapreduce.map.speculative=false
-Dhbase.snapshot.thread.pool.max=20

Ingat tips berikut saat Anda mengimpor:

Untuk meningkatkan performa pemuatan data, pastikan Anda memiliki pekerja cluster Dataproc yang cukup untuk menjalankan tugas impor peta secara paralel. Secara default, pekerja Dataproc-standar n1-8 akan menjalankan delapan tugas impor. Memiliki cukup pekerja memastikan bahwa tugas impor memiliki daya komputasi yang cukup untuk diselesaikan dalam waktu yang wajar, tetapi tidak terlalu banyak daya sehingga dapat membebani instance Bigtable.
- Jika Anda juga tidak menggunakan instance Bigtable untuk beban kerja lainnya, kalikan jumlah node di instance Bigtable dengan 3, lalu bagi dengan 8 (dengan pekerja dataproc n1-standard-8). Gunakan hasil sebagai jumlah pekerja Dataproc.
- Jika Anda menggunakan instance untuk beban kerja lain sekaligus mengimpor data HBase, kurangi nilai pekerja Dataproc atau tingkatkan jumlah node Bigtable untuk memenuhi persyaratan workload.
Selama proses impor, Anda harus memantau penggunaan CPU instance Bigtable. Jika pemakaian CPU di seluruh instance Bigtable terlalu tinggi, Anda mungkin perlu menambahkan node tambahan. Menambahkan node akan langsung meningkatkan pemanfaatan CPU, tetapi memerlukan waktu hingga 20 menit setelah node ditambahkan agar cluster dapat mencapai performa yang optimal.

Untuk informasi selengkapnya tentang pemantauan instance Bigtable, lihat Memantau instance Bigtable.

Memvalidasi data yang diimpor di Bigtable

Selanjutnya, validasi migrasi data dengan melakukan perbandingan hash antara tabel sumber dan tujuan untuk mendapatkan keyakinan dengan integritas data yang dimigrasikan. Pertama, jalankan tugas hash-table untuk membuat hash rentang baris di tabel sumber. Kemudian, selesaikan validasi dengan menjalankan tugas sync-table untuk menghitung dan mencocokkan hash dari Bigtable dengan sumbernya.

Untuk membuat hash yang akan digunakan untuk validasi, jalankan perintah berikut untuk setiap tabel yang Anda migrasikan:

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/

Ganti HBASE_TABLE_NAME dengan nama tabel HBase yang Anda buatkan snapshot-nya.

Jalankan perintah berikut di command shell:

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

Ganti kode berikut:

HBASE_TABLE_NAME: nama tabel HBase tempat Anda mengimpor
BIGTABLE_TABLE_NAME: nama tabel Bigtable yang menjadi tujuan impor

Secara opsional, Anda dapat menambahkan --dryrun=false ke perintah jika ingin mengaktifkan sinkronisasi antara sumber dan target untuk membedakan rentang hash.

Setelah tugas sync-table selesai, penghitung untuk tugas akan ditampilkan di Konsol Google Cloud tempat tugas dieksekusi. Jika tugas impor berhasil mengimpor semua data, nilai untuk HASHES_MATCHED memiliki nilai dan nilai untuk HASHES_NOT_MATCHED adalah 0.

Jika HASHES_NOT_MATCHED menampilkan nilai, Anda dapat menjalankan ulang sync-table dalam mode debug untuk memunculkan rentang yang berbeda dan detail tingkat sel seperti Source missing cell, Target missing cell, atau Different values. Untuk mengaktifkan mode debug, konfigurasikan --properties mapreduce.map.log.level=DEBUG. Setelah tugas dijalankan, gunakan Cloud Logging dan telusuri ekspresi jsonPayload.class="org.apache.hadoop.hbase.mapreduce.SyncTable" untuk meninjau pembagian sel.

Anda dapat mencoba tugas impor lagi atau menggunakan SyncTable untuk menyinkronkan tabel sumber dan target dengan menetapkan dryrun=false. Tinjau HBase SyncTable dan opsi konfigurasi tambahan sebelum melanjutkan.

Hasil SyncTable di Cloud Logging

Mengupdate aplikasi untuk mengirim pembacaan dan penulisan ke Bigtable

Setelah memvalidasi data untuk setiap tabel dalam cluster, Anda dapat mengonfigurasi aplikasi untuk merutekan semua traffic-nya ke Bigtable, lalu menghentikan penggunaan cluster HBase.

Setelah migrasi selesai, Anda dapat menghapus snapshot.