6.1 Sino ang nag-imbento ng HBase at bakit

Sa panayam na ito, pag-uusapan natin ang tungkol sa napakagandang tool tulad ng Hbase, na kamakailan ay nakakuha ng mahusay na katanyagan: halimbawa, ginagamit ito ng Facebook bilang batayan ng sistema ng pagmemensahe nito, at marami na itong sinasabi.

Tatalakayin ng lecture ang tungkol sa konsepto ng Big Table at ang libreng pagpapatupad nito, mga tampok ng trabaho at pagkakaiba mula sa parehong mga classical relational database (tulad ng MySQL at Oracle) at mga key-value storage tulad ng Redis, Aerospike at memcached. Gaya ng dati, magsimula tayo sa kasaysayan ng isyu. Tulad ng maraming iba pang proyekto ng BigData, ipinanganak ang Hbase mula sa isang konsepto na binuo ng Google. Ang mga prinsipyo sa likod ng Hbase ay inilarawan sa Bigtable: A Distributed Storage System for Structured Data article .

Tulad ng napag-usapan natin sa mga nakaraang lektura, ang mga ordinaryong file ay angkop na angkop para sa pagproseso ng data ng batch gamit ang paradigm ng MapReduce. Sa kabilang banda, ang impormasyong nakaimbak sa mga file ay medyo hindi maginhawa upang i-update; Ang mga file ay inaalis din ng posibilidad ng random na pag-access. Para sa mabilis at maginhawang trabaho na may random na pag-access, mayroong isang klase ng nosql system tulad ng key-value storage, tulad ng Aerospike, Redis, Couchbase, Memcached. Gayunpaman, ang pagpoproseso ng batch ay kadalasang napaka-inconvenient sa mga system na ito. Ang Hbase ay isang pagtatangka na pagsamahin ang kaginhawahan ng pagproseso ng batch sa kaginhawahan ng pag-update at random na pag-access.

6.2 Modelo ng data

Ang HBase ay isang distributed, column-oriented, multiversion key-value database.

  • Ang data ay nakaayos sa mga talahanayan na na-index ng isang pangunahing key na tinatawag na RowKey sa Hbase.
  • Para sa bawat RowKey key, maaaring mag-imbak ng walang limitasyong hanay ng mga attribute (o column).
  • Ang mga column ay isinaayos sa mga pangkat ng mga column na tinatawag na Column Family. Bilang panuntunan, ang mga column na may parehong paggamit at pattern ng storage ay pinagsama sa isang Column Family.
  • Para sa bawat katangian, maraming iba't ibang bersyon ang maaaring iimbak. Ang iba't ibang bersyon ay may iba't ibang timestamp.

Ang mga tala ay pisikal na nakaimbak sa RowKey na pinagsunod-sunod na pagkakasunud-sunod. Sa kasong ito, ang data na nauugnay sa iba't ibang Column Family ay naka-imbak nang hiwalay, na nagbibigay-daan, kung kinakailangan, na basahin ang data lamang mula sa gustong pamilya ng column.

Kapag na-delete ang isang partikular na katangian, hindi ito agad-agad na tatanggalin, ngunit minarkahan lang ng espesyal na watawat ng lapida. Ang pisikal na pagtanggal ng data ay magaganap sa ibang pagkakataon, kapag ang operasyon ng Major Compaction ay ginanap.

Ang mga katangiang kabilang sa parehong pangkat ng column at naaayon sa parehong key ay pisikal na iniimbak bilang isang pinagsunod-sunod na listahan. Ang anumang katangian ay maaaring wala o naroroon para sa bawat key, at kung ang katangian ay wala, hindi ito nagiging sanhi ng overhead ng pag-iimbak ng mga walang laman na halaga.

Java university

Ang listahan at mga pangalan ng pangkat ng column ay naayos at may malinaw na layout. Sa antas ng pangkat ng column, nakatakda ang mga parameter gaya ng time to live (TTL) at ang maximum na bilang ng mga nakaimbak na bersyon. Kung ang pagkakaiba sa pagitan ng timestamp para sa isang partikular na bersyon at ang kasalukuyang oras ay mas malaki kaysa sa TTL, ang entry ay minarkahan para sa pagtanggal. Kung ang bilang ng mga bersyon para sa isang partikular na katangian ay lumampas sa maximum na bilang ng mga bersyon, ang tala ay minarkahan din para sa pagtanggal.

Ang modelo ng data ng Hbase ay maaalala bilang isang key-value na tugma:

<table, RowKey, Column Family, Column, timestamp> -> Value

6.3 Mga suportadong operasyon

