HBase - Guida rapida

Dal 1970, RDBMS è la soluzione per la memorizzazione dei dati e problemi legati alla manutenzione. Dopo l'avvento dei big data, le aziende hanno compreso il vantaggio di elaborare i big data e hanno iniziato a optare per soluzioni come Hadoop.

Hadoop utilizza un file system distribuito per l'archiviazione di big data e MapReduce per elaborarlo. Hadoop eccelle nell'archiviazione e nell'elaborazione di dati enormi di vari formati come arbitrari, semi o anche non strutturati.

Limitazioni di Hadoop

Hadoop può eseguire solo l'elaborazione in batch e l'accesso ai dati sarà effettuato solo in modo sequenziale. Ciò significa che si deve cercare nell'intero set di dati anche il più semplice dei lavori.

Un enorme set di dati durante l'elaborazione si traduce in un altro enorme set di dati, che dovrebbe essere elaborato in sequenza. A questo punto, è necessaria una nuova soluzione per accedere a qualsiasi punto di dati in una singola unità di tempo (accesso casuale).

Database ad accesso casuale Hadoop

Applicazioni come HBase, Cassandra, couchDB, Dynamo e MongoDB sono alcuni dei database che archiviano enormi quantità di dati e accedono ai dati in modo casuale.

Cos'è HBase?

HBase è un database distribuito orientato alle colonne costruito sul file system Hadoop. È un progetto open source ed è scalabile orizzontalmente.

HBase è un modello di dati simile alla grande tabella di Google progettato per fornire un rapido accesso casuale a enormi quantità di dati strutturati. Sfrutta la tolleranza agli errori fornita da Hadoop File System (HDFS).

Fa parte dell'ecosistema Hadoop che fornisce accesso in lettura / scrittura casuale in tempo reale ai dati nel file system Hadoop.

È possibile memorizzare i dati in HDFS direttamente o tramite HBase. Il consumatore di dati legge / accede ai dati in HDFS in modo casuale utilizzando HBase. HBase si trova in cima al file system Hadoop e fornisce accesso in lettura e scrittura.

HBase e HDFS

HDFS	HBase
HDFS è un file system distribuito adatto per l'archiviazione di file di grandi dimensioni.	HBase è un database costruito su HDFS.
HDFS non supporta ricerche rapide di record individuali.	HBase fornisce ricerche veloci per tabelle più grandi.
Fornisce elaborazione batch ad alta latenza; nessun concetto di elaborazione in batch.	Fornisce accesso a bassa latenza a singole righe da miliardi di record (accesso casuale).
Fornisce solo accesso sequenziale ai dati.	HBase utilizza internamente le tabelle hash e fornisce l'accesso casuale e memorizza i dati in file HDFS indicizzati per ricerche più veloci.

Meccanismo di memorizzazione in HBase

HBase è un file column-oriented databasee le tabelle in esso contenute sono ordinate per riga. Lo schema della tabella definisce solo le famiglie di colonne, che sono le coppie chiave-valore. Una tabella ha più famiglie di colonne e ciascuna famiglia di colonne può avere un numero qualsiasi di colonne. I valori delle colonne successive vengono archiviati in modo contiguo sul disco. Ogni valore di cella della tabella ha un timestamp. In breve, in un HBase:

La tabella è una raccolta di righe.
Row è una raccolta di famiglie di colonne.
La famiglia di colonne è una raccolta di colonne.
La colonna è una raccolta di coppie di valori chiave.

Di seguito è riportato uno schema di esempio di tabella in HBase.

Rowid	Famiglia di colonne			Famiglia di colonne			Famiglia di colonne			Famiglia di colonne
Rowid	col1	col2	col3	col1	col2	col3	col1	col2	col3	col1	col2	col3
1
2
3

Orientato a colonna e orientato a riga

I database orientati alle colonne sono quelli che memorizzano le tabelle di dati come sezioni di colonne di dati, piuttosto che come righe di dati. A breve, avranno famiglie di colonne.

Database orientato alle righe	Database orientato alle colonne
È adatto per OLTP (Online Transaction Process).	È adatto per Online Analytical Processing (OLAP).
Tali database sono progettati per un numero limitato di righe e colonne.	I database orientati alle colonne sono progettati per tabelle di grandi dimensioni.

L'immagine seguente mostra le famiglie di colonne in un database orientato alle colonne:

HBase e RDBMS

HBase	RDBMS
HBase è senza schema, non ha il concetto di schema a colonne fisse; definisce solo famiglie di colonne.	Un RDBMS è governato dal suo schema, che descrive l'intera struttura delle tabelle.
È costruito per tavoli larghi. HBase è scalabile orizzontalmente.	È sottile e costruito per piccoli tavoli. Difficile da scalare.
Non ci sono transazioni in HBase.	RDBMS è transazionale.
Ha dati denormalizzati.	Avrà dati normalizzati.
È utile per dati semi-strutturati e strutturati.	È utile per i dati strutturati.

Caratteristiche di HBase

HBase è scalabile linearmente.
Ha il supporto automatico dei guasti.
Fornisce letture e scritture coerenti.
Si integra con Hadoop, sia come sorgente che come destinazione.
Ha una semplice API Java per il client.
Fornisce la replica dei dati tra i cluster.

Dove utilizzare HBase

Apache HBase viene utilizzato per avere accesso in lettura / scrittura casuale e in tempo reale ai Big Data.
Ospita tabelle molto grandi sopra cluster di hardware di base.
Apache HBase è un database non relazionale modellato sul Bigtable di Google. Bigtable agisce su Google File System, allo stesso modo Apache HBase funziona su Hadoop e HDFS.

Applicazioni di HBase

Viene utilizzato ogni volta che è necessario scrivere applicazioni pesanti.
HBase viene utilizzato ogni volta che è necessario fornire un accesso casuale veloce ai dati disponibili.
Aziende come Facebook, Twitter, Yahoo e Adobe utilizzano internamente HBase.

Storia HBase

Anno	Evento
Novembre 2006	Google ha pubblicato il documento su BigTable.
Febbraio 2007	Il prototipo HBase iniziale è stato creato come contributo di Hadoop.
Ottobre 2007	È stato rilasciato il primo HBase utilizzabile insieme a Hadoop 0.15.0.
Gennaio 2008	HBase è diventato il sottoprogetto di Hadoop.
Ottobre 2008	HBase 0.18.1 è stato rilasciato.
Gennaio 2009	HBase 0.19.0 è stato rilasciato.
Settembre 2009	HBase 0.20.0 è stato rilasciato.
Maggio 2010	HBase è diventato il progetto di primo livello Apache.

In HBase, le tabelle sono suddivise in regioni e sono servite dai server regionali. Le regioni sono divise verticalmente per famiglie di colonne in "Stores". Gli archivi vengono salvati come file in HDFS. Di seguito è mostrata l'architettura di HBase.

Note: Il termine "negozio" viene utilizzato per le regioni per spiegare la struttura di archiviazione.

HBase ha tre componenti principali: la libreria client, un server master e server regionali. I server regionali possono essere aggiunti o rimossi secondo i requisiti.

MasterServer

Il server principale -

Assegna le regioni ai server della regione e utilizza Apache ZooKeeper per questa attività.
Gestisce il bilanciamento del carico delle regioni tra i server della regione. Scarica i server occupati e sposta le regioni su server meno occupati.
Mantiene lo stato del cluster negoziando il bilanciamento del carico.
È responsabile delle modifiche allo schema e di altre operazioni sui metadati come la creazione di tabelle e famiglie di colonne.

Regioni

Le regioni non sono altro che tabelle suddivise e distribuite nei server regionali.

Server regionale

I server regionali hanno regioni che:

Comunica con il cliente e gestisci le operazioni relative ai dati.
Gestisci le richieste di lettura e scrittura per tutte le regioni sottostanti.
Decidi la dimensione della regione seguendo le soglie delle dimensioni della regione.

Quando diamo uno sguardo più approfondito al server della regione, contiene regioni e archivi come mostrato di seguito:

L'archivio contiene archivio di memoria e HFiles. Memstore è proprio come una memoria cache. Tutto ciò che è inserito nell'HBase viene inizialmente memorizzato qui. Successivamente, i dati vengono trasferiti e salvati in Hfile come blocchi e il memstore viene svuotato.

Zookeeper

Zookeeper è un progetto open source che fornisce servizi come il mantenimento delle informazioni di configurazione, la denominazione, la sincronizzazione distribuita, ecc.
Zookeeper ha nodi temporanei che rappresentano diversi server regionali. I server principali utilizzano questi nodi per rilevare i server disponibili.
Oltre alla disponibilità, i nodi vengono utilizzati anche per tenere traccia degli errori del server o delle partizioni di rete.
I client comunicano con i server regionali tramite guardiano dello zoo.
In modalità pseudo e standalone, HBase stesso si prenderà cura del guardiano dello zoo.

Questo capitolo spiega come HBase è installato e inizialmente configurato. Java e Hadoop sono necessari per procedere con HBase, quindi devi scaricare e installare java e Hadoop nel tuo sistema.

Configurazione preinstallazione

Prima di installare Hadoop in ambiente Linux, è necessario configurare Linux utilizzando ssh(Secure Shell). Seguire i passaggi indicati di seguito per configurare l'ambiente Linux.

Creazione di un utente

Prima di tutto, si consiglia di creare un utente separato per Hadoop per isolare il file system Hadoop dal file system Unix. Seguire i passaggi indicati di seguito per creare un utente.

Aprire la radice utilizzando il comando "su".
Creare un utente dall'account root utilizzando il comando "useradd username".
Ora puoi aprire un account utente esistente utilizzando il comando "su username".

Apri il terminale Linux e digita i seguenti comandi per creare un utente.

$ su
password:
# useradd hadoop
# passwd hadoop
New passwd:
Retype new passwd

Configurazione SSH e generazione di chiavi

La configurazione di SSH è necessaria per eseguire diverse operazioni sul cluster come l'avvio, l'arresto e le operazioni della shell daemon distribuita. Per autenticare diversi utenti di Hadoop, è necessario fornire una coppia di chiavi pubblica / privata per un utente Hadoop e condividerla con utenti diversi.

I seguenti comandi vengono utilizzati per generare una coppia chiave-valore utilizzando SSH. Copia le chiavi pubbliche da id_rsa.pub in authorized_keys e fornisci i permessi di proprietario, lettura e scrittura rispettivamente al file authorized_keys.

$ ssh-keygen -t rsa
$ cat ~/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys $ chmod 0600 ~/.ssh/authorized_keys

Verifica ssh

ssh localhost

Installazione di Java

Java è il prerequisito principale per Hadoop e HBase. Prima di tutto, dovresti verificare l'esistenza di java nel tuo sistema usando "java -version". La sintassi del comando della versione Java è fornita di seguito.

$ java -version

Se tutto funziona correttamente, ti darà il seguente output.

java version "1.7.0_71"
Java(TM) SE Runtime Environment (build 1.7.0_71-b13)
Java HotSpot(TM) Client VM (build 25.0-b02, mixed mode)

Se java non è installato nel tuo sistema, segui i passaggi indicati di seguito per l'installazione di java.

Passo 1

Scarica java (JDK <ultima versione> - X64.tar.gz) visitando il seguente link Oracle Java .

Poi jdk-7u71-linux-x64.tar.gz verrà scaricato nel tuo sistema.

Passo 2

Generalmente troverai il file java scaricato nella cartella Download. Verificalo ed estrai il filejdk-7u71-linux-x64.gz file utilizzando i seguenti comandi.

$ cd Downloads/
$ ls jdk-7u71-linux-x64.gz $ tar zxf jdk-7u71-linux-x64.gz
$ ls
jdk1.7.0_71 jdk-7u71-linux-x64.gz

Passaggio 3

Per rendere java disponibile a tutti gli utenti, è necessario spostarlo nella posizione "/ usr / local /". Apri root e digita i seguenti comandi.

$ su
password:
# mv jdk1.7.0_71 /usr/local/
# exit

Passaggio 4

Per l'allestimento PATH e JAVA_HOME variabili, aggiungi i seguenti comandi a ~/.bashrc file.

export JAVA_HOME=/usr/local/jdk1.7.0_71
export PATH= $PATH:$JAVA_HOME/bin

Ora applica tutte le modifiche al sistema in esecuzione corrente.