Ang listahan ng mga suportadong operasyon sa hbase ay medyo simple. 4 pangunahing operasyon ang sinusuportahan:

  • Ilagay : magdagdag ng bagong entry sa hbase. Ang timestamp ng entry na ito ay maaaring itakda sa pamamagitan ng kamay, kung hindi, awtomatiko itong itatakda sa kasalukuyang oras.
  • Kunin : Kumuha ng data para sa isang partikular na RowKey. Maaari mong tukuyin ang Column Family kung saan namin kukunin ang data at ang bilang ng mga bersyon na gusto naming basahin.
  • I-scan : basahin ang mga tala nang isa-isa. Maaari mong tukuyin ang rekord kung saan kami magsisimulang magbasa, ang tala kung saan babasahin, ang bilang ng mga tala na babasahin, ang Column Family kung saan isasagawa ang pagbabasa at ang maximum na bilang ng mga bersyon para sa bawat tala.
  • Tanggalin : Markahan ang isang partikular na bersyon para sa pagtanggal. Walang pisikal na pagtanggal, ito ay ipagpapaliban hanggang sa susunod na Major Compaction (tingnan sa ibaba).

6.4 Arkitektura

Ang HBase ay isang distributed database na maaaring tumakbo sa dose-dosenang o daan-daang mga pisikal na server, na tinitiyak ang tuluy-tuloy na operasyon kahit na ang ilan sa mga ito ay nabigo. Samakatuwid, ang arkitektura ng HBase ay medyo kumplikado kumpara sa mga klasikong relational database.

Gumagamit ang HBase ng dalawang pangunahing proseso para sa trabaho nito:

1. Server ng Rehiyon - Nagsisilbi sa isa o higit pang mga rehiyon. Ang rehiyon ay isang hanay ng mga talaan na tumutugma sa isang partikular na hanay ng magkakasunod na RowKey. Ang bawat rehiyon ay naglalaman ng:

  • Ang Persistent Storage ay ang pangunahing imbakan ng data sa HBase. Ang data ay pisikal na nakaimbak sa HDFS, sa isang espesyal na format ng HFile. Ang data sa HFile ay naka-store sa RowKey sorted order. Ang isang pares (rehiyon, pamilya ng column) ay tumutugma sa hindi bababa sa isang HFIle.
  • MemStore - sumulat ng buffer. Dahil ang data ay naka-imbak sa HFile d sa pinagsunod-sunod na pagkakasunud-sunod, medyo mahal ang pag-update ng HFile bawat tala. Sa halip, kapag nagsusulat, ang data ay pumapasok sa isang espesyal na lugar ng memorya ng MemStore, kung saan ito naipon nang ilang oras. Kapag ang MemStore ay napunan sa ilang kritikal na halaga, ang data ay isinusulat sa isang bagong HFile.
  • BlockCache - cache para sa pagbabasa. Nagbibigay-daan sa iyong makabuluhang makatipid ng oras sa data na madalas na binabasa.
  • Sumulat ng Ahead Log (WAL) . Dahil ang data ay nakasulat sa memstore, may ilang panganib ng pagkawala ng data dahil sa isang pag-crash. Upang maiwasang mangyari ito, ang lahat ng mga operasyon bago ang aktwal na pagpapatupad ng mga manipulasyon ay nahuhulog sa isang espesyal na log file. Pinapayagan ka nitong mabawi ang data pagkatapos ng anumang pagkabigo.

2. Master Server - ang pangunahing server sa cluster ng HBase. Pinamamahalaan ng Master ang pamamahagi ng mga rehiyon sa mga Server ng Rehiyon, nagpapanatili ng rehistro ng mga rehiyon, namamahala sa paglulunsad ng mga regular na gawain, at gumagawa ng iba pang kapaki-pakinabang na gawain.

Upang i-coordinate ang mga aksyon sa pagitan ng mga serbisyo, ginagamit ng HBase ang Apache ZooKeeper, isang espesyal na serbisyo na idinisenyo upang pamahalaan ang mga configuration at i-synchronize ang mga serbisyo.

Kapag tumaas ang dami ng data sa rehiyon at umabot ito sa isang partikular na laki, magsisimula ang Hbase na hatiin, isang operasyon na naghahati sa rehiyon ng 2. Upang maiwasan ang patuloy na paghahati ng mga rehiyon, maaari mong paunang itakda ang mga hangganan ng mga rehiyon at dagdagan ang kanilang maximum laki.

Dahil ang data para sa isang rehiyon ay maaaring maimbak sa ilang HFile, pana-panahong pinagsasama-sama ng Hbase ang mga ito upang mapabilis ang gawain. Ang operasyong ito ay tinatawag na compaction sa Hbase. Ang mga compaction ay may dalawang uri:

  • Maliit na compaction . Awtomatikong nagsisimula, tumatakbo sa background. May mababang priyoridad kumpara sa ibang mga pagpapatakbo ng Hbase.
  • Pangunahing compaction . Ito ay inilunsad sa pamamagitan ng kamay o sa paglitaw ng ilang partikular na pag-trigger (halimbawa, sa pamamagitan ng isang timer). Ito ay may mataas na priyoridad at maaaring makabuluhang pabagalin ang cluster. Pinakamainam na gawin ang Major Compaction sa oras na maliit ang load sa cluster. Pisikal ding tinatanggal ng Major Compaction ang data na dating minarkahan ng lapida.

6.5 Mga paraan upang gumana sa HBase

HBase Shell

Ang pinakamadaling paraan upang makapagsimula sa Hbase ay ang paggamit ng hbase shell utility. Ito ay magagamit kaagad pagkatapos i-install ang hbase sa anumang hbase cluster node.

Ang Hbase shell ay isang jruby console na may built-in na suporta para sa lahat ng pangunahing pagpapatakbo ng Hbase. Ang sumusunod ay isang halimbawa ng paglikha ng talahanayan ng mga user na may dalawang pamilya ng column, paggawa ng ilang manipulasyon dito, at pag-drop ng talahanayan sa dulo sa hbase shell:

create 'users', {NAME => 'user_profile', VERSIONS => 5}, {NAME => 'user_posts', VERSIONS => 1231231231} 
put 'users', 'id1', 'user_profile:name', 'alexander' 
put 'users', 'id1', 'user_profile:second_name', 'alexander' 
get 'users', 'id1' 
put 'users', 'id1', 'user_profile:second_name', 'kuznetsov' 
get 'users', 'id1' 
get 'users', 'id1', {COLUMN => 'user_profile:second_name', VERSIONS => 5} 
put 'users', 'id2', 'user_profile:name', 'vasiliy' 
put 'users', 'id2', 'user_profile:second_name', 'ivanov' 
scan 'users', {COLUMN => 'user_profile:second_name', VERSIONS => 5} 
delete 'users', 'id1', 'user_profile:second_name' 
get 'users', 'id1' 
disable 'users' 
drop 'users'

Native API

Tulad ng karamihan sa iba pang mga proyektong nauugnay sa hadoop, ang hbase ay ipinatupad sa java, kaya ang katutubong api ay magagamit sa Java. Ang Native API ay medyo mahusay na dokumentado sa opisyal na website. Narito ang isang halimbawa ng paggamit ng Hbase API na kinuha mula doon:

import java.io.IOException;

import org.apache.hadoop.hbase.*;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.util.Bytes;

public class MyLittleHBaseClient {
  public static void main(String[] args) throws IOException {
	Configuration config = HBaseConfiguration.create();
	Connection connection = ConnectionFactory.createConnection(config);
	try {
  	Table table = connection.getTable(TableName.valueOf("myLittleHBaseTable"));
  	try {
    	Put p = new Put(Bytes.toBytes("myLittleRow"));
    	p.add(Bytes.toBytes("myLittleFamily"), Bytes.toBytes("someQualifier"),
    	Bytes.toBytes("Some Value"));
    	table.put(p);

    	Get g = new Get(Bytes.toBytes("myLittleRow"));
    	Result r = table.get(g);
    	byte [] value = r.getValue(Bytes.toBytes("myLittleFamily"),
      	Bytes.toBytes("someQualifier"));

    	String valueStr = Bytes.toString(value);
    	System.out.println("GET: " + valueStr);

    	Scan s = new Scan();
    	s.addColumn(Bytes.toBytes("myLittleFamily"), Bytes.toBytes("someQualifier"));
    	ResultScanner scanner = table.getScanner(s);
    	try {
       	for (Result rr = scanner.next(); rr != null; rr = scanner.next()) {
         	System.out.println("Found row: " + rr);
       	}
     	} finally {
       	scanner.close();
     	}
   	} finally {
     	if (table != null) table.close();
   	}
 	} finally {
   	connection.close();
 	}
  }
}

Pagtitipid, REST at suporta para sa iba pang mga programming language

Para magtrabaho mula sa iba pang mga programming language, nagbibigay ang Hbase ng Thrift API at Rest API. Batay sa kanila, ang mga kliyente ay binuo para sa lahat ng mga pangunahing wika ng programming: python, PHP, Java Script, atbp.