$ source ~/.bashrc

Passaggio 5

Utilizzare i seguenti comandi per configurare le alternative Java:

# alternatives --install /usr/bin/java java usr/local/java/bin/java 2

# alternatives --install /usr/bin/javac javac usr/local/java/bin/javac 2

# alternatives --install /usr/bin/jar jar usr/local/java/bin/jar 2


# alternatives --set java usr/local/java/bin/java

# alternatives --set javac usr/local/java/bin/javac

# alternatives --set jar usr/local/java/bin/jar

Ora verifica il file java -version comando dal terminale come spiegato sopra.

Download di Hadoop

Dopo aver installato java, devi installare Hadoop. Prima di tutto, verifica l'esistenza di Hadoop utilizzando il comando "Hadoop version" come mostrato di seguito.

hadoop version

Se tutto funziona correttamente, ti darà il seguente output.

Hadoop 2.6.0
Compiled by jenkins on 2014-11-13T21:10Z
Compiled with protoc 2.5.0
From source with checksum 18e43357c8f927c0695f1e9522859d6a
This command was run using
/home/hadoop/hadoop/share/hadoop/common/hadoop-common-2.6.0.jar

Se il tuo sistema non è in grado di individuare Hadoop, scarica Hadoop nel tuo sistema. Segui i comandi indicati di seguito per farlo.

Scarica ed estrai hadoop-2.6.0 da Apache Software Foundation utilizzando i seguenti comandi.

$ su
password:
# cd /usr/local
# wget http://mirrors.advancedhosters.com/apache/hadoop/common/hadoop-
2.6.0/hadoop-2.6.0-src.tar.gz
# tar xzf hadoop-2.6.0-src.tar.gz
# mv hadoop-2.6.0/* hadoop/
# exit

Installazione di Hadoop

Installa Hadoop in una delle modalità richieste. Qui, stiamo dimostrando le funzionalità di HBase in modalità pseudo distribuita, quindi installa Hadoop in modalità pseudo distribuita.

I seguenti passaggi vengono utilizzati per l'installazione Hadoop 2.4.1.

Passaggio 1: configurazione di Hadoop

Puoi impostare le variabili d'ambiente Hadoop aggiungendo i seguenti comandi a ~/.bashrc file.

export HADOOP_HOME=/usr/local/hadoop
export HADOOP_MAPRED_HOME=$HADOOP_HOME export HADOOP_COMMON_HOME=$HADOOP_HOME
export HADOOP_HDFS_HOME=$HADOOP_HOME export YARN_HOME=$HADOOP_HOME
export HADOOP_COMMON_LIB_NATIVE_DIR=$HADOOP_HOME/lib/native export PATH=$PATH:$HADOOP_HOME/sbin:$HADOOP_HOME/bin
export HADOOP_INSTALL=$HADOOP_HOME

Ora applica tutte le modifiche al sistema in esecuzione corrente.

$ source ~/.bashrc

Passaggio 2: configurazione di Hadoop

Puoi trovare tutti i file di configurazione di Hadoop nella posizione "$ HADOOP_HOME / etc / hadoop". È necessario apportare modifiche a questi file di configurazione in base alla propria infrastruttura Hadoop.

$ cd $HADOOP_HOME/etc/hadoop

Per sviluppare programmi Hadoop in java, è necessario reimpostare la variabile d'ambiente java in hadoop-env.sh file sostituendo JAVA_HOME value con la posizione di java nel tuo sistema.

export JAVA_HOME=/usr/local/jdk1.7.0_71

Dovrai modificare i seguenti file per configurare Hadoop.

core-site.xml

Il core-site.xml file contiene informazioni come il numero di porta utilizzato per l'istanza Hadoop, la memoria allocata per il file system, il limite di memoria per la memorizzazione dei dati e la dimensione dei buffer di lettura / scrittura.

Apri core-site.xml e aggiungi le seguenti proprietà tra i tag <configuration> e </configuration>.

<configuration>
   <property>
      <name>fs.default.name</name>
      <value>hdfs://localhost:9000</value>
   </property>
</configuration>

hdfs-site.xml

Il hdfs-site.xml file contiene informazioni come il valore dei dati di replica, il percorso namenode e il percorso datanode dei file system locali, in cui si desidera archiviare l'infrastruttura Hadoop.

Assumiamo i seguenti dati.

dfs.replication (data replication value) = 1
(In the below given path /hadoop/ is the user name.
hadoopinfra/hdfs/namenode is the directory created by hdfs file system.)

namenode path = //home/hadoop/hadoopinfra/hdfs/namenode
(hadoopinfra/hdfs/datanode is the directory created by hdfs file system.)

datanode path = //home/hadoop/hadoopinfra/hdfs/datanode

Apri questo file e aggiungi le seguenti proprietà tra i tag <configuration>, </configuration>.

<configuration>
   <property>
      <name>dfs.replication</name >
      <value>1</value>
   </property>
	
   <property>
      <name>dfs.name.dir</name>
      <value>file:///home/hadoop/hadoopinfra/hdfs/namenode</value>
   </property>
	
   <property>
      <name>dfs.data.dir</name>
      <value>file:///home/hadoop/hadoopinfra/hdfs/datanode</value>
   </property>
</configuration>

Note: Nel file sopra, tutti i valori delle proprietà sono definiti dall'utente ed è possibile apportare modifiche in base alla propria infrastruttura Hadoop.

yarn-site.xml

Questo file viene utilizzato per configurare il filato in Hadoop. Apri il file filato-site.xml e aggiungi la seguente proprietà tra <configuration $ gt ;, </ configuration $ gt; tag in questo file.

<configuration>
   <property>
      <name>yarn.nodemanager.aux-services</name>
      <value>mapreduce_shuffle</value>
   </property>
</configuration>

mapred-site.xml

Questo file viene utilizzato per specificare quale framework MapReduce stiamo utilizzando. Per impostazione predefinita, Hadoop contiene un modello di filato-site.xml. Prima di tutto, è necessario copiare il file damapred-site.xml.template per mapred-site.xml file utilizzando il seguente comando.

$ cp mapred-site.xml.template mapred-site.xml

Aperto mapred-site.xml file e aggiungi le seguenti proprietà tra i tag <configuration> e </configuration>.

<configuration>
   <property>
      <name>mapreduce.framework.name</name>
      <value>yarn</value>
   </property>
</configuration>

Verifica dell'installazione di Hadoop

I seguenti passaggi vengono utilizzati per verificare l'installazione di Hadoop.

Passaggio 1: configurazione del nodo del nome

Impostare il namenode utilizzando il comando "hdfs namenode -format" come segue.

$ cd ~ $ hdfs namenode -format

Il risultato atteso è il seguente.

10/24/14 21:30:55 INFO namenode.NameNode: STARTUP_MSG:
/************************************************************
STARTUP_MSG: Starting NameNode
STARTUP_MSG: host = localhost/192.168.1.11
STARTUP_MSG: args = [-format]
STARTUP_MSG: version = 2.4.1
...
...
10/24/14 21:30:56 INFO common.Storage: Storage directory
/home/hadoop/hadoopinfra/hdfs/namenode has been successfully formatted.
10/24/14 21:30:56 INFO namenode.NNStorageRetentionManager: Going to
retain 1 images with txid >= 0
10/24/14 21:30:56 INFO util.ExitUtil: Exiting with status 0
10/24/14 21:30:56 INFO namenode.NameNode: SHUTDOWN_MSG:
/************************************************************
SHUTDOWN_MSG: Shutting down NameNode at localhost/192.168.1.11
************************************************************/

Passaggio 2: verifica di Hadoop dfs

Il seguente comando viene utilizzato per avviare dfs. L'esecuzione di questo comando avvierà il tuo file system Hadoop.

$ start-dfs.sh

L'output previsto è il seguente.

10/24/14 21:37:56
Starting namenodes on [localhost]
localhost: starting namenode, logging to /home/hadoop/hadoop-
2.4.1/logs/hadoop-hadoop-namenode-localhost.out
localhost: starting datanode, logging to /home/hadoop/hadoop-
2.4.1/logs/hadoop-hadoop-datanode-localhost.out
Starting secondary namenodes [0.0.0.0]

Passaggio 3: verifica dello script del filato

Il seguente comando viene utilizzato per avviare lo script del filato. L'esecuzione di questo comando avvierà i tuoi demoni filati.

$ start-yarn.sh

L'output previsto è il seguente.

starting yarn daemons
starting resourcemanager, logging to /home/hadoop/hadoop-
2.4.1/logs/yarn-hadoop-resourcemanager-localhost.out
localhost: starting nodemanager, logging to /home/hadoop/hadoop-
2.4.1/logs/yarn-hadoop-nodemanager-localhost.out

Passaggio 4: accesso a Hadoop sul browser

Il numero di porta predefinito per accedere a Hadoop è 50070. Utilizza il seguente URL per ottenere i servizi Hadoop sul tuo browser.

http://localhost:50070

Passaggio 5: verifica tutte le applicazioni di Cluster

Il numero di porta predefinito per accedere a tutte le applicazioni del cluster è 8088. Utilizzare il seguente URL per visitare questo servizio.

http://localhost:8088/

Installazione di HBase

Possiamo installare HBase in una qualsiasi delle tre modalità: modalità standalone, modalità pseudo distribuita e modalità completamente distribuita.

Installazione di HBase in modalità standalone

Scarica l'ultima versione stabile del modulo HBase http://www.interior-dsgn.com/apache/hbase/stable/utilizzando il comando "wget" ed estrarlo utilizzando il comando tar "zxvf". Vedere il comando seguente.

$cd usr/local/ $wget http://www.interior-dsgn.com/apache/hbase/stable/hbase-0.98.8-
hadoop2-bin.tar.gz
$tar -zxvf hbase-0.98.8-hadoop2-bin.tar.gz

Passa alla modalità super utente e sposta la cartella HBase in / usr / local come mostrato di seguito.