6.6 Ang ilang mga tampok ng pagtatrabaho sa HBase

  1. Ang Hbase ay isinasama sa labas ng kahon sa MapReduce, at maaaring gamitin bilang input at output gamit ang espesyal na TableInputFormat at TableOutputFormat.

  2. Napakahalagang piliin ang tamang RowKey. Ang RowKey ay dapat magbigay ng isang mahusay na pantay na pamamahagi sa mga rehiyon, kung hindi man ay may panganib ng tinatawag na "mainit na mga rehiyon" - mga rehiyon na ginagamit nang mas madalas kaysa sa iba, na humahantong sa hindi mahusay na paggamit ng mga mapagkukunan ng system.

  3. Kung ang data ay hindi na-upload nang isa-isa, ngunit kaagad sa malalaking batch, sinusuportahan ng Hbase ang isang espesyal na mekanismo ng BulkLoad na nagbibigay-daan sa iyong mag-upload ng data nang mas mabilis kaysa sa paggamit ng iisang Puts. Ang BulkLoad ay mahalagang dalawang hakbang na operasyon:

    • Pagbubuo ng HFile nang walang partisipasyon ng mga puts gamit ang isang espesyal na trabaho sa MapReduce
    • Direktang pagpasok ng mga file na ito sa Hbase

  4. Sinusuportahan ng Hbase ang pag-output ng mga sukatan nito sa server ng pagsubaybay sa Ganglia. Maaari itong maging lubhang kapaki-pakinabang kapag pinangangasiwaan ang Hbase upang malaman ang mga isyu sa hbase.

susi ng hilera

Ang RowKey ay ang user ID, na isang GUUID, isang string na espesyal na binuo upang maging kakaiba sa buong mundo. Ang mga GUIID ay ipinamamahagi nang pantay-pantay, na nagbibigay ng mahusay na pamamahagi ng data sa mga server.

Pamilya ng Kolum

Gumagamit ang aming storage ng dalawang pamilya ng column:

  • datos. Ang pangkat ng mga column na ito ay nag-iimbak ng data na hindi na nauugnay para sa mga layunin ng pag-advertise, gaya ng katotohanang bumisita ang isang user sa ilang partikular na URL. Ang TTL para sa Column Family na ito ay nakatakda sa 2 buwan, ang limitasyon sa bilang ng mga bersyon ay 2000.
  • longdata. Ang pangkat ng mga column na ito ay nag-iimbak ng data na hindi nawawala ang kaugnayan nito sa paglipas ng panahon, gaya ng kasarian, petsa ng kapanganakan, at iba pang "walang hanggan" na katangian ng user.

mga nagsasalita

Ang bawat uri ng mga katotohanan ng user ay iniimbak sa isang hiwalay na column. Halimbawa, iniimbak ng column na Data:_v ang mga URL na binisita ng user, at iniimbak ng column na LongData:gender ang kasarian ng user.

Ang time stamp ng katotohanang ito ay naka-store bilang timestamp. Halimbawa, sa column na Data:_v, ang timestamp ay ang oras na binisita ng user ang isang partikular na URL.

Ang istraktura ng pag-iimbak ng data ng user na ito ay napakahusay sa aming pattern ng paggamit at nagbibigay-daan sa iyong mabilis na i-update ang data ng user, mabilis na makuha ang lahat ng kinakailangang impormasyon tungkol sa mga user, at, gamit ang MapReduce, mabilis na iproseso ang data tungkol sa lahat ng user nang sabay-sabay.

6.7 Mga alternatibo

Ang HBase ay medyo kumplikado sa pangangasiwa at paggamit, kaya bago gamitin ang HBase makatuwirang tingnan ang mga alternatibo:

  • Mga Relasyonal na Database . Isang napakagandang alternatibo, lalo na sa kaso kapag ang data ay magkasya sa isang makina. Gayundin, una sa lahat, dapat mong isipin ang tungkol sa mga relational database sa kaso kapag ang mga transaksyon ng mga index maliban sa pangunahin ay mahalaga.

  • Imbakan ng Key-Value . Ang mga storage tulad ng Redis at Aerospike ay mas angkop kapag kailangan ang latency at hindi gaanong mahalaga ang pagproseso ng batch.

  • Mga file at ang kanilang pagpoproseso sa MapReduce . Kung ang data ay idinagdag lamang at bihirang na-update/binago, pagkatapos ay mas mahusay na huwag gumamit ng HBase, ngunit iimbak lamang ang data sa mga file. Upang pasimplehin ang trabaho sa mga file, maaari kang gumamit ng mga tool tulad ng Hive, Pig at Impala.

Ang paggamit ng HBase ay makatwiran kapag:

  • Mayroong maraming data, at hindi sila magkasya sa isang computer / server
  • Ang data ay madalas na ina-update at tinatanggal
  • Mayroong isang tahasang "susi" sa data, kung saan ito ay maginhawa upang itali ang lahat ng iba pa
  • Kailangan ng batch processing
  • Kailangan ng random na pag-access sa data sa pamamagitan ng mga partikular na key