$su
$password: enter your password here
mv hbase-0.99.1/* Hbase/

Configurazione di HBase in modalità standalone

Prima di procedere con HBase, è necessario modificare i seguenti file e configurare HBase.

hbase-env.sh

Imposta java Home per HBase e apri hbase-env.shfile dalla cartella conf. Modifica la variabile d'ambiente JAVA_HOME e cambia il percorso esistente alla tua variabile JAVA_HOME corrente come mostrato di seguito.

cd /usr/local/Hbase/conf
gedit hbase-env.sh

Questo aprirà il file env.sh di HBase. Ora sostituisci l'esistenteJAVA_HOME valore con il valore corrente come mostrato di seguito.

export JAVA_HOME=/usr/lib/jvm/java-1.7.0

hbase-site.xml

Questo è il file di configurazione principale di HBase. Impostare la directory dei dati in una posizione appropriata aprendo la cartella home di HBase in / usr / local / HBase. All'interno della cartella conf, troverai diversi file, apri il filehbase-site.xml file come mostrato di seguito.

#cd /usr/local/HBase/
#cd conf
# gedit hbase-site.xml

Dentro il hbase-site.xmlfile, troverai i tag <configuration> e </configuration>. Al loro interno, impostare la directory HBase sotto la chiave di proprietà con il nome "hbase.rootdir" come mostrato di seguito.

<configuration>
   //Here you have to set the path where you want HBase to store its files.
   <property>
      <name>hbase.rootdir</name>
      <value>file:/home/hadoop/HBase/HFiles</value>
   </property>
	
   //Here you have to set the path where you want HBase to store its built in zookeeper  files.
   <property>
      <name>hbase.zookeeper.property.dataDir</name>
      <value>/home/hadoop/zookeeper</value>
   </property>
</configuration>

Con questo, l'installazione di HBase e la parte di configurazione è completata con successo. Possiamo avviare HBase usandostart-hbase.shscript fornito nella cartella bin di HBase. Per questo, apri HBase Home Folder ed esegui lo script di avvio HBase come mostrato di seguito.

$cd /usr/local/HBase/bin
$./start-hbase.sh

Se tutto va bene, quando si tenta di eseguire lo script di avvio HBase, verrà visualizzato un messaggio che informa che HBase è stato avviato.

starting master, logging to /usr/local/HBase/bin/../logs/hbase-tpmaster-localhost.localdomain.out

Installazione di HBase in modalità pseudo-distribuita

Vediamo ora come è installato HBase in modalità pseudo-distribuita.

Configurazione di HBase

Prima di procedere con HBase, configura Hadoop e HDFS sul tuo sistema locale o su un sistema remoto e assicurati che siano in esecuzione. Interrompi HBase se è in esecuzione.

hbase-site.xml

Modifica il file hbase-site.xml per aggiungere le seguenti proprietà.

<property>
   <name>hbase.cluster.distributed</name>
   <value>true</value>
</property>

Menzionerà in quale modalità dovrebbe essere eseguito HBase. Nello stesso file dal file system locale, modificare hbase.rootdir, l'indirizzo dell'istanza HDFS, utilizzando la sintassi dell'URI hdfs: ////. Stiamo eseguendo HDFS sul localhost alla porta 8030.

<property>
   <name>hbase.rootdir</name>
   <value>hdfs://localhost:8030/hbase</value>
</property>

Avvio di HBase

Al termine della configurazione, accedere alla cartella principale di HBase e avviare HBase utilizzando il comando seguente.

$cd /usr/local/HBase
$bin/start-hbase.sh

Note: Prima di avviare HBase, assicurati che Hadoop sia in esecuzione.

Controllo della directory HBase in HDFS

HBase crea la sua directory in HDFS. Per vedere la directory creata, vai a Hadoop bin e digita il seguente comando.

$ ./bin/hadoop fs -ls /hbase

Se tutto va bene, ti darà il seguente output.

Found 7 items
drwxr-xr-x - hbase users 0 2014-06-25 18:58 /hbase/.tmp
drwxr-xr-x - hbase users 0 2014-06-25 21:49 /hbase/WALs
drwxr-xr-x - hbase users 0 2014-06-25 18:48 /hbase/corrupt
drwxr-xr-x - hbase users 0 2014-06-25 18:58 /hbase/data
-rw-r--r-- 3 hbase users 42 2014-06-25 18:41 /hbase/hbase.id
-rw-r--r-- 3 hbase users 7 2014-06-25 18:41 /hbase/hbase.version
drwxr-xr-x - hbase users 0 2014-06-25 21:49 /hbase/oldWALs

Avvio e arresto di un master

Utilizzando "local-master-backup.sh" puoi avviare fino a 10 server. Apri la cartella home di HBase, master ed esegui il seguente comando per avviarlo.

$ ./bin/local-master-backup.sh 2 4

Per uccidere un master di backup, è necessario il suo ID processo, che verrà archiviato in un file denominato “/tmp/hbase-USER-X-master.pid.” puoi uccidere il master di backup usando il seguente comando.

$ cat /tmp/hbase-user-1-master.pid |xargs kill -9

Avvio e arresto di RegionServers

È possibile eseguire più server regionali da un unico sistema utilizzando il seguente comando.

$ .bin/local-regionservers.sh start 2 3

Per arrestare un server regionale, utilizzare il seguente comando.

$ .bin/local-regionservers.sh stop 3

Avvio di HBaseShell

Dopo aver installato HBase con successo, è possibile avviare HBase Shell. Di seguito sono riportate le sequenze di passaggi da seguire per avviare la shell HBase. Apri il terminale e accedi come super utente.

Avvia il file system Hadoop

Sfoglia la cartella sbin di Hadoop home e avvia il file system Hadoop come mostrato di seguito.

$cd $HADOOP_HOME/sbin
$start-all.sh

Avvia HBase

Sfogliare la cartella bin della directory principale HBase e avviare HBase.

$cd /usr/local/HBase
$./bin/start-hbase.sh

Avvia HBase Master Server

Questa sarà la stessa directory. Avviarlo come mostrato di seguito.

$./bin/local-master-backup.sh start 2 (number signifies specific
server.)

Regione iniziale

Avvia il server regionale come mostrato di seguito.

$./bin/./local-regionservers.sh start 3

Avvia HBase Shell

È possibile avviare la shell HBase utilizzando il seguente comando.

$cd bin
$./hbase shell

Questo ti darà il prompt della shell HBase come mostrato di seguito.

2014-12-09 14:24:27,526 INFO [main] Configuration.deprecation:
hadoop.native.lib is deprecated. Instead, use io.native.lib.available
HBase Shell; enter 'help<RETURN>' for list of supported commands.
Type "exit<RETURN>" to leave the HBase Shell
Version 0.98.8-hadoop2, r6cfc8d064754251365e070a10a82eb169956d5fe, Fri
Nov 14 18:26:29 PST 2014

hbase(main):001:0>

Interfaccia Web HBase

Per accedere all'interfaccia web di HBase, digitare il seguente URL nel browser.

http://localhost:60010

Questa interfaccia elenca i server regionali, i master di backup e le tabelle HBase attualmente in esecuzione.

Server della regione HBase e master di backup

Tabelle HBase

Impostazione dell'ambiente Java

Possiamo anche comunicare con HBase utilizzando le librerie Java, ma prima di accedere a HBase utilizzando l'API Java è necessario impostare il percorso di classe per quelle librerie.

Impostazione del percorso di classe

Prima di procedere con la programmazione, impostare il classpath sulle librerie HBase in .bashrcfile. Aperto.bashrc in uno qualsiasi degli editor come mostrato di seguito.

$ gedit ~/.bashrc

Impostare classpath per le librerie HBase (cartella lib in HBase) in esso come mostrato di seguito.

export CLASSPATH = $CLASSPATH://home/hadoop/hbase/lib/*

Questo per evitare l'eccezione "classe non trovata" durante l'accesso a HBase utilizzando l'API java.

Questo capitolo spiega come avviare la shell interattiva HBase fornita con HBase.

HBase Shell

HBase contiene una shell che consente di comunicare con HBase. HBase utilizza il file system Hadoop per archiviare i propri dati. Avrà un server principale e server regionali. La memorizzazione dei dati avverrà sotto forma di regioni (tabelle). Queste regioni verranno suddivise e archiviate nei server della regione.

Il server master gestisce questi server regionali e tutte queste attività vengono eseguite su HDFS. Di seguito sono riportati alcuni dei comandi supportati da HBase Shell.

Comandi generali

status - Fornisce lo stato di HBase, ad esempio, il numero di server.
version - Fornisce la versione di HBase utilizzata.
table_help - Fornisce aiuto per i comandi di riferimento alla tabella.
whoami - Fornisce informazioni sull'utente.

Linguaggio di definizione dei dati

Questi sono i comandi che operano sulle tabelle in HBase.

create - Crea una tabella.
list - Elenca tutte le tabelle in HBase.
disable - Disabilita una tabella.
is_disabled - Verifica se una tabella è disabilitata.
enable - Abilita una tabella.
is_enabled - Verifica se una tabella è abilitata.
describe - Fornisce la descrizione di una tabella.
alter - Altera un tavolo.
exists - Verifica se esiste una tabella.
drop - Elimina un tavolo da HBase.
drop_all - Elimina le tabelle che corrispondono alla "regex" fornita nel comando.
Java Admin API- Prima di tutti i comandi precedenti, Java fornisce un'API di amministrazione per ottenere le funzionalità DDL tramite la programmazione. Sottoorg.apache.hadoop.hbase.client package, HBaseAdmin e HTableDescriptor sono le due classi importanti in questo pacchetto che forniscono funzionalità DDL.

Linguaggio di manipolazione dei dati

put - Inserisce un valore di cella in una colonna specificata in una riga specificata in una tabella particolare.
get - Recupera il contenuto di una riga o di una cella.
delete - Elimina un valore di cella in una tabella.
deleteall - Elimina tutte le celle in una data riga.
scan - Scansiona e restituisce i dati della tabella.
count - Conta e restituisce il numero di righe in una tabella.
truncate - Disabilita, rilascia e ricrea una tabella specificata.
Java client API - Prima di tutti i comandi precedenti, Java fornisce un'API client per ottenere le funzionalità DML, CRUD (Crea Recupera Aggiorna Elimina) operazioni e altro tramite la programmazione, nel pacchetto org.apache.hadoop.hbase.client. HTable Put e Get sono le classi importanti in questo pacchetto.

Avvio di HBase Shell

Per accedere alla shell HBase, devi navigare nella cartella home di HBase.

cd /usr/localhost/
cd Hbase

È possibile avviare la shell interattiva HBase utilizzando “hbase shell” comando come mostrato di seguito.

./bin/hbase shell

Se hai installato con successo HBase nel tuo sistema, ti darà il prompt della shell HBase come mostrato di seguito.

HBase Shell; enter 'help<RETURN>' for list of supported commands.
Type "exit<RETURN>" to leave the HBase Shell
Version 0.94.23, rf42302b28aceaab773b15f234aa8718fff7eea3c, Wed Aug 27
00:54:09 UTC 2014

hbase(main):001:0>

Per uscire dal comando della shell interattiva in qualsiasi momento, digita exit o usa <ctrl + c>. Verificare il funzionamento della shell prima di procedere oltre. Utilizzare illist comando per questo scopo. Listè un comando utilizzato per ottenere l'elenco di tutte le tabelle in HBase. Prima di tutto, verifica l'installazione e la configurazione di HBase nel tuo sistema usando questo comando come mostrato di seguito.

hbase(main):001:0> list

Quando digiti questo comando, ti dà il seguente output.

hbase(main):001:0> list
TABLE

I comandi generali in HBase sono status, version, table_help e whoami. Questo capitolo spiega questi comandi.

stato

Questo comando restituisce lo stato del sistema inclusi i dettagli dei server in esecuzione sul sistema. La sua sintassi è la seguente:

hbase(main):009:0> status

Se esegui questo comando, restituisce il seguente output.

hbase(main):009:0> status
3 servers, 0 dead, 1.3333 average load

versione

Questo comando restituisce la versione di HBase utilizzata nel sistema. La sua sintassi è la seguente:

hbase(main):010:0> version

Se esegui questo comando, restituisce il seguente output.

hbase(main):009:0> version
0.98.8-hadoop2, r6cfc8d064754251365e070a10a82eb169956d5fe, Fri Nov 14
18:26:29 PST 2014

table_help

Questo comando ti guida su cosa e come usare i comandi con riferimenti a tabelle. Di seguito è riportata la sintassi per utilizzare questo comando.

hbase(main):02:0> table_help

Quando si utilizza questo comando, vengono visualizzati gli argomenti della guida per i comandi relativi alle tabelle. Di seguito è riportato l'output parziale di questo comando.

hbase(main):002:0> table_help
Help for table-reference commands.
You can either create a table via 'create' and then manipulate the table
via commands like 'put', 'get', etc.
See the standard help information for how to use each of these commands.
However, as of 0.96, you can also get a reference to a table, on which
you can invoke commands.
For instance, you can get create a table and keep around a reference to
it via:
 hbase> t = create 't', 'cf'…...

chi sono

Questo comando restituisce i dettagli utente di HBase. Se esegui questo comando, restituisce l'utente HBase corrente come mostrato di seguito.

hbase(main):008:0> whoami
hadoop (auth:SIMPLE)
groups: hadoop

HBase è scritto in java, quindi fornisce l'API java per comunicare con HBase. L'API Java è il modo più veloce per comunicare con HBase. Di seguito è riportata l'API Admin Java di riferimento che copre le attività utilizzate per gestire le tabelle.

Classe HBaseAdmin

HBaseAdminè una classe che rappresenta l'amministratore. Questa classe appartiene alorg.apache.hadoop.hbase.clientpacchetto. Usando questa classe, puoi eseguire le attività di un amministratore. Puoi ottenere l'istanza di Admin usandoConnection.getAdmin() metodo.

Metodi e descrizione

S.No.	Metodi e descrizione
1	void createTable(HTableDescriptor desc) Crea una nuova tabella.
2	void createTable(HTableDescriptor desc, byte[][] splitKeys) Crea una nuova tabella con un set iniziale di aree vuote definite dalle chiavi di divisione specificate.
3	void deleteColumn(byte[] tableName, String columnName) Elimina una colonna da una tabella.
4	void deleteColumn(String tableName, String columnName) Elimina una colonna da una tabella.
5	void deleteTable(String tableName) Elimina una tabella.

Descrittore di classe

Questa classe contiene i dettagli su una tabella HBase come:

i descrittori di tutte le famiglie di colonne,
se il tavolo è un tavolo da catalogo,
se la tabella è di sola lettura,
la dimensione massima del mem store,
quando dovrebbe verificarsi la divisione della regione,
co-processori ad esso associati, ecc.

Costruttori

S.No.	Costruttore e riepilogo
1	HTableDescriptor(TableName name) Costruisce un descrittore di tabella che specifica un oggetto TableName.

Metodi e descrizione

S.No.	Metodi e descrizione
1	HTableDescriptor addFamily(HColumnDescriptor family) Aggiunge una famiglia di colonne al descrittore specificato

Creazione di una tabella utilizzando HBase Shell

Puoi creare una tabella usando il create, qui è necessario specificare il nome della tabella e il nome della famiglia di colonne. Ilsyntax per creare una tabella nella shell HBase è mostrato di seguito.

create ‘<table name>’,’<column family>’

Esempio

Di seguito è riportato uno schema di esempio di una tabella denominata emp. Ha due famiglie di colonne: "dati personali" e "dati professionali".

Tasto riga	dati personali	dati professionali

È possibile creare questa tabella nella shell HBase come mostrato di seguito.

hbase(main):002:0> create 'emp', 'personal data', 'professional data'

E ti darà il seguente output.

0 row(s) in 1.1300 seconds
=> Hbase::Table - emp

Verifica

È possibile verificare se la tabella viene creata utilizzando il listcomando come mostrato di seguito. Qui puoi osservare la tabella emp creata.

hbase(main):002:0> list
TABLE 
emp
2 row(s) in 0.0340 seconds

Creazione di una tabella utilizzando Java API

Puoi creare una tabella in HBase usando il createTable() metodo di HBaseAdminclasse. Questa classe appartiene alorg.apache.hadoop.hbase.clientpacchetto. Di seguito sono riportati i passaggi per creare una tabella in HBase utilizzando Java API.

Passaggio 1: creare un'istanza di HBaseAdmin

Questa classe richiede l'oggetto Configuration come parametro, quindi inizialmente creare un'istanza della classe Configuration e passare questa istanza a HBaseAdmin.

Configuration conf = HBaseConfiguration.create();
HBaseAdmin admin = new HBaseAdmin(conf);

Passaggio 2: creare TableDescriptor

HTableDescriptor è una classe che appartiene a org.apache.hadoop.hbaseclasse. Questa classe è come un contenitore di nomi di tabelle e famiglie di colonne.

//creating table descriptor
HTableDescriptor table = new HTableDescriptor(toBytes("Table name"));

//creating column family descriptor
HColumnDescriptor family = new HColumnDescriptor(toBytes("column family"));

//adding coloumn family to HTable
table.addFamily(family);

Passaggio 3: eseguire tramite Admin

Usando il createTable() metodo di HBaseAdmin class, puoi eseguire la tabella creata in modalità Admin.

admin.createTable(table);

Di seguito è riportato il programma completo per creare una tabella tramite admin.

import java.io.IOException;

import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.HColumnDescriptor;
import org.apache.hadoop.hbase.HTableDescriptor;
import org.apache.hadoop.hbase.client.HBaseAdmin;
import org.apache.hadoop.hbase.TableName;

import org.apache.hadoop.conf.Configuration;

public class CreateTable {
      
   public static void main(String[] args) throws IOException {

      // Instantiating configuration class
      Configuration con = HBaseConfiguration.create();

      // Instantiating HbaseAdmin class
      HBaseAdmin admin = new HBaseAdmin(con);

      // Instantiating table descriptor class
      HTableDescriptor tableDescriptor = new
      HTableDescriptor(TableName.valueOf("emp"));

      // Adding column families to table descriptor
      tableDescriptor.addFamily(new HColumnDescriptor("personal"));
      tableDescriptor.addFamily(new HColumnDescriptor("professional"));

      // Execute the table through admin
      admin.createTable(tableDescriptor);
      System.out.println(" Table created ");
   }
}

Compilare ed eseguire il programma sopra come mostrato di seguito.

$javac CreateTable.java
$java CreateTable

Il seguente dovrebbe essere l'output:

Table created

Elencare una tabella utilizzando HBase Shell

list è il comando utilizzato per elencare tutte le tabelle in HBase. Di seguito è riportata la sintassi del comando list.

hbase(main):001:0 > list

Quando digiti questo comando ed esegui nel prompt di HBase, verrà visualizzato l'elenco di tutte le tabelle in HBase come mostrato di seguito.

hbase(main):001:0> list
TABLE
emp

Qui puoi osservare una tabella chiamata emp.

Elenco delle tabelle utilizzando l'API Java

Seguire i passaggi indicati di seguito per ottenere l'elenco delle tabelle da HBase utilizzando l'API java.

Passo 1

Hai un metodo chiamato listTables() in classe HBaseAdminper ottenere l'elenco di tutte le tabelle in HBase. Questo metodo restituisce un array diHTableDescriptor oggetti.

//creating a configuration object
Configuration conf = HBaseConfiguration.create();

//Creating HBaseAdmin object
HBaseAdmin admin = new HBaseAdmin(conf);

//Getting all the list of tables using HBaseAdmin object
HTableDescriptor[] tableDescriptor = admin.listTables();

Passo 2

Puoi ottenere la lunghezza del file HTableDescriptor[] array utilizzando la variabile length di HTableDescriptorclasse. Ottieni il nome delle tabelle da questo oggetto utilizzandogetNameAsString()metodo. Esegui il ciclo "for" usando questi e ottieni l'elenco delle tabelle in HBase.

Di seguito è riportato il programma per elencare tutte le tabelle in HBase utilizzando l'API Java.

import java.io.IOException;

import org.apache.hadoop.conf.Configuration;

import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.HTableDescriptor;
import org.apache.hadoop.hbase.MasterNotRunningException;
import org.apache.hadoop.hbase.client.HBaseAdmin;

public class ListTables {

   public static void main(String args[])throws MasterNotRunningException, IOException{

      // Instantiating a configuration class
      Configuration conf = HBaseConfiguration.create();

      // Instantiating HBaseAdmin class
      HBaseAdmin admin = new HBaseAdmin(conf);

      // Getting all the list of tables using HBaseAdmin object
      HTableDescriptor[] tableDescriptor = admin.listTables();

      // printing all the table names.
      for (int i=0; i<tableDescriptor.length;i++ ){
         System.out.println(tableDescriptor[i].getNameAsString());
      }
   
   }
}

Compilare ed eseguire il programma sopra come mostrato di seguito.

$javac ListTables.java
$java ListTables

Il seguente dovrebbe essere l'output:

User
emp

Disattivazione di una tabella utilizzando HBase Shell

Per eliminare una tabella o modificarne le impostazioni, è necessario prima disabilitare la tabella utilizzando il comando disable. Puoi riattivarlo utilizzando il comando enable.

Di seguito è riportata la sintassi per disabilitare una tabella:

disable ‘emp’

Esempio

Di seguito è riportato un esempio che mostra come disabilitare una tabella.

hbase(main):025:0> disable 'emp'
0 row(s) in 1.2760 seconds

Verifica

Dopo aver disabilitato la tabella, puoi ancora percepirne l'esistenza list e existscomandi. Non puoi scansionarlo. Ti darà il seguente errore.

hbase(main):028:0> scan 'emp'
ROW         COLUMN + CELL
ERROR: emp is disabled.

è disabilitato

Questo comando viene utilizzato per scoprire se una tabella è disabilitata. La sua sintassi è la seguente.

hbase> is_disabled 'table name'

L'esempio seguente verifica se la tabella denominata emp è disabilitata. Se è disabilitato, restituirà true e in caso contrario restituirà false.

hbase(main):031:0> is_disabled 'emp'
true
0 row(s) in 0.0440 seconds

disabilitare tutto

Questo comando viene utilizzato per disabilitare tutte le tabelle che corrispondono alla regex data. La sintassi perdisable_all comando è dato di seguito.

hbase> disable_all 'r.*'

Supponiamo che ci siano 5 tabelle in HBase, vale a dire raja, rajani, rajendra, rajesh e raju. Il codice seguente disabiliterà tutte le tabelle che iniziano conraj.

hbase(main):002:07> disable_all 'raj.*'
raja
rajani
rajendra
rajesh
raju
Disable the above 5 tables (y/n)?
y
5 tables successfully disabled

Disabilitare una tabella utilizzando l'API Java

Per verificare se una tabella è disabilitata, isTableDisabled() viene utilizzato il metodo e per disabilitare una tabella, disableTable()viene utilizzato il metodo. Questi metodi appartengono aHBaseAdminclasse. Seguire i passaggi indicati di seguito per disabilitare una tabella.

Passo 1

Istanziare HBaseAdmin classe come mostrato di seguito.

// Creating configuration object
Configuration conf = HBaseConfiguration.create();

// Creating HBaseAdmin object
HBaseAdmin admin = new HBaseAdmin(conf);

Passo 2

Verificare se la tabella è disabilitata utilizzando isTableDisabled() metodo come mostrato di seguito.

Boolean b = admin.isTableDisabled("emp");

Passaggio 3

Se la tabella non è disabilitata, disabilitarla come mostrato di seguito.

if(!b){
   admin.disableTable("emp");
   System.out.println("Table disabled");
}

Di seguito è riportato il programma completo per verificare se la tabella è disabilitata; in caso contrario, come disabilitarlo.

import java.io.IOException;

import org.apache.hadoop.conf.Configuration;

import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.MasterNotRunningException;
import org.apache.hadoop.hbase.client.HBaseAdmin;

public class DisableTable{

   public static void main(String args[]) throws MasterNotRunningException, IOException{

      // Instantiating configuration class
      Configuration conf = HBaseConfiguration.create();
 
      // Instantiating HBaseAdmin class
      HBaseAdmin admin = new HBaseAdmin(conf);

      // Verifying weather the table is disabled
      Boolean bool = admin.isTableDisabled("emp");
      System.out.println(bool);

      // Disabling the table using HBaseAdmin object
      if(!bool){
         admin.disableTable("emp");
         System.out.println("Table disabled");
      }
   }
}

Compilare ed eseguire il programma sopra come mostrato di seguito.

$javac DisableTable.java
$java DsiableTable

Il seguente dovrebbe essere l'output:

false
Table disabled

Abilitazione di una tabella utilizzando HBase Shell

Sintassi per abilitare una tabella:

enable ‘emp’

Esempio

Di seguito è riportato un esempio per abilitare una tabella.

hbase(main):005:0> enable 'emp'
0 row(s) in 0.4580 seconds

Verifica

Dopo aver abilitato la tabella, scansionala. Se puoi vedere lo schema, la tua tabella è abilitata correttamente.

hbase(main):006:0> scan 'emp'

   ROW                        COLUMN + CELL

1 column = personal data:city, timestamp = 1417516501, value = hyderabad

1 column = personal data:name, timestamp = 1417525058, value = ramu

1 column = professional data:designation, timestamp = 1417532601, value = manager

1 column = professional data:salary, timestamp = 1417524244109, value = 50000

2 column = personal data:city, timestamp = 1417524574905, value = chennai

2 column = personal data:name, timestamp = 1417524556125, value = ravi

2 column = professional data:designation, timestamp = 14175292204, value = sr:engg

2 column = professional data:salary, timestamp = 1417524604221, value = 30000 

3 column = personal data:city, timestamp = 1417524681780, value = delhi

3 column = personal data:name, timestamp = 1417524672067, value = rajesh

3 column = professional data:designation, timestamp = 14175246987, value = jr:engg

3 column = professional data:salary, timestamp = 1417524702514, value = 25000

3 row(s) in 0.0400 seconds

è abilitato

Questo comando viene utilizzato per verificare se una tabella è abilitata. La sua sintassi è la seguente:

hbase> is_enabled 'table name'

Il codice seguente verifica se la tabella denominata empè abilitato. Se è abilitato, restituirà true e in caso contrario restituirà false.

hbase(main):031:0> is_enabled 'emp'
true
0 row(s) in 0.0440 seconds

Abilita una tabella utilizzando l'API Java

Per verificare se una tabella è abilitata, isTableEnabled()viene utilizzato il metodo; e per abilitare una tabella,enableTable()viene utilizzato il metodo. Questi metodi appartengono aHBaseAdminclasse. Seguire i passaggi indicati di seguito per abilitare una tabella.

Passo 1

Istanziare HBaseAdmin classe come mostrato di seguito.

// Creating configuration object
Configuration conf = HBaseConfiguration.create();

// Creating HBaseAdmin object
HBaseAdmin admin = new HBaseAdmin(conf);

Passo 2

Verificare se la tabella è abilitata utilizzando isTableEnabled() metodo come mostrato di seguito.

Boolean bool = admin.isTableEnabled("emp");

Passaggio 3

Se la tabella non è disabilitata, disabilitarla come mostrato di seguito.

if(!bool){
   admin.enableTable("emp");
   System.out.println("Table enabled");
}

Di seguito è riportato il programma completo per verificare se la tabella è abilitata e, in caso contrario, come abilitarlo.

import java.io.IOException;

import org.apache.hadoop.conf.Configuration;

import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.MasterNotRunningException;
import org.apache.hadoop.hbase.client.HBaseAdmin;

public class EnableTable{

   public static void main(String args[]) throws MasterNotRunningException, IOException{

      // Instantiating configuration class
      Configuration conf = HBaseConfiguration.create();

      // Instantiating HBaseAdmin class
      HBaseAdmin admin = new HBaseAdmin(conf);

      // Verifying whether the table is disabled
      Boolean bool = admin.isTableEnabled("emp");
      System.out.println(bool);

      // Enabling the table using HBaseAdmin object
      if(!bool){
         admin.enableTable("emp");
         System.out.println("Table Enabled");
      }
   }
}

Compilare ed eseguire il programma sopra come mostrato di seguito.

$javac EnableTable.java
$java EnableTable

Il seguente dovrebbe essere l'output:

false
Table Enabled

descrivere

Questo comando restituisce la descrizione della tabella. La sua sintassi è la seguente:

hbase> describe 'table name'

Di seguito è riportato l'output del comando description sul file emp tavolo.

hbase(main):006:0> describe 'emp'
   DESCRIPTION
      ENABLED
      
'emp', {NAME ⇒ 'READONLY', DATA_BLOCK_ENCODING ⇒ 'NONE', BLOOMFILTER
⇒ 'ROW', REPLICATION_SCOPE ⇒ '0', COMPRESSION ⇒ 'NONE', VERSIONS ⇒
'1', TTL true

⇒ 'FOREVER', MIN_VERSIONS ⇒ '0', KEEP_DELETED_CELLS ⇒ 'false',
BLOCKSIZE ⇒ '65536', IN_MEMORY ⇒ 'false', BLOCKCACHE ⇒ 'true'}, {NAME
⇒ 'personal

data', DATA_BLOCK_ENCODING ⇒ 'NONE', BLOOMFILTER ⇒ 'ROW',
REPLICATION_SCOPE ⇒ '0', VERSIONS ⇒ '5', COMPRESSION ⇒ 'NONE',
MIN_VERSIONS ⇒ '0', TTL

⇒ 'FOREVER', KEEP_DELETED_CELLS ⇒ 'false', BLOCKSIZE ⇒ '65536',
IN_MEMORY ⇒ 'false', BLOCKCACHE ⇒ 'true'}, {NAME ⇒ 'professional
data', DATA_BLO

CK_ENCODING ⇒ 'NONE', BLOOMFILTER ⇒ 'ROW', REPLICATION_SCOPE ⇒ '0',
VERSIONS ⇒ '1', COMPRESSION ⇒ 'NONE', MIN_VERSIONS ⇒ '0', TTL ⇒
'FOREVER', K

EEP_DELETED_CELLS ⇒ 'false', BLOCKSIZE ⇒ '65536', IN_MEMORY ⇒
'false', BLOCKCACHE ⇒ 'true'}, {NAME ⇒ 'table_att_unset',
DATA_BLOCK_ENCODING ⇒ 'NO 

NE', BLOOMFILTER ⇒ 'ROW', REPLICATION_SCOPE ⇒ '0', COMPRESSION ⇒
'NONE', VERSIONS ⇒ '1', TTL ⇒ 'FOREVER', MIN_VERSIONS ⇒ '0',
KEEP_DELETED_CELLS

⇒ 'false', BLOCKSIZE ⇒ '6

alterare

Alter è il comando utilizzato per apportare modifiche a una tabella esistente. Utilizzando questo comando, è possibile modificare il numero massimo di celle di una famiglia di colonne, impostare ed eliminare operatori di ambito di tabella ed eliminare una famiglia di colonne da una tabella.

Modifica del numero massimo di celle di una famiglia di colonne

Di seguito è riportata la sintassi per modificare il numero massimo di celle di una famiglia di colonne.

hbase> alter 't1', NAME ⇒ 'f1', VERSIONS ⇒ 5

Nell'esempio seguente, il numero massimo di celle è impostato su 5.

hbase(main):003:0> alter 'emp', NAME ⇒ 'personal data', VERSIONS ⇒ 5
Updating all regions with the new schema...
0/1 regions updated.
1/1 regions updated.
Done.
0 row(s) in 2.3050 seconds

Operatori di ambito tabella

Utilizzando alter, puoi impostare e rimuovere operatori di ambito di tabella come MAX_FILESIZE, READONLY, MEMSTORE_FLUSHSIZE, DEFERRED_LOG_FLUSH, ecc.

Impostazione di sola lettura

Di seguito viene fornita la sintassi per rendere una tabella di sola lettura.

hbase>alter 't1', READONLY(option)

Nell'esempio seguente, abbiamo creato il file emp tabella di sola lettura.

hbase(main):006:0> alter 'emp', READONLY
Updating all regions with the new schema...
0/1 regions updated.
1/1 regions updated.
Done.
0 row(s) in 2.2140 seconds

Rimozione degli operatori dell'ambito della tabella

Possiamo anche rimuovere gli operatori dell'ambito della tabella. Di seguito è riportata la sintassi per rimuovere "MAX_FILESIZE" dalla tabella emp.

hbase> alter 't1', METHOD ⇒ 'table_att_unset', NAME ⇒ 'MAX_FILESIZE'

Eliminazione di una famiglia di colonne

Utilizzando alter, puoi anche eliminare una famiglia di colonne. Di seguito è riportata la sintassi per eliminare una famiglia di colonne utilizzando alter.

hbase> alter ‘ table name ’, ‘delete’ ⇒ ‘ column family ’

Di seguito è riportato un esempio per eliminare una famiglia di colonne dalla tabella "emp".

Supponiamo che ci sia una tabella denominata dipendente in HBase. Contiene i seguenti dati:

hbase(main):006:0> scan 'employee'

   ROW                   COLUMN+CELL

row1 column = personal:city, timestamp = 1418193767, value = hyderabad

row1 column = personal:name, timestamp = 1418193806767, value = raju

row1 column = professional:designation, timestamp = 1418193767, value = manager

row1 column = professional:salary, timestamp = 1418193806767, value = 50000

1 row(s) in 0.0160 seconds

Ora eliminiamo la famiglia di colonne denominata professional utilizzando il comando alter.

hbase(main):007:0> alter 'employee','delete'⇒'professional'
Updating all regions with the new schema...
0/1 regions updated.
1/1 regions updated.
Done.
0 row(s) in 2.2380 seconds

Ora verifica i dati nella tabella dopo la modifica. Si noti che la famiglia di colonne "professionale" non esiste più, poiché l'abbiamo eliminata.

hbase(main):003:0> scan 'employee'
   ROW             COLUMN + CELL
row1 column = personal:city, timestamp = 14181936767, value = hyderabad

row1 column = personal:name, timestamp = 1418193806767, value = raju

1 row(s) in 0.0830 seconds

Aggiunta di una famiglia di colonne utilizzando l'API Java

È possibile aggiungere una famiglia di colonne a una tabella utilizzando il metodo addColumn() di HBAseAdminclasse. Seguire i passaggi indicati di seguito per aggiungere una famiglia di colonne a una tabella.

Passo 1

Istanziare il file HBaseAdmin classe.

// Instantiating configuration object
Configuration conf = HBaseConfiguration.create();

// Instantiating HBaseAdmin class
HBaseAdmin admin = new HBaseAdmin(conf);

Passo 2

Il addColumn() richiede un nome di tabella e un oggetto di HColumnDescriptorclasse. Quindi istanziare il fileHColumnDescriptorclasse. Il costruttore diHColumnDescriptora sua volta richiede un nome di famiglia di colonne che deve essere aggiunto. Qui stiamo aggiungendo una famiglia di colonne denominata "contactDetails" alla tabella "dipendente" esistente.

// Instantiating columnDescriptor object

HColumnDescriptor columnDescriptor = new
HColumnDescriptor("contactDetails");

Passaggio 3

Aggiungi la famiglia di colonne utilizzando addColumnmetodo. Passa il nome della tabella e il fileHColumnDescriptor oggetto di classe come parametri di questo metodo.

// Adding column family
admin.addColumn("employee", new HColumnDescriptor("columnDescriptor"));

Di seguito è riportato il programma completo per aggiungere una famiglia di colonne a una tabella esistente.

import java.io.IOException;

import org.apache.hadoop.conf.Configuration;

import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.HColumnDescriptor;
import org.apache.hadoop.hbase.MasterNotRunningException;
import org.apache.hadoop.hbase.client.HBaseAdmin;

public class AddColoumn{

   public static void main(String args[]) throws MasterNotRunningException, IOException{

      // Instantiating configuration class.
      Configuration conf = HBaseConfiguration.create();

      // Instantiating HBaseAdmin class.
      HBaseAdmin admin = new HBaseAdmin(conf);

      // Instantiating columnDescriptor class
      HColumnDescriptor columnDescriptor = new HColumnDescriptor("contactDetails");
      
      // Adding column family
      admin.addColumn("employee", columnDescriptor);
      System.out.println("coloumn added");
   }
}

Compilare ed eseguire il programma sopra come mostrato di seguito.

$javac AddColumn.java
$java AddColumn

La compilazione sopra funziona solo se hai impostato il classpath in " .bashrc". In caso contrario, seguire la procedura indicata di seguito per compilare il file .java.

//if "/home/home/hadoop/hbase " is your Hbase home folder then.

$javac -cp /home/hadoop/hbase/lib/*: Demo.java

Se tutto va bene, produrrà il seguente output:

column added

Eliminazione di una famiglia di colonne utilizzando l'API Java

È possibile eliminare una famiglia di colonne da una tabella utilizzando il metodo deleteColumn() di HBAseAdminclasse. Seguire i passaggi indicati di seguito per aggiungere una famiglia di colonne a una tabella.

Passo 1

Istanziare il file HBaseAdmin classe.

// Instantiating configuration object
Configuration conf = HBaseConfiguration.create();

// Instantiating HBaseAdmin class
HBaseAdmin admin = new HBaseAdmin(conf);

Passo 2

Aggiungi la famiglia di colonne utilizzando deleteColumn()metodo. Passare il nome della tabella e il nome della famiglia di colonne come parametri a questo metodo.

// Deleting column family
admin.deleteColumn("employee", "contactDetails");

Di seguito è riportato il programma completo per eliminare una famiglia di colonne da una tabella esistente.

import java.io.IOException;

import org.apache.hadoop.conf.Configuration;

import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.MasterNotRunningException;
import org.apache.hadoop.hbase.client.HBaseAdmin;

public class DeleteColoumn{

   public static void main(String args[]) throws MasterNotRunningException, IOException{

      // Instantiating configuration class.
      Configuration conf = HBaseConfiguration.create();

      // Instantiating HBaseAdmin class.
      HBaseAdmin admin = new HBaseAdmin(conf);

      // Deleting a column family
      admin.deleteColumn("employee","contactDetails");
      System.out.println("coloumn deleted"); 
   }
}

Compilare ed eseguire il programma sopra come mostrato di seguito.

$javac DeleteColumn.java $java DeleteColumn

Il seguente dovrebbe essere l'output:

column deleted

Esistenza di Table utilizzando HBase Shell

È possibile verificare l'esistenza di una tabella utilizzando il existscomando. L'esempio seguente mostra come utilizzare questo comando.

hbase(main):024:0> exists 'emp'
Table emp does exist

0 row(s) in 0.0750 seconds

==================================================================

hbase(main):015:0> exists 'student'
Table student does not exist

0 row(s) in 0.0480 seconds

Verifica dell'esistenza della tabella utilizzando l'API Java

È possibile verificare l'esistenza di una tabella in HBase utilizzando il tableExists() metodo del HBaseAdmin classe. Seguire i passaggi indicati di seguito per verificare l'esistenza di una tabella in HBase.

Passo 1

Instantiate the HBaseAdimn class

// Instantiating configuration object
Configuration conf = HBaseConfiguration.create();

// Instantiating HBaseAdmin class
HBaseAdmin admin = new HBaseAdmin(conf);

Passo 2

Verificare l'esistenza della tabella utilizzando il tableExists( ) metodo.

Di seguito è riportato il programma Java per testare l'esistenza di una tabella in HBase utilizzando l'API Java.

import java.io.IOException;

import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.client.HBaseAdmin;

public class TableExists{

   public static void main(String args[])throws IOException{

      // Instantiating configuration class
      Configuration conf = HBaseConfiguration.create();

      // Instantiating HBaseAdmin class
      HBaseAdmin admin = new HBaseAdmin(conf);

      // Verifying the existance of the table
      boolean bool = admin.tableExists("emp");
      System.out.println( bool);
   }
}

Compilare ed eseguire il programma sopra come mostrato di seguito.

$javac TableExists.java $java TableExists

Il seguente dovrebbe essere l'output:

true

Eliminare una tabella utilizzando HBase Shell

Usando il dropcomando, puoi eliminare una tabella. Prima di rilasciare un tavolo, devi disabilitarlo.

hbase(main):018:0> disable 'emp'
0 row(s) in 1.4580 seconds

hbase(main):019:0> drop 'emp'
0 row(s) in 0.3060 seconds

Verificare se la tabella viene eliminata utilizzando il comando exist.

hbase(main):020:07gt; exists 'emp'
Table emp does not exist
0 row(s) in 0.0730 seconds

drop_all

Questo comando viene utilizzato per eliminare le tabelle corrispondenti alla "regex" fornita nel comando. La sua sintassi è la seguente:

hbase> drop_all ‘t.*’

Note: Prima di rilasciare una tabella, è necessario disabilitarla.

Esempio

Supponiamo che ci siano tabelle chiamate raja, rajani, rajendra, rajesh e raju.

hbase(main):017:0> list
TABLE
raja
rajani
rajendra 
rajesh
raju
9 row(s) in 0.0270 seconds

Tutte queste tabelle iniziano con le lettere raj. Prima di tutto, disabilitiamo tutte queste tabelle usando ildisable_all comando come mostrato di seguito.

hbase(main):002:0> disable_all 'raj.*'
raja
rajani
rajendra
rajesh
raju
Disable the above 5 tables (y/n)?
y
5 tables successfully disabled

Ora puoi eliminarli tutti usando il file drop_all comando come indicato di seguito.

hbase(main):018:0> drop_all 'raj.*'
raja
rajani
rajendra
rajesh
raju
Drop the above 5 tables (y/n)?
y
5 tables successfully dropped

Eliminazione di una tabella utilizzando l'API Java

Puoi eliminare una tabella utilizzando il file deleteTable() metodo in HBaseAdminclasse. Seguire i passaggi indicati di seguito per eliminare una tabella utilizzando l'API Java.

Passo 1

Creare un'istanza della classe HBaseAdmin.

// creating a configuration object
Configuration conf = HBaseConfiguration.create();

// Creating HBaseAdmin object
HBaseAdmin admin = new HBaseAdmin(conf);

Passo 2

Disabilita la tabella utilizzando il disableTable() metodo del HBaseAdmin classe.

admin.disableTable("emp1");

Passaggio 3

Ora elimina la tabella utilizzando il file deleteTable() metodo del HBaseAdmin classe.

admin.deleteTable("emp12");

Di seguito è riportato il programma Java completo per eliminare una tabella in HBase.

import java.io.IOException;

import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.client.HBaseAdmin;

public class DeleteTable {

   public static void main(String[] args) throws IOException {

      // Instantiating configuration class
      Configuration conf = HBaseConfiguration.create();

      // Instantiating HBaseAdmin class
      HBaseAdmin admin = new HBaseAdmin(conf);

      // disabling table named emp
      admin.disableTable("emp12");

      // Deleting emp
      admin.deleteTable("emp12");
      System.out.println("Table deleted");
   }
}

Compilare ed eseguire il programma sopra come mostrato di seguito.

$javac DeleteTable.java $java DeleteTable

Il seguente dovrebbe essere l'output:

Table deleted

Uscita

Si esce dalla shell digitando il exit comando.

hbase(main):021:0> exit

Arresto di HBase

Per interrompere HBase, accedere alla cartella principale di HBase e digitare il comando seguente.

./bin/stop-hbase.sh

Arresto di HBase utilizzando l'API Java

È possibile arrestare HBase utilizzando shutdown() metodo del HBaseAdminclasse. Seguire i passaggi indicati di seguito per arrestare HBase:

Passo 1

Istanziare la classe HbaseAdmin.

// Instantiating configuration object
Configuration conf = HBaseConfiguration.create();

// Instantiating HBaseAdmin object
HBaseAdmin admin = new HBaseAdmin(conf);

Passo 2

Spegnere l'HBase utilizzando il shutdown() metodo del HBaseAdmin classe.

admin.shutdown();

Di seguito è riportato il programma per arrestare HBase.

import java.io.IOException;

import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.client.HBaseAdmin;

public class ShutDownHbase{

   public static void main(String args[])throws IOException {

      // Instantiating configuration class
      Configuration conf = HBaseConfiguration.create();

      // Instantiating HBaseAdmin class
      HBaseAdmin admin = new HBaseAdmin(conf);

      // Shutting down HBase
      System.out.println("Shutting down hbase");
      admin.shutdown();
   }
}

Compilare ed eseguire il programma sopra come mostrato di seguito.

$javac ShutDownHbase.java $java ShutDownHbase

Il seguente dovrebbe essere l'output:

Shutting down hbase

Questo capitolo descrive l'API del client java per HBase che viene utilizzata per eseguire CRUDoperazioni sulle tabelle HBase. HBase è scritto in Java e dispone di un'API Java Native. Pertanto fornisce l'accesso programmatico a DML (Data Manipulation Language).

Configurazione di classe HBase

Aggiunge i file di configurazione HBase a una configurazione. Questa classe appartiene alorg.apache.hadoop.hbase pacchetto.

Metodi e descrizione

S.No.	Metodi e descrizione
1	static org.apache.hadoop.conf.Configuration create() Questo metodo crea una configurazione con le risorse HBase.

Classe HTable

HTable è una classe interna HBase che rappresenta una tabella HBase. È un'implementazione della tabella utilizzata per comunicare con una singola tabella HBase. Questa classe appartiene alorg.apache.hadoop.hbase.client classe.

Costruttori

S.No.	Costruttori e descrizione
1	HTable()
2	HTable(TableName tableName, ClusterConnection connection, ExecutorService pool) Utilizzando questo costruttore, puoi creare un oggetto per accedere a una tabella HBase.

Metodi e descrizione

S.No.	Metodi e descrizione
1	void close() Rilascia tutte le risorse di HTable.
2	void delete(Delete delete) Elimina le celle / riga specificate.
3	boolean exists(Get get) Utilizzando questo metodo, è possibile verificare l'esistenza di colonne nella tabella, come specificato da Get.
4	Result get(Get get) Recupera determinate celle da una determinata riga.
5	org.apache.hadoop.conf.Configuration getConfiguration() Restituisce l'oggetto Configuration utilizzato da questa istanza.
6	TableName getName() Restituisce l'istanza del nome della tabella di questa tabella.
7	HTableDescriptor getTableDescriptor() Restituisce il descrittore di tabella per questa tabella.
8	byte[] getTableName() Restituisce il nome di questa tabella.
9	void put(Put put) Usando questo metodo, puoi inserire dati nella tabella.

Classe Put

Questa classe viene utilizzata per eseguire operazioni Put per una singola riga. Appartiene alorg.apache.hadoop.hbase.client pacchetto.

Costruttori

S.No.	Costruttori e descrizione
1	Put(byte[] row) Utilizzando questo costruttore, è possibile creare un'operazione Put per la riga specificata.
2	Put(byte[] rowArray, int rowOffset, int rowLength) Utilizzando questo costruttore, è possibile creare una copia della chiave di riga passata per mantenerla locale.
3	Put(byte[] rowArray, int rowOffset, int rowLength, long ts) Utilizzando questo costruttore, è possibile creare una copia della chiave di riga passata per mantenerla locale.
4	Put(byte[] row, long ts) Usando questo costruttore, possiamo creare un'operazione Put per la riga specificata, usando un dato timestamp.

Metodi

S.No.	Metodi e descrizione
1	Put add(byte[] family, byte[] qualifier, byte[] value) Aggiunge la colonna e il valore specificati a questa operazione di inserimento.
2	Put add(byte[] family, byte[] qualifier, long ts, byte[] value) Aggiunge la colonna e il valore specificati, con il timestamp specificato come versione a questa operazione Put.
3	Put add(byte[] family, ByteBuffer qualifier, long ts, ByteBuffer value) Aggiunge la colonna e il valore specificati, con il timestamp specificato come versione a questa operazione Put.
4	Put add(byte[] family, ByteBuffer qualifier, long ts, ByteBuffer value) Aggiunge la colonna e il valore specificati, con il timestamp specificato come versione a questa operazione Put.

Classe Get

Questa classe viene utilizzata per eseguire operazioni Get su una singola riga. Questa classe appartiene alorg.apache.hadoop.hbase.client pacchetto.

Costruttore

S.No.	Costruttore e descrizione
1	Get(byte[] row) Utilizzando questo costruttore, è possibile creare un'operazione Get per la riga specificata.
2	Get(Get get)

Metodi

S.No.	Metodi e descrizione
1	Get addColumn(byte[] family, byte[] qualifier) Recupera la colonna dalla famiglia specifica con il qualificatore specificato.
2	Get addFamily(byte[] family) Recupera tutte le colonne dalla famiglia specificata.

Elimina classe

Questa classe viene utilizzata per eseguire operazioni di eliminazione su una singola riga. Per eliminare un'intera riga, creare un'istanza di un oggetto Delete con la riga da eliminare. Questa classe appartiene alorg.apache.hadoop.hbase.client pacchetto.

Costruttore

S.No.	Costruttore e descrizione
1	Delete(byte[] row) Crea un'operazione di eliminazione per la riga specificata.
2	Delete(byte[] rowArray, int rowOffset, int rowLength) Crea un'operazione di eliminazione per la riga e il timestamp specificati.
3	Delete(byte[] rowArray, int rowOffset, int rowLength, long ts) Crea un'operazione di eliminazione per la riga e il timestamp specificati.
4	Delete(byte[] row, long timestamp) Crea un'operazione di eliminazione per la riga e il timestamp specificati.

Metodi

S.No.	Metodi e descrizione
1	Delete addColumn(byte[] family, byte[] qualifier) Elimina l'ultima versione della colonna specificata.
2	Delete addColumns(byte[] family, byte[] qualifier, long timestamp) Elimina tutte le versioni della colonna specificata con un timestamp minore o uguale al timestamp specificato.
3	Delete addFamily(byte[] family) Elimina tutte le versioni di tutte le colonne della famiglia specificata.
4	Delete addFamily(byte[] family, long timestamp) Elimina tutte le colonne della famiglia specificata con un timestamp minore o uguale al timestamp specificato.

Risultato della classe

Questa classe viene utilizzata per ottenere il risultato di una singola riga di una query Get o Scan.

Costruttori

S.No.	Costruttori
1	Result() Utilizzando questo costruttore, è possibile creare un risultato vuoto senza payload KeyValue; restituisce null se chiami raw Cells ().

Metodi

S.No.	Metodi e descrizione
1	byte[] getValue(byte[] family, byte[] qualifier) Questo metodo viene utilizzato per ottenere l'ultima versione della colonna specificata.
2	byte[] getRow() Questo metodo viene utilizzato per recuperare la chiave di riga che corrisponde alla riga da cui è stato creato questo risultato.

Inserimento di dati utilizzando HBase Shell

Questo capitolo mostra come creare dati in una tabella HBase. Per creare dati in una tabella HBase, vengono utilizzati i seguenti comandi e metodi:

put comando,
add() metodo di Put classe e
put() metodo di HTable classe.

Ad esempio, creeremo la seguente tabella in HBase.

Utilizzando putcomando, puoi inserire righe in una tabella. La sua sintassi è la seguente:

put ’<table name>’,’row1’,’<colfamily:colname>’,’<value>’

Inserimento della prima riga

Inseriamo i valori della prima riga nella tabella emp come mostrato di seguito.

hbase(main):005:0> put 'emp','1','personal data:name','raju'
0 row(s) in 0.6600 seconds
hbase(main):006:0> put 'emp','1','personal data:city','hyderabad'
0 row(s) in 0.0410 seconds
hbase(main):007:0> put 'emp','1','professional
data:designation','manager'
0 row(s) in 0.0240 seconds
hbase(main):007:0> put 'emp','1','professional data:salary','50000'
0 row(s) in 0.0240 seconds

Inserisci le righe rimanenti utilizzando il comando put allo stesso modo. Se inserisci l'intera tabella, otterrai il seguente output.

hbase(main):022:0> scan 'emp'

   ROW                        COLUMN+CELL
1 column=personal data:city, timestamp=1417524216501, value=hyderabad

1 column=personal data:name, timestamp=1417524185058, value=ramu

1 column=professional data:designation, timestamp=1417524232601,

 value=manager
 
1 column=professional data:salary, timestamp=1417524244109, value=50000

2 column=personal data:city, timestamp=1417524574905, value=chennai

2 column=personal data:name, timestamp=1417524556125, value=ravi

2 column=professional data:designation, timestamp=1417524592204,

 value=sr:engg
 
2 column=professional data:salary, timestamp=1417524604221, value=30000

3 column=personal data:city, timestamp=1417524681780, value=delhi

3 column=personal data:name, timestamp=1417524672067, value=rajesh

3 column=professional data:designation, timestamp=1417524693187,

value=jr:engg
3 column=professional data:salary, timestamp=1417524702514,

value=25000

Inserimento di dati utilizzando l'API Java

È possibile inserire dati in Hbase utilizzando il file add() metodo del Putclasse. Puoi salvarlo usando il fileput() metodo del HTableclasse. Queste classi appartengono alorg.apache.hadoop.hbase.clientpacchetto. Di seguito sono riportati i passaggi per creare dati in una tabella di HBase.

Passaggio 1: creare un'istanza della classe di configurazione

Il Configurationclass aggiunge i file di configurazione HBase al proprio oggetto. È possibile creare un oggetto di configurazione utilizzando ilcreate() metodo del HbaseConfiguration classe come mostrato di seguito.

Configuration conf = HbaseConfiguration.create();

Passaggio 2: creare un'istanza della classe HTable

Hai una classe chiamata HTable, un'implementazione di Table in HBase. Questa classe viene utilizzata per comunicare con una singola tabella HBase. Durante la creazione di un'istanza di questa classe, accetta l'oggetto di configurazione e il nome della tabella come parametri. Puoi istanziare la classe HTable come mostrato di seguito.

HTable hTable = new HTable(conf, tableName);

Passaggio 3: istanzia la PutClass

Per inserire dati in una tabella HBase, il file add()vengono utilizzati il metodo e le sue varianti. Questo metodo appartiene aPut, quindi istanziare la classe put. Questa classe richiede il nome della riga in cui si desidera inserire i dati, in formato stringa. Puoi istanziare il filePut classe come mostrato di seguito.

Put p = new Put(Bytes.toBytes("row1"));

Passaggio 4: inserire i dati

Il add() metodo di Putclass viene utilizzata per inserire dati. Richiede array di 3 byte che rappresentano rispettivamente la famiglia di colonne, il qualificatore di colonna (nome di colonna) e il valore da inserire. Inserire i dati nella tabella HBase utilizzando il metodo add () come mostrato di seguito.

p.add(Bytes.toBytes("coloumn family "), Bytes.toBytes("column
name"),Bytes.toBytes("value"));

Passaggio 5: salvare i dati nella tabella

Dopo aver inserito le righe richieste, salva le modifiche aggiungendo l'istanza put al file put() metodo della classe HTable come mostrato di seguito.

hTable.put(p);

Passaggio 6: chiudere l'istanza HTable

Dopo aver creato i dati nella tabella HBase, chiudere il file HTable istanza utilizzando il close() metodo come mostrato di seguito.

hTable.close();

Di seguito è riportato il programma completo per creare dati nella tabella HBase.

import java.io.IOException;

import org.apache.hadoop.conf.Configuration;

import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.client.HTable;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.util.Bytes;

public class InsertData{

   public static void main(String[] args) throws IOException {

      // Instantiating Configuration class
      Configuration config = HBaseConfiguration.create();

      // Instantiating HTable class
      HTable hTable = new HTable(config, "emp");

      // Instantiating Put class
      // accepts a row name.
      Put p = new Put(Bytes.toBytes("row1")); 

      // adding values using add() method
      // accepts column family name, qualifier/row name ,value
      p.add(Bytes.toBytes("personal"),
      Bytes.toBytes("name"),Bytes.toBytes("raju"));

      p.add(Bytes.toBytes("personal"),
      Bytes.toBytes("city"),Bytes.toBytes("hyderabad"));

      p.add(Bytes.toBytes("professional"),Bytes.toBytes("designation"),
      Bytes.toBytes("manager"));

      p.add(Bytes.toBytes("professional"),Bytes.toBytes("salary"),
      Bytes.toBytes("50000"));
      
      // Saving the put Instance to the HTable.
      hTable.put(p);
      System.out.println("data inserted");
      
      // closing HTable
      hTable.close();
   }
}

Compilare ed eseguire il programma sopra come mostrato di seguito.

$javac InsertData.java $java InsertData

Il seguente dovrebbe essere l'output:

data inserted

Aggiornamento dei dati utilizzando HBase Shell

È possibile aggiornare un valore di cella esistente utilizzando il putcomando. Per fare ciò, segui la stessa sintassi e menziona il tuo nuovo valore come mostrato di seguito.

put ‘table name’,’row ’,'Column family:column name',’new value’

Il valore appena fornito sostituisce il valore esistente, aggiornando la riga.

Esempio

Supponiamo che ci sia una tabella in HBase chiamata emp con i seguenti dati.

hbase(main):003:0> scan 'emp'
 ROW              COLUMN + CELL
row1 column = personal:name, timestamp = 1418051555, value = raju
row1 column = personal:city, timestamp = 1418275907, value = Hyderabad
row1 column = professional:designation, timestamp = 14180555,value = manager
row1 column = professional:salary, timestamp = 1418035791555,value = 50000
1 row(s) in 0.0100 seconds

Il comando seguente aggiornerà il valore della città del dipendente denominato "Raju" a Delhi.

hbase(main):002:0> put 'emp','row1','personal:city','Delhi'
0 row(s) in 0.0400 seconds

La tabella aggiornata appare come segue dove puoi osservare la città di Raju è stata cambiata in "Delhi".

hbase(main):003:0> scan 'emp'
  ROW          COLUMN + CELL
row1 column = personal:name, timestamp = 1418035791555, value = raju
row1 column = personal:city, timestamp = 1418274645907, value = Delhi
row1 column = professional:designation, timestamp = 141857555,value = manager
row1 column = professional:salary, timestamp = 1418039555, value = 50000
1 row(s) in 0.0100 seconds

Aggiornamento dei dati utilizzando l'API Java

È possibile aggiornare i dati in una cella particolare utilizzando il put()metodo. Seguire i passaggi indicati di seguito per aggiornare un valore di cella esistente di una tabella.

Passaggio 1: creare un'istanza della classe di configurazione

Configurationclass aggiunge i file di configurazione HBase al proprio oggetto. È possibile creare un oggetto di configurazione utilizzando ilcreate() metodo del HbaseConfiguration classe come mostrato di seguito.

Configuration conf = HbaseConfiguration.create();

Passaggio 2: creare un'istanza della classe HTable

Hai una classe chiamata HTable, un'implementazione di Table in HBase. Questa classe viene utilizzata per comunicare con una singola tabella HBase. Durante la creazione di un'istanza di questa classe, accetta l'oggetto di configurazione e il nome della tabella come parametri. È possibile creare un'istanza della classe HTable come mostrato di seguito.

HTable hTable = new HTable(conf, tableName);

Passaggio 3: istanzia la classe put

Per inserire dati nella tabella HBase, il file add()vengono utilizzati il metodo e le sue varianti. Questo metodo appartiene aPut, quindi crea un'istanza di putclasse. Questa classe richiede il nome della riga in cui si desidera inserire i dati, in formato stringa. Puoi istanziare il filePut classe come mostrato di seguito.

Put p = new Put(Bytes.toBytes("row1"));

Passaggio 4: aggiorna una cella esistente

p.add(Bytes.toBytes("coloumn family "), Bytes.toBytes("column
name"),Bytes.toBytes("value"));
p.add(Bytes.toBytes("personal"),
Bytes.toBytes("city"),Bytes.toBytes("Delih"));

Passaggio 5: salvare i dati nella tabella

Dopo aver inserito le righe richieste, salva le modifiche aggiungendo l'istanza put al file put() metodo della classe HTable come mostrato di seguito.

hTable.put(p);

Passaggio 6: chiudere l'istanza HTable

Dopo aver creato i dati nella tabella HBase, chiudere il file HTable istanza utilizzando il metodo close () come mostrato di seguito.

hTable.close();

Di seguito è riportato il programma completo per aggiornare i dati in una determinata tabella.

import java.io.IOException;

import org.apache.hadoop.conf.Configuration;

import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.client.HTable;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.util.Bytes;

public class UpdateData{

   public static void main(String[] args) throws IOException {

      // Instantiating Configuration class
      Configuration config = HBaseConfiguration.create();

      // Instantiating HTable class
      HTable hTable = new HTable(config, "emp");

      // Instantiating Put class
      //accepts a row name
      Put p = new Put(Bytes.toBytes("row1"));

      // Updating a cell value
      p.add(Bytes.toBytes("personal"),
      Bytes.toBytes("city"),Bytes.toBytes("Delih"));

      // Saving the put Instance to the HTable.
      hTable.put(p);
      System.out.println("data Updated");

      // closing HTable
      hTable.close();
   }
}

Compilare ed eseguire il programma sopra come mostrato di seguito.

$javac UpdateData.java $java UpdateData

Il seguente dovrebbe essere l'output:

data Updated

Lettura dei dati utilizzando HBase Shell

Il get comando e il get() metodo di HTableclass sono usati per leggere i dati da una tabella in HBase. Utilizzandogetcomando, puoi ottenere una singola riga di dati alla volta. La sua sintassi è la seguente:

get ’<table name>’,’row1’

Esempio

L'esempio seguente mostra come utilizzare il comando get. Esaminiamo la prima riga del fileemp tavolo.

hbase(main):012:0> get 'emp', '1'

   COLUMN                     CELL
   
personal : city timestamp = 1417521848375, value = hyderabad

personal : name timestamp = 1417521785385, value = ramu

professional: designation timestamp = 1417521885277, value = manager

professional: salary timestamp = 1417521903862, value = 50000

4 row(s) in 0.0270 seconds

Leggere una colonna specifica

Di seguito è riportata la sintassi per leggere una colonna specifica utilizzando il get metodo.

hbase> get 'table name', ‘rowid’, {COLUMN ⇒ ‘column family:column name ’}

Esempio

Di seguito è riportato l'esempio per leggere una colonna specifica nella tabella HBase.

hbase(main):015:0> get 'emp', 'row1', {COLUMN ⇒ 'personal:name'}
  COLUMN                CELL  
personal:name timestamp = 1418035791555, value = raju
1 row(s) in 0.0080 seconds

Lettura dei dati utilizzando l'API Java

Per leggere i dati da una tabella HBase, utilizzare il get()metodo della classe HTable. Questo metodo richiede un'istanza diGetclasse. Seguire i passaggi indicati di seguito per recuperare i dati dalla tabella HBase.

Passaggio 1: creare un'istanza della classe di configurazione

Configuration conf = HbaseConfiguration.create();

Passaggio 2: creare un'istanza della classe HTable

Hai una classe chiamata HTable, un'implementazione di Table in HBase. Questa classe viene utilizzata per comunicare con una singola tabella HBase. Durante la creazione di un'istanza di questa classe, accetta l'oggetto di configurazione e il nome della tabella come parametri. È possibile creare un'istanza della classe HTable come mostrato di seguito.

HTable hTable = new HTable(conf, tableName);

Passaggio 3: creare un'istanza della classe Get

È possibile recuperare i dati dalla tabella HBase utilizzando il get() metodo del HTableclasse. Questo metodo estrae una cella da una data riga. Richiede un fileGetoggetto classe come parametro. Crealo come mostrato di seguito.

Get get = new Get(toBytes("row1"));

Passaggio 4: leggere i dati

Durante il recupero dei dati, puoi ottenere una singola riga per id, o ottenere un set di righe da un set di id di riga, o scansionare un'intera tabella o un sottoinsieme di righe.

È possibile recuperare i dati di una tabella HBase utilizzando le varianti del metodo di aggiunta in Get classe.

Per ottenere una colonna specifica da una famiglia di colonne specifica, utilizzare il metodo seguente.

get.addFamily(personal)

Per ottenere tutte le colonne da una specifica famiglia di colonne, utilizzare il metodo seguente.

get.addColumn(personal, name)

Passaggio 5: ottieni il risultato

Ottieni il risultato passando il tuo Get istanza di classe al metodo get di HTableclasse. Questo metodo restituisce ilResultoggetto di classe, che contiene il risultato richiesto. Di seguito è riportato l'utilizzo diget() metodo.

Result result = table.get(g);

Passaggio 6: lettura dei valori dall'istanza dei risultati

Il Result class fornisce il getValue()metodo per leggere i valori dalla sua istanza. Usalo come mostrato di seguito per leggere i valori dal fileResult esempio.

byte [] value = result.getValue(Bytes.toBytes("personal"),Bytes.toBytes("name"));
byte [] value1 = result.getValue(Bytes.toBytes("personal"),Bytes.toBytes("city"));

Di seguito è riportato il programma completo per leggere i valori da una tabella HBase.

import java.io.IOException;

import org.apache.hadoop.conf.Configuration;

import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.client.Get;
import org.apache.hadoop.hbase.client.HTable;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.util.Bytes;

public class RetriveData{

   public static void main(String[] args) throws IOException, Exception{
   
      // Instantiating Configuration class
      Configuration config = HBaseConfiguration.create();

      // Instantiating HTable class
      HTable table = new HTable(config, "emp");

      // Instantiating Get class
      Get g = new Get(Bytes.toBytes("row1"));

      // Reading the data
      Result result = table.get(g);

      // Reading values from Result class object
      byte [] value = result.getValue(Bytes.toBytes("personal"),Bytes.toBytes("name"));

      byte [] value1 = result.getValue(Bytes.toBytes("personal"),Bytes.toBytes("city"));

      // Printing the values
      String name = Bytes.toString(value);
      String city = Bytes.toString(value1);
      
      System.out.println("name: " + name + " city: " + city);
   }
}

Compilare ed eseguire il programma sopra come mostrato di seguito.

$javac RetriveData.java $java RetriveData

Il seguente dovrebbe essere l'output:

name: Raju city: Delhi

Eliminazione di una cella specifica in una tabella

Usando il deletecomando, puoi eliminare una cella specifica in una tabella. La sintassi didelete il comando è il seguente:

delete ‘<table name>’, ‘<row>’, ‘<column name >’, ‘<time stamp>’

Esempio

Ecco un esempio per eliminare una cella specifica. Qui stiamo cancellando lo stipendio.

hbase(main):006:0> delete 'emp', '1', 'personal data:city',
1417521848375
0 row(s) in 0.0060 seconds

Eliminazione di tutte le celle in una tabella

Utilizzando il comando "deleteall", puoi eliminare tutte le celle di una riga. Di seguito è riportata la sintassi del comando deleteall.

deleteall ‘<table name>’, ‘<row>’,

Esempio

Ecco un esempio del comando "deleteall", in cui stiamo eliminando tutte le celle della riga1 della tabella emp.

hbase(main):007:0> deleteall 'emp','1'
0 row(s) in 0.0240 seconds

Verifica la tabella utilizzando il file scancomando. Di seguito viene fornita un'istantanea della tabella dopo l'eliminazione della tabella.

hbase(main):022:0> scan 'emp'

ROW                  COLUMN + CELL

2 column = personal data:city, timestamp = 1417524574905, value = chennai 

2 column = personal data:name, timestamp = 1417524556125, value = ravi

2 column = professional data:designation, timestamp = 1417524204, value = sr:engg

2 column = professional data:salary, timestamp = 1417524604221, value = 30000

3 column = personal data:city, timestamp = 1417524681780, value = delhi

3 column = personal data:name, timestamp = 1417524672067, value = rajesh
 
3 column = professional data:designation, timestamp = 1417523187, value = jr:engg

3 column = professional data:salary, timestamp = 1417524702514, value = 25000

Eliminazione dei dati utilizzando l'API Java

È possibile eliminare i dati da una tabella HBase utilizzando il delete() metodo del HTableclasse. Seguire i passaggi indicati di seguito per eliminare i dati da una tabella.

Passaggio 1: creare un'istanza della classe di configurazione

Configuration conf = HbaseConfiguration.create();

Passaggio 2: creare un'istanza della classe HTable

Hai una classe chiamata HTable, un'implementazione di Table in HBase. Questa classe viene utilizzata per comunicare con una singola tabella HBase. Durante la creazione di un'istanza di questa classe, accetta l'oggetto di configurazione e il nome della tabella come parametri. È possibile creare un'istanza della classe HTable come mostrato di seguito.

HTable hTable = new HTable(conf, tableName);

Passaggio 3: creare un'istanza della classe di eliminazione

Istanziare il file Deleteclass passando il rowid della riga da eliminare, in formato array di byte. Puoi anche passare timestamp e Rowlock a questo costruttore.

Delete delete = new Delete(toBytes("row1"));

Passaggio 4: selezionare i dati da eliminare

È possibile eliminare i dati utilizzando i metodi di eliminazione di Deleteclasse. Questa classe ha vari metodi di eliminazione. Scegli le colonne o le famiglie di colonne da eliminare utilizzando questi metodi. Dai un'occhiata ai seguenti esempi che mostrano l'utilizzo dei metodi della classe Delete.

delete.deleteColumn(Bytes.toBytes("personal"), Bytes.toBytes("name"));
delete.deleteFamily(Bytes.toBytes("professional"));

Passaggio 5: eliminare i dati

Elimina i dati selezionati passando il file delete istanza al delete() metodo del HTable classe come mostrato di seguito.

table.delete(delete);

Passaggio 6: chiudere HTableInstance

Dopo aver eliminato i dati, chiudere il file HTable Esempio.

table.close();

Di seguito è riportato il programma completo per eliminare i dati dalla tabella HBase.

import java.io.IOException;

import org.apache.hadoop.conf.Configuration;

import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.client.Delete;
import org.apache.hadoop.hbase.client.HTable;
import org.apache.hadoop.hbase.util.Bytes;

public class DeleteData {

   public static void main(String[] args) throws IOException {

      // Instantiating Configuration class
      Configuration conf = HBaseConfiguration.create();

      // Instantiating HTable class
      HTable table = new HTable(conf, "employee");

      // Instantiating Delete class
      Delete delete = new Delete(Bytes.toBytes("row1"));
      delete.deleteColumn(Bytes.toBytes("personal"), Bytes.toBytes("name"));
      delete.deleteFamily(Bytes.toBytes("professional"));

      // deleting the data
      table.delete(delete);

      // closing the HTable object
      table.close();
      System.out.println("data deleted.....");
   }
}

Compilare ed eseguire il programma sopra come mostrato di seguito.

$javac Deletedata.java $java DeleteData

Il seguente dovrebbe essere l'output:

data deleted

Scansione utilizzando HBase Shell

Il scanviene utilizzato per visualizzare i dati in HTable. Utilizzando il comando di scansione, è possibile ottenere i dati della tabella. La sua sintassi è la seguente:

scan ‘<table name>’

Esempio

L'esempio seguente mostra come leggere i dati da una tabella utilizzando il comando scan. Qui stiamo leggendo ilemp tavolo.

hbase(main):010:0> scan 'emp'

ROW                           COLUMN + CELL

1 column = personal data:city, timestamp = 1417521848375, value = hyderabad
 
1 column = personal data:name, timestamp = 1417521785385, value = ramu

1 column = professional data:designation, timestamp = 1417585277,value = manager

1 column = professional data:salary, timestamp = 1417521903862, value = 50000

1 row(s) in 0.0370 seconds

Scansione tramite API Java

Il programma completo per scansionare i dati dell'intera tabella utilizzando Java API è il seguente.

import java.io.IOException;

import org.apache.hadoop.conf.Configuration;

import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.util.Bytes;

import org.apache.hadoop.hbase.client.HTable;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.client.ResultScanner;
import org.apache.hadoop.hbase.client.Scan;


public class ScanTable{

   public static void main(String args[]) throws IOException{

      // Instantiating Configuration class
      Configuration config = HBaseConfiguration.create();

      // Instantiating HTable class
      HTable table = new HTable(config, "emp");

      // Instantiating the Scan class
      Scan scan = new Scan();

      // Scanning the required columns
      scan.addColumn(Bytes.toBytes("personal"), Bytes.toBytes("name"));
      scan.addColumn(Bytes.toBytes("personal"), Bytes.toBytes("city"));

      // Getting the scan result
      ResultScanner scanner = table.getScanner(scan);

      // Reading values from scan result
      for (Result result = scanner.next(); result != null; result = Scanner.next())

      System.out.println("Found row : " + result);
      //closing the scanner
      scanner.close();
   }
}

Compilare ed eseguire il programma sopra come mostrato di seguito.

$javac ScanTable.java $java ScanTable

Il seguente dovrebbe essere l'output:

Found row :
keyvalues={row1/personal:city/1418275612888/Put/vlen=5/mvcc=0,
row1/personal:name/1418035791555/Put/vlen=4/mvcc=0}

contare

Puoi contare il numero di righe di una tabella utilizzando il countcomando. La sua sintassi è la seguente:

count ‘<table name>’

Dopo aver eliminato la prima riga, la tabella emp avrà due righe. Verificare come mostrato di seguito.

hbase(main):023:0> count 'emp'
2 row(s) in 0.090 seconds
⇒ 2

troncare

Questo comando disabilita i drop e ricrea una tabella. La sintassi ditruncate è come segue:

hbase> truncate 'table name'

Esempio

Di seguito è riportato l'esempio del comando truncate. Qui abbiamo troncato il fileemp tavolo.

hbase(main):011:0> truncate 'emp'
Truncating 'one' table (it may take a while):
   - Disabling table...
   - Truncating table...
   0 row(s) in 1.5950 seconds

Dopo aver troncato la tabella, utilizzare il comando di scansione per verificare. Otterrai una tabella con zero righe.

hbase(main):017:0> scan ‘emp’
ROW                  COLUMN + CELL
0 row(s) in 0.3110 seconds

Possiamo concedere e revocare le autorizzazioni agli utenti in HBase. Sono disponibili tre comandi per motivi di sicurezza: grant, revoke e user_permission.

concedere

Il grantIl comando concede diritti specifici come lettura, scrittura, esecuzione e amministrazione su una tabella a un determinato utente. La sintassi del comando grant è la seguente:

hbase> grant <user> <permissions> [<table> [<column family> [&ltcolumn; qualifier>]]

Possiamo concedere zero o più privilegi a un utente dal set di RWXCA, dove

R - rappresenta il privilegio di lettura.
W - rappresenta il privilegio di scrittura.
X - rappresenta il privilegio di esecuzione.
C - rappresenta creare privilegio.
A - rappresenta il privilegio di amministratore.

Di seguito è riportato un esempio che concede tutti i privilegi a un utente denominato "Tutorialspoint".

hbase(main):018:0> grant 'Tutorialspoint', 'RWXCA'

revocare

Il revokecomando viene utilizzato per revocare i diritti di accesso di un utente a una tabella. La sua sintassi è la seguente:

hbase> revoke <user>

Il codice seguente revoca tutte le autorizzazioni all'utente denominato "Tutorialspoint".

hbase(main):006:0> revoke 'Tutorialspoint'

user_permission

Questo comando viene utilizzato per elencare tutte le autorizzazioni per una determinata tabella. La sintassi diuser_permission è come segue:

hbase>user_permission ‘tablename’

Il codice seguente elenca tutti i permessi utente della tabella "emp".

hbase(main):013:0> user_permission 'emp